gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { getConsecutiveDispatchBlocker, getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
 
 /** Helper: create temp dir and open an in-dir DB for dispatch-guard tests */
@@ -47,6 +47,33 @@ test("dispatch guard blocks when prior milestone has incomplete slices", (t) =>
   );
 });
 
+test("dispatch guard skips prior DB parked or deferred milestones without marker files", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Parked", status: "parked" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Incomplete", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M002", title: "Deferred", status: "deferred" });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "Incomplete", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M003", title: "Current", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
+    null,
+  );
+});
+
 test("dispatch guard blocks later slice in same milestone when earlier incomplete", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));
@@ -254,6 +281,46 @@ test("dispatch guard does not skip prior milestone from SUMMARY projection when
   );
 });
 
+test("consecutive dispatch guard blocks complete-milestone after repeat cap", () => {
+  // REPEAT_CAP = 2: two same-unit dispatches are allowed; the third is blocked.
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009"), null);
+  assert.match(
+    getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009") ?? "",
+    /same-unit repeat cap reached/,
+  );
+});
+
+test("consecutive dispatch guard resets when unit changes", () => {
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "research-slice", "M001/parallel-research"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+});
+
+test("consecutive dispatch guard resets when phase changes", () => {
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "validate-milestone", "M001"), null);
+});
+
 test("dispatch guard does not skip failed milestone SUMMARY without blocker prose", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -11,12 +11,14 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";
+import type { AutoSession } from "../auto/session.ts";
 import type { GSDState } from "../types.ts";
+import { enableDebug, disableDebug, getDebugLogPath } from "../debug-logger.ts";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
   return {
@@ -42,6 +44,27 @@ function makeContext(basePath: string, stateOverrides?: Partial<GSDState>): Disp
   };
 }
 
+function makeContextFor(
+  basePath: string,
+  mid: string,
+  sid: string,
+  tid: string,
+  session?: Partial<AutoSession>,
+): DispatchContext {
+  return {
+    basePath,
+    mid,
+    midTitle: "Test Milestone",
+    state: makeState({
+      activeMilestone: { id: mid, title: "Test Milestone" },
+      activeSlice: { id: sid, title: "Second Slice" },
+      activeTask: { id: tid, title: "First Task" },
+    }),
+    prefs: undefined,
+    session: session as AutoSession | undefined,
+  };
+}
+
 // ─── Scaffold helpers ──────────────────────────────────────────────────────
 
 function scaffoldSlicePlan(basePath: string, mid: string, sid: string): void {
@@ -118,6 +141,84 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
     `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: executing recovery checks active milestone worktree task plans before re-dispatching plan-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-6192-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+  writeFileSync(join(worktreeRoot, ".git"), "gitdir: /tmp/fake-worktree-gitdir\n");
+  scaffoldMilestoneContext(worktreeRoot, "M002");
+  scaffoldSlicePlan(worktreeRoot, "M002", "S03");
+  scaffoldTaskPlan(worktreeRoot, "M002", "S03", "T01");
+
+  const ctx = makeContext(tmp);
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M002/S03/T01",
+    `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
+test("dispatch: active session worktree task plan wins over missing original-root task plan", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-artifact-root-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M004");
+  scaffoldSlicePlan(tmp, "M004", "S02");
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M004");
+  mkdirSync(worktreeRoot, { recursive: true });
+  scaffoldMilestoneContext(worktreeRoot, "M004");
+  scaffoldSlicePlan(worktreeRoot, "M004", "S02");
+  scaffoldTaskPlan(worktreeRoot, "M004", "S02", "T01");
+
+  const ctx = makeContextFor(tmp, "M004", "S02", "T01", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M004",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M004/S02/T01",
+    `unitId should be M004/S02/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
+test("dispatch: artifact checks trust active session basePath even when originalBasePath matches", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-session-basepath-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M004");
+  scaffoldSlicePlan(tmp, "M004", "S02");
+
+  const activeMilestoneRoot = join(tmp, ".gsd", "runtime-active", "M004");
+  mkdirSync(activeMilestoneRoot, { recursive: true });
+  scaffoldMilestoneContext(activeMilestoneRoot, "M004");
+  scaffoldSlicePlan(activeMilestoneRoot, "M004", "S02");
+  scaffoldTaskPlan(activeMilestoneRoot, "M004", "S02", "T01");
+
+  const ctx = makeContextFor(tmp, "M004", "S02", "T01", {
+    basePath: activeMilestoneRoot,
+    originalBasePath: activeMilestoneRoot,
+    currentMilestoneId: "M004",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M004/S02/T01",
+    `unitId should be M004/S02/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
 test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async (t) => {
   // Simulate: plan-slice ran but T01-PLAN.md is still missing (e.g. agent crashed mid-write).
   // Dispatch should still re-dispatch plan-slice, not hard-stop.
@@ -138,3 +239,41 @@ test("dispatch: plan-slice recovery loop — second call after plan-slice still
   assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
     "should keep dispatching plan-slice until task plans appear");
 });
+
+test("dispatch: missing task plan recovery logs root/worktree diagnostic when debug enabled — issue #6194", async (t) => {
+  // The diagnostic exists to surface root/worktree artifact-path mismatches
+  // when the recovery rule fires. It must report the paths that were checked
+  // so a stuck session can be traced — not just that recovery happened.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-6194-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  enableDebug(tmp);
+  t.after(() => disableDebug());
+
+  const ctx = makeContext(tmp);
+  const result = await resolveDispatch(ctx);
+  assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
+    "recovery rule must fire for the diagnostic to be exercised");
+
+  const logPath = getDebugLogPath();
+  assert.ok(logPath, "debug log path should be set while debug is enabled");
+
+  const entry = readFileSync(logPath!, "utf8")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as Record<string, unknown>)
+    .find((e) => e.event === "dispatch-missing-task-plan-recovery");
+
+  assert.ok(entry, "diagnostic event should be logged when recovery fires in debug mode");
+  assert.equal(entry!.basePathUsedForArtifactChecks, tmp);
+  assert.equal(entry!.artifactExists, false, "task plan is genuinely absent");
+  assert.equal(entry!.expectedTaskPlanExists, false, "expected task plan is genuinely absent");
+  assert.equal(entry!.projectionArtifactExists, false, "projection task plan is genuinely absent");
+  assert.equal(entry!.hasRootWorktreeMismatch, false, "root/worktree mismatch should be false in single-root scenario");
+  assert.equal(typeof entry!.expectedTaskPlanPath, "string");
+  assert.equal(typeof entry!.projectionTaskPlanPath, "string");
+});

