@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

package/src/resources/extensions/gsd/tests/checkout-branch-stash-guard.test.ts

@@ -5,7 +5,7 @@ import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSy
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkoutBranchWithStashGuard } from "../auto-worktree.ts";
+import { checkoutBranchWithStashGuard } from "../worktree-git-recovery.ts";
 
 function git(args: string[], cwd: string): string {
   return execFileSync("git", args, {
@@ -159,4 +159,69 @@ describe("checkoutBranchWithStashGuard", () => {
     const stashList = git(["stash", "list"], repo).trim();
     assert.equal(stashList, "");
   });
+
+  test("auto-resolves combined non-.gsd untracked collision and .gsd index conflict", (t) => {
+    // Regression for: gate checked nonGsdUnmerged.length === 0 but ignored
+    // .gsd/ index conflicts, so a failed pop with both an untracked non-.gsd/
+    // collision AND a .gsd/ tracked conflict would drop the stash while leaving
+    // .gsd/ index unmerged entries unresolved.
+    const repo = createRepo(t);
+    // Add .gsd/DECISIONS.md to base so both branches diverge from it
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "base\n");
+    git(["add", ".gsd/DECISIONS.md"], repo);
+    git(["commit", "-m", "add decisions"], repo);
+
+    git(["checkout", "-b", "milestone/M003"], repo);
+    // Branch has its own version of DECISIONS.md (non-JSONL .gsd/ file)
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "target-version\n");
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"dark\"}\n");
+    git(["add", ".gsd/DECISIONS.md", ".harness/settings.json"], repo);
+    git(["commit", "-m", "branch state"], repo);
+    git(["checkout", "main"], repo);
+
+    // On main: tracked .gsd/ change (creates unmerged index entry on pop) +
+    // untracked harness file (triggers "already exists, no checkout").
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "local-version\n");
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"light\"}\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M003", "test-combined-gsd-conflict");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M003");
+    const decisions = readFileSync(join(repo, ".gsd", "DECISIONS.md"), "utf8");
+    assert.equal(decisions, "target-version\n");
+    assert.doesNotMatch(decisions, /<<<<<<<|=======|>>>>>>>/);
+    const status = git(["status", "--porcelain"], repo).trim();
+    assert.equal(status, "");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
+
+  test("auto-resolves non-.gsd untracked restore collisions (e.g. harness config outside .gsd/)", (t) => {
+    const repo = createRepo(t);
+    // Target branch has a harness config file committed; source (main) has it untracked.
+    // Use a path not affected by global gitignore rules (unlike .claude/settings.local.json).
+    git(["checkout", "-b", "milestone/M001"], repo);
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"dark\"}\n");
+    git(["add", ".harness/settings.json"], repo);
+    git(["commit", "-m", "add harness settings"], repo);
+    git(["checkout", "main"], repo);
+
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"light\"}\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M001", "test-non-gsd-untracked-collision");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M001");
+    const wtContent = readFileSync(join(repo, ".harness", "settings.json"), "utf8");
+    assert.equal(wtContent, "{\"theme\":\"dark\"}\n");
+    const status = git(["status", "--porcelain"], repo).trim();
+    assert.equal(status, "");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
 });

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -73,4 +73,48 @@ describe("clear stale pending auto-start (#3667)", () => {
       "pending auto-start gate must clear stale map entries for completed discussions",
     );
   });
