Merge pull request #55 from MaxLinCode/claude/fix-contract-handling

MaxLinCode · web-flow · commit 204e16c6c7c9 · 2026-03-23T15:00:40.000-07:00
Fix contract handling
diff --git a/.gitignore b/.gitignore
@@ -11,3 +11,4 @@ coverage
 packages/integrations/*.manual-eval-report.json
 packages/integrations/manual-eval-report.json
 packages/integrations/*.prompt-improvement.md
+apps/web/src/lib/server/.DS_Store
diff --git a/apps/web/src/lib/server/conversation-state.test.ts b/apps/web/src/lib/server/conversation-state.test.ts
@@ -193,6 +193,54 @@ describe("deriveConversationReplyState", () => {
     ]);
     expect(result.discourseState?.mode).toBe("confirming");
   });
+
+  it("persists pending_write_contract when resolvedContract is provided", () => {
+    const contract = { requiredSlots: ["day", "time"] as ("day" | "time" | "duration" | "target")[], intentKind: "plan" as const };
+
+    const result = deriveConversationReplyState({
+      snapshot: buildSnapshot(),
+      policy: {
+        action: "ask_clarification",
+        committedSlots: { day: "tomorrow" },
+        resolvedContract: contract
+      },
+      interpretation: {
+        turnType: "planning_request",
+        confidence: 0.58,
+        resolvedEntityIds: [],
+        ambiguity: "high",
+        missingSlots: ["time"]
+      },
+      reply: "What time should I schedule it?",
+      userTurnText: "schedule gym tomorrow",
+      summaryText: null,
+      occurredAt: "2026-03-22T16:05:00.000Z"
+    });
+
+    expect(result.discourseState?.pending_write_contract).toEqual(contract);
+  });
+
+  it("does not set pending_write_contract when resolvedContract is absent", () => {
+    const result = deriveConversationReplyState({
+      snapshot: buildSnapshot(),
+      policy: {
+        action: "reply_only",
+        committedSlots: {}
+      },
+      interpretation: {
+        turnType: "informational",
+        confidence: 0.93,
+        resolvedEntityIds: [],
+        ambiguity: "none"
+      },
+      reply: "Your schedule is empty.",
+      userTurnText: "what's on my schedule?",
+      summaryText: null,
+      occurredAt: "2026-03-22T16:05:00.000Z"
+    });
+
+    expect(result.discourseState?.pending_write_contract).toBeUndefined();
+  });
 });
 
 describe("deriveMutationState", () => {
@@ -306,4 +354,126 @@ describe("deriveMutationState", () => {
     ]);
     expect(result.discourseState.mode).toBe("editing");
   });
+
+  it("clears resolved_slots and pending_write_contract on successful mutation", () => {
+    const snapshot = buildSnapshot();
+    snapshot.discourseState = {
+      ...snapshot.discourseState!,
+      resolved_slots: { day: "tomorrow", time: "17:00" },
+      pending_write_contract: { requiredSlots: ["day", "time"], intentKind: "plan" }
+    };
+
+    const processing: ProcessedInboxResult = {
+      outcome: "planned",
+      inboxItem: {
+        id: "inbox-1",
+        userId: "user-1",
+        rawText: "schedule gym",
+        normalizedText: "schedule gym",
+        processingStatus: "planned",
+        linkedTaskIds: ["task-1"],
+        createdAt: "2026-03-22T16:00:00.000Z"
+      },
+      plannerRun: {
+        id: "run-1",
+        userId: "user-1",
+        inboxItemId: "inbox-1",
+        version: "test",
+        modelInput: {},
+        modelOutput: {},
+        confidence: 0.92
+      },
+      createdTasks: [
+        {
+          id: "task-1",
+          userId: "user-1",
+          sourceInboxItemId: "inbox-1",
+          lastInboxItemId: "inbox-1",
+          title: "Gym",
+          lifecycleState: "scheduled",
+          externalCalendarEventId: null,
+          externalCalendarId: null,
+          scheduledStartAt: "2026-03-23T17:00:00.000Z",
+          scheduledEndAt: "2026-03-23T18:00:00.000Z",
+          calendarSyncStatus: "in_sync",
+          calendarSyncUpdatedAt: null,
+          rescheduleCount: 0,
+          lastFollowupAt: null,
+          followupReminderSentAt: null,
+          completedAt: null,
+          archivedAt: null,
+          priority: "medium",
+          urgency: "medium"
+        }
+      ],
+      scheduleBlocks: [
+        {
+          id: "block-1",
+          userId: "user-1",
+          taskId: "task-1",
+          startAt: "2026-03-23T17:00:00.000Z",
+          endAt: "2026-03-23T18:00:00.000Z",
+          confidence: 0.92,
+          reason: "User requested 5 PM.",
+          rescheduleCount: 0,
+          externalCalendarId: null
+        }
+      ],
+      followUpMessage: "Scheduled gym for 5 PM."
+    };
+
+    const result = deriveMutationState({
+      snapshot,
+      processing,
+      occurredAt: "2026-03-22T16:10:00.000Z"
+    });
+
+    expect(result.discourseState.resolved_slots).toEqual({});
+    expect(result.discourseState.pending_write_contract).toBeUndefined();
+  });
+
+  it("preserves resolved_slots and pending_write_contract on needs_clarification", () => {
+    const snapshot = buildSnapshot();
+    snapshot.discourseState = {
+      ...snapshot.discourseState!,
+      resolved_slots: { day: "tomorrow" },
+      pending_write_contract: { requiredSlots: ["day", "time"], intentKind: "plan" }
+    };
+
+    const processing: ProcessedInboxResult = {
+      outcome: "needs_clarification",
+      inboxItem: {
+        id: "inbox-1",
+        userId: "user-1",
+        rawText: "schedule gym tomorrow",
+        normalizedText: "schedule gym tomorrow",
+        processingStatus: "needs_clarification",
+        linkedTaskIds: [],
+        createdAt: "2026-03-22T16:00:00.000Z"
+      },
+      plannerRun: {
+        id: "run-1",
+        userId: "user-1",
+        inboxItemId: "inbox-1",
+        version: "test",
+        modelInput: {},
+        modelOutput: {},
+        confidence: 0.5
+      },
+      reason: "time",
+      followUpMessage: "What time should I schedule the gym?"
+    };
+
+    const result = deriveMutationState({
+      snapshot,
+      processing,
+      occurredAt: "2026-03-22T16:10:00.000Z"
+    });
+
+    expect(result.discourseState.resolved_slots).toEqual({ day: "tomorrow" });
+    expect(result.discourseState.pending_write_contract).toEqual({
+      requiredSlots: ["day", "time"],
+      intentKind: "plan"
+    });
+  });
 });
diff --git a/apps/web/src/lib/server/conversation-state.ts b/apps/web/src/lib/server/conversation-state.ts
@@ -19,7 +19,7 @@ import { type ProcessedInboxResult } from "@atlas/db";
 
 type DeriveConversationReplyStateInput = {
   snapshot: ConversationStateSnapshot;
-  policy: Pick<TurnPolicyDecision, "action" | "clarificationSlots" | "targetProposalId" | "committedSlots"> & {
+  policy: Pick<TurnPolicyDecision, "action" | "clarificationSlots" | "targetProposalId" | "committedSlots" | "resolvedContract"> & {
     action: Extract<TurnPolicyAction, "reply_only" | "ask_clarification" | "present_proposal">;
   };
   interpretation: TurnInterpretation;
@@ -144,10 +144,15 @@ export function deriveConversationReplyState(input: DeriveConversationReplyState
   }).state;
 
   const committedSlots = input.policy.committedSlots;
-  const nextDiscourseState =
-    committedSlots && Object.keys(committedSlots).length > 0
-      ? { ...updatedDiscourseState, resolved_slots: committedSlots }
-      : updatedDiscourseState;
+  const nextDiscourseState = {
+    ...updatedDiscourseState,
+    ...(committedSlots && Object.keys(committedSlots).length > 0
+      ? { resolved_slots: committedSlots }
+      : {}),
+    ...(input.policy.resolvedContract
+      ? { pending_write_contract: input.policy.resolvedContract }
+      : {})
+  };
 
   return {
     summaryText: input.summaryText,
@@ -268,11 +273,16 @@ export function deriveMutationState(input: DeriveMutationStateInput) {
     }
   ).state;
 
+  const isFlowComplete = input.processing.outcome !== "needs_clarification";
+  const finalDiscourseState = isFlowComplete
+    ? { ...discourseState, resolved_slots: {}, pending_write_contract: undefined }
+    : discourseState;
+
   return {
     mode: (input.processing.outcome === "needs_clarification" ? "conversation_then_mutation" : "mutation") as
       ConversationRecordMode,
     entityRegistry: trimEntityRegistry(entityRegistry),
-    discourseState
+    discourseState: finalDiscourseState
   };
 }
 
diff --git a/apps/web/src/lib/server/telegram-webhook.ts b/apps/web/src/lib/server/telegram-webhook.ts
@@ -370,7 +370,8 @@ export async function handleTelegramWebhook(
               action: routedWithContext.policy.action,
               clarificationSlots: routedWithContext.policy.clarificationSlots,
               targetProposalId: routedWithContext.policy.targetProposalId,
-              committedSlots: routedWithContext.policy.committedSlots
+              committedSlots: routedWithContext.policy.committedSlots,
+              resolvedContract: routedWithContext.policy.resolvedContract
             },
             interpretation: routedWithContext.interpretation,
             reply: conversationResponse.reply,
@@ -438,7 +439,8 @@ export async function handleTelegramWebhook(
               snapshot: conversationState,
               policy: {
                 action: "ask_clarification",
-                committedSlots: routedWithContext.policy.committedSlots
+                committedSlots: routedWithContext.policy.committedSlots,
+                resolvedContract: routedWithContext.policy.resolvedContract
               },
               interpretation: routedWithContext.interpretation,
               reply: recoveredMutation.userReplyMessage,
diff --git a/apps/web/src/lib/server/turn-router.test.ts b/apps/web/src/lib/server/turn-router.test.ts
@@ -177,4 +177,81 @@ describe("turn router", () => {
 
     expect(result.policy.committedSlots).toEqual({});
   });
+
+  it("includes resolvedContract on policy output for planning_request", async () => {
+    mockClassification({
+      turnType: "planning_request",
+      confidence: 0.95
+    });
+    mockExtractSlots.mockResolvedValueOnce({
+      extractedValues: { day: "tomorrow", time: "18:00" },
+      confidence: { day: 0.95, time: 0.95 },
+      unresolvable: []
+    });
+
+    const result = await routeMessageTurn({
+      rawText: "Schedule gym tomorrow at 6pm",
+      normalizedText: "Schedule gym tomorrow at 6pm",
+      recentTurns: []
+    });
+
+    expect(result.policy.resolvedContract).toEqual({
+      requiredSlots: ["day", "time"],
+      intentKind: "plan"
+    });
+  });
+
+  it("carries forward priorContract from discourse state for clarification_answer", async () => {
+    const priorContract = { requiredSlots: ["time"] as ("day" | "time" | "duration" | "target")[], intentKind: "edit" as const };
+
+    mockClassification({
+      turnType: "clarification_answer",
+      confidence: 0.9
+    });
+    mockExtractSlots.mockResolvedValueOnce({
+      extractedValues: { time: "17:00" },
+      confidence: { time: 0.92 },
+      unresolvable: []
+    });
+
+    const result = await routeMessageTurn({
+      rawText: "5pm",
+      normalizedText: "5pm",
+      recentTurns: [],
+      discourseState: {
+        focus_entity_id: null,
+        currently_editable_entity_id: null,
+        last_user_mentioned_entity_ids: [],
+        last_presented_items: [],
+        pending_clarifications: [],
+        pending_write_contract: priorContract,
+        mode: "clarifying"
+      }
+    });
+
+    expect(result.policy.resolvedContract).toEqual(priorContract);
+  });
+
+  it("falls back to default contract when no prior contract exists", async () => {
+    mockClassification({
+      turnType: "clarification_answer",
+      confidence: 0.9
+    });
+    mockExtractSlots.mockResolvedValueOnce({
+      extractedValues: { time: "17:00" },
+      confidence: { time: 0.92 },
+      unresolvable: []
+    });
+
+    const result = await routeMessageTurn({
+      rawText: "5pm",
+      normalizedText: "5pm",
+      recentTurns: []
+    });
+
+    expect(result.policy.resolvedContract).toEqual({
+      requiredSlots: ["day", "time"],
+      intentKind: "plan"
+    });
+  });
 });
diff --git a/apps/web/src/lib/server/turn-router.ts b/apps/web/src/lib/server/turn-router.ts
@@ -16,7 +16,9 @@ import {
   type TurnRoutingInput,
   type WriteContract,
   type CommitPolicyOutput,
-  SLOT_COMMITTING_TURN_TYPES
+  SLOT_COMMITTING_TURN_TYPES,
+  DEFAULT_WRITE_CONTRACT,
+  resolveWriteContract
 } from "@atlas/core";
 
 import { decideTurnPolicy } from "./decide-turn-policy";
@@ -26,10 +28,6 @@ import { extractSlots } from "./slot-extractor";
 export type TurnRouterInput = TurnRoutingInput;
 export type TurnRouterResult = RoutedTurn;
 
-const DEFAULT_CONTRACT: WriteContract = {
-  requiredSlots: ["day", "time"],
-  intentKind: "plan"
-};
 
 export async function routeMessageTurn(input: TurnRouterInput): Promise<TurnRouterResult> {
   const discourseState = input.discourseState ?? createEmptyDiscourseState();
@@ -43,7 +41,11 @@ export async function routeMessageTurn(input: TurnRouterInput): Promise<TurnRout
   });
 
   // Pipeline B: extract slots (conditional)
-  const activeContract = discourseState.pending_write_contract ?? DEFAULT_CONTRACT;
+  const priorContract = discourseState.pending_write_contract;
+  const activeContract = resolveWriteContract({
+    turnType: classification.turnType,
+    priorContract
+  }) ?? DEFAULT_WRITE_CONTRACT;
   let slotExtraction = null;
 
   if (SLOT_COMMITTING_TURN_TYPES.has(classification.turnType)) {
@@ -62,7 +64,8 @@ export async function routeMessageTurn(input: TurnRouterInput): Promise<TurnRout
     confidence: compactConfidence(slotExtraction?.confidence ?? {}),
     unresolvable: slotExtraction?.unresolvable ?? [],
     priorResolvedSlots: discourseState.resolved_slots ?? {},
-    activeContract
+    activeContract,
+    priorContract
   });
 
   const policy = decideTurnPolicy({
@@ -76,7 +79,7 @@ export async function routeMessageTurn(input: TurnRouterInput): Promise<TurnRout
 
   return routedTurnSchema.parse({
     interpretation,
-    policy
+    policy: { ...policy, resolvedContract: activeContract }
   });
 }
 
diff --git a/packages/core/src/commit-policy.ts b/packages/core/src/commit-policy.ts
@@ -7,7 +7,7 @@ export type CommitPolicyInput = {
   unresolvable: SlotKey[];
   priorResolvedSlots: ResolvedSlots;
   activeContract: WriteContract;
-  priorContract?: WriteContract;
+  priorContract?: WriteContract | undefined;
 };
 
 export type CommitPolicyOutput = {
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
diff --git a/packages/core/src/write-contract.test.ts b/packages/core/src/write-contract.test.ts
diff --git a/packages/core/src/write-contract.ts b/packages/core/src/write-contract.ts