package/src/resources/extensions/gsd/tests/doctor-empty-worktree.test.ts

@@ -0,0 +1,65 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for doctor repair of empty milestone worktrees.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { createWorktree, worktreePath } from "../worktree-manager.ts";
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-empty-worktree-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  writeFileSync(join(base, "package.json"), "{\"scripts\":{}}\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+  return base;
+}
+
+test("doctor fix recreates an empty registered milestone worktree", async (t) => {
+  const base = makeRepo();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  createWorktree(base, "M001", { branch: "milestone/M001" });
+  const wtPath = worktreePath(base, "M001");
+  writeFileSync(join(wtPath, "milestone-note.txt"), "worktree branch content\n", "utf-8");
+  runGit(["add", "milestone-note.txt"], wtPath);
+  runGit(["commit", "-m", "test: add milestone content"], wtPath);
+  for (const entry of readdirSync(wtPath)) {
+    if (entry === ".git") continue;
+    rmSync(join(wtPath, entry), { recursive: true, force: true });
+  }
+  assert.ok(existsSync(join(wtPath, ".git")), "test setup keeps registered worktree marker");
+  assert.equal(existsSync(join(wtPath, "package.json")), false, "test setup removes project content");
+
+  const report = await runGSDDoctor(base, {
+    fix: true,
+    fixLevel: "all",
+    isolationMode: "worktree",
+  });
+
+  assert.ok(
+    report.issues.some((issue) => issue.code === "worktree_empty_with_project_content"),
+    "doctor reports the empty worktree",
+  );
+  assert.ok(
+    report.fixesApplied.some((fix) => fix.includes("recreated empty worktree")),
+    "doctor applies the repair",
+  );
+  assert.ok(existsSync(join(wtPath, "package.json")), "worktree content is restored");
+  assert.ok(existsSync(join(wtPath, "milestone-note.txt")), "branch content is restored");
+});

package/src/resources/extensions/gsd/tests/doctor-forensics-db-open-regression.test.ts

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { closeDatabase } from "../gsd-db.ts";
+import { buildForensicReport } from "../forensics.ts";
+import { handleDoctor } from "../commands-handlers.ts";
+import { withCommandCwd } from "../commands/context.ts";
+
+test("#5194 forensics opens DB before computing completion counts", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-forensics-db-open-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  closeDatabase();
+
+  const report = await buildForensicReport(base);
+  assert.ok(report.dbCompletionCounts, "forensics should expose DB completion counts when .gsd exists");
+  assert.equal(report.dbCompletionCounts?.milestonesTotal, 0);
+  assert.equal(report.dbCompletionCounts?.slicesTotal, 0);
+  assert.equal(report.dbCompletionCounts?.tasksTotal, 0);
+});
+
+test("#5194 doctor command does not emit false db_unavailable when gsd.db exists", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-db-open-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, "gsd.db"), "");
+  closeDatabase();
+
+  const notifications: string[] = [];
+  const ctx = { ui: { notify: (msg: string) => notifications.push(msg) } } as any;
+  const pi = {} as any;
+
+  await withCommandCwd(base, async () => {
+    await handleDoctor("--json", ctx, pi);
+  });
+
+  const jsonReport = notifications.find((entry) => entry.trim().startsWith("{"));
+  assert.ok(jsonReport, "doctor --json should emit a JSON report");
+  assert.doesNotMatch(
+    jsonReport!,
+    /"code"\s*:\s*"db_unavailable"/,
+    "doctor should not report db_unavailable when it can open project DB",
+  );
+});