+
+  test("guided-flow recovers a finished-but-unconsumed discussion instead of dead-ending", () => {
+    // CONTEXT exists + no live turn means the discussion completed but the
+    // agent_end handoff never consumed the entry (e.g. an external-engine
+    // post-hoc gate re-arm wiped the depth verification after the save).
+    // Without recovery, every /gsd prints "Discussion already in progress"
+    // forever: the stale heuristic requires CONTEXT to be absent and
+    // discussPlanComplete requires a ROADMAP that planning never produced.
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes("milestoneHasContext && !isAgentTurnInFlight(ctx)"),
+      "pending-entry guard must have a recovery branch for CONTEXT-present, no-turn-in-flight entries",
+    );
+    assert.ok(
+      source.includes("extractDepthVerificationMilestoneId(pendingGateId) === entry.milestoneId"),
+      "recovery must only clear a pending gate belonging to the entry's own milestone",
+    );
+    assert.ok(
+      source.includes("if (checkAutoStartAfterDiscuss(basePath)) return;"),
+      "recovery must re-run the discuss→auto handoff after clearing the stale gate",
+    );
+  });
+
+  test("guided-flow does not treat a live discuss turn as a stale pending entry", () => {
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes("!isAgentTurnInFlight(ctx)"),
+      "stale-entry deletion must be gated on no agent turn being in flight — a dispatched " +
+      "discuss turn can think for over 30s before writing its first artifact, and deleting " +
+      "its entry re-dispatches the workflow (duplicate interview + duplicate completion message)",
+    );
+    assert.ok(
+      source.includes('const milestoneHasDraft = !!resolveMilestoneFile(basePath, entry.milestoneId, "CONTEXT-DRAFT");'),
+      "stale-entry check must treat an existing CONTEXT-DRAFT as proof of an in-progress interview",
+    );
+    assert.ok(
+      source.includes("!milestoneHasDraft"),
+      "stale-entry deletion must require the CONTEXT-DRAFT to be absent",
+    );
+    assert.ok(
+      source.includes("ctx.hasPendingMessages"),
+      "in-flight detection must also cover dispatched-but-not-yet-started queued messages",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -696,3 +696,25 @@ test("ensureCodebaseMapFresh: does not rewrite expired metadata when fingerprint
     cleanup(base);
   }
 });
+
+test("ensureCodebaseMapFresh: detects file changes within the TTL window", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    // Generate initial map with a long TTL so the cache is still active.
+    const initial = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+    assert.equal(initial.status, "generated");
+
+    // Add a new tracked file while the TTL is still active.
+    addFile(base, "src/new.ts");
+
+    // Must detect the change even though the TTL has not expired.
+    const refreshed = ensureCodebaseMapFresh(base, undefined, { ttlMs: 60_000 });
+    assert.equal(refreshed.status, "updated");
+    assert.equal(refreshed.reason, "files-changed");
+    const written = readCodebaseMap(base);
+    assert.ok(written?.includes("`src/new.ts`"));
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-dispatcher-workspace-git.test.ts

@@ -64,3 +64,14 @@ test("getWorkspaceGitBlockMessageForBase allows doctor on product conflicts", as
     cleanup(base);
   }
 });
