gsd-pi 2.79.0 → 2.80.0

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -23,6 +23,11 @@ import {
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
 import type { GSDPreferences } from "../preferences.ts";
 import type { GSDState } from "../types.ts";
 
@@ -342,6 +347,62 @@ test("deep project setup: pre-dispatch can run before the first milestone exists
   }
 });
 
+test("deep project setup: bootstrap continues queued M002 without milestone context", async () => {
+  const base = makeRepo();
+  try {
+    writeCapturedDeepPrefs(base);
+    writeValidProjectAndRequirements(base);
+    mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "runtime", "research-decision.json"), '{"decision":"skip"}\n');
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "First milestone", status: "complete" });
+    insertMilestone({ id: "M002", title: "Second milestone", status: "queued" });
+    closeDatabase();
+
+    const messages: unknown[] = [];
+    const pi = {
+      ...makePi(messages),
+      getThinkingLevel: () => "medium",
+    };
+    const s = new AutoSession();
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(`queued-${randomUUID()}`) as any,
+      pi as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        lockBase: () => base,
+        buildResolver: () => ({}) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, true);
+    assert.equal(s.active, true);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.equal(messages.length, 0, "queued deep milestone must not re-enter smart new-milestone discussion");
+  } finally {
+    try { closeDatabase(); } catch {}
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: pre-dispatch takes precedence over an existing draft milestone", async () => {
   const base = makeBase();
   try {
@@ -1020,7 +1081,7 @@ test("deep project setup: research-project blocker placeholder is a file, not th
   const base = makeBase();
   try {
     const expectedPath = resolveExpectedArtifactPath("research-project", "PROJECT-RESEARCH", base);
-    assert.equal(expectedPath, join(base, ".gsd", "research", "PROJECT-RESEARCH-BLOCKER.md"));
+    assert.equal(expectedPath, join(realpathSync(base), ".gsd", "research", "PROJECT-RESEARCH-BLOCKER.md"));
 
     mkdirSync(join(base, ".gsd", "research"), { recursive: true });
     const diagnosis = writeBlockerPlaceholder(

package/src/resources/extensions/gsd/tests/execute-summary-save-empty-project.test.ts

@@ -0,0 +1,109 @@
+// gsd-2 / execute-summary-save PROJECT registration hard-fail tests
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { openDatabase, closeDatabase, getAllMilestones } from "../gsd-db.ts";
+import { markApprovalGateVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
+import { executeSummarySave } from "../tools/workflow-tool-executors.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-summary-save-empty-project-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* swallow */ }
+}
+
+function openTestDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+async function inProjectDir<T>(dir: string, fn: () => Promise<T>): Promise<T> {
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(dir);
+    return await fn();
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+function setupBase(t: { after: (fn: () => void) => void }): string {
+  const base = makeTmpBase();
+  // Force deep planning so the root-artifact guard requires a verified approval gate,
+  // matching the production flow that surfaces the regression.
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: deep\n---\n");
+  openTestDb(base);
+  markApprovalGateVerified("depth_verification_project_confirm", base);
+  t.after(() => {
+    clearDiscussionFlowState(base);
+    closeDatabase();
+    cleanup(base);
+  });
+  return base;
+}
+
+test("executeSummarySave returns isError when PROJECT.md content has zero parseable milestone lines", async (t) => {
+  const base = setupBase(t);
+
+  const content = [
+    "# Project",
+    "",
+    "## What This Is",
+    "",
+    "Bad-separator regression fixture.",
+    "",
+    "## Milestone Sequence",
+    "",
+    // Wrong separator: " : " instead of em-dash / -- / -  → MILESTONE_LINE_RE matches zero lines.
+    "- [ ] M001: Foundation : Establish the first runnable slice.",
+    "",
+    "## Next Section",
+    "",
+    "Trailing prose with no list bullets so MILESTONE_LINE_RE cannot bridge across lines.",
+    "",
+  ].join("\n");
+
+  const result = await inProjectDir(base, () => executeSummarySave({
+    artifact_type: "PROJECT",
+    content,
+  }, base));
+
+  assert.equal(result.isError, true);
+  assert.equal(result.details.error, "milestone_registration_empty_parse");
+  assert.match(result.content[0].text, /zero parseable milestone lines/);
+  assert.equal(getAllMilestones().length, 0);
+});
+
+test("executeSummarySave registers milestones when PROJECT.md uses canonical em-dash format", async (t) => {
+  const base = setupBase(t);
+
+  const content = [
+    "# Project",
+    "",
+    "## What This Is",
+    "",
+    "Canonical milestone-sequence fixture.",
+    "",
+    "## Milestone Sequence",
+    "",
+    "- [ ] M001: Foo — bar",
+    "- [ ] M002: Baz — qux",
+    "",
+  ].join("\n");
+
+  const result = await inProjectDir(base, () => executeSummarySave({
+    artifact_type: "PROJECT",
+    content,
+  }, base));
+
+  assert.notEqual(result.isError, true);
+  assert.deepEqual(result.details.registeredMilestones, ["M001", "M002"]);
+  assert.equal(getAllMilestones().length, 2);
+});

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

@@ -1,3 +1,5 @@
+// GSD Extension - Database regression tests.
+
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
@@ -29,7 +31,10 @@ import {
   getTask,
   getSliceTasks,
   checkpointDatabase,
+  refreshOpenDatabaseFromDisk,
+  tryCreateMemoriesFts,
 } from '../gsd-db.ts';
+import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
 
 const _require = createRequire(import.meta.url);
 
@@ -910,6 +915,31 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test('gsd-db: FTS5 unavailable warning normalizes provider typo', () => {
+    const previousStderr = setStderrLoggingEnabled(false);
+    _resetLogs();
+    try {
+      const ok = tryCreateMemoriesFts({
+        exec(): void {
+          throw new Error('no such moduel : fts5');
+        },
+        prepare(): never {
+          throw new Error('prepare should not be called');
+        },
+        close(): void {},
+      });
+
+      assert.equal(ok, false, 'FTS5 creation should report fallback');
+      const warning = peekLogs().find((entry) => entry.component === 'db' && entry.message.includes('FTS5 unavailable'));
+      assert.ok(warning, 'FTS5 fallback warning should be logged');
+      assert.match(warning!.message, /no such module: fts5/);
+      assert.doesNotMatch(warning!.message, /moduel/);
+    } finally {
+      _resetLogs();
+      setStderrLoggingEnabled(previousStderr);
+    }
+  });
+
   // ─── checkpointDatabase ────────────────────────────────────────────────────
 
   describe('checkpointDatabase', () => {
@@ -952,6 +982,71 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── refreshOpenDatabaseFromDisk ───────────────────────────────────────────
+
+  describe('refreshOpenDatabaseFromDisk', () => {
+    test('refreshOpenDatabaseFromDisk: reopens the active file-backed database and sees external writes', (t) => {
+      const dbPath = tempDbPath();
+      t.after(() => cleanup(dbPath));
+
+      openDatabase(dbPath);
+      insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+      insertSlice({
+        id: 'S01',
+        milestoneId: 'M001',
+        title: 'Slice 1',
+        status: 'pending',
+        sequence: 1,
+      });
+      insertTask({
+        id: 'T01',
+        milestoneId: 'M001',
+        sliceId: 'S01',
+        title: 'Task 1',
+        status: 'pending',
+        sequence: 1,
+      });
+
+      const adapterBefore = _getAdapter()!;
+
+      const externalDb = openRawSqliteForTest(dbPath);
+      try {
+        externalDb.exec(`
+          INSERT INTO tasks (milestone_id, slice_id, id, title, status, sequence)
+          VALUES ('M001', 'S01', 'T02', 'Task 2', 'pending', 2)
+        `);
+      } finally {
+        externalDb.close();
+      }
+
+      const visibleBeforeRefresh = getSliceTasks('M001', 'S01').map(task => task.id);
+      assert.ok(visibleBeforeRefresh.includes('T01'));
+
+      assert.equal(refreshOpenDatabaseFromDisk(), true);
+      assert.notEqual(_getAdapter(), adapterBefore, 'refresh must replace the active adapter rather than becoming a no-op');
+      const sliceTaskIds = getSliceTasks('M001', 'S01').map(task => task.id);
+      assert.deepEqual(sliceTaskIds, ['T01', 'T02']);
+      assert.equal(isDbAvailable(), true);
+    });
+
+    test('refreshOpenDatabaseFromDisk: refuses in-memory databases without closing them', () => {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+      assert.equal(refreshOpenDatabaseFromDisk(), false);
+      assert.equal(isDbAvailable(), true);
+      assert.ok(_getAdapter()!.prepare("SELECT 1 FROM milestones WHERE id = 'M001'").get());
+
+      closeDatabase();
+    });
+
+    test('refreshOpenDatabaseFromDisk: is a no-op when no database is open', () => {
+      closeDatabase();
+      assert.equal(refreshOpenDatabaseFromDisk(), false);
+      assert.equal(isDbAvailable(), false);
+    });
+  });
+
   // ─── getDbStatus ───────────────────────────────────────────────────────────
 
   describe('getDbStatus', () => {

package/src/resources/extensions/gsd/tests/guided-flow-prompt-consolidation.test.ts

@@ -101,6 +101,20 @@ describe("guided-flow → auto-prompts consolidation (#5183)", () => {
       prompt.includes("Implement the thing"),
       "must include task plan body content from disk",
     );
+    assert.ok(prompt.includes("## Context Mode"), "execute-task should include standalone Context Mode guidance");
+    assert.ok(prompt.includes("execution lane"), "execute-task should render the execution lane");
+  });
+
+  test("buildExecuteTaskPrompt omits Context Mode when disabled", async () => {
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      ["---", "context_mode:", "  enabled: false", "---", ""].join("\n"),
+    );
+
+    const prompt = await buildExecuteTaskPrompt(MID, SID, S_TITLE, TID, T_TITLE, base);
+
+    assert.ok(!prompt.includes("## Context Mode"));
+    assert.ok(!prompt.includes("Context Mode (execution lane)"));
   });
 
   test("buildCompleteSlicePrompt carries the complete-slice contract", async () => {

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -1,3 +1,5 @@
+// GSD Extension — Auto recovery integration tests.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync, chmodSync } from "node:fs";
@@ -401,6 +403,57 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", (t
   assert.equal(result, false, "should fail when plan has no task entries (empty scaffold, #699)");
 });
 
+test("verifyExpectedArtifact plan-slice trusts DB tasks over legacy plan syntax", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    closeDatabase();
+    cleanup(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Second task", status: "pending" });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01: Slice\n\n## Tasks\n\nTask rows live in the DB; this projection intentionally has no legacy task syntax.\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan\n");
+
+  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+  assert.equal(result, true, "DB task rows plus task plan files should verify plan-slice");
+});
+
+test("verifyExpectedArtifact plan-slice still fails when a DB-backed task plan file is missing", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    closeDatabase();
+    cleanup(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Second task", status: "pending" });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01: Slice\n\n## Tasks\n\nTask rows live in the DB; this projection intentionally has no legacy task syntax.\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+  assert.equal(result, false, "DB task rows must still require matching task plan files");
+});
+
 // ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
 
 test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", (t) => {
@@ -456,6 +509,32 @@ test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (
   );
 });
 
+test("verifyExpectedArtifact accepts indented legacy plan-slice task markers", (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+    "# S01: Test Slice",
+    "",
+    "## Tasks",
+    "",
+    "  - [ ] **T01: Implement feature** `est:1h`",
+    "",
+    "  ### T02 -- Write tests",
+  ].join("\n"));
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+
+  assert.strictEqual(
+    verifyExpectedArtifact("plan-slice", "M001/S01", base),
+    true,
+    "Indented legacy task markers should be treated as completed plan-slice artifacts",
+  );
+});
+
 test("verifyExpectedArtifact execute-task rejects heading-style plan without checked checkbox (#3607)", (t) => {
   const base = makeTmpBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -399,6 +399,140 @@ test("runDispatch pauses when complete-milestone summary exists on disk but the
   assert.equal(stopCalls, 0, "mismatch pause should not hard-stop the loop");
 });
 
+test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
+  const capture = createEventCapture();
+  let invalidateCalls = 0;
+  let stopCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-plan-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: First task** `est:1h`\n");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const deps = makeMockDeps(capture, {
+    invalidateAllCaches: () => { invalidateCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "plan-slice",
+      unitId: "M001/S01",
+      prompt: "plan the slice",
+      matchedRule: "planning → plan-slice",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "plan-slice/M001/S01" },
+      { key: "plan-slice/M001/S01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(invalidateCalls, 1, "Level 1 artifact recovery should invalidate caches");
+  assert.equal(stopCalls, 0, "Level 1 artifact recovery should not hard-stop");
+  assert.deepEqual(loopState.recentUnits, [], "Level 1 artifact recovery should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 1 artifact recovery should reset the recovery counter");
+});
+
+test("runDispatch escapes Level 2 stuck stop when artifact verifies after cache invalidation", async (t) => {
+  const capture = createEventCapture();
+  let invalidateCalls = 0;
+  let stopCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-plan-l2-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: First task** `est:1h`\n");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const deps = makeMockDeps(capture, {
+    invalidateAllCaches: () => { invalidateCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "plan-slice",
+      unitId: "M001/S01",
+      prompt: "plan the slice",
+      matchedRule: "planning → plan-slice",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "plan-slice/M001/S01" },
+      { key: "plan-slice/M001/S01" },
+    ],
+    stuckRecoveryAttempts: 1,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(invalidateCalls, 1, "Level 2 escape should invalidate caches before rechecking artifacts");
+  assert.equal(stopCalls, 0, "verified artifacts should escape Level 2 hard stop");
+  assert.deepEqual(loopState.recentUnits, [], "Level 2 artifact escape should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 2 artifact escape should reset the recovery counter");
+});
+
 test("runUnitPhase emits unit-start and unit-end with causedBy reference", async () => {
   const capture = createEventCapture();
 

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -147,4 +147,12 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     prompt.includes(SKILL_ACTIVATION_SUBSTRING),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
+  assert.ok(
+    prompt.includes("Context Mode (research lane):"),
+    "embedded parallel research subagent prompts should use nested Context Mode guidance",
+  );
+  assert.ok(
+    !prompt.includes("## Context Mode\n\nLane: **research lane**."),
+    "embedded parallel research subagent prompts should not use standalone Context Mode heading",
+  );
 });

package/src/resources/extensions/gsd/tests/paused-session-via-db.test.ts

@@ -64,6 +64,7 @@ test("readPausedSessionMetadata round-trips a real PausedSessionMetadata payload
     activeRunDir: null,
     autoStartTime: Date.now(),
     milestoneLock: null,
+    pauseReason: "Blocked: waiting for UAT",
   };
   setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, meta);
 
@@ -73,6 +74,7 @@ test("readPausedSessionMetadata round-trips a real PausedSessionMetadata payload
   assert.equal(loaded!.unitType, "plan-slice");
   assert.equal(loaded!.unitId, "M001/S01");
   assert.equal(loaded!.sessionFile, "/tmp/session.jsonl");
+  assert.equal(loaded!.pauseReason, "Blocked: waiting for UAT");
 });
 
 test("readPausedSessionMetadata auto-deletes stale pseudo-milestone pause rows", (t) => {

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

@@ -1,3 +1,5 @@
+// GSD Extension — Plan-slice tool integration tests.
+
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
@@ -8,6 +10,7 @@ import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, ge
 import { handlePlanSlice } from '../tools/plan-slice.ts';
 import { parsePlan } from '../parsers-legacy.ts';
 import { parseTaskPlanFile } from '../files.ts';
+import { deriveState, invalidateStateCache } from '../state.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-plan-slice-'));
@@ -98,6 +101,30 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice advances DB-derived state out of planning immediately', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    invalidateStateCache();
+    const before = await deriveState(base);
+    assert.equal(before.phase, 'planning');
+    assert.equal(before.progress?.tasks?.total, 0);
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    invalidateStateCache();
+    const after = await deriveState(base);
+    assert.notEqual(after.phase, 'planning');
+    assert.equal(after.progress?.tasks?.total, 2);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice leaves omitted enrichment fields empty instead of rendering placeholders', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));