gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

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

@@ -17,7 +17,7 @@ import {
   getSlice,
 } from "../gsd-db.ts";
 import { autoHealSketchFlags } from "../state-reconciliation/drift/sketch-flag.ts";
-import { deriveStateFromDb } from "../state.ts";
+import { deriveState, deriveStateFromDb } from "../state.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";
 
@@ -198,6 +198,47 @@ test("ADR-011: autoHealSketchFlags flips is_sketch=0 when PLAN file exists", asy
   assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "post-heal: flag cleared");
 });
 
+test("ADR-011: deriveStateFromDb auto-heals stale sketch flag when PLAN exists", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedMilestoneWithSketchedS02(base);
+  writeS01Artifacts(base);
+  writePreferences(base, "phases:\n  skip_research: false");
+  // Simulate plan-slice completion where PLAN exists but is_sketch was not flipped.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-PLAN.md"),
+    "# S02 Plan\n",
+  );
+  process.chdir(base);
+
+  const state = await deriveStateFromDb(base);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "derive should clear stale is_sketch");
+  assert.equal(state.phase, "planning", "state should advance past refining once stale flag is healed");
+});
+
+test("ADR-011: deriveState uses canonical artifact root for sketch-flag healing", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedMilestoneWithSketchedS02(base);
+  writeS01Artifacts(base);
+  writePreferences(base, "phases:\n  skip_research: false");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-PLAN.md"),
+    "# S02 Plan\n",
+  );
+  const worktreePath = join(base, "worker");
+  mkdirSync(worktreePath, { recursive: true });
+  process.chdir(worktreePath);
+
+  const state = await deriveState(worktreePath, { projectRootForReads: base });
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "deriveState should heal from canonical artifact root");
+  assert.equal(state.phase, "planning", "state should advance past refining when PLAN exists at canonical root");
+});
+
 test("ADR-011: schema v16 is idempotent — re-opening DB preserves is_sketch and sketch_scope columns", async (t) => {
   const originalCwd = process.cwd();
   const base = mkdtempSync(join(tmpdir(), "gsd-adr011-schema-"));

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

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt reports missing template variables with balanced braces", () => {
+  assert.throws(
+    () => loadPrompt("guided-discuss-milestone", {
+      milestoneId: "M001",
+      milestoneTitle: "Missing working directory",
+      structuredQuestionsAvailable: "false",
+      fastPathInstruction: "",
+      inlinedTemplates: "context template",
+      commitInstruction: "Do not commit during this test.",
+    }),
+    (error) => {
+      assert.ok(error instanceof Error);
+      assert.match(error.message, /template declares \{\{workingDirectory\}\} but no value was provided/);
+      assert.doesNotMatch(error.message, /\{\{workingDirectory\}\}\}/);
+      return true;
+    },
+  );
+});

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

@@ -10,7 +10,12 @@ import assert from "node:assert/strict";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
-import { MAX_TRANSIENT_AUTO_RESUMES, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import {
+  MAX_TRANSIENT_AUTO_RESUMES,
+  isTerminalDeletedWorktreeProviderError,
+  resetTransientRetryState,
+  shouldDeferTransientErrorToCoreRetry,
+} from "../bootstrap/agent-end-recovery.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -399,6 +404,25 @@ test("pauseAutoForProviderError falls back to indefinite pause when not rate lim
   ]);
 });
 
+test("isTerminalDeletedWorktreeProviderError matches removed auto-worktree paths only", () => {
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/.gsd/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/src/file.ts" does not exist'),
+    false,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" failed with EACCES'),
+    false,
+  );
+});
+
 // ── resumeAutoAfterProviderDelay ────────────────────────────────────────────
 
 test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded base path", async () => {
@@ -659,3 +683,15 @@ test("agent-session retryable error regex matches server_error (underscore)", ()
   // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
   assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });
+
+test("exhausted retry errors are not deferred back to core retry handling", () => {
+  const cls = classifyError("Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload");
+  assert.equal(cls.kind, "server");
+  assert.equal(
+    shouldDeferTransientErrorToCoreRetry(
+      cls,
+      "Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload",
+    ),
+    false,
+  );
+});

package/src/resources/extensions/gsd/tests/quality-gates.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Validates planning and task template quality-gate content.
+
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,11 +30,14 @@ console.log("\n=== Level 1: Templates contain quality gate headings ===");
   const plan = loadTemplate("plan");
   assertTrue(plan.includes("## Threat Surface"), "plan.md contains ## Threat Surface");
   assertTrue(plan.includes("## Requirement Impact"), "plan.md contains ## Requirement Impact");
