@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -26,6 +26,7 @@ import {
   renderPreferencesForSystemPrompt,
   _resetParseWarningFlag,
 } from "../preferences.ts";
+import { collectPreferenceDiagnostics, formatPreferenceDiagnostic } from "../preferences-diagnostics.ts";
 import { formatConfiguredModel, toPersistedModelId } from "../commands-prefs-wizard.ts";
 import { _resetLogs, peekLogs } from "../workflow-logger.ts";
 import type { GSDPreferences, GSDModelConfigV2, GSDPhaseModelConfig } from "../preferences.ts";
@@ -819,6 +820,188 @@ bad: [
   _resetLogs();
 });
 
+test("malformed global preferences load with a structured parse diagnostic", (t) => {
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-diagnostic-home-"));
+  t.after(() => {
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    _resetParseWarningFlag();
+    _resetLogs();
+  });
+
+  process.env.GSD_HOME = tempGsdHome;
+  _resetParseWarningFlag();
+  _resetLogs();
+  writeFileSync(
+    join(tempGsdHome, "PREFERENCES.md"),
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const loaded = loadGlobalGSDPreferences();
+  assert.notEqual(loaded, null);
+  assert.deepEqual(loaded!.preferences, {});
+  const diagnostic = loaded!.diagnostics?.[0];
+  assert.equal(diagnostic?.kind, "parse");
+  assert.equal(diagnostic?.severity, "error");
+  assert.equal(diagnostic?.line, 5);
+  assert.equal(diagnostic?.column, 5);
+  assert.equal(diagnostic?.ignored, true);
+  assert.match(diagnostic?.message ?? "", /Implicit keys need/);
+
+  const formatted = formatPreferenceDiagnostic(diagnostic!);
+  assert.match(formatted, /GSD global preferences error/);
+  assert.match(formatted, /line 5, column 5/);
+  assert.match(formatted, /Preferences from this file were ignored/);
+});
+
+test("project preference validation errors load with structured diagnostics", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-validation-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-validation-home-"));
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 3\n---\n",
+    "utf-8",
+  );
+
+  const loaded = loadProjectGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.preferences.version, undefined);
+  const diagnostic = loaded!.diagnostics?.find((item) => item.kind === "validation");
+  assert.equal(diagnostic?.scope, "project");
+  assert.equal(diagnostic?.severity, "error");
+  assert.equal(diagnostic?.sanitized, true);
+  assert.match(diagnostic?.message ?? "", /unsupported version 3/);
+
+  const collected = collectPreferenceDiagnostics(tempProject);
+  assert.ok(
+    collected.some((item) => item.path === loaded!.path && item.message.includes("unsupported version 3")),
+    "collector should include project validation diagnostics",
+  );
+});
+
+test("malformed project preferences do not override effective global wrapper", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-home-"));
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    _resetParseWarningFlag();
+    _resetLogs();
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  _resetParseWarningFlag();
+  _resetLogs();
+
+  const globalPath = getGlobalGSDPreferencesPath();
+  const projectPath = getProjectGSDPreferencesPath(tempProject);
+  writeFileSync(globalPath, "---\nlanguage: Spanish\n---\n", "utf-8");
+  writeFileSync(
+    projectPath,
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const projectPrefs = loadProjectGSDPreferences(tempProject);
+  assert.equal(projectPrefs?.ignored, true);
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.path, globalPath);
+  assert.equal(loaded!.scope, "global");
+  assert.equal(loaded!.preferences.language, "Spanish");
+  assert.ok(
+    loaded!.diagnostics?.some((item) => item.path === projectPath && item.kind === "parse"),
+    "effective global preferences should carry malformed project diagnostics",
+  );
+});
+
+test("malformed global preferences: loadEffectiveGSDPreferences returns null without project file", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-malformed-global-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-malformed-home-"));
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    _resetParseWarningFlag();
+    _resetLogs();
+  });
+
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  _resetParseWarningFlag();
+  _resetLogs();
+
+  const globalPath = getGlobalGSDPreferencesPath();
+  writeFileSync(
+    globalPath,
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const globalPrefs = loadGlobalGSDPreferences();
+  assert.equal(globalPrefs?.ignored, true, "malformed global should be marked ignored");
+
+  // Symmetric with malformed project + no global: effective result should be null,
+  // not an effective object with ignored:true leaking through.
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.equal(loaded, null, "effective preferences should be null when only global file is malformed");
+});
+
 // ── Experimental preferences ─────────────────────────────────────────────────
 
 test("experimental.rtk: true is accepted and stored", () => {

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   RUN_UAT_BROWSER_TOOL_NAMES,
+  resolveToolPresentationPlan,
   buildRunUatResultPresentation,
   buildRunUatPresentationForType,
   RUN_UAT_READ_ONLY_TOOL_NAMES,
@@ -179,6 +180,33 @@ test("browser-executable UAT presentation uses direct browser tools", () => {
   assert.ok(!presentation.presentedTools.some((toolName) => toolName.startsWith("mcp__gsd-browser__")));
 });
 
+test("run-uat presentation plans carry typed tool-surface snapshots", () => {
+  const plan = resolveToolPresentationPlan({
+    phase: "run-uat",
+    surface: "mcp",
+    workflowMcpServerName: "gsd-workflow",
+    availableToolNames: [
+      "gsd_uat_exec",
+      "gsd_uat_result_save",
+      "read",
+    ],
+    includeBrowserTools: [],
+  });
+
+  assert.equal(plan.toolSurface.source, "presentation-plan");
+  assert.equal(plan.toolSurface.phase, "run-uat");
+  assert.deepEqual(plan.toolSurface.scopedToolNames, [
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "read",
+  ]);
+  assert.deepEqual(plan.toolSurface.presentedToolNames, [
+    "mcp__gsd-workflow__gsd_uat_exec",
+    "mcp__gsd-workflow__gsd_uat_result_save",
+    "read",
+  ]);
+});
+
 test("live-runtime and mixed UAT presentations also surface browser tools", () => {
   // Regression (M001/S03): the run-uat prompt tells live-runtime and mixed to
   // drive a browser, so the runner must actually receive the browser tools and
@@ -517,6 +545,24 @@ test("plan-slice prompt clarifies gsd_plan_slice handles task persistence", () =
   assert.match(prompt, /gsd_plan_slice` handles task persistence/i);
 });
 
+test("plan-slice prompt references web app UAT guidance when planning browser work", () => {
+  const prompt = readPrompt("plan-slice");
+  assert.match(prompt, /Web App UAT guidance/i);
+  assert.match(prompt, /Playwright smoke scaffolding/i);
+});
+
+test("complete-slice prompt references web app UAT mode rules", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(prompt, /Web App UAT guidance/i);
+  assert.match(prompt, /browser-executable|runtime-executable/i);
+});
+
+test("plan-milestone prompt seeds web verification strategy", () => {
+  const prompt = readPrompt("plan-milestone");
+  assert.match(prompt, /Web apps/i);
+  assert.match(prompt, /Playwright|browser_\*/i);
+});
+
 test("replan-slice prompt uses gsd_replan_slice as canonical DB-backed tool", () => {
   const prompt = readPrompt("replan-slice");
   assert.match(prompt, /gsd_replan_slice/);
@@ -564,6 +610,33 @@ test("validate-milestone prompt dispatches parallel reviewers", () => {
   assert.match(prompt, /assessment evidence/i);
 });
 
+// ─── ADR-029: forward preloaded evidence to validate reviewers ────────
+test("validate-milestone forwards preloaded evidence to reviewers and keeps full reads on-demand", () => {
+  const prompt = readPrompt("validate-milestone");
+  // Orchestrator is told to embed the preloaded evidence into reviewer tasks.
+  assert.match(prompt, /[Ee]mbed the relevant preloaded evidence/);
+  // Each reviewer is told to use the preloaded evidence, not re-read from disk.
+  const useCount = (prompt.match(/do not re-read them from disk/g) ?? []).length;
+  assert.ok(useCount >= 3, `expected all three reviewers to use preloaded evidence, found ${useCount}`);
+  // Full reads are explicitly the on-demand exception, not the routine path.
+  assert.match(prompt, /only if (its|the) preloaded (excerpt|evidence) is missing, truncated, or inconsistent/i);
+});
+
+// ─── ADR-029: research-milestone grounds instead of surveying ─────────
+test("research-milestone prompt grounds in preloaded context instead of open-ended survey", () => {
+  const prompt = readPrompt("research-milestone");
+  // Grounded-research invariant present.
+  assert.match(prompt, /do not re-survey/i);
+  assert.match(prompt, /Codebase Snapshot and Project Classification/);
+  // The old open-ended survey license is gone (no "use `scout` to build a broad map").
+  assert.doesNotMatch(prompt, /use `scout` to build a broad map/);
+  // resolve_library/docs lookups remain permitted (bounded, external).
+  assert.match(prompt, /resolve_library/);
+  // Incremental save enables resume after interruption.
+  assert.match(prompt, /Save \*\*incrementally\*\*/);
+  assert.match(prompt, /Resume — Prior Partial Research/);
+});
+
 // ─── Prompt migration: replan-slice → gsd_replan_slice ────────────────
 
 test("replan-slice prompt names gsd_replan_slice as the tool to use", () => {
@@ -700,8 +773,8 @@ test("guided-discuss prompts require 3-or-4 options plus Other-let-me-discuss in
     );
     assert.match(
       prompt,
-      /grounded in (the |your |)investigation/i,
-      `${name} must require options grounded in prior investigation`,
+      /grounded in (the |your |)(investigation|preloaded context)/i,
+      `${name} must require options grounded in the preloaded context / prior investigation`,
     );
   }
 });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -740,6 +740,15 @@ test("MAX_TRANSIENT_AUTO_RESUMES is at least 8 for sustained overload resilience
   );
 });
 
+// ── OpenAI-completions mid-stream cut (#577) ─────────────────────────────────
+
+test("classifyError: 'Stream ended without finish_reason' is transient network (#577)", () => {
+  const result = classifyError("Stream ended without finish_reason");
+  assert.ok(isTransient(result), "Stream ended without finish_reason must be transient");
+  assert.equal(result.kind, "network");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
 // ── Stream idle timeout / partial response (#4558) ──────────────────────────
 
 test("classifyError: 'Stream idle timeout - partial response received' is transient network", () => {

package/src/resources/extensions/gsd/tests/provider-payload-policy.test.ts

@@ -0,0 +1,165 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { ContextManagementConfig } from "../preferences-types.js";
+import type { ProviderPayloadPolicyDeps } from "../provider-payload-policy.js";
+
+import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
+
+function createDeps(
+  overrides: Partial<ProviderPayloadPolicyDeps> & {
+    context?: ContextManagementConfig | undefined;
+    autoActive?: boolean;
+    sourceContextBlock?: string | null;
+  } = {},
+): ProviderPayloadPolicyDeps {
+  return {
+    isAutoActive: () => overrides.autoActive ?? false,
+    loadContextManagementConfig: () => overrides.context,
+    renderSourceContextBlock: () => overrides.sourceContextBlock ?? null,
+    getEffectiveServiceTier: () => undefined,
+    supportsServiceTier: () => false,
+    ...overrides,
+  };
+}
+
+function textFromMessage(message: { content?: unknown }): string {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const text = content.find((block): block is { text: string } => {
+    return Boolean(block && typeof block === "object" && "text" in block && typeof block.text === "string");
+  });
+  return text?.text ?? "";
+}
+
+test("provider payload policy truncates tool results outside auto-mode without masking", () => {
+  const messageText = "m".repeat(50);
+  const responsesOutput = "r".repeat(50);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      { role: "toolResult", content: [{ type: "text", text: messageText }] },
+    ],
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "keep me" }] },
+      { type: "function_call_output", call_id: "call_test", output: responsesOutput },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({ context: { observation_mask_turns: 1, tool_result_max_chars: 10 } }),
+  });
+
+  const truncatedMessage = textFromMessage(payload.messages[1]);
+  const truncatedResponsesOutput = String(payload.input[1]?.output ?? "");
+  assert.match(truncatedMessage, /\[truncated\]/);
+  assert.match(truncatedResponsesOutput, /\[truncated\]/);
+  assert.doesNotMatch(truncatedMessage, /result masked/);
+  assert.doesNotMatch(truncatedResponsesOutput, /result masked/);
+});
+
+test("provider payload policy appends source context after masking and truncation", () => {
+  const sourceContextBlock = "## Source Context Block\n\n" + "full source text ".repeat(20);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "old turn" }] },
+      { role: "toolResult", content: [{ type: "text", text: "old result ".repeat(20) }] },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      { role: "user", content: [{ type: "text", text: "new turn" }] },
+      { role: "toolResult", content: [{ type: "text", text: "new result ".repeat(20) }] },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      context: { observation_mask_turns: 1, tool_result_max_chars: 80 },
+      sourceContextBlock,
+    }),
+  });
+
+  const oldResult = textFromMessage(payload.messages[1]);
+  const newResult = textFromMessage(payload.messages[4]);
+  const appendedContext = textFromMessage(payload.messages[payload.messages.length - 1]);
+
+  assert.match(oldResult, /result masked/);
+  assert.match(newResult, /\[truncated\]/);
+  assert.equal(appendedContext, sourceContextBlock);
+  assert.doesNotMatch(appendedContext, /\[truncated\]/);
+});
+
+test("provider payload policy applies ordering to Responses input payloads", () => {
+  const sourceContextBlock = "## Source Context Block\n\n" + "responses source text ".repeat(20);
+  const payload = {
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "old turn" }] },
+      { type: "function_call_output", call_id: "call_old", output: "old result ".repeat(20) },
+      { type: "message", role: "assistant", content: [{ type: "output_text", text: "ok" }] },
+      { role: "user", content: [{ type: "input_text", text: "new turn" }] },
+      { type: "function_call_output", call_id: "call_new", output: "new result ".repeat(20) },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      context: { observation_mask_turns: 1, tool_result_max_chars: 80 },
+      sourceContextBlock,
+    }),
+  });
+
+  assert.match(String(payload.input[1]?.output ?? ""), /result masked/);
+  assert.match(String(payload.input[4]?.output ?? ""), /\[truncated\]/);
+  assert.equal(textFromMessage(payload.input[payload.input.length - 1]), sourceContextBlock);
+});
+
+test("provider payload policy replaces existing source context blocks", () => {
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      { role: "user", content: [{ type: "text", text: "## Source Context Block\n\nstale" }] },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      sourceContextBlock: "## Source Context Block\n\nfresh",
+    }),
+  });
+
+  const sourceMessages = payload.messages.filter((message) => {
+    return textFromMessage(message).startsWith("## Source Context Block");
+  });
+  assert.equal(sourceMessages.length, 1);
+  assert.equal(textFromMessage(sourceMessages[0]), "## Source Context Block\n\nfresh");
+});
+
+test("provider payload policy sets service tier only for supported models", () => {
+  const unsupported = {};
+  applyProviderPayloadPolicy({
+    payload: unsupported,
+    modelId: "claude-opus-4-6",
+    deps: createDeps({
+      getEffectiveServiceTier: () => "priority",
+      supportsServiceTier: (modelId) => modelId === "gpt-5.4",
+    }),
+  });
+  assert.equal("service_tier" in unsupported, false);
+
+  const supported: Record<string, unknown> = {};
+  applyProviderPayloadPolicy({
+    payload: supported,
+    modelId: "gpt-5.4",
+    deps: createDeps({
+      getEffectiveServiceTier: () => "priority",
+      supportsServiceTier: (modelId) => modelId === "gpt-5.4",
+    }),
+  });
+  assert.equal(supported.service_tier, "priority");
+});

package/src/resources/extensions/gsd/tests/pull-request-process.test.ts

@@ -0,0 +1,47 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for process-level pull request policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildPullRequestEvidence,
+  createDraftPullRequestFromEvidence,
+} from "../pull-request-process.js";
+
+test("buildPullRequestEvidence omits AI credit by policy", () => {
+  const evidence = buildPullRequestEvidence({
+    milestoneId: "M001",
+    milestoneTitle: "Git process",
+    aiAssisted: true,
+  });
+
+  assert.equal(evidence.title, "feat: Git process");
+  assert.ok(!evidence.body.includes("## AI Assistance Disclosure"));
+  assert.ok(!evidence.body.includes("AI assistance"));
+});
+
+test("createDraftPullRequestFromEvidence forwards exact evidence and branch options", () => {
+  const calls: unknown[][] = [];
+  const url = createDraftPullRequestFromEvidence(
+    "/repo",
+    "M001",
+    { title: "feat: Git process", body: "body" },
+    { head: "milestone/M001", base: "main" },
+    {
+      createDraftPR: (basePath, milestoneId, title, body, opts) => {
+        calls.push([basePath, milestoneId, title, body, opts]);
+        return "https://github.example/pr/1";
+      },
+    },
+  );
+
+  assert.equal(url, "https://github.example/pr/1");
+  assert.deepEqual(calls, [[
+    "/repo",
+    "M001",
+    "feat: Git process",
+    "body",
+    { head: "milestone/M001", base: "main" },
+  ]]);
+});

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -18,6 +18,11 @@ import {
 } from "../bootstrap/write-gate.ts";
 import { classifyCommand } from "../safety/destructive-guard.ts";
 import { toRoundResultResponse } from "../../remote-questions/manager.ts";
+import {
+  markInteractiveElicitationStart,
+  markInteractiveElicitationEnd,
+  clearInFlightTools,
+} from "../auto-tool-tracking.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -708,3 +713,92 @@ test("register-hooks gates MCP ask_user_questions cancellation before requiremen
   assert.equal(requirementBlock?.block, true, "requirement save must be blocked while gate is pending");
   assert.match(requirementBlock?.reason ?? "", /has not been confirmed/);
 });
+
+// ─── Foreground self-cancel regression (#cc-elicitation-self-cancel) ───
+// Product-visible symptom: under claude-code-cli + gsd-MCP, ask_user_questions
+// is routed as an SDK elicitation (the human boundary). The message_update hook
+// would arm the approval-gate pause and emit the "waiting for your approval -
+// pausing" notice, tearing down that elicitation and looping a re-ask. The fix
+// makes message_update bail while an interactive elicitation is in flight, while
+// still pausing for prose-only approvals (native-TUI provider, where the marker
+// is always false). This drives the real registered hook end-to-end.
+test("register-hooks message_update does NOT pause while an interactive elicitation is the human boundary, but still pauses otherwise", async (t) => {
+  const dir = makeTempDir("elicitation-pause-guard");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+  clearPendingAutoStart(dir);
+  clearInFlightTools();
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+      clearPendingAutoStart(dir);
+      clearInFlightTools();
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  const notices: Array<{ text: string; level: string }> = [];
+  const ctx = {
+    cwd: dir,
+    ui: { notify: (text: string, level: string) => notices.push({ text, level }) },
+  } as any;
+
+  registerHooks(pi, []);
+
+  // A discuss-milestone is the active unit, so the approval text would normally
+  // arm the pause/notice path.
+  setPendingAutoStart(dir, {
+    basePath: dir,
+    milestoneId: "M001",
+    ctx,
+    pi: { sendMessage: () => undefined } as any,
+  });
+
+  // The model's plain-text approval question — identical in both phases.
+  const approvalMessage = {
+    role: "assistant",
+    content: [
+      { type: "text", text: "Here is the milestone plan.\n\nDid I capture the project correctly?" },
+    ],
+  };
+
+  const fireMessageUpdate = async () => {
+    for (const handler of handlers.get("message_update") ?? []) {
+      await handler({ message: approvalMessage }, ctx);
+    }
+  };
+
+  // Phase 1 — FIX: an interactive elicitation is in flight (claude-code-cli
+  // foreground). The pause/notice MUST be suppressed.
+  markInteractiveElicitationStart();
+  await fireMessageUpdate();
+  assert.equal(
+    notices.some((n) => /waiting for your approval - pausing/.test(n.text)),
+    false,
+    "must NOT emit the approval-pause notice while the elicitation is the human boundary",
+  );
+  markInteractiveElicitationEnd();
+
+  // Phase 2 — control: no elicitation in flight (native-TUI provider or a
+  // prose-only approval). The same message MUST still pause.
+  notices.length = 0;
+  await fireMessageUpdate();
+  assert.equal(
+    notices.some((n) => /discuss-milestone M001 is waiting for your approval - pausing/.test(n.text)),
+    true,
+    "prose-only approval with no elicitation in flight must still arm the pause notice",
+  );
+});