@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

package/src/resources/extensions/gsd/tests/phase-anchor.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -9,11 +9,11 @@ import type { PhaseAnchor } from "../phase-anchor.js";
 
 function makeTempBase(): string {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-anchor-test-"));
-  mkdirSync(join(tmp, ".gsd", "milestones", "M001", "anchors"), { recursive: true });
+  mkdirSync(join(tmp, ".gsd"), { recursive: true });
   return tmp;
 }
 
-test("writePhaseAnchor creates anchor file in correct location", () => {
+test("writePhaseAnchor creates anchor file under runtime state", () => {
   const base = makeTempBase();
   try {
     const anchor: PhaseAnchor = {
@@ -26,7 +26,35 @@ test("writePhaseAnchor creates anchor file in correct location", () => {
       nextSteps: ["Plan the implementation slices"],
     };
     writePhaseAnchor(base, "M001", anchor);
-    assert.ok(existsSync(join(base, ".gsd", "milestones", "M001", "anchors", "discuss.json")));
+    assert.ok(existsSync(join(base, ".gsd", "runtime", "anchors", "M001", "discuss.json")));
+    assert.equal(existsSync(join(base, ".gsd", "milestones", "M001", "anchors", "discuss.json")), false);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("readPhaseAnchor falls back to legacy anchor location", () => {
+  const base = makeTempBase();
+  try {
+    const legacyDir = join(base, ".gsd", "milestones", "M001", "anchors");
+    mkdirSync(legacyDir, { recursive: true });
+    writeFileSync(
+      join(legacyDir, "research-slice.json"),
+      JSON.stringify({
+        phase: "research-slice",
+        milestoneId: "M001",
+        generatedAt: "2026-07-07T00:00:00.000Z",
+        intent: "Keep reading old anchors during upgrade.",
+        decisions: [],
+        blockers: [],
+        nextSteps: [],
+      }),
+      "utf-8",
+    );
+
+    const read = readPhaseAnchor(base, "M001", "research-slice");
+    assert.ok(read);
+    assert.equal(read.intent, "Keep reading old anchors during upgrade.");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -6,7 +6,7 @@ import { tmpdir } from 'node:os';
 
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getTask, getSliceTasks, getGateResults } from '../gsd-db.ts';
 import { handlePlanTask } from '../tools/plan-task.ts';
-import { parseTaskPlanFile } from '../files.ts';
+import { parsePlan } from '../parsers-legacy.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-plan-task-'));
@@ -60,7 +60,7 @@ function validParams() {
   };
 }
 
-test('handlePlanTask writes planning state and renders task plan', async () => {
+test('handlePlanTask writes planning state and renders the flat-phase slice plan', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
 
@@ -75,11 +75,13 @@ test('handlePlanTask writes planning state and renders task plan', async () => {
     assert.equal(task?.description, 'Implement the DB-backed task planning handler.');
     assert.equal(task?.estimate, '30m');
 
-    const taskPlanPath = join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md');
-    assert.ok(existsSync(taskPlanPath), 'task plan should be rendered to disk');
-    const taskPlan = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
-    assert.equal(taskPlan.frontmatter.estimated_files, 1);
-    assert.deepEqual(taskPlan.frontmatter.skills_used, []);
+    const slicePlanPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    assert.equal(result.taskPlanPath, slicePlanPath);
+    assert.ok(existsSync(slicePlanPath), 'slice plan should be rendered to disk');
+    assert.equal(existsSync(join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md')), false);
+    const slicePlan = parsePlan(readFileSync(slicePlanPath, 'utf-8'));
+    assert.equal(slicePlan.tasks[0]?.id, 'T02');
+    assert.equal(slicePlan.tasks[0]?.files?.[0], 'src/resources/extensions/gsd/tools/plan-task.ts');
   } finally {
     cleanup(base);
   }
@@ -215,17 +217,17 @@ test('handlePlanTask rejects missing parent slice', async () => {
   }
 });
 
-test('handlePlanTask surfaces render failures without changing parse-visible task plan state', async () => {
+test('handlePlanTask surfaces render failures without changing parse-visible slice plan state', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
 
   try {
     seedParent();
     insertTask({ id: 'T02', sliceId: 'S02', milestoneId: 'M001', title: 'Cached task', status: 'pending' });
-    const taskPlanPath = join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md');
-    writeFileSync(taskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T02: Cached task\n', 'utf-8');
-    rmSync(taskPlanPath, { force: true });
-    mkdirSync(taskPlanPath, { recursive: true });
+    const slicePlanPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    writeFileSync(slicePlanPath, '# S02: Cached slice\n\n<tasks>\n- [ ] **T02**: Cached task\n</tasks>\n', 'utf-8');
+    rmSync(slicePlanPath, { force: true });
+    mkdirSync(slicePlanPath, { recursive: true });
 
     const result = await handlePlanTask(validParams(), base);
     assert.ok('error' in result);
@@ -243,15 +245,16 @@ test('handlePlanTask keeps the sketch flag set when the flat-phase slice plan sy
     insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
     insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
 
-    // The per-task render writes T02-PLAN.md and succeeds, but the flat-phase
-    // slice re-render (the canonical PLAN.md that embeds task checkboxes) targets
-    // phases/01-test/01-02-PLAN.md. Pre-creating that path as a directory forces
-    // EISDIR on the slice sync, so the canonical slice plan never reflects the
-    // task. The sketch flag must therefore stay set — the slice keeps refining —
-    // instead of leaving the slice out of refining over a stale plan.
+    // The flat-phase slice render targets phases/01-test/01-02-PLAN.md.
+    // Pre-creating that path as a directory forces EISDIR, so the canonical
+    // slice plan never reflects the task. The sketch flag must therefore stay
+    // set — the slice keeps refining — instead of leaving the slice out of
+    // refining over a stale plan.
     mkdirSync(join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md'), { recursive: true });
 
     const result = await handlePlanTask(validParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /render failed:/);
     assert.equal(getSlice('M001', 'S02')?.is_sketch, 1, 'sketch flag must stay set when the canonical slice plan could not sync');
     assert.ok(getTask('M001', 'S02', 'T02'), 'the task itself is still persisted so the slice can re-sync on retry');
   } finally {
@@ -265,8 +268,8 @@ test('handlePlanTask reruns idempotently and refreshes parse-visible state', asy
 
   try {
     seedParent();
-    const taskPlanPath = join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md');
-    writeFileSync(taskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T02: Cached task\n', 'utf-8');
+    const slicePlanPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    writeFileSync(slicePlanPath, '# S02: Cached slice\n\n<tasks>\n- [ ] **T02**: Cached task\n</tasks>\n', 'utf-8');
 
     const first = await handlePlanTask(validParams(), base);
     assert.ok(!('error' in first));
@@ -282,9 +285,9 @@ test('handlePlanTask reruns idempotently and refreshes parse-visible state', asy
     assert.equal(task?.description, 'Updated task handler description.');
     assert.equal(task?.estimate, '1h');
 
-    const parsed = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
-    assert.equal(parsed.frontmatter.estimated_steps, 1);
-    assert.match(readFileSync(taskPlanPath, 'utf-8'), /Updated task handler description\./);
+    const parsed = parsePlan(readFileSync(slicePlanPath, 'utf-8'));
+    assert.equal(parsed.tasks[0]?.id, 'T02');
+    assert.match(readFileSync(slicePlanPath, 'utf-8'), /Updated task handler description\./);
   } finally {
     cleanup(base);
   }

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

@@ -92,6 +92,35 @@ test("writePlanningDirectory is idempotent: writing twice produces stable conten
   assert.equal(roadmap2, roadmap1);
 });
 
+test("writePlanningDirectory does not emit an ingestible PLAN.md for a task-less (sketch) slice", async () => {
+  // Regression for #1285: a milestone-level sketch slice has zero DB tasks.
+  // The projection must not write a placeholder NN-01-PLAN.md — the reverse
+  // transform maps one task per plan file, so a placeholder would materialize
+  // a phantom "Plan NN" task and make auto-mode skip planning.
+  const base = makeTmp();
+  insertSlice({
+    milestoneId: "M001", id: "S02", title: "Sketch slice", status: "pending",
+    risk: "medium", depends: ["S01"], demo: "designed", sequence: 2,
+  });
+  // S02 intentionally has no tasks.
+
+  await writePlanningDirectory(base, "flat-phases");
+
+  const phaseDirs = readdirSync(join(base, ".planning", "phases"), { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+  const sketchDir = phaseDirs.find((d) => /^02-/.test(d));
+  assert.ok(sketchDir, `expected a 02- phase dir for the sketch slice, got ${JSON.stringify(phaseDirs)}`);
+
+  const planFiles = readdirSync(join(base, ".planning", "phases", sketchDir!))
+    .filter((f) => f.endsWith("PLAN.md"));
+  assert.equal(planFiles.length, 0, `sketch slice should have no PLAN.md, got ${JSON.stringify(planFiles)}`);
+
+  // The slice remains discoverable via ROADMAP.md.
+  const roadmap = readFileSync(join(base, ".planning", "ROADMAP.md"), "utf-8");
+  assert.match(roadmap, /Sketch slice/);
+});
+
 test("writePlanningDirectory throws for unsupported layouts", async () => {
   const base = makeTmp();
   await assert.rejects(() => writePlanningDirectory(base, "multi-milestone"), /not yet supported/);

package/src/resources/extensions/gsd/tests/post-execution-checks.test.ts

@@ -496,6 +496,28 @@ describe("checkImportResolution", () => {
     }
   });
 
+  test("ignores generated Convex _generated imports", () => {
+    tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    mkdirSync(join(tempDir, "convex"), { recursive: true });
+    writeFileSync(
+      join(tempDir, "convex", "stagedLibraryEdits.ts"),
+      "import type { DataModel } from './_generated/dataModel';\nexport const model = {} as DataModel;"
+    );
+
+    try {
+      const task = createTask({
+        id: "T01",
+        key_files: ["convex/stagedLibraryEdits.ts"],
+      });
+
+      const results = checkImportResolution(task, [], tempDir);
+      assert.deepEqual(results, []);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
   test("fails when import doesn't resolve", () => {
     tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });

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

@@ -823,6 +823,90 @@ test("pre-dispatch hook action validation via validatePreferences", () => {
   assert.ok(e3.some(e => e.includes("invalid action")));
 });
 
+test("planning_subagents validation accepts configured read-only planning specialists", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "plan-milestone": { allowed: ["security", "reviewer"] },
+      "plan-slice": { allowed: ["scout", "security", "security"] },
+    },
+  } as any);
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.planning_subagents?.["plan-milestone"]?.allowed, ["security", "reviewer"]);
+  assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, ["scout", "security"]);
+});
+
+test("planning_subagents validation rejects unsupported units and unsafe agents", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "execute-task": { allowed: ["security"] },
+      "plan-slice": { allowed: ["worker"] },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagents, undefined);
+  assert.ok(errors.some(e => e.includes("unsupported unit \"execute-task\"")));
+  assert.ok(errors.some(e => e.includes("\"worker\"") && e.includes("read-only planning specialist")));
+});
+
+test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-planning-subagents-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-planning-subagents-home-"));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    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);
+  clearGSDPreferencesCache();
+
+  writeFileSync(
+    getGlobalGSDPreferencesPath(),
+    [
+      "---",
+      "version: 1",
+      "planning_subagents:",
+      "  plan-slice:",
+      "    allowed: [scout, reviewer]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      "---",
+      "version: 1",
+      "planning_subagents:",
+      "  plan-slice:",
+      "    allowed: [security]",
+      "  plan-milestone:",
+      "    allowed: [planner]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-slice"]?.allowed, [
+    "scout",
+    "reviewer",
+    "security",
+  ]);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, ["planner"]);
+});
+
 // ── Model config parsing ─────────────────────────────────────────────────────
 
 test("parses OpenRouter model config with org/model IDs and fallbacks", () => {

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -54,6 +54,10 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   },
   post_unit_hooks: [{ command: "npm test" }],
   pre_dispatch_hooks: [{ command: "npm run lint" }],
+  planning_subagents: {
+    "plan-milestone": { allowed: ["scout", "planner"] },
+    "plan-slice": { allowed: ["scout"] },
+  },
   dynamic_routing: { enabled: true },
   disabled_model_providers: ["slow-provider"],
   uok: { enabled: true },

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

@@ -13,6 +13,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 import { buildExecuteTaskPrompt, buildPlanSlicePrompt, buildReactiveExecutePrompt, buildResearchSlicePrompt, inlineDependencySummaries } from "../auto-prompts.js";
+import { buildDiscussSlicePrompt } from "../guided-flow.js";
 import { computeBudgets, truncateAtSectionBoundary } from "../context-budget.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -735,3 +736,89 @@ describe("prompt-budget: modelRegistry + sessionContextWindow behavior", () => {
     }
   });
 });
+
+// ─── execute-task + discuss-slice inline caps (plan 039) ──────────────────────
+
+describe("prompt-budget: execute-task inline cap (039)", () => {
+  it("keeps the authoritative task plan whole but drops trailing templates when the plan alone exceeds the inline budget", async () => {
+    const base = createFixtureBase();
+    try {
+      const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      const taskDir = join(sliceDir, "tasks");
+      mkdirSync(taskDir, { recursive: true });
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap\n");
+      writeFileSync(join(sliceDir, "S01-PLAN.md"), "# Slice Plan\n");
+      // Oversized task plan (~60K) — well past the 20K inline ceiling.
+      const bigPlan = "# Task Plan\n\nMARKER_TASKPLAN_HEAD\n\n" + Array.from({ length: 30 }, (_, i) =>
+        `### Step ${i}\n\n${"Implementation detail. ".repeat(90)}`
+      ).join("\n\n");
+      writeFileSync(join(taskDir, "T01-PLAN.md"), bigPlan);
+
+      const prompt = await buildExecuteTaskPrompt("M001", "S01", "Slice", "T01", "Task", base, {
+        level: "standard",
+        sessionContextWindow: 32_000,
+      });
+
+      // The task plan is the authoritative execution contract — never truncated;
+      // its content survives whole even when it alone exceeds the inline budget.
+      assert.match(prompt, /MARKER_TASKPLAN_HEAD/);
+      assert.match(prompt, /### Step 29/);
+      // Trailing lower-priority templates are dropped — the on-demand decisions
+      // template that "standard" normally inlines is gone because the task plan
+      // consumed the entire inline budget. (Baseline: the tiny-plan test above
+      // asserts this block IS present.)
+      assert.doesNotMatch(prompt, /### On-demand Decisions Template/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});
+
+describe("prompt-budget: discuss-slice inline cap (039)", () => {
+  it("prepends the configured response language", async () => {
+    const base = createFixtureBase();
+    const gsdHome = mkdtempSync(join(tmpdir(), "gsd-discuss-slice-language-home-"));
+    const previousGsdHome = process.env.GSD_HOME;
+    process.env.GSD_HOME = gsdHome;
+
+    try {
+      writeFileSync(join(gsdHome, "PREFERENCES.md"), "---\nversion: 1\nlanguage: 中文\n---\n", "utf-8");
+      mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+      const prompt = await buildDiscussSlicePrompt("M001", "S01", "Current", base);
+
+      assert.match(prompt, /^## Response Language\n\nAlways respond in 中文/);
+    } finally {
+      if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = previousGsdHome;
+      cleanup(base);
+      cleanup(gsdHome);
+    }
+  });
+
+  it("caps the inlined block — roadmap survives first, the trailing decisions register truncates", async () => {
+    const base = createFixtureBase();
+    try {
+      const msDir = join(base, ".gsd", "milestones", "M001");
+      mkdirSync(join(msDir, "slices", "S01"), { recursive: true });
+      writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap\n\nMARKER_ROADMAP\n\n- [ ] **S01: Current** `risk:low`\n");
+      writeFileSync(join(msDir, "M001-CONTEXT.md"), "# Context\n\nMARKER_CONTEXT\n");
+      // Huge decisions register (~60K) — the unbounded-growth surface the cap bounds.
+      const bigDecisions = "# Decisions\n\n" + Array.from({ length: 40 }, (_, i) =>
+        `### D${String(i).padStart(3, "0")}\n\n${"Decision rationale detail. ".repeat(60)}`
+      ).join("\n\n");
+      writeFileSync(join(base, ".gsd", "DECISIONS.md"), bigDecisions);
+
+      const prompt = await buildDiscussSlicePrompt("M001", "S01", "Current", base);
+
+      // Roadmap is first in the inlined block → survives the cap.
+      assert.match(prompt, /MARKER_ROADMAP/);
+      // The cap fired (capPreamble ceiling is 20K; the block is ~60K).
+      assert.match(prompt, /\[\.\.\.truncated/);
+      // The last decision (trailing content) is dropped.
+      assert.doesNotMatch(prompt, /### D039/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

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

@@ -23,7 +23,10 @@ import {
 } from "../bootstrap/agent-end-recovery.ts";
 import { blockModelUntil, clearTemporaryModelBlocksForTest } from "../blocked-models.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phase-helpers.ts";
-import { _classifyZeroToolProviderMessageForTest } from "../auto/unit-phase.ts";
+import {
+  _classifyZeroToolProviderMessageForTest,
+  _zeroToolPseudoToolCallSnippetForTest,
+} from "../auto/unit-phase.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 import { clearGuidedUnitContext, getGuidedUnitContext, setGuidedUnitContext } from "../guided-unit-context.ts";
@@ -77,6 +80,21 @@ test("zero-tool provider classifier treats weekly limit wording as transient rat
   assert.equal(result.kind, "rate-limit");
 });
 
+test("zero-tool pseudo tool-call detector identifies serialization drift", () => {
+  const snippet = _zeroToolPseudoToolCallSnippetForTest(
+    'bash<arg_key>command</arg_key><arg_value>ls -la /tmp && echo "---SRC---"</arg_value></tool_call>',
+  );
+  assert.ok(snippet, "pseudo tool-call text should be recognized");
+  assert.match(snippet, /bash<arg_key>command<\/arg_key>/);
+});
+
+test("zero-tool provider classifier does not treat pseudo tool-call text as an error class", () => {
+  const result = _classifyZeroToolProviderMessageForTest(
+    'bash<arg_key>command</arg_key><arg_value>ls -la /tmp && echo "---SRC---"</arg_value></tool_call>',
+  );
+  assert.equal(result, null, "pseudo tool-call text is drift, not a provider error");
+});
+
 test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
   const result = classifyError("You are out of extra usage. Please wait before retrying.");
   assert.ok(isTransient(result));
@@ -651,6 +669,108 @@ test("rate-limit agent_end walks past unavailable fallback models before pausing
   }
 });
 
+test("retry-exhausted abort/unknown provider stop reasons trigger model fallback (#1364)", async () => {
+  const originalCwd = process.cwd();
+  const originalSetTimeout = globalThis.setTimeout;
+
+  globalThis.setTimeout = ((fn: (...args: unknown[]) => void, delay?: number) => {
+    if ((delay ?? 0) === 0) {
+      fn();
+    }
+    return 0 as unknown as ReturnType<typeof setTimeout>;
+  }) as typeof setTimeout;
+
+  try {
+    for (const reason of ["abort", "unknown"]) {
+      const base = mkdtempSync(join(tmpdir(), `gsd-stop-reason-${reason}-`));
+      const notifications: Array<{ message: string; level?: string }> = [];
+      const setModelCalls: string[] = [];
+      const sendMessageCalls: unknown[][] = [];
+
+      try {
+        resetTransientRetryState();
+        clearTemporaryModelBlocksForTest();
+        autoSession.reset();
+        mkdirSync(join(base, ".gsd"), { recursive: true });
+        writeFileSync(
+          join(base, ".gsd", "PREFERENCES.md"),
+          [
+            "---",
+            "models:",
+            "  execution:",
+            "    model: gpt-5.5",
+            "    provider: openai-codex",
+            "    fallbacks:",
+            "      - anthropic/claude-sonnet-4-6",
+            "---",
+          ].join("\n"),
+          "utf-8",
+        );
+        process.chdir(base);
+
+        autoSession.active = true;
+        autoSession.basePath = base;
+        autoSession.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+        autoSession.autoModeStartModel = { provider: "openai-codex", id: "gpt-5.5" };
+
+        const availableModels = [
+          { id: "gpt-5.5", provider: "openai-codex", api: "responses" },
+          { id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" },
+        ];
+        const ctx = {
+          model: availableModels[0],
+          modelRegistry: { getAvailable: () => availableModels },
+          ui: {
+            notify(message: string, level?: "info" | "warning" | "error" | "success") {
+              notifications.push({ message, level });
+            },
+            setStatus: () => {},
+            setWidget: () => {},
+            setWorkingMessage: () => {},
+          },
+        } as any;
+        const pi = {
+          setModel: async (model: { provider: string; id: string }) => {
+            setModelCalls.push(`${model.provider}/${model.id}`);
+            return true;
+          },
+          sendMessage: (...args: unknown[]) => {
+            sendMessageCalls.push(args);
+          },
+        } as any;
+
+        await handleAgentEnd(pi, {
+          messages: [{
+            role: "assistant",
+            stopReason: "error",
+            errorMessage: `Retry failed after 3 attempts: Unhandled stop reason: ${reason}`,
+          }],
+        } as any, ctx);
+
+        assert.deepEqual(setModelCalls, ["anthropic/claude-sonnet-4-6"], `${reason} should switch to configured fallback`);
+        assert.equal(sendMessageCalls.length, 1, `${reason} fallback recovery must trigger a continuation turn`);
+        assert.deepEqual(sendMessageCalls[0][1], { triggerTurn: true });
+        assert.ok(
+          notifications.some((n) => n.message.includes("anthropic/claude-sonnet-4-6")),
+          `${reason} notification should name the selected fallback`,
+        );
+      } finally {
+        process.chdir(originalCwd);
+        clearTemporaryModelBlocksForTest();
+        resetTransientRetryState();
+        autoSession.reset();
+        rmSync(base, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    globalThis.setTimeout = originalSetTimeout;
+    process.chdir(originalCwd);
+    clearTemporaryModelBlocksForTest();
+    resetTransientRetryState();
+    autoSession.reset();
+  }
+});
+
 test("isTerminalDeletedWorktreeProviderError matches removed auto-worktree paths only", () => {
   assert.equal(
     isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" does not exist'),

package/src/resources/extensions/gsd/tests/reactive-executor.test.ts

@@ -608,3 +608,42 @@ test("getDependencyTaskSummaryPaths handles missing dependency summaries gracefu
     rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("#1343: getPriorTaskSummaryPaths excludes sibling-slice summaries in flat-phase", async () => {
+  const { getPriorTaskSummaryPaths } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-reactive-flat-prior-"));
+  try {
+    // Flat-phase: slices S01 and S02 share the phase dir and overlap task ids.
+    const phaseDir = join(repo, ".gsd", "phases", "01-test");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "S01-T01-SUMMARY.md"), "---\nid: T01\n---\n# S01 T01\n");
+    writeFileSync(join(phaseDir, "S02-T01-SUMMARY.md"), "---\nid: T01\n---\n# S02 T01\n");
+
+    // S02/T02 prior summaries must not pull the sibling S01-T01 summary.
+    const paths = await getPriorTaskSummaryPaths("M001", "S02", "T02", repo);
+    assert.equal(paths.length, 1, "Should only return the current slice's prior summary");
+    assert.ok(paths[0].includes("S02-T01-SUMMARY"), "Should include S02's T01");
+    assert.ok(!paths.some((p) => p.includes("S01-T01-SUMMARY")), "Should NOT include sibling S01's T01");
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("#1343: getDependencyTaskSummaryPaths excludes sibling-slice summaries in flat-phase", async () => {
+  const { getDependencyTaskSummaryPaths } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-reactive-flat-dep-"));
+  try {
+    const phaseDir = join(repo, ".gsd", "phases", "01-test");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "S01-T01-SUMMARY.md"), "---\nid: T01\n---\n# S01 T01\n");
+    writeFileSync(join(phaseDir, "S02-T01-SUMMARY.md"), "---\nid: T01\n---\n# S02 T01\n");
+
+    // S02/T02 depends on T01 — must resolve S02's T01, not the sibling S01's.
+    const paths = await getDependencyTaskSummaryPaths("M001", "S02", "T02", ["T01"], repo);
+    assert.equal(paths.length, 1, "Should only return the current slice's dependency summary");
+    assert.ok(paths[0].includes("S02-T01-SUMMARY"), "Should include S02's T01");
+    assert.ok(!paths.some((p) => p.includes("S01-T01-SUMMARY")), "Should NOT include sibling S01's T01");
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});