+  assertTrue(plan.includes("node --test"), "plan.md instructs using node --test for verification");
 
   const taskPlan = loadTemplate("task-plan");
   assertTrue(taskPlan.includes("## Failure Modes"), "task-plan.md contains ## Failure Modes");
   assertTrue(taskPlan.includes("## Load Profile"), "task-plan.md contains ## Load Profile");
   assertTrue(taskPlan.includes("## Negative Tests"), "task-plan.md contains ## Negative Tests");
+  assertTrue(taskPlan.includes("node --test"), "task-plan.md instructs using node --test for verification");
+  assertTrue(taskPlan.includes("node -e"), "task-plan.md mentions inline node -e as disallowed guidance");
 
   const sliceSummary = loadTemplate("slice-summary");
   assertTrue(sliceSummary.includes("## Operational Readiness"), "slice-summary.md contains ## Operational Readiness");

package/src/resources/extensions/gsd/tests/queue-reorder-ui.test.ts

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { showQueueReorder } from "../queue-reorder-ui.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+describe("queue-reorder-ui", () => {
+  test("keeps cursor visible while scrolling long queue with arrow keys (#4656)", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 20, configurable: true });
+
+    try {
+      const pending = Array.from({ length: 20 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+
+      let resolved: { order: string[]; depsToRemove: Array<{ milestone: string; dep: string }> } | null = null;
+      let lastRender: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, (value: any) => {
+              resolved = value;
+            });
+
+            for (let i = 0; i < 15; i++) component.handleInput("\u001b[B");
+            lastRender = component.render(100);
+            component.handleInput("\r");
+            return resolved;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, [], pending);
+
+      const joined = lastRender.join("\n");
+      assert.ok(joined.includes("M016"), "selected item should stay visible after scrolling");
+      assert.ok(lastRender.length <= 16, `overlay should fit terminal max-height, got ${lastRender.length}`);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/remediation-completion-guard.test.ts

@@ -1,6 +1,6 @@
 /**
- * Regression test for #2675: completing-milestone dispatch rule must
- * block completion when VALIDATION verdict is "needs-remediation".
+ * Regression tests for non-passing VALIDATION verdicts: completing-milestone
+ * dispatch must block completion when VALIDATION needs remediation or attention.
  *
  * Without this guard, needs-remediation + allSlicesDone causes a loop:
  * complete-milestone dispatched → agent refuses (correct) → no SUMMARY
@@ -66,6 +66,93 @@ test("completing-milestone blocks when VALIDATION verdict is needs-remediation (
   }
 });
 
+test("completing-milestone blocks when VALIDATION verdict is needs-attention (#5747)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-attention-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: needs-attention",
+        "remediation_round: 0",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Acceptance proof is incomplete and needs human attention.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes("needs-attention"),
+        "reason should mention needs-attention",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("completing-milestone blocks when VALIDATION verdict is fail (#5920)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-fail-verdict-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: fail",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Blocking failures remain unresolved.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes('verdict is "fail"'),
+        "reason should mention fail verdict",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("completing-milestone proceeds normally when VALIDATION verdict is pass (#2675 guard)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-remediation-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, before, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync, renameSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync, renameSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -228,4 +228,31 @@ test('validateProjectId accepts valid values', () => {
     }
 });
 
+test('ensureGsdSymlink prefers marker directory when marker/computed identities diverge and both have state (#5685)', () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-split-brain-")));
+    run("git init -b main", repo);
+    run('git config user.name "Pi Test"', repo);
+    run('git config user.email "pi@example.com"', repo);
+    writeFileSync(join(repo, "README.md"), "# Split Brain Test\n", "utf-8");
+    run("git add README.md", repo);
+    run('git commit -m "init"', repo);
+
+    const computedPath = externalGsdRoot(repo);
+    mkdirSync(computedPath, { recursive: true });
+    writeFileSync(join(computedPath, "computed-state.txt"), "computed\n", "utf-8");
+
+    const markerId = "marker-state-id";
+    const markerPath = join(stateDir, "projects", markerId);
+    mkdirSync(markerPath, { recursive: true });
+    writeFileSync(join(markerPath, "marker-state.txt"), "marker\n", "utf-8");
+    writeFileSync(join(repo, ".gsd-id"), `${markerId}\n`, "utf-8");
+
+    const resolved = ensureGsdSymlink(repo);
+    assert.deepStrictEqual(resolved, markerPath, "marker-backed state directory is preferred in split-brain condition");
+    assert.deepStrictEqual(realpathSync(join(repo, ".gsd")), realpathSync(markerPath), ".gsd symlink resolves to marker-backed state directory");
+    assert.deepStrictEqual(readFileSync(join(repo, ".gsd-id"), "utf-8").trim(), markerId, ".gsd-id marker persists the marker-backed identity");
+
+    rmSync(repo, { recursive: true, force: true });
+});
+
 });

package/src/resources/extensions/gsd/tests/repository-registry.test.ts

@@ -0,0 +1,52 @@
+// GSD-2 + Repository registry seam tests.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRepositoryRegistryFromPreferences } from "../repository-registry.ts";
+
+test("repository registry includes implicit project root and declared child repos", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, "frontend"), { recursive: true });
+  mkdirSync(join(base, "backend"), { recursive: true });
+
+  const registry = createRepositoryRegistryFromPreferences(base, {
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend", role: "web UI", verification: ["npm test"] },
+        backend: { path: "./backend", role: "API", commit_policy: "skip" },
+      },
+    },
+  });
+
+  assert.equal(registry.mode, "parent");
+  assert.equal(registry.projectRoot, base);
+  assert.equal(registry.byId.get("project")?.root, base);
+  assert.equal(registry.byId.get("frontend")?.root, join(base, "frontend"));
+  assert.equal(registry.byId.get("backend")?.root, join(base, "backend"));
+  assert.deepEqual(registry.byId.get("frontend")?.verification, ["npm test"]);
+  assert.equal(registry.byId.get("backend")?.commitPolicy, "skip");
+});
+
+test("repository registry rejects repositories outside project root", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+
+  assert.throws(
+    () => createRepositoryRegistryFromPreferences(base, {
+      workspace: {
+        mode: "parent",
+        repositories: {
+          unsafe: { path: "../outside" },
+        },
+      },
+    }),
+    /outside project root/,
+  );
+});

package/src/resources/extensions/gsd/tests/run-uat-replay-cap.test.ts

@@ -36,7 +36,7 @@ function makeUatProject(): string {
   return base;
 }
 
-test("run-uat dispatch stops after three attempts without a verdict", async () => {
+test("run-uat dispatch skips after three attempts without a verdict", async () => {
   const basePath = makeUatProject();
   const rule = DISPATCH_RULES.find((r) => r.name === "run-uat (post-completion)");
   assert.ok(rule, "run-uat dispatch rule is registered");
@@ -58,8 +58,7 @@ test("run-uat dispatch stops after three attempts without a verdict", async () =
     }
 
     const capped = await rule.match(ctx as any);
-    assert.equal(capped?.action, "stop");
-    assert.match(capped?.reason ?? "", /dispatched 3 times/);
+    assert.equal(capped?.action, "skip");
     assert.equal(getUatCount(basePath, "M001", "S01"), 4);
   } finally {
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -25,6 +25,9 @@ import {
   isSessionLockHeld,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import { registerAutoWorker, getAutoWorker } from "../db/auto-workers.ts";
+import { normalizeRealPath } from "../paths.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -94,6 +97,38 @@ describe('session-lock-regression', async () => {
     }
   }
 
+  // ─── 2b. Dead lock PID is marked stopping in workers table ────────────
+  console.log('\n=== 2b. dead lock PID marks worker stopping ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      openDatabase(join(base, ".gsd", "gsd.db"));
+      const projectRoot = normalizeRealPath(base);
+      const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+      const deadPid = 99999;
+      writeFileSync(join(gsdRoot(base), "auto.lock"), JSON.stringify({
+        pid: deadPid,
+        startedAt: new Date().toISOString(),
+        unitType: "starting",
+        unitId: "bootstrap",
+        unitStartedAt: new Date().toISOString(),
+      }));
+      // Align worker PID with stale lock metadata.
+      _getAdapter()?.prepare("UPDATE workers SET pid = :pid WHERE worker_id = :id")
+        .run({ ":pid": deadPid, ":id": workerId });
+
+      const result = acquireSessionLock(base);
+      assert.ok(result.acquired, "acquire recovers stale lock");
+      assert.equal(getAutoWorker(workerId)?.status, "stopping");
+      releaseSessionLock(base);
+    } finally {
+      try { closeDatabase(); } catch { /* noop */ }
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
   // ─── 3. updateSessionLock preserves lock data ─────────────────────────
   console.log('\n=== 3. updateSessionLock writes metadata ===');
   {

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -5,13 +5,22 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  _hasEmptyAgentEndContent,
   _handleSessionSwitchAgentEnd,
+  handleAgentEnd,
   isBareClaudeCodeStreamAbortPlaceholder,
   isClaudeCodeSessionSwitchAbortMessage,
 } from "../bootstrap/agent-end-recovery.js";
