Fix double-prompting, ambiguous synthesis, and forward-action language bugs

Bug 1: When the LLM classifier confirms a turn without populating
resolvedProposalId, the confirmation case now falls back to scanning
the entity registry for a single active proposal instead of always
re-presenting. Removes the double-prompting loop.

Bug 3 (caused by Bug 1): Fixing Bug 1 prevents originatingTurnText
from being set to the user's "Yes"/"Ok" confirmation text, which was
causing synthesizeMutationText to produce "Yes" as the planner input
and triggering the planner's ambiguity error.

Bug 2: Add a safety rule to the conversation-response prompt blocking
forward-action language like "I can proceed" or "I'll go ahead and"
on the non-writing path.

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

Author: MaxLinCode

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

@@ -169,6 +169,47 @@ describe("decideTurnPolicy", () => {
     });
   });
 
+  it("recovers from registry when confirmation has no resolvedProposalId but one active proposal exists", () => {
+    expect(
+      decideTurnPolicy(
+        input(
+          {
+            turnType: "confirmation",
+            confidence: 0.95,
+            // resolvedProposalId intentionally absent — classifier missed it
+          },
+          {},
+          {
+            rawText: "Yes",
+            normalizedText: "Yes",
+            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,
+                  slotSnapshot: {},
+                },
+              },
+            ],
+          },
+        ),
+      ),
+    ).toMatchObject({
+      action: "recover_and_execute",
+      targetProposalId: "proposal-1",
+      mutationInputSource: "recovered_proposal",
+    });
+  });
+
   it("treats affirmative consent on a pending proposal as execution", () => {
     expect(
       decideTurnPolicy(

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

@@ -1,6 +1,7 @@
 import {
   type CommitPolicyOutput,
   containsWriteVerb,
+  type ConversationEntity,
   deriveAmbiguity,
   deriveConsentRequirement,
   type TurnAmbiguity,
@@ -64,16 +65,20 @@ export function decideTurnPolicy(
         ...(targetEntityId ? { targetEntityId } : {}),
         committedSlots: commitResult.committedSlots,
       };
-    case "confirmation":
-      if (classification.resolvedProposalId) {
+    case "confirmation": {
+      const proposalId =
+        classification.resolvedProposalId ??
+        resolveSingleActiveProposalId(input.routingContext.entityRegistry ?? []);
+
+      if (proposalId) {
         return {
           action: "recover_and_execute",
           reason: "The turn confirms one recoverable pending proposal.",
           requiresWrite: true,
           requiresConfirmation: false,
           useMutationPipeline: true,
           ...(targetEntityId ? { targetEntityId } : {}),
-          targetProposalId: classification.resolvedProposalId,
+          targetProposalId: proposalId,
           mutationInputSource: "recovered_proposal",
           committedSlots: commitResult.committedSlots,
         };
@@ -82,22 +87,14 @@ export function decideTurnPolicy(
       return {
         action: "present_proposal",
         reason:
-          "Confirmation language arrived for a ready consent-gated write, but no recoverable proposal exists yet; present proposal now.",
+          "Confirmation language arrived but no recoverable proposal exists; present proposal now.",
         requiresWrite: true,
         requiresConfirmation: true,
         useMutationPipeline: false,
         clarificationSlots: [],
         committedSlots: commitResult.committedSlots,
       };
-    // return {
-    //   action: "ask_clarification",
-    //   reason: "Confirmation language without one recoverable proposal should ask which proposal to apply.",
-    //   requiresWrite: false,
-    //   requiresConfirmation: false,
-    //   useMutationPipeline: false,
-    //   clarificationSlots: ["proposal"],
-    //   committedSlots: commitResult.committedSlots
-    // };
+    }
     case "clarification_answer":
     case "planning_request":
     case "edit_request":
@@ -210,6 +207,17 @@ function deriveStructuredWriteReadiness(
   };
 }
 
+function resolveSingleActiveProposalId(
+  registry: ConversationEntity[],
+): string | undefined {
+  const active = registry.filter(
+    (e) =>
+      e.kind === "proposal_option" &&
+      (e.status === "active" || e.status === "presented"),
+  );
+  return active.length === 1 ? active[0]!.id : undefined;
+}
+
 function buildPolicyFromStructuredReadiness(
   readiness: StructuredWriteReadiness,
   targetEntityId: string | undefined,

packages/integrations/src/prompts/conversation-response.ts

@@ -53,6 +53,7 @@ export const conversationResponseSystemPrompt = buildPromptSpec([
       "Do not make hard claims that any task, schedule, or reminder definitely exists or was created, updated, moved, completed, or archived.",
       "Do not present continuity context as authoritative Atlas state.",
       "Avoid first-person state claims like 'I created', 'I moved', 'I already have', or 'I haven't created yet' when you are reasoning only from continuity context.",
+      "Do not use forward-action language like 'I can proceed', 'I'll go ahead and', 'I'm ready to', or 'I can do that now' that implies an imminent write on the non-writing path.",
     ],
   },
   {