Fix confirmation with edits

Author: MaxLinCode

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

@@ -415,6 +415,79 @@ describe("decideTurnPolicy", () => {
     });
   });
 
+  it("routes compound confirmation (classified as clarification_answer) with enough info to execute_mutation when proposal ID cleared", () => {
+    const result = decideTurnPolicy(
+      input(
+        // resolvedProposalId is cleared by the guard — no stale proposal binding
+        { turnType: "clarification_answer", confidence: 0.9, resolvedEntityIds: ["task-1"] },
+        { committedSlots: { day: "tomorrow", time: "17:00" } },
+        {
+          rawText: "ok but make it 5pm",
+          normalizedText: "ok but make it 5pm",
+          recentTurns: [],
+          entityRegistry: [
+            {
+              id: "proposal-1",
+              conversationId: "conversation-1",
+              kind: "proposal_option",
+              label: "Schedule it tomorrow at 3pm",
+              status: "presented",
+              createdAt: "2026-03-20T16:00:00.000Z",
+              updatedAt: "2026-03-20T16:00:00.000Z",
+              data: {
+                route: "conversation_then_mutation",
+                replyText: "Would you like me to schedule it tomorrow at 3pm?",
+                confirmationRequired: true,
+                targetEntityId: "task-1"
+              }
+            }
+          ]
+        }
+      )
+    );
+
+    expect(result).toMatchObject({
+      action: "execute_mutation",
+      mutationInputSource: "direct_user_turn"
+    });
+    expect(result.targetProposalId).toBeUndefined();
+  });
+
+  it("routes compound confirmation (classified as clarification_answer) with missing slots to ask_clarification", () => {
+    expect(
+      decideTurnPolicy(
+        input(
+          { turnType: "clarification_answer", confidence: 0.9 },
+          { committedSlots: { day: "tomorrow" }, missingSlots: ["time"], needsClarification: ["time"] },
+          {
+            rawText: "ok but tomorrow",
+            normalizedText: "ok but tomorrow",
+            recentTurns: [],
+            entityRegistry: [
+              {
+                id: "proposal-1",
+                conversationId: "conversation-1",
+                kind: "proposal_option",
+                label: "Schedule it at 3pm",
+                status: "presented",
+                createdAt: "2026-03-20T16:00:00.000Z",
+                updatedAt: "2026-03-20T16:00:00.000Z",
+                data: {
+                  route: "conversation_then_mutation",
+                  replyText: "Would you like me to schedule it at 3pm?",
+                  confirmationRequired: true
+                }
+              }
+            ]
+          }
+        )
+      )
+    ).toMatchObject({
+      action: "ask_clarification",
+      clarificationSlots: expect.arrayContaining(["time"])
+    });
+  });
+
   it("returns committedSlots on every policy decision", () => {
     const slots = { day: "tomorrow", time: "17:00" };
     const result = decideTurnPolicy(

apps/web/src/lib/server/llm-classifier.test.ts

@@ -122,17 +122,27 @@ describe("classifyTurn", () => {
       expect(client.responses.parse).toHaveBeenCalledOnce();
     });
 
-    it("fast-exits informational when no clarifications and no write verbs", async () => {
-      const result = await classifyTurn({
-        normalizedText: "What do I have tomorrow?",
-        discourseState: null,
-        entityRegistry: []
+    it("routes informational questions through LLM when fast-exit is disabled", async () => {
+      const client = mockClient({
+        turnType: "informational",
+        confidence: 0.91,
+        reasoning: "User is asking about their schedule"
       });
 
+      const result = await classifyTurn(
+        {
+          normalizedText: "What do I have tomorrow?",
+          discourseState: null,
+          entityRegistry: []
+        },
+        client
+      );
+
       expect(result).toMatchObject({
         turnType: "informational",
-        confidence: 0.93
+        confidence: 0.91
       });
+      expect(client.responses.parse).toHaveBeenCalledOnce();
     });
 
     it("does not fast-exit informational when active clarifications exist", async () => {

apps/web/src/lib/server/llm-classifier.ts

@@ -29,7 +29,7 @@ export async function classifyTurn(
   const singleProposal = activeProposals.length === 1 ? activeProposals[0] : null;
 
   // Fast-exit confirmation: exact match + exactly one active/presented proposal
-  if (isConfirmationTurn(lower) && singleProposal) {
+  if (isPureConfirmationTurn(lower) && singleProposal) {
     return {
       turnType: "confirmation",
       confidence: 0.97,
@@ -40,18 +40,19 @@ export async function classifyTurn(
     };
   }
 
+  // TEMP: disabled informational fast-exit until routing stabilizes
   // Fast-exit informational: question lead + no write verbs + no active clarifications
-  const activeClarifications = discourseState
-    ? getActivePendingClarifications(discourseState)
-    : [];
+  // const activeClarifications = discourseState
+  //   ? getActivePendingClarifications(discourseState)
+  //   : [];
 
-  if (isInformationalTurn(lower) && activeClarifications.length === 0 && !containsWriteVerb(lower)) {
-    return {
-      turnType: "informational",
-      confidence: 0.93,
-      resolvedEntityIds
-    };
-  }
+  // if (isInformationalTurn(lower) && activeClarifications.length === 0 && !containsWriteVerb(lower)) {
+  //   return {
+  //     turnType: "informational",
+  //     confidence: 0.93,
+  //     resolvedEntityIds
+  //   };
+  // }
 
   // Everything else → LLM
   try {
@@ -73,10 +74,8 @@ export async function classifyTurn(
   }
 }
 
-function isConfirmationTurn(lower: string) {
-  return /^(yes|yeah|yep|ok|okay|do it|sounds good|works|that works|go ahead|please do|confirm)([.,!? ]*)?$/.test(
-    lower
-  );
+function isPureConfirmationTurn(lower: string) {
+  return /^(ok|okay|yes|yep|yeah|confirm|do it|go ahead)([.,!? ]*)?$/.test(lower);
 }
 
 function isInformationalTurn(lower: string) {

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

@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 
 import type { TurnClassifierOutput } from "@atlas/core";
 
-import { routeMessageTurn } from "./turn-router";
+import { routeMessageTurn, containsModificationPayload } from "./turn-router";
 
 vi.mock("./llm-classifier", () => ({
   classifyTurn: vi.fn()
@@ -254,4 +254,123 @@ describe("turn router", () => {
       intentKind: "plan"
     });
   });
+
+  it("reclassifies compound confirmation with active proposal to clarification_answer", async () => {
+    mockClassification({
+      turnType: "confirmation",
+      confidence: 0.95,
+      resolvedProposalId: "proposal-1"
+    });
+    mockExtractSlots.mockResolvedValueOnce({
+      extractedValues: { time: "17:00" },
+      confidence: { time: 0.92 },
+      unresolvable: []
+    });
+
+    const result = await routeMessageTurn({
+      rawText: "ok but make it 5pm",
+      normalizedText: "ok but make it 5pm",
+      recentTurns: [],
+      entityRegistry: [
+        {
+          id: "proposal-1",
+          conversationId: "conversation-1",
+          kind: "proposal_option",
+          label: "Schedule it at 3pm",
+          status: "presented",
+          createdAt: "2026-03-20T16:00:00.000Z",
+          updatedAt: "2026-03-20T16:00:00.000Z",
+          data: {
+            route: "conversation_then_mutation",
+            replyText: "Would you like me to schedule it at 3pm?",
+            confirmationRequired: true,
+            targetEntityId: null,
+            mutationInputSource: null
+          }
+        }
+      ]
+    });
+
+    expect(result.interpretation.turnType).toBe("clarification_answer");
+    expect(result.interpretation.resolvedProposalId).toBeUndefined();
+    expect(result.policy.action).not.toBe("recover_and_execute");
+  });
+
+  it("does not reclassify pure confirmation with active proposal", async () => {
+    mockClassification({
+      turnType: "confirmation",
+      confidence: 0.97,
+      resolvedProposalId: "proposal-1"
+    });
+
+    const result = await routeMessageTurn({
+      rawText: "ok",
+      normalizedText: "ok",
+      recentTurns: [],
+      entityRegistry: [
+        {
+          id: "proposal-1",
+          conversationId: "conversation-1",
+          kind: "proposal_option",
+          label: "Schedule it at 3pm",
+          status: "active",
+          createdAt: "2026-03-20T16:00:00.000Z",
+          updatedAt: "2026-03-20T16:00:00.000Z",
+          data: {
+            route: "conversation_then_mutation",
+            replyText: "Would you like me to schedule it at 3pm?",
+            confirmationRequired: true,
+            targetEntityId: null,
+            mutationInputSource: null
+          }
+        }
+      ]
+    });
+
+    expect(result.interpretation.turnType).toBe("confirmation");
+    expect(result.policy.action).toBe("recover_and_execute");
+  });
+
+  it("does not reclassify compound confirmation without active proposal context", async () => {
+    mockClassification({
+      turnType: "confirmation",
+      confidence: 0.9
+    });
+
+    const result = await routeMessageTurn({
+      rawText: "ok but 5pm",
+      normalizedText: "ok but 5pm",
+      recentTurns: [],
+      entityRegistry: []
+    });
+
+    expect(result.interpretation.turnType).toBe("confirmation");
+  });
+});
+
+describe("containsModificationPayload", () => {
+  it("detects time patterns", () => {
+    expect(containsModificationPayload("ok but 5pm")).toBe(true);
+    expect(containsModificationPayload("sure, at 3")).toBe(true);
+    expect(containsModificationPayload("yes 17:00")).toBe(true);
+  });
+
+  it("detects day patterns", () => {
+    expect(containsModificationPayload("ok but tomorrow")).toBe(true);
+    expect(containsModificationPayload("yes friday")).toBe(true);
+  });
+
+  it("detects modification signals", () => {
+    expect(containsModificationPayload("ok but different")).toBe(true);
+    expect(containsModificationPayload("yes change it")).toBe(true);
+    expect(containsModificationPayload("sure, actually")).toBe(true);
+  });
+
+  it("does not match pure confirmations", () => {
+    expect(containsModificationPayload("ok")).toBe(false);
+    expect(containsModificationPayload("yes")).toBe(false);
+    expect(containsModificationPayload("sure")).toBe(false);
+    expect(containsModificationPayload("do it")).toBe(false);
+    expect(containsModificationPayload("yup")).toBe(false);
+  });
 });

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

@@ -2,6 +2,7 @@ import {
   applyCommitPolicy,
   createEmptyDiscourseState,
   routedTurnSchema,
+  type ConversationEntity,
   type ConversationTurn,
   type RoutedTurn,
   type SlotKey,
@@ -32,12 +33,31 @@ export async function routeMessageTurn(input: TurnRouterInput): Promise<TurnRout
   const entityRegistry = input.entityRegistry ?? [];
 
   // Pipeline A: classify intent
-  const classification = await classifyTurn({
+  let classification = await classifyTurn({
     normalizedText: input.normalizedText,
     discourseState,
     entityRegistry
   });
 
+  // Guard: reclassify compound confirmations (confirmation + modification payload)
+  // so slot extraction runs and the edit is not silently dropped.
+  // Scoped to active write/proposal context only.
+  if (classification.turnType === "confirmation") {
+    const hasActiveProposal = entityRegistry.some(
+      (e: ConversationEntity) =>
+        e.kind === "proposal_option" &&
+        (e.status === "active" || e.status === "presented")
+    );
+
+    if (hasActiveProposal && containsModificationPayload(input.normalizedText)) {
+      classification = {
+        ...classification,
+        turnType: "clarification_answer",
+        resolvedProposalId: undefined
+      };
+    }
+  }
+
   // Pipeline B: extract slots (conditional)
   const priorContract = discourseState.pending_write_contract;
   const activeContract = resolveWriteContract({
@@ -163,3 +183,18 @@ export function getConversationRouteForPolicy(action: TurnPolicyAction): Extract
 > {
   return action === "reply_only" ? "conversation" : "conversation_then_mutation";
 }
+
+export function containsModificationPayload(text: string): boolean {
+  const lower = text.toLowerCase();
+  // Time patterns: "5pm", "17:00", "at 3"
+  if (/\d{1,2}(:\d{2})?\s*(am|pm|a\.m\.|p\.m\.)/i.test(lower)) return true;
+  if (/\d{1,2}:\d{2}/.test(lower)) return true;
+  if (/\bat\s+\d{1,2}\b/.test(lower)) return true;
+  // Day patterns: "tomorrow", "friday", "next week"
+  if (/\b(tomorrow|today|tonight|monday|tuesday|wednesday|thursday|friday|saturday|sunday|next\s+\w+)\b/.test(lower)) return true;
+  // Duration: "for 1 hour", "30 minutes"
+  if (/\b\d+\s*(hour|minute|min|hr)s?\b/.test(lower)) return true;
+  // Modification signals: "but", "change", "make it", "instead", "actually"
+  if (/\b(but|change|make it|instead|switch|rather|actually|different)\b/.test(lower)) return true;
+  return false;
+}

packages/integrations/src/prompts/turn-classifier.ts

@@ -36,6 +36,7 @@ export const turnClassifierSystemPrompt = buildPromptSpec([
       "Bare noun phrases without question marks or write verbs in planning context are likely planning_request (task capture).",
       "Questions starting with what/when/where/why/how/who/which are typically informational.",
       "When uncertain between planning_request and informational, consider whether the text implies action or just discussion.",
+      "If the user confirms a proposal but also provides new or changed scheduling details (time, day, duration, target), classify as clarification_answer, not confirmation. Examples: 'ok but make it 5pm', 'yes but on friday', 'sounds good, change the time to 3'. Pure confirmation without modifications ('ok', 'yes', 'do it') remains confirmation.",
       "Set confidence between 0 and 1. Use higher confidence (>0.85) when context strongly supports the classification. Use lower confidence (<0.7) when the classification is uncertain."
     ]
   },