+import { _setAutoActiveForTest } from "../auto.js";
 import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js";
+import { _resetPendingResolve, _setCurrentResolve } from "../auto/resolve.js";
 import type { ErrorContext } from "../auto/types.js";
 
+test.afterEach(() => {
+  _setAutoActiveForTest(false);
+  _resetPendingResolve();
+});
+
 test("user-abort message during session-switch is dropped (not propagated as cancellation)", () => {
   // The Anthropic SDK emits this exact string when newSession() aborts an
   // in-flight stream during a unit-to-unit session transition. Before the fix
@@ -112,23 +121,61 @@ test("late bare Claude Code stream-aborted placeholder is classified as internal
   );
 });
 
+test("mid-unit bare Claude Code stream-aborted placeholder resolves the unit", async () => {
+  // A placeholder without an active session-switch grace window belongs to the
+  // current unit. Resolving it prevents auto-mode from hanging while still
+  // allowing the next unit to run.
+  const results: unknown[] = [];
+  const warnings: string[] = [];
+  _setAutoActiveForTest(true);
+  _setCurrentResolve((result) => results.push(result));
+
+  const event = {
+    messages: [{
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }],
+  };
+
+  await handleAgentEnd({} as any, event, {
+    ui: {
+      notify: (message: string, level: string) => {
+        if (level === "warning") warnings.push(message);
+      },
+    },
+  } as any);
+
+  assert.deepEqual(results, [{ status: "completed", event }]);
+  assert.deepEqual(warnings, ["Claude Code stream aborted mid-unit (no diagnostic). Continuing."]);
+});
+
 test("typed session-transition abort events are classified as internal", () => {
   assert.equal(
     shouldIgnoreAgentEndForActiveUnit({
       abortOrigin: "session-transition",
+      messages: [{ stopReason: "aborted" }],
     }),
     true,
   );
 
+  assert.equal(
+    shouldIgnoreAgentEndForActiveUnit({
+      abortOrigin: "session-transition",
+      messages: [{ stopReason: "end_turn" }],
+    }),
+    false,
+  );
+
   assert.equal(
     shouldIgnoreAgentEndForActiveUnit({
       abortOrigin: "user",
+      messages: [{ stopReason: "aborted" }],
     }),
     false,
   );
 
   assert.equal(
-    shouldIgnoreAgentEndForActiveUnit({}),
+    shouldIgnoreAgentEndForActiveUnit({ messages: [] }),
     false,
   );
 });