+
+test("getWorkspaceGitBlockMessageForBase allows forensics on product conflicts", async () => {
+  const base = makeTempRepo("gsd-dispatch-ws-git-forensics-");
+  try {
+    seedProductConflict(base);
+    const blocked = await getWorkspaceGitBlockMessageForBase(base, "forensics");
+    assert.equal(blocked, null);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -10,7 +10,7 @@
  */
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -472,17 +472,55 @@ test("auto-dispatch needs-attention pause message references /gsd verdict", asyn
   }
 });
 
-test("state.ts needs-remediation blocker messages reference /gsd verdict", async () => {
+test("guidance.ts needs-remediation blocker messages reference /gsd verdict", async () => {
   // We don't need to invoke deriveState — just assert the substring is in the
-  // source. The blocker strings are constructed inline and shipped to the user
-  // verbatim, so a static check is sufficient and avoids fragile DB setup.
-  const stateSource = readFileSync(
-    new URL("../state.ts", import.meta.url).pathname,
+  // source. The blocker strings are constructed in the guidance catalog and
+  // shipped to the user verbatim, so a static check is sufficient and avoids
+  // fragile DB setup.
+  const guidanceSource = readFileSync(
+    new URL("../guidance.ts", import.meta.url).pathname,
     "utf-8",
   );
-  const occurrences = stateSource.match(/`\/gsd verdict /g) ?? [];
+  const occurrences = guidanceSource.match(/`\/gsd verdict /g) ?? [];
   assert.ok(
     occurrences.length >= 2,
-    `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
+    `expected at least 2 references to /gsd verdict in guidance.ts blockers, found ${occurrences.length}`,
   );
 });
+
+// ─── WAL checkpoint regression (#563) ───────────────────────────────────
+
+test("handleVerdict pass checkpoints WAL so subsequent processes see the updated verdict (#563)", async () => {
+  // Regression: before the fix, executeValidateMilestone wrote the assessment
+  // only into the WAL file.  The next /gsd auto invocation (a new process)
+  // opened gsd.db directly and saw stale pre-verdict data because the WAL
+  // had not been flushed.  The fix adds checkpointDatabase() after a
+  // successful verdict so the WAL is truncated and gsd.db is self-contained.
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Checkpoint Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    writeValidation(base, "M001", "needs-attention");
+
+    const { ctx } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    // After handleVerdict succeeds, PRAGMA wal_checkpoint(TRUNCATE) must have
+    // run.  The WAL file is truncated to zero bytes — a new process reading
+    // gsd.db directly sees the updated verdict without needing the WAL.
+    const walPath = join(base, ".gsd", "gsd.db-wal");
+    if (existsSync(walPath)) {
+      const { size } = statSync(walPath);
+      assert.equal(
+        size,
+        0,
+        "WAL must be zero bytes after handleVerdict pass — checkpointDatabase() was not called (#563)",
+      );
+    }
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -258,6 +258,48 @@ describe('complete-slice verification gate (#3580)', () => {
     }
   });
 
+  test('allows a browser UAT declared as a bare keyword under ## UAT Type (M006/S01 format drift)', async () => {
+    // Regression: the agent wrote `## UAT Type\nbrowser-executable` (no
+    // `- UAT mode:` bullet). The old parser defaulted that to artifact-driven
+    // and the gate rejected the slice in a loop.
+    const body = [
+      '## UAT Type',
+      'browser-executable',
+      '',
+      '## Smoke Test',
+      '1. Open the page in a browser and perform add/edit/complete/delete once.',
+    ].join('\n');
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: body }),
+      basePath,
+    );
+    if ('error' in result) {
+      assert.doesNotMatch(
+        result.error,
+        /requires browser verification/i,
+        `bare browser-executable declaration must pass the browser gate, got: ${result.error}`,
+      );
+    }
+  });
+
+  test('explains the missing declaration when a browser UAT has no parseable UAT mode', async () => {
+    // When nothing was declared, the error must not claim the agent
+    // "declared artifact-driven" — it must show the expected bullet format.
+    const body = [
+      '## Smoke Test',
+      '1. Open the page in a browser and perform add/edit/complete/delete once.',
+    ].join('\n');
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: body }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to reject an undeclared browser UAT');
+    const error = (result as { error: string }).error;
+    assert.match(error, /no parseable UAT mode declaration/i);
+    assert.match(error, /- UAT mode: browser-executable/);
+    assert.doesNotMatch(error, /but declares "UAT mode: artifact-driven"/);
+  });
+
   test('allows a browser UAT when it is declared mixed (mixed receives browser tools)', async () => {
     const body = BROWSER_UAT_BODY.replace('artifact-driven', 'mixed (artifact-driven + browser)');
     const result = await handleCompleteSlice(

package/src/resources/extensions/gsd/tests/consent-question.test.ts

@@ -0,0 +1,351 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  type AnswerOutcome,
+  classifyQuestion,
+  evaluateAnswer,
+  evaluateAskUserQuestionsRound,
+  failPolicyForKind,
+  formatUnansweredConsentQuestionMessage,
+  isAwaitingUserInput,
+  lastAssistantText,
+  messageHasPendingAskUserQuestionsTool,
+  shouldPauseForQuestion,
+} from "../consent-question.ts";
+
+const GATE_OPTIONS = [
+  { label: "Yes, you got it (Recommended)" },
+  { label: "Needs adjustment" },
+];
+
+const CONSENT_OPTIONS = [
+  { label: "Option A (Recommended)" },
+  { label: "Option B" },
+];
+
+function assistantMessage(text: string): unknown {
+  return { role: "assistant", content: [{ type: "text", text }] };
+}
+
+// ── Classification ──────────────────────────────────────────────────────────
+
+test("classifyQuestion: gate ids, consent defaults, prose kinds", () => {
+  assert.deepEqual(
+    classifyQuestion({ id: "depth_verification_M001_confirm" }),
+    { kind: "gate", gateSubKind: "approval" },
+  );
+  assert.deepEqual(
+    classifyQuestion({ id: "depth_verification" }),
+    { kind: "gate", gateSubKind: "depth-verification" },
+  );
+  assert.deepEqual(
+    classifyQuestion({ id: "destructive_confirm_rm" }),
+    { kind: "gate", gateSubKind: "destructive-confirm" },
+  );
+  // Any other structured question is a real elicitation → consent, fail-closed.
+  assert.equal(classifyQuestion({ id: "m004_shape", options: CONSENT_OPTIONS }).kind, "consent");
+  assert.equal(classifyQuestion({ id: "free_text_q" }).kind, "consent");
+  // Prose classification.
+  assert.equal(classifyQuestion({ text: "Should I proceed with the write?" }).kind, "consent");
+  assert.equal(
+    classifyQuestion({ text: "Want me to research this or skip?", unitType: "research-decision" }).kind,
+    "decision",
+  );
+  assert.equal(classifyQuestion({ text: "Here is the summary of changes." }).kind, "informational");
+});
+
+test("failPolicyForKind: only informational is fail-open", () => {
+  assert.equal(failPolicyForKind("gate"), "closed");
+  assert.equal(failPolicyForKind("consent"), "closed");
+  assert.equal(failPolicyForKind("decision"), "closed");
+  assert.equal(failPolicyForKind("informational"), "open");
+});
+
+// ── Policy table: (kind × answer shape) → outcome ───────────────────────────
+
+type Row = {
+  name: string;
+  question: { id: string; options?: Array<{ label?: string }> };
+  details: Parameters<typeof evaluateAnswer>[0]["details"];
+  expected: AnswerOutcome;
+};
+
+const gateQ = { id: "depth_verification_M001_confirm", options: GATE_OPTIONS };
+const consentQ = { id: "boundary_choice", options: CONSENT_OPTIONS };
+
+const POLICY_TABLE: Row[] = [
+  // gate
+  { name: "gate × confirm selected → verified", question: gateQ, details: { response: { answers: { [gateQ.id]: { selected: "Yes, you got it (Recommended)" } } } }, expected: "verified" },
+  { name: "gate × decline selected → declined", question: gateQ, details: { response: { answers: { [gateQ.id]: { selected: "Needs adjustment" } } } }, expected: "declined" },
+  { name: "gate × empty selected → waiting", question: gateQ, details: { response: { answers: { [gateQ.id]: { selected: "" } } } }, expected: "waiting" },
+  { name: "gate × empty selected array → waiting", question: gateQ, details: { response: { answers: { [gateQ.id]: { selected: [] } } } }, expected: "waiting" },
+  { name: "gate × missing response → waiting", question: gateQ, details: {}, expected: "waiting" },
+  { name: "gate × notes-only → waiting (notes never satisfy a gate)", question: gateQ, details: { response: { answers: { [gateQ.id]: { notes: "looks fine" } } } }, expected: "waiting" },
+  { name: "gate × cancelled → cancelled", question: gateQ, details: { cancelled: true, response: null }, expected: "cancelled" },
+  // consent
+  { name: "consent × valid selected → answered", question: consentQ, details: { response: { answers: { [consentQ.id]: { selected: "Option B" } } } }, expected: "answered" },
+  { name: "consent × empty selected → waiting (#528)", question: consentQ, details: { response: { answers: { [consentQ.id]: { selected: "" } } } }, expected: "waiting" },
+  { name: "consent × missing answer → waiting", question: consentQ, details: { response: { answers: {} } }, expected: "waiting" },
+  { name: "consent × missing response → waiting", question: consentQ, details: {}, expected: "waiting" },
+  { name: "consent × notes-only → answered (a real user utterance)", question: consentQ, details: { response: { answers: { [consentQ.id]: { notes: "neither — keep it simple" } } } }, expected: "answered" },
+  { name: "consent × cancelled → cancelled", question: consentQ, details: { cancelled: true, response: null }, expected: "cancelled" },
+];
+
+for (const row of POLICY_TABLE) {
+  test(`policy table: ${row.name}`, () => {
+    assert.equal(evaluateAnswer({ question: row.question, details: row.details }), row.expected);
+  });
+}
+
+// ── Round evaluation ────────────────────────────────────────────────────────
+
+test("evaluateAskUserQuestionsRound: most blocking outcome wins", () => {
+  const details = {
+    response: {
+      answers: {
+        [consentQ.id]: { selected: "Option A (Recommended)" },
+        second: { selected: "" },
+      },
+    },
+  };
+  assert.equal(
+    evaluateAskUserQuestionsRound([consentQ, { id: "second", options: CONSENT_OPTIONS }], details),
+    "waiting",
+  );
+  assert.equal(evaluateAskUserQuestionsRound([consentQ], { cancelled: true }), "cancelled");
+  assert.equal(
+    evaluateAskUserQuestionsRound([consentQ], {
+      response: { answers: { [consentQ.id]: { selected: "Option A (Recommended)" } } },
+    }),
+    "answered",
+  );
+  // Empty round with no response is a no-op for callers.
+  assert.equal(evaluateAskUserQuestionsRound([], {}), "answered");
+});
+
+// ── Regression: #528 empty selected on a consent question never answers ─────
+
+test("#528: empty selected on a NON-gate question is waiting, not answered", () => {
+  const outcome = evaluateAskUserQuestionsRound(
+    [{ id: "scope_check", options: CONSENT_OPTIONS }],
+    { response: { answers: { scope_check: { selected: "" } } } },
+  );
+  assert.equal(outcome, "waiting");
+  const message = formatUnansweredConsentQuestionMessage([{ id: "scope_check" }]);
+  assert.match(message, /scope_check/);
+  assert.match(message, /not consent/i);
+});
+
+// ── Regression: #682 pause promotion outside the old unit-type allowlist ────
+
+test("#682: consent question in a non-allowlisted unit type pauses", () => {
+  const messages = [assistantMessage("The slice is staged. Ready to proceed with the merge?")];
+  assert.equal(shouldPauseForQuestion("execute-task", messages), true);
+});
+
+test("#682: consent question in interactive mode (no unit type) pauses", () => {
+  const messages = [assistantMessage("Does this capture your intent correctly?")];
+  assert.equal(shouldPauseForQuestion(undefined, messages), true);
+});
+
+test("#682: cancellation marker pauses regardless of unit type", () => {
+  const messages = [assistantMessage("ask_user_questions was cancelled before receiving a response")];
+  assert.equal(shouldPauseForQuestion(undefined, messages), true);
+  assert.equal(shouldPauseForQuestion("execute-task", messages), true);
+});
+
+test("shouldPauseForQuestion: informational prose never pauses", () => {
+  const messages = [assistantMessage("All tests pass. Moving on to the next task.")];
+  assert.equal(shouldPauseForQuestion(undefined, messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
+});
+
+test("shouldPauseForQuestion: plain non-approval question does not pause", () => {
+  // Generic questions (no approval/consent language) stay informational —
+  // matches the historical contract in deep-project-auto-loop tests.
+  const messages = [assistantMessage("Which file did you mean?")];
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
+});
+
+test("shouldPauseForQuestion: explicit waiting-for-approval phrase pauses without a question mark", () => {
+  // The streaming pre-filter (no "?" → bail) must not skip the explicit
+  // wait-phrase boundary, which carries no question mark.
+  const messages = [assistantMessage("I am waiting for your approval before writing the file.")];
+  assert.equal(shouldPauseForQuestion(undefined, messages), true);
+});
+
+// ── Message-text extraction (merged from user-input-boundary tests) ─────────
+
+test("lastAssistantText extracts the latest assistant text block content", () => {
+  assert.equal(
+    lastAssistantText([
+      { role: "assistant", content: "Older message" },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "First line" },
+          { type: "text", text: "Second line" },
+        ],
+      },
+    ]),
+    "First line\nSecond line",
+  );
+  assert.equal(lastAssistantText(null), "");
+});
+
+test("lastAssistantText includes thinking blocks so rate-limit notices are not dropped", () => {
+  // Turn with only a thinking block (no text block) — must not return ""
+  const result = lastAssistantText([
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "You've hit your limit · resets in 2h" },
+      ],
+    },
+  ]);
+  assert.ok(result.includes("You've hit your limit"), `expected rate-limit text, got: ${JSON.stringify(result)}`);
+});
+
+// ── Awaiting-input boundaries (merged from user-input-boundary tests) ───────
+
+test("isAwaitingUserInput does not trigger on thinking-block question marks", () => {
+  // A thinking block with a question mark must NOT pause auto-mode —
+  // it's internal reasoning, not a user-visible prompt.
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "Should I skip research? Let me check the config." },
+      ],
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
+});
+
+test("isAwaitingUserInput does not trigger on thinking-block approval phrases", () => {
+  // A thinking block with approval phrases must NOT pause auto-mode.
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "The user confirmed and approved the plan. Should I proceed?" },
+      ],
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-requirements", messages), false);
+});
+
+test("isAwaitingUserInput treats plain-text next steps menus as waiting for the user (#454)", () => {
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        "Next steps:",
+        "1. Walk through the runtime placement check above.",
+        "2. Build a release once you're satisfied.",
+        "3. Other.",
+      ].join("\n"),
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), true);
+});
+
+test("isAwaitingUserInput still triggers on text-block question marks when thinking is also present", () => {
+  // When thinking + text are both present and the text asks a question, it should still pause.
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "Internal reasoning without questions." },
+        { type: "text", text: "Does this look correct?" },
+      ],
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), true);
+});
+
+// ── In-flight ask_user_questions detection (merged from user-input-boundary) ─
+
+test("messageHasPendingAskUserQuestionsTool detects in-flight structured question tools", () => {
+  // state: "running" with no externalResult → still in-flight
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "text", text: "Which direction?" },
+        { type: "toolCall", name: "mcp__gsd-workflow__ask_user_questions", state: "running" },
+      ],
+    }),
+    true,
+  );
+
+  // no state, no externalResult — streaming block that hasn't completed yet
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "toolCall", name: "ask_user_questions" },
+      ],
+    }),
+    true,
+  );
+
+  // state: "completed" — legacy state-based completion
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "toolCall", name: "ask_user_questions", state: "completed" },
+      ],
+    }),
+    false,
+  );
+
+  // externalResult present — Claude Code signals completion via externalResult, not state
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "toolCall", name: "ask_user_questions", externalResult: { content: [], isError: false } },
+      ],
+    }),
+    false,
+  );
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        {
+          type: "toolCall",
+          name: "ask_user_questions",
+          externalResult: { content: [{ type: "text", text: "answer" }], isError: false },
+        },
+      ],
+    }),
+    false,
+  );
+
+  // serverToolUse shape (claude-code-cli MCP path) — no externalResult → in-flight
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "serverToolUse", name: "mcp__gsd-workflow__ask_user_questions" },
+      ],
+    }),
+    true,
+  );
+  // serverToolUse shape — externalResult present → completed
+  assert.equal(
+    messageHasPendingAskUserQuestionsTool({
+      role: "assistant",
+      content: [
+        { type: "serverToolUse", name: "ask_user_questions", externalResult: { content: [], isError: false } },
+      ],
+    }),
+    false,
+  );
+});