@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.6ccd27b3

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,
+  );
+});

package/src/resources/extensions/gsd/tests/custom-verify-retry-store.test.ts

@@ -17,11 +17,13 @@ function makeSession(activeRunDir: string): {
   activeRunDir: string;
   basePath: string;
   verificationRetryCount: Map<string, number>;
+  exhaustedVerificationUnits: Set<string>;
 } {
   return {
     activeRunDir,
     basePath: activeRunDir,
     verificationRetryCount: new Map<string, number>(),
+    exhaustedVerificationUnits: new Set<string>(),
   };
 }
 
@@ -137,3 +139,68 @@ test("saveCustomVerifyRetryCounts deletes empty retry files and ignores missing
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("saveCustomVerifyRetryCounts persists exhaustedVerificationUnits and hydrateCustomVerifyRetryCounts restores them", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    session.exhaustedVerificationUnits.add("execute-task:M001/S001/T001");
+    session.exhaustedVerificationUnits.add("execute-task:M001/S001/T002");
+
+    saveCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    const session2 = makeSession(dir);
+    hydrateCustomVerifyRetryCounts(session2, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    assert.deepEqual(
+      [...session2.exhaustedVerificationUnits].sort(),
+      ["execute-task:M001/S001/T001", "execute-task:M001/S001/T002"],
+    );
+    assert.equal(session2.verificationRetryCount.size, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("saveCustomVerifyRetryCounts keeps file when only exhaustedVerificationUnits is non-empty", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    session.exhaustedVerificationUnits.add("execute-task:M001/S001/T001");
+
+    saveCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    const saved = JSON.parse(readFileSync(customVerifyRetryStatePath(session), "utf-8"));
+    assert.deepEqual(saved.exhausted, ["execute-task:M001/S001/T001"]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("hydrateCustomVerifyRetryCounts skips hydration when exhaustedVerificationUnits is already populated", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    session.exhaustedVerificationUnits.add("pre-existing:key");
+    mkdirSync(join(dir, "runtime"));
+    writeFileSync(customVerifyRetryStatePath(session), JSON.stringify({
+      counts: { "execute-task/M001/S001/T001": 2 },
+      exhausted: ["execute-task:M001/S001/T002"],
+    }));
+
+    hydrateCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    assert.deepEqual([...session.exhaustedVerificationUnits], ["pre-existing:key"]);
+    assert.equal(session.verificationRetryCount.size, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -920,9 +920,9 @@ describe('db-writer', () => {
       decision,
     });
 
-    test('detects deferral in scope with M###/S## pattern in choice', () => {
+    test('detects deferral in scope when the scope names the slice', () => {
       const result = extractDeferredSliceRef(
-        fields('deferral of low-priority work', 'Move M001/S03 to backlog', ''),
+        fields('deferral of slice M001/S03', 'Move low-priority work to backlog', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M001', sliceId: 'S03' });
     });
@@ -950,14 +950,14 @@ describe('db-writer', () => {
 
     test('recognises "deferring" variant', () => {
       const result = extractDeferredSliceRef(
-        fields('deferring this slice', 'M005/S02 can wait', ''),
+        fields('slice prioritization', 'deferring M005/S02 until later', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M005', sliceId: 'S02' });
     });
 
     test('recognises "defers" variant', () => {
       const result = extractDeferredSliceRef(
-        fields('team defers slice', 'M100/S10 not urgent', ''),
+        fields('slice prioritization', 'team defers slice M100/S10', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M100', sliceId: 'S10' });
     });
@@ -969,6 +969,17 @@ describe('db-writer', () => {
       assert.deepStrictEqual(result, { milestoneId: 'M003', sliceId: 'S01' });
     });
 
+    test('does not treat a planning scope reference as a deferred slice', () => {
+      const result = extractDeferredSliceRef(
+        fields(
+          'planning',
+          'Plan S01 as the happy-path money loop only; Defer full duplicate/replay idempotency + polling reconciliation backstop (R006).',
+          'M003/S01 scope boundary for the BTC money loop (which requirements land in the first slice vs deferred follow-on slices).',
+        ),
+      );
+      assert.strictEqual(result, null);
+    });
+
     test('returns null when no deferral keyword is present', () => {
       const result = extractDeferredSliceRef(
         fields('approved work', 'M001/S01 is ready', 'proceed with M001/S01'),

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -6,7 +6,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
-import { runDispatch, runPreDispatch } from "../auto/phases.ts";
+import { runDispatch } from "../auto/dispatch.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";
@@ -15,7 +16,7 @@ import { resolveDispatch, setResearchProjectPromptBuilderForTest } from "../auto
 import { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { finalizeProjectResearchTimeout } from "../project-research-policy.ts";
 import { resetRegistry } from "../rule-registry.ts";
-import { approvalGateIdForUnit, isAwaitingUserInput, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.ts";
+import { approvalGateIdForUnit, isAwaitingUserInput, isExplicitApprovalResponse, shouldPauseForQuestion } from "../consent-question.ts";
 import {
   clearPendingAutoStart,
   checkDeepProjectSetupAfterTurn,
@@ -1402,7 +1403,7 @@ test("deep project setup: user-quoted remote question failure does not pause aut
   ];
 
   assert.equal(isAwaitingUserInput(messages), false);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: plain-text approval wait is treated as waiting for user input", () => {
@@ -1426,7 +1427,7 @@ test("deep project setup: opening interview question does not trigger approval a
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: grounding interview question with requirements context does not trigger approval abort", () => {
@@ -1441,7 +1442,7 @@ test("deep project setup: grounding interview question with requirements context
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: persistence and anti-goals interview prompt does not trigger approval abort", () => {
@@ -1460,7 +1461,7 @@ test("deep project setup: persistence and anti-goals interview prompt does not t
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: discovery questions before writing PROJECT do not trigger approval abort", () => {
@@ -1479,7 +1480,7 @@ test("deep project setup: discovery questions before writing PROJECT do not trig
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: discovery question mentioning write intent does not trigger approval abort", () => {
@@ -1491,7 +1492,7 @@ test("deep project setup: discovery question mentioning write intent does not tr
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: scope discovery question mentioning add does not trigger approval abort", () => {
@@ -1503,7 +1504,7 @@ test("deep project setup: scope discovery question mentioning add does not trigg
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-project", messages), false);
+  assert.equal(shouldPauseForQuestion("discuss-project", messages), false);
 });
 
 test("deep project setup: requirements preview question from screenshot is treated as waiting", () => {
@@ -1523,12 +1524,12 @@ test("deep project setup: requirements preview question from screenshot is treat
   ];
 
   assert.equal(isAwaitingUserInput(messages), true);
-  assert.equal(shouldPauseForUserApprovalQuestion("discuss-requirements", messages), true);
+  assert.equal(shouldPauseForQuestion("discuss-requirements", messages), true);
 });
 
 test("deep project setup: research decision question triggers approval boundary pause", () => {
   assert.equal(
-    shouldPauseForUserApprovalQuestion("research-decision", [
+    shouldPauseForQuestion("research-decision", [
       {
         role: "assistant",
         content: "Run domain research now? (y/n)",

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -569,6 +569,42 @@ describe('derive-state-helpers', () => {
     }
   });
 
+  // ─── Batch slice query: multi-milestone slices loaded in one query ─────
+  test('buildRegistryAndFindActive: batched slice query preserves ordering across milestones', async () => {
+    const base = createFixtureBase();
+    try {
+      // M001 is complete so the loop advances past it.
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+      // M002 is a queued shell milestone with no context and no slices — should be deferred.
+      mkdirSync(join(base, '.gsd', 'milestones', 'M002'), { recursive: true });
+      // M003 is the real active milestone with slices in non-trivial sequence order.
+      writeFile(base, 'milestones/M003/M003-CONTEXT.md', '# M003: Real\n\nReal milestone.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Complete', status: 'complete' });
+      insertMilestone({ id: 'M002', title: 'Shell', status: 'queued' });
+      insertMilestone({ id: 'M003', title: 'Real', status: 'active' });
+      // Slices intentionally inserted with out-of-order sequences to prove ordering.
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'M1 Second', status: 'complete', risk: 'low', depends: [], sequence: 2 });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'M1 First', status: 'complete', risk: 'low', depends: [], sequence: 1 });
+      insertSlice({ id: 'S03', milestoneId: 'M003', title: 'M3 Second', status: 'active', risk: 'low', depends: [], sequence: 5 });
+      insertSlice({ id: 'S04', milestoneId: 'M003', title: 'M3 First', status: 'active', risk: 'low', depends: [], sequence: 3 });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assert.equal(state.activeMilestone?.id, 'M003', 'batched: M003 is active after complete M001 and shell M002');
+      assert.equal(state.activeSlice?.id, 'S04', 'batched: first slice by sequence is active');
+      assert.equal(state.registry.find(e => e.id === 'M001')?.status, 'complete', 'batched: M001 complete');
+      assert.equal(state.registry.find(e => e.id === 'M002')?.status, 'pending', 'batched: shell M002 deferred to pending');
+      assert.equal(state.registry.find(e => e.id === 'M003')?.status, 'active', 'batched: M003 active');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   // ─── Deferred queued shell: shell milestone deferred, real one promoted ──
   test('buildRegistryAndFindActive: queued shell deferred, later real milestone becomes active (#3470)', async () => {
     const base = createFixtureBase();