Complete phase 1 target handling and slot key cleanup

- Add workflowChanged: boolean to CommitPolicyOutput; set from operationChanged
  so commit-policy is the sole authority on workflow identity decisions
- Thin down buildResolvedOperation: use commitResult.resolvedTargetRef for
  targetRef; reset originatingText/startedAt when workflowChanged or no prior op
- Fix PERSISTABLE_SLOT_KEYS to dot-path format (scheduleFields.*) matching the
  clarificationSlots format from commit-policy; drop "target" (now in targetRef)
- Remove "target" from slotKeySchema in index.ts — target is resolved via
  classification.resolvedEntityIds, not slot extraction
- Add target-change tests: switch clears prior schedule fields, workflowChanged
  is true, resolvedTargetRef carries the new entity ID
- Rename "Committed slots" reason string in proposal-rules to "Resolved fields"

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: MaxLinCode

apps/web/src/lib/server/conversation-state.test.ts

@@ -55,14 +55,14 @@ describe("deriveConversationReplyState", () => {
       snapshot: buildSnapshot(),
       policy: {
         action: "ask_clarification",
-        clarificationSlots: ["time"],
+        clarificationSlots: ["scheduleFields.time"],
       },
       interpretation: {
         turnType: "planning_request",
         confidence: 0.58,
         resolvedEntityIds: [],
         ambiguity: "high",
-        missingFields: ["time"],
+        missingFields: ["scheduleFields.time"],
       },
       reply: "What time should I schedule the Malaysia trip planning?",
       userTurnText: "schedule malaysia trip planning tomorrow",
@@ -75,12 +75,12 @@ describe("deriveConversationReplyState", () => {
       kind: "clarification",
       status: "active",
       data: {
-        reason: "time",
+        reason: "scheduleFields.time",
       },
     });
     expect(result.discourseState?.pending_clarifications).toEqual([
       expect.objectContaining({
-        slot: "time",
+        slot: "scheduleFields.time",
         status: "pending",
       }),
     ]);
@@ -217,15 +217,15 @@ describe("deriveConversationReplyState", () => {
       snapshot: buildSnapshot(),
       policy: {
         action: "ask_clarification",
-        clarificationSlots: ["time"],
+        clarificationSlots: ["scheduleFields.time"],
         resolvedOperation: op,
       },
       interpretation: {
         turnType: "planning_request",
         confidence: 0.58,
         resolvedEntityIds: [],
         ambiguity: "high",
-        missingFields: ["time"],
+        missingFields: ["scheduleFields.time"],
       },
       reply: "What time should I schedule it?",
       userTurnText: "schedule gym tomorrow",

apps/web/src/lib/server/conversation-state.ts

@@ -464,7 +464,11 @@ function upsertActiveProposalEntity(
   return nextProposal;
 }
 
-const PERSISTABLE_SLOT_KEYS = new Set(["day", "time", "duration", "target"]);
+const PERSISTABLE_SLOT_KEYS = new Set([
+  "scheduleFields.day",
+  "scheduleFields.time",
+  "scheduleFields.duration",
+]);
 
 function derivePersistableClarificationSlots(slots: string[] | undefined) {
   if (!slots) {

apps/web/src/lib/server/decide-turn-policy.test.ts

@@ -16,8 +16,10 @@ import {
 
 const emptyCommit: CommitPolicyOutput = {
   resolvedFields: {},
+  resolvedTargetRef: null,
   needsClarification: [],
   missingFields: [],
+  workflowChanged: false,
 };
 
 function input(

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

@@ -29,7 +29,7 @@ export type TurnRouterResult = RoutedTurn;
 // Required schedule fields per operation kind — mirrors commit-policy internals.
 function requiredSlotsForOperation(
   operationKind: OperationKind,
-): ("day" | "time" | "duration" | "target")[] {
+): ("day" | "time" | "duration")[] {
   switch (operationKind) {
     case "plan":
       return ["day", "time"];
@@ -109,6 +109,9 @@ export async function routeMessageTurn(
     unresolvable: slotExtraction?.unresolvable ?? [],
     operationKind,
     priorPendingWriteOperation: priorOperation,
+    ...(classification.resolvedEntityIds[0] !== undefined
+      ? { currentTargetEntityId: classification.resolvedEntityIds[0] }
+      : {}),
   });
 
   const policy = decideTurnPolicy({
@@ -145,13 +148,14 @@ function buildResolvedOperation(
   priorOperation: PendingWriteOperation | undefined,
   currentTurnText: string,
 ): PendingWriteOperation {
+  const isNewWorkflow = commitResult.workflowChanged || !priorOperation;
   return {
     operationKind,
-    targetRef: priorOperation?.targetRef ?? null,
+    targetRef: commitResult.resolvedTargetRef,
     resolvedFields: commitResult.resolvedFields,
     missingFields: commitResult.missingFields,
-    originatingText: priorOperation?.originatingText ?? currentTurnText,
-    startedAt: priorOperation?.startedAt ?? new Date().toISOString(),
+    originatingText: isNewWorkflow ? currentTurnText : priorOperation.originatingText,
+    startedAt: isNewWorkflow ? new Date().toISOString() : priorOperation.startedAt,
   };
 }
 
@@ -220,11 +224,11 @@ function unique(values: string[]) {
 
 function compactConfidence(
   confidence: Record<string, number | null | undefined>,
-): Partial<Record<"day" | "time" | "duration" | "target", number>> {
-  const result: Partial<Record<"day" | "time" | "duration" | "target", number>> = {};
+): Partial<Record<"day" | "time" | "duration", number>> {
+  const result: Partial<Record<"day" | "time" | "duration", number>> = {};
   for (const [key, value] of Object.entries(confidence)) {
     if (typeof value === "number") {
-      result[key as "day" | "time" | "duration" | "target"] = value;
+      result[key as "day" | "time" | "duration"] = value;
     }
   }
   return result;

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

@@ -11,10 +11,11 @@ function t(hour: number, minute: number): TimeSpec {
 function priorOp(
   operationKind: PendingWriteOperation["operationKind"],
   scheduleFields: PendingWriteOperation["resolvedFields"]["scheduleFields"],
+  targetEntityId?: string,
 ): PendingWriteOperation {
   return {
     operationKind,
-    targetRef: null,
+    targetRef: targetEntityId ? { entityId: targetEntityId } : null,
     resolvedFields: { scheduleFields },
     missingFields: [],
     originatingText: "prior turn",
@@ -256,4 +257,62 @@ describe("applyCommitPolicy", () => {
     expect(result.resolvedFields.scheduleFields?.day).toBe("friday");
     expect(result.needsClarification).toContain("scheduleFields.time");
   });
+
+  it("sets resolvedTargetRef from currentTargetEntityId when no prior operation", () => {
+    const result = applyCommitPolicy(
+      buildInput({
+        turnType: "planning_request",
+        currentTargetEntityId: "task-abc",
+      }),
+    );
+
+    expect(result.resolvedTargetRef).toEqual({ entityId: "task-abc" });
+    expect(result.workflowChanged).toBe(false);
+  });
+
+  it("carries forward prior targetRef when no new entity is resolved", () => {
+    const result = applyCommitPolicy(
+      buildInput({
+        turnType: "clarification_answer",
+        priorPendingWriteOperation: priorOp("plan", { day: "tomorrow" }, "task-abc"),
+      }),
+    );
+
+    expect(result.resolvedTargetRef).toEqual({ entityId: "task-abc" });
+    expect(result.workflowChanged).toBe(false);
+  });
+
+  it("clears prior schedule fields and sets workflowChanged when target changes", () => {
+    const result = applyCommitPolicy(
+      buildInput({
+        turnType: "planning_request",
+        extractedValues: { day: "friday" },
+        confidence: { day: 0.9 },
+        currentTargetEntityId: "task-xyz",
+        priorPendingWriteOperation: priorOp("plan", { time: t(14, 0) }, "task-abc"),
+      }),
+    );
+
+    expect(result.resolvedTargetRef).toEqual({ entityId: "task-xyz" });
+    expect(result.workflowChanged).toBe(true);
+    expect(result.resolvedFields.scheduleFields?.time).toBeUndefined();
+    expect(result.resolvedFields.scheduleFields?.day).toBe("friday");
+  });
+
+  it("does not set workflowChanged when target is the same entity", () => {
+    const result = applyCommitPolicy(
+      buildInput({
+        turnType: "clarification_answer",
+        extractedValues: { time: t(17, 0) },
+        confidence: { time: 0.9 },
+        currentTargetEntityId: "task-abc",
+        priorPendingWriteOperation: priorOp("plan", { day: "tomorrow" }, "task-abc"),
+      }),
+    );
+
+    expect(result.resolvedTargetRef).toEqual({ entityId: "task-abc" });
+    expect(result.workflowChanged).toBe(false);
+    expect(result.resolvedFields.scheduleFields?.day).toBe("tomorrow");
+    expect(result.resolvedFields.scheduleFields?.time).toEqual(t(17, 0));
+  });
 });

packages/core/src/commit-policy.ts

@@ -2,12 +2,13 @@ import type {
   OperationKind,
   PendingWriteOperation,
   ResolvedFields,
+  TargetRef,
   TimeSpec,
   TurnInterpretation,
 } from "./index";
 import { timeSpecsEqual } from "./time-spec";
 
-type ScheduleSlot = "day" | "time" | "duration" | "target";
+type ScheduleSlot = "day" | "time" | "duration";
 
 export type CommitPolicyInput = {
   turnType: TurnInterpretation["turnType"];
@@ -16,12 +17,15 @@ export type CommitPolicyInput = {
   unresolvable: ScheduleSlot[];
   operationKind: OperationKind;
   priorPendingWriteOperation?: PendingWriteOperation | undefined;
+  currentTargetEntityId?: string;
 };
 
 export type CommitPolicyOutput = {
   resolvedFields: ResolvedFields;
+  resolvedTargetRef: TargetRef;
   needsClarification: string[];
   missingFields: string[];
+  workflowChanged: boolean;
 };
 
 export const SLOT_COMMITTING_TURN_TYPES = new Set<
@@ -56,11 +60,19 @@ export function applyCommitPolicy(
     unresolvable,
     operationKind,
     priorPendingWriteOperation,
+    currentTargetEntityId,
   } = input;
 
+  // Target change: a new entity ID that differs from the prior workflow's target
+  // means the user switched subjects. Treat it the same as an operation change —
+  // prior committed schedule fields belong to a different task and must be cleared.
+  const targetChanged =
+    currentTargetEntityId !== undefined &&
+    currentTargetEntityId !== priorPendingWriteOperation?.targetRef?.entityId;
+
   const operationChanged =
     priorPendingWriteOperation != null &&
-    operationKind !== priorPendingWriteOperation.operationKind;
+    (operationKind !== priorPendingWriteOperation.operationKind || targetChanged);
 
   const priorScheduleFields: Partial<Record<ScheduleSlot, unknown>> =
     operationChanged
@@ -125,7 +137,12 @@ export function applyCommitPolicy(
     .filter((slot) => committedSchedule[slot] === undefined)
     .map((slot) => `scheduleFields.${slot}`);
 
-  return { resolvedFields, needsClarification, missingFields };
+  // Carry forward the prior target unless this turn introduced a new one.
+  const resolvedTargetRef: TargetRef = currentTargetEntityId
+    ? { entityId: currentTargetEntityId }
+    : (priorPendingWriteOperation?.targetRef ?? null);
+
+  return { resolvedFields, resolvedTargetRef, needsClarification, missingFields, workflowChanged: operationChanged };
 }
 
 function slotValuesEqual(slot: ScheduleSlot, a: unknown, b: unknown): boolean {

packages/core/src/index.ts

@@ -957,7 +957,7 @@ export const routedTurnSchema = z.object({
   policy: turnPolicyDecisionSchema,
 });
 
-const slotKeySchema = z.enum(["day", "time", "duration", "target"]);
+const slotKeySchema = z.enum(["day", "time", "duration"]);
 
 const slotConfidenceSchema = z.object({
   day: z.number().nullable().optional(),

packages/core/src/proposal-rules.ts

@@ -168,7 +168,7 @@ function deriveSlotsCompatibility(
 
   return {
     compatible: true,
-    reason: "Committed slots are compatible with the proposal snapshot.",
+    reason: "Resolved fields are compatible with the proposal snapshot.",
   };
 }