@@ -188,6 +235,17 @@ test("empty-content aborted during session-switch is silently ignored", () => {
   assert.equal(cancelledWith, null);
 });
 
+test("missing agent_end content is classified as empty abort content", () => {
+  // Providers may omit content entirely for a late aborted agent_end. That is
+  // equivalent to empty content and must not pause/cancel the next unit.
+  assert.equal(_hasEmptyAgentEndContent(undefined), true);
+  assert.equal(_hasEmptyAgentEndContent(null), true);
+  assert.equal(_hasEmptyAgentEndContent([]), true);
+  assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "" }]), true);
+  assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "   " }]), true);
+  assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "partial" }]), false);
+});
+
 test("completed assistant content with aborted stopReason during session-switch is ignored", () => {
   // newSession() can abort the just-finished provider stream while the last
   // assistant message still carries the completed unit summary. That is a

package/src/resources/extensions/gsd/tests/slice-parallel-conflict.test.ts

@@ -21,9 +21,9 @@ function makeTmpBase(): string {
 }
 
 function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
-  const dir = join(base, ".gsd", "milestones", mid, sid);
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
   mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "PLAN.md"), content, "utf-8");
+  writeFileSync(join(dir, `${sid}-PLAN.md`), content, "utf-8");
 }
 
 describe("hasFileConflict", () => {