Update unneeded slot references

Author: MaxLinCode

apps/web/src/lib/server/turn-router.ts

@@ -10,7 +10,7 @@ import {
   type RoutedTurn,
   resolveOperationKind,
   routedTurnSchema,
-  SLOT_COMMITTING_TURN_TYPES,
+  FIELD_COMMITTING_TURN_TYPES,
   type TurnAmbiguity,
   type TurnClassifierOutput,
   type TurnInterpretation,
@@ -27,7 +27,7 @@ export type TurnRouterInput = TurnRoutingInput;
 export type TurnRouterResult = RoutedTurn;
 
 // Required schedule fields per operation kind — mirrors commit-policy internals.
-function requiredSlotsForOperation(
+function requiredScheduleFieldsForOperation(
   operationKind: OperationKind,
 ): ("day" | "time" | "duration")[] {
   switch (operationKind) {
@@ -56,7 +56,7 @@ export async function routeMessageTurn(
   });
 
   // Guard: reclassify compound confirmations (confirmation + modification payload)
-  // so slot extraction runs and the edit is not silently dropped.
+  // so field extraction runs and the edit is not silently dropped.
   // Scoped to active write/proposal context only.
   if (classification.turnType === "confirmation") {
     const hasActiveProposal = entityRegistry.some(
@@ -77,28 +77,30 @@ export async function routeMessageTurn(
     }
   }
 
-  // Pipeline B: extract slots (conditional)
+  // Pipeline B: extract fields via the slot extractor (conditional)
   const priorOperation = discourseState.pending_write_operation;
   const operationKind =
     resolveOperationKind({
       turnType: classification.turnType,
       priorOperationKind: priorOperation?.operationKind,
     }) ?? "plan";
 
-  let slotExtraction = null;
+  let fieldExtraction = null;
 
-  if (SLOT_COMMITTING_TURN_TYPES.has(classification.turnType)) {
+  if (FIELD_COMMITTING_TURN_TYPES.has(classification.turnType)) {
     const priorScheduleFields =
       priorOperation?.resolvedFields.scheduleFields ?? {};
-    const pendingSlots = requiredSlotsForOperation(operationKind).filter(
-      (slot) =>
-        priorScheduleFields[slot as keyof typeof priorScheduleFields] ===
+    const pendingScheduleFields = requiredScheduleFieldsForOperation(
+      operationKind,
+    ).filter(
+      (fieldKey) =>
+        priorScheduleFields[fieldKey as keyof typeof priorScheduleFields] ===
         undefined,
     );
 
-    slotExtraction = await extractSlots({
+    fieldExtraction = await extractSlots({
       currentTurnText: input.normalizedText,
-      pendingSlots,
+      pendingSlots: pendingScheduleFields,
       priorResolvedSlots: priorScheduleFields,
       conversationContext: deriveConversationContext(input.recentTurns),
     });
@@ -107,9 +109,9 @@ export async function routeMessageTurn(
   // Policy layer: commit + route
   const commitResult = applyCommitPolicy({
     turnType: classification.turnType,
-    extractedValues: slotExtraction?.extractedValues ?? {},
-    confidence: compactConfidence(slotExtraction?.confidence ?? {}),
-    unresolvable: slotExtraction?.unresolvable ?? [],
+    extractedValues: fieldExtraction?.extractedValues ?? {},
+    confidence: compactConfidence(fieldExtraction?.confidence ?? {}),
+    unresolvable: fieldExtraction?.unresolvable ?? [],
     operationKind,
     priorPendingWriteOperation: priorOperation,
     ...(classification.resolvedEntityIds[0] !== undefined

packages/core/src/commit-policy.test.ts

@@ -35,7 +35,7 @@ function buildInput(overrides: Partial<CommitPolicyInput>): CommitPolicyInput {
 }
 
 describe("applyCommitPolicy", () => {
-  it("does not commit slots for informational turns", () => {
+  it("does not commit fields for informational turns", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "informational",
@@ -47,7 +47,7 @@ describe("applyCommitPolicy", () => {
     expect(result.resolvedFields.scheduleFields?.time).toBeUndefined();
   });
 
-  it("does not commit slots for confirmation turns", () => {
+  it("does not commit fields for confirmation turns", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "confirmation",
@@ -59,7 +59,7 @@ describe("applyCommitPolicy", () => {
     expect(result.resolvedFields.scheduleFields?.time).toBeUndefined();
   });
 
-  it("commits slots above confidence threshold for planning_request", () => {
+  it("commits fields above confidence threshold for planning_request", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "planning_request",
@@ -114,7 +114,7 @@ describe("applyCommitPolicy", () => {
     expect(result.needsClarification).not.toContain("scheduleFields.time");
   });
 
-  it("routes unresolvable slots to needsClarification", () => {
+  it("routes unresolvable fields to needsClarification", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "clarification_answer",
@@ -127,7 +127,7 @@ describe("applyCommitPolicy", () => {
     expect(result.needsClarification).toContain("scheduleFields.time");
   });
 
-  it("resets prior slots on operation kind change", () => {
+  it("resets prior fields on operation kind change", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "planning_request",
@@ -145,7 +145,7 @@ describe("applyCommitPolicy", () => {
     expect(result.resolvedFields.scheduleFields?.day).toBe("friday");
   });
 
-  it("does not reset slots when operation kind is unchanged", () => {
+  it("does not reset fields when operation kind is unchanged", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "planning_request",
@@ -201,7 +201,7 @@ describe("applyCommitPolicy", () => {
     expect(result.resolvedFields.scheduleFields?.time).toEqual(t(17, 0));
   });
 
-  it("commits slots for edit_request turn type", () => {
+  it("commits fields for edit_request turn type", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "edit_request",
@@ -228,7 +228,7 @@ describe("applyCommitPolicy", () => {
     expect(result.needsClarification).toContain("scheduleFields.time");
   });
 
-  it("does not flag unresolvable slot that is already resolved from prior turn", () => {
+  it("does not flag an unresolvable field that is already resolved from prior turn", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "clarification_answer",
@@ -244,7 +244,7 @@ describe("applyCommitPolicy", () => {
     expect(result.resolvedFields.scheduleFields?.day).toBe("friday");
   });
 
-  it("handles unresolvable slots not in extractedValues", () => {
+  it("handles unresolvable fields not in extractedValues", () => {
     const result = applyCommitPolicy(
       buildInput({
         turnType: "clarification_answer",

packages/core/src/commit-policy.ts

@@ -8,13 +8,13 @@ import type {
 } from "./index";
 import { timeSpecsEqual } from "./time-spec";
 
-type ScheduleSlot = "day" | "time" | "duration";
+type ScheduleFieldKey = "day" | "time" | "duration";
 
 export type CommitPolicyInput = {
   turnType: TurnInterpretation["turnType"];
-  extractedValues: Partial<Record<ScheduleSlot, unknown>>;
-  confidence: Partial<Record<ScheduleSlot, number>>;
-  unresolvable: ScheduleSlot[];
+  extractedValues: Partial<Record<ScheduleFieldKey, unknown>>;
+  confidence: Partial<Record<ScheduleFieldKey, number>>;
+  unresolvable: ScheduleFieldKey[];
   operationKind: OperationKind;
   priorPendingWriteOperation?: PendingWriteOperation | undefined;
   currentTargetEntityId?: string;
@@ -28,7 +28,7 @@ export type CommitPolicyOutput = {
   workflowChanged: boolean;
 };
 
-export const SLOT_COMMITTING_TURN_TYPES = new Set<
+export const FIELD_COMMITTING_TURN_TYPES = new Set<
   TurnInterpretation["turnType"]
 >(["clarification_answer", "planning_request", "edit_request"]);
 
@@ -39,7 +39,7 @@ const CORRECTION_THRESHOLD = 0.9;
 // Contract derivation lives here rather than as a pre-extraction gate.
 function requiredFieldsForOperation(
   operationKind: OperationKind,
-): ScheduleSlot[] {
+): ScheduleFieldKey[] {
   switch (operationKind) {
     case "plan":
       return ["day", "time"];
@@ -77,53 +77,54 @@ export function applyCommitPolicy(
     (operationKind !== priorPendingWriteOperation.operationKind ||
       targetChanged);
 
-  const priorScheduleFields: Partial<Record<ScheduleSlot, unknown>> =
+  const priorScheduleFields: Partial<Record<ScheduleFieldKey, unknown>> =
     operationChanged
       ? {}
       : {
           ...(priorPendingWriteOperation?.resolvedFields.scheduleFields ?? {}),
         };
 
   const needsClarification: string[] = [];
-  const committedSchedule: Partial<Record<ScheduleSlot, unknown>> = {
+  const committedScheduleFields: Partial<Record<ScheduleFieldKey, unknown>> = {
     ...priorScheduleFields,
   };
 
-  if (SLOT_COMMITTING_TURN_TYPES.has(turnType)) {
-    const slotKeys = Object.keys(extractedValues) as ScheduleSlot[];
+  if (FIELD_COMMITTING_TURN_TYPES.has(turnType)) {
+    const extractedFieldKeys = Object.keys(extractedValues) as ScheduleFieldKey[];
 
-    for (const slot of slotKeys) {
-      const value = extractedValues[slot];
+    for (const fieldKey of extractedFieldKeys) {
+      const value = extractedValues[fieldKey];
       if (value === undefined) continue;
 
-      if (unresolvable.includes(slot)) {
-        needsClarification.push(`scheduleFields.${slot}`);
+      if (unresolvable.includes(fieldKey)) {
+        needsClarification.push(`scheduleFields.${fieldKey}`);
         continue;
       }
 
-      const slotConfidence = confidence[slot] ?? 0;
-      if (slotConfidence < CONFIDENCE_THRESHOLD) {
-        needsClarification.push(`scheduleFields.${slot}`);
+      const fieldConfidence = confidence[fieldKey] ?? 0;
+      if (fieldConfidence < CONFIDENCE_THRESHOLD) {
+        needsClarification.push(`scheduleFields.${fieldKey}`);
         continue;
       }
 
-      const priorValue = priorScheduleFields[slot];
+      const priorValue = priorScheduleFields[fieldKey];
       const isCorrection =
-        priorValue !== undefined && !slotValuesEqual(slot, priorValue, value);
-      if (isCorrection && slotConfidence < CORRECTION_THRESHOLD) {
-        needsClarification.push(`scheduleFields.${slot}`);
+        priorValue !== undefined &&
+        !scheduleFieldValuesEqual(fieldKey, priorValue, value);
+      if (isCorrection && fieldConfidence < CORRECTION_THRESHOLD) {
+        needsClarification.push(`scheduleFields.${fieldKey}`);
         continue;
       }
 
-      committedSchedule[slot] = value;
+      committedScheduleFields[fieldKey] = value;
     }
 
-    for (const slot of unresolvable) {
-      const dotPath = `scheduleFields.${slot}`;
+    for (const fieldKey of unresolvable) {
+      const dotPath = `scheduleFields.${fieldKey}`;
       if (
-        !slotKeys.includes(slot) &&
+        !extractedFieldKeys.includes(fieldKey) &&
         !needsClarification.includes(dotPath) &&
-        committedSchedule[slot] === undefined
+        committedScheduleFields[fieldKey] === undefined
       ) {
         needsClarification.push(dotPath);
       }
@@ -132,15 +133,15 @@ export function applyCommitPolicy(
 
   const resolvedFields: ResolvedFields = {
     scheduleFields:
-      Object.keys(committedSchedule).length > 0
-        ? (committedSchedule as ResolvedFields["scheduleFields"])
+      Object.keys(committedScheduleFields).length > 0
+        ? (committedScheduleFields as ResolvedFields["scheduleFields"])
         : undefined,
   };
 
-  const requiredSlots = requiredFieldsForOperation(operationKind);
-  const missingFields = requiredSlots
-    .filter((slot) => committedSchedule[slot] === undefined)
-    .map((slot) => `scheduleFields.${slot}`);
+  const requiredFieldKeys = requiredFieldsForOperation(operationKind);
+  const missingFields = requiredFieldKeys
+    .filter((fieldKey) => committedScheduleFields[fieldKey] === undefined)
+    .map((fieldKey) => `scheduleFields.${fieldKey}`);
 
   // Carry forward the prior target unless this turn introduced a new one.
   const resolvedTargetRef: TargetRef = currentTargetEntityId
@@ -156,8 +157,12 @@ export function applyCommitPolicy(
   };
 }
 
-function slotValuesEqual(slot: ScheduleSlot, a: unknown, b: unknown): boolean {
-  if (slot === "time" && a && b) {
+function scheduleFieldValuesEqual(
+  fieldKey: ScheduleFieldKey,
+  a: unknown,
+  b: unknown,
+): boolean {
+  if (fieldKey === "time" && a && b) {
     return timeSpecsEqual(a as TimeSpec, b as TimeSpec);
   }
   return a === b;