package/src/resources/extensions/gsd/tests/evidence-cross-ref.test.ts

@@ -0,0 +1,97 @@
+// Project/App: GSD-2
+// File Purpose: Tests for verification evidence cross-reference mismatch policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { crossReferenceEvidence } from "../safety/evidence-cross-ref.ts";
+import type { EvidenceEntry } from "../safety/evidence-collector.ts";
+
+test("claims of passing verification become errors when recorded bash evidence failed", () => {
+  const mismatches = crossReferenceEvidence(
+    [{ command: "npm test", exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command: "npm test",
+        exitCode: 1,
+        outputSnippet: "failed",
+        timestamp: Date.now(),
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "error");
+  assert.match(mismatches[0].reason, /Claimed exitCode=0/);
+});
+
+test("passing retry evidence is not invalidated by an earlier failed run of the same command", () => {
+  const command = "node todo.js add 'Task A' && node todo.js add 'Task B' && node todo.js done 1";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed after retry" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 1,
+        outputSnippet: "Task #1 not found",
+        timestamp: 1,
+      },
+      {
+        kind: "bash",
+        toolCallId: "call-2",
+        command,
+        exitCode: 0,
+        outputSnippet: "Marked #1 done.",
+        timestamp: 2,
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.deepEqual(mismatches, []);
+});
+
+test("stale verification evidence batches are ignored when a newer completion batch exists", () => {
+  const command = "node todo.js add 'Task A' && node todo.js add 'Task B' && node todo.js done 1";
+  const resetCommand = `rm -f "$HOME/.config/todo/data.json" && ${command}`;
+  const mismatches = crossReferenceEvidence(
+    [
+      { command, exitCode: 0, verdict: "pass", createdAt: "2026-05-14T11:16:48.588Z" },
+      { command, exitCode: 1, verdict: "fail before reset", createdAt: "2026-05-14T11:28:36.952Z" },
+      { command: resetCommand, exitCode: 0, verdict: "pass after reset", createdAt: "2026-05-14T11:28:36.952Z" },
+    ],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 1,
+        outputSnippet: "Task #1 not found",
+        timestamp: 1,
+      },
+      {
+        kind: "bash",
+        toolCallId: "call-2",
+        command: resetCommand,
+        exitCode: 0,
+        outputSnippet: "Marked #1 done.",
+        timestamp: 2,
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.deepEqual(mismatches, []);
+});
+
+test("missing recorded bash evidence remains a warning", () => {
+  const mismatches = crossReferenceEvidence(
+    [{ command: "npm test", exitCode: 0, verdict: "passed" }],
+    [],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "warning");
+});

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -1,6 +1,9 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for the context-mode gsd_exec sandbox.
+
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -235,6 +238,101 @@ test('executeGsdExec: rejects empty script', async () => {
   }
 });
 
+test('executeGsdExec: rejects original-root scripts from milestone worktrees', async () => {
+  const base = freshBase();
+  try {
+    const originalRoot = join(base, 'project');
+    const worktree = join(originalRoot, '.gsd', 'worktrees', 'M004');
+    mkdirSync(worktree, { recursive: true });
+
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: `cd ${originalRoot} && node todo.js --help` },
+      { baseDir: worktree, preferences: { context_mode: { enabled: true } } },
+    );
+
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'invalid_params');
+    assert.match(
+      (result.details as { detail?: string }).detail ?? '',
+      /original project root/,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: rejects original-root traversal after shell boolean operators', async () => {
+  const base = freshBase();
+  try {
+    const originalRoot = join(base, 'project');
+    const worktree = join(originalRoot, '.gsd', 'worktrees', 'M004');
+    mkdirSync(worktree, { recursive: true });
+
+    const scripts = [
+      'echo hi && cd ../../.. && pwd',
+      'true || cd ../../..',
+    ];
+
+    for (const script of scripts) {
+      const result = await executeGsdExec(
+        { runtime: 'bash', script },
+        { baseDir: worktree, preferences: { context_mode: { enabled: true } } },
+      );
+      assert.equal(result.isError, true);
+      assert.equal((result.details as { error?: string }).error, 'invalid_params');
+      assert.match((result.details as { detail?: string }).detail ?? '', /original project root/);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: allows active worktree paths from milestone worktrees', async () => {
+  const base = freshBase();
+  try {
+    const originalRoot = join(base, 'project');
+    const worktree = join(originalRoot, '.gsd', 'worktrees', 'M004');
+    mkdirSync(worktree, { recursive: true });
+
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: `cd ${worktree} && pwd` },
+      { baseDir: worktree, preferences: { context_mode: { enabled: true } } },
+    );
+
+    assert.equal(result.isError, false);
+    assert.equal(result.details.exit_code, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: rejects relative traversal to original root from milestone worktree', async () => {
+  const base = freshBase();
+  try {
+    const originalRoot = join(base, 'project');
+    const worktree = join(originalRoot, '.gsd', 'worktrees', 'M004');
+    mkdirSync(worktree, { recursive: true });
+
+    const scripts = [
+      'cd ../../.. && pwd',
+      "node -e \"process.chdir('../../..'); console.log(process.cwd())\"",
+      "node -e \"const p = require('node:path'); process.chdir(p.join(process.cwd(), '../../..')); console.log(process.cwd())\"",
+    ];
+
+    for (const script of scripts) {
+      const result = await executeGsdExec(
+        { runtime: 'bash', script },
+        { baseDir: worktree, preferences: { context_mode: { enabled: true } } },
+      );
+      assert.equal(result.isError, true, `expected script to be rejected: ${script}`);
+      assert.equal((result.details as { error?: string }).error, 'invalid_params');
+      assert.match((result.details as { detail?: string }).detail ?? '', /original project root/);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('validatePreferences: rejects invalid context_mode preference values', () => {
   const result = validatePreferences({
     context_mode: {

package/src/resources/extensions/gsd/tests/execution-entry-missing-context-4671.test.ts

@@ -45,7 +45,7 @@ function buildState(phase: Phase): GSDState {
 
 function makeBasePath(prefix: string): string {
   const dir = mkdtempSync(join(tmpdir(), `gsd-4671-${prefix}-`));
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(dir, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
   return dir;
 }
 
@@ -99,6 +99,20 @@ describe("#4671 execution-entry phase missing-context recovery", () => {
     }
   });
 
+  test("phase=executing with slice PLAN.md present → falls through (milestone already passed discuss)", async () => {
+    const basePath = makeBasePath("has-plan");
+    try {
+      writeFileSync(
+        join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+        "# S01 Plan\n\n- [ ] **T01**: work\n",
+      );
+      const action = await findRule().match(buildCtx(basePath, buildState("executing")));
+      assert.strictEqual(action, null, "rule must fall through when planning artifacts already exist");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
   test("phase=executing accepts finalized CONTEXT.md from GSD_PROJECT_ROOT fallback", async () => {
     const projectRoot = makeBasePath("project-root-context");
     const worktreeBase = makeBasePath("worktree-context");

package/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts

@@ -141,6 +141,14 @@ test("Feature 1: executive summary paragraph is rendered", () => {
   assert.ok(html.includes("$2.50 spent"), "should contain cost");
 });
 
+test("report uses the shared GSD HTML shell", () => {
+  const html = generateHtmlReport(mockData(), mockOpts());
+  assert.ok(html.includes('<span class="logo">GSD</span>'), "should render shared shell logo");
+  assert.ok(html.includes('<span class="kind-chip">Report</span>'), "should render report kind chip");
+  assert.ok(html.includes('<nav class="toc" aria-label="Report sections">'), "should render shared shell TOC");
+  assert.ok(html.includes('<main>'), "should render content inside shared shell main");
+});
+
 test("Feature 1: executive summary includes budget context when set", () => {
   const data = mockData({ health: { ...mockData().health, budgetCeiling: 10.00 } });
   const html = generateHtmlReport(data, mockOpts());

package/src/resources/extensions/gsd/tests/freeform-decisions.test.ts

@@ -14,6 +14,7 @@ import {
 import {
   saveDecisionToDb,
 } from '../db-writer.ts';
+import { getAllDecisionsFromMemories } from '../context-store.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -31,11 +32,14 @@ function cleanupDir(dir: string): void {
   } catch { /* swallow */ }
 }
 
-/** Query all decisions from the DB ordered by seq. */
+/**
+ * Query all decisions. ADR-013 Stage 3 (PR #5755): decisions are written
+ * exclusively to memories; this helper returns the same Decision shape the
+ * previous SELECT * FROM decisions produced so the assertions below stay
+ * one-line lookups.
+ */
 function queryAllDecisions(): Array<Record<string, unknown>> {
-  const adapter = _getAdapter();
-  if (!adapter) return [];
-  return adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
+  return getAllDecisionsFromMemories().map((d) => ({ ...d }));
 }
 
 // ═══════════════════════════════════════════════════════════════════════════