gsd-pi 2.82.0-dev.3a3c6509d → 2.82.0-dev.4285182e8

package/src/resources/extensions/gsd/tests/auto-post-unit-step-message.test.ts

@@ -1,4 +1,5 @@
-// GSD-2 — Tests for step-mode completion messages in auto-post-unit
+// Project/App: GSD-2
+// File Purpose: Tests for step-mode completion messages in auto-post-unit.
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -31,7 +32,7 @@ test("buildStepCompleteMessage: milestone complete surfaces review guidance", ()
   assert.doesNotMatch(msg, /Next:/);
 });
 
-test("buildStepCompleteMessage: mid-flight step includes next unit label and /clear hint", () => {
+test("buildStepCompleteMessage: mid-flight step includes next unit label and /gsd next hint", () => {
   const state = makeState({
     phase: "executing",
     activeSlice: { id: "S01", title: "Core" },
@@ -40,7 +41,7 @@ test("buildStepCompleteMessage: mid-flight step includes next unit label and /cl
   const msg = buildStepCompleteMessage(state);
   assert.match(msg, /Next: Execute T03: Wire notify/);
   assert.match(msg, /\/clear/);
-  assert.match(msg, /\/gsd to continue/);
+  assert.match(msg, /\/gsd next to continue one step/);
 });
 
 test("buildStepCompleteMessage: unknown phase falls back to generic continue label", () => {
@@ -51,9 +52,9 @@ test("buildStepCompleteMessage: unknown phase falls back to generic continue lab
   assert.match(msg, /\/clear/);
 });
 
-test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points users at /clear + /gsd", () => {
+test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points users at /clear + /gsd next", () => {
   assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/clear/);
-  assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd/);
+  assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd next/);
 });
 
 test("shouldReturnStepWizardAfterUnit: terminal milestone completion continues to merge-back path", () => {

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -0,0 +1,378 @@
+/**
+ * Tests for /gsd verdict — manual override of milestone validation verdict.
+ *
+ * Covers parseValidationFile section extraction and handleVerdict end-to-end:
+ * pass override, needs-remediation override with rationale, missing rationale
+ * rejection, active-milestone fallback, missing VALIDATION rejection.
+ *
+ * Also asserts the three paused-state messages reference /gsd verdict so the
+ * user has a discoverable recovery path.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { handleVerdict, parseValidationFile } from "../commands-verdict.ts";
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
+
+interface NotifyCall {
+  message: string;
+  kind: string;
+}
+
+function makeMockCtx(): { ctx: any; calls: NotifyCall[] } {
+  const calls: NotifyCall[] = [];
+  const ctx = {
+    ui: {
+      notify: (message: string, kind: string) => {
+        calls.push({ message, kind });
+      },
+    },
+  };
+  return { ctx, calls };
+}
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-verdict-${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"));
+}
+
+function seedMilestone(milestoneId: string, title: string, status = "active"): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)",
+  ).run(milestoneId, title, status, new Date().toISOString());
+}
+
+function seedSlice(milestoneId: string, sliceId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO slices (milestone_id, id, title, status, created_at) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, `Slice ${sliceId}`, status, new Date().toISOString());
+}
+
+function writeValidation(base: string, milestoneId: string, verdict: string, round = 0): string {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(milestoneDir, { recursive: true });
+  const path = join(milestoneDir, `${milestoneId}-VALIDATION.md`);
+  const md = [
+    "---",
+    `verdict: ${verdict}`,
+    `remediation_round: ${round}`,
+    "---",
+    "",
+    `# Milestone Validation: ${milestoneId}`,
+    "",
+    "## Success Criteria Checklist",
+    "- [x] Criterion A met",
+    "- [x] Criterion B met",
+    "",
+    "## Slice Delivery Audit",
+    "| Slice | Result |",
+    "| --- | --- |",
+    "| S01 | delivered |",
+    "",
+    "## Cross-Slice Integration",
+    "No cross-slice mismatches detected.",
+    "",
+    "## Requirement Coverage",
+    "All requirements covered.",
+    "",
+    "## Verdict Rationale",
+    `Initial verdict was ${verdict}.`,
+    "",
+  ].join("\n");
+  writeFileSync(path, md);
+  return path;
+}
+
+// ─── parseValidationFile ────────────────────────────────────────────────
+
+test("parseValidationFile extracts all standard sections and frontmatter", () => {
+  const md = [
+    "---",
+    "verdict: needs-attention",
+    "remediation_round: 2",
+    "---",
+    "",
+    "# Milestone Validation: M001",
+    "",
+    "## Success Criteria Checklist",
+    "- [x] First",
+    "- [ ] Second",
+    "",
+    "## Slice Delivery Audit",
+    "| Slice | Delivered |",
+    "",
+    "## Cross-Slice Integration",
+    "Boundary intact.",
+    "",
+    "## Requirement Coverage",
+    "R001 covered.",
+    "",
+    "## Verification Class Compliance",
+    "Operational: MET",
+    "",
+    "## Verdict Rationale",
+    "Acceptance proof incomplete.",
+    "",
+    "## Remediation Plan",
+    "Address acceptance proof.",
+    "",
+  ].join("\n");
+
+  const parsed = parseValidationFile(md);
+
+  assert.equal(parsed.verdict, "needs-attention");
+  assert.equal(parsed.remediationRound, 2);
+  assert.match(parsed.successCriteriaChecklist, /First/);
+  assert.match(parsed.successCriteriaChecklist, /Second/);
+  assert.match(parsed.sliceDeliveryAudit, /Delivered/);
+  assert.match(parsed.crossSliceIntegration, /Boundary intact/);
+  assert.match(parsed.requirementCoverage, /R001 covered/);
+  assert.match(parsed.verificationClasses ?? "", /Operational: MET/);
+  assert.match(parsed.verdictRationale, /Acceptance proof incomplete/);
+  assert.match(parsed.remediationPlan ?? "", /Address acceptance proof/);
+});
+
+test("parseValidationFile omits optional sections when absent", () => {
+  const md = [
+    "---",
+    "verdict: pass",
+    "remediation_round: 0",
+    "---",
+    "",
+    "## Success Criteria Checklist",
+    "- [x] All met",
+    "",
+    "## Slice Delivery Audit",
+    "Done.",
+    "",
+    "## Cross-Slice Integration",
+    "Clean.",
+    "",
+    "## Requirement Coverage",
+    "Complete.",
+    "",
+    "## Verdict Rationale",
+    "All criteria met.",
+  ].join("\n");
+
+  const parsed = parseValidationFile(md);
+
+  assert.equal(parsed.verdict, "pass");
+  assert.equal(parsed.remediationRound, 0);
+  assert.equal(parsed.verificationClasses, undefined);
+  assert.equal(parsed.remediationPlan, undefined);
+});
+
+// ─── handleVerdict — argument validation ────────────────────────────────
+
+test("handleVerdict rejects missing verdict", async () => {
+  const { ctx, calls } = makeMockCtx();
+  await handleVerdict("", ctx, "/tmp/unused");
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /Usage: \/gsd verdict/);
+  assert.equal(calls[0].kind, "warning");
+});
+
+test("handleVerdict rejects invalid verdict", async () => {
+  const { ctx, calls } = makeMockCtx();
+  await handleVerdict("yolo", ctx, "/tmp/unused");
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /Invalid verdict "yolo"/);
+  assert.equal(calls[0].kind, "warning");
+});
+
+test("handleVerdict rejects needs-remediation without --rationale", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    writeValidation(base, "M001", "pass");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("needs-remediation --milestone M001", ctx, base);
+
+    assert.ok(
+      calls.some((c) => /--rationale is required/.test(c.message)),
+      `expected rationale-required warning, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict rejects when VALIDATION file is missing", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    assert.ok(
+      calls.some((c) => /No VALIDATION file found/.test(c.message)),
+      `expected missing-VALIDATION warning, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+// ─── handleVerdict — pass override flow ─────────────────────────────────
+
+test("handleVerdict pass override flips verdict and preserves sections", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    const validationPath = writeValidation(base, "M001", "needs-attention");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: pass$/m, "verdict should flip to pass");
+    assert.match(rewritten, /Criterion A met/, "success criteria preserved");
+    assert.match(rewritten, /S01 \| delivered/, "slice audit preserved");
+    assert.match(rewritten, /Manually overridden via \/gsd verdict/, "default rationale applied");
+
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /needs-attention.*->.*pass/.test(c.message)),
+      `expected success notification, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict needs-remediation override with --rationale rewrites verdict", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    const validationPath = writeValidation(base, "M001", "pass");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict(
+      'needs-remediation --milestone M001 --rationale "found missing slice"',
+      ctx,
+      base,
+    );
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: needs-remediation$/m);
+    assert.match(rewritten, /found missing slice/);
+
+    assert.ok(
+      calls.some((c) => /gsd_reassess_roadmap/.test(c.message)),
+      "needs-remediation override should suggest gsd_reassess_roadmap follow-up",
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict resolves active milestone when --milestone omitted", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M042", "Active Milestone");
+    seedSlice("M042", "S01", "complete");
+    const validationPath = writeValidation(base, "M042", "needs-attention");
+
+    const { ctx, calls } = makeMockCtx();
+    invalidateStateCache();
+    await handleVerdict("pass", ctx, base);
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: pass$/m);
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /M042/.test(c.message)),
+      `expected success notification naming M042, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+// ─── Pause messages reference /gsd verdict ─────────────────────────────
+
+test("auto-dispatch needs-attention pause message references /gsd verdict", async () => {
+  const { DISPATCH_RULES } = await import("../auto-dispatch.ts");
+  const rule = DISPATCH_RULES.find((r) => r.name === "completing-milestone → complete-milestone");
+  assert.ok(rule, "completing-milestone rule should exist");
+
+  const base = mkdtempSync(join(tmpdir(), "gsd-verdict-paused-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds work.\n",
+    );
+
+    const result = await rule!.match({
+      mid: "M001",
+      midTitle: "Test",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    } as any);
+
+    assert.ok(result !== null);
+    assert.equal(result!.action, "stop");
+    if (result!.action === "stop") {
+      assert.match(result!.reason, /\/gsd verdict/);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("state.ts needs-remediation blocker messages reference /gsd verdict", async () => {
+  // We don't need to invoke deriveState — just assert the substring is in the
+  // source. The blocker strings are constructed inline and shipped to the user
+  // verbatim, so a static check is sufficient and avoids fragile DB setup.
+  const stateSource = readFileSync(
+    new URL("../state.ts", import.meta.url).pathname,
+    "utf-8",
+  );
+  const occurrences = stateSource.match(/`\/gsd verdict /g) ?? [];
+  assert.ok(
+    occurrences.length >= 2,
+    `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
+  );
+});

package/src/resources/extensions/gsd/tests/gsdroot-worktree-detection.test.ts

@@ -3,7 +3,7 @@
  *
  * gsdRoot() must return the canonical project .gsd directory when basePath
  * is inside a .gsd/worktrees/<name>/ structure. Worktree-local .gsd folders
- * are legacy projection roots only; runtime state is DB-authoritative at the
+ * are projection roots; runtime/control state stays DB-authoritative at the
  * project .gsd.
  *
  * The bug: when a git worktree lives at /project/.gsd/worktrees/M008/,
@@ -21,7 +21,7 @@ import { mkdtempSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 
-import { gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
+import { gsdProjectionRoot, gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
 
 describe("gsdRoot() worktree detection (#2594)", () => {
   let projectRoot: string;
@@ -76,6 +76,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
     assert.equal(resolveGsdPathContract(worktreeBase).worktreeGsd, worktreeGsd);
+    assert.equal(gsdProjectionRoot(worktreeBase), worktreeGsd);
   });
 
   test("returns project .gsd when worktree .gsd does not exist yet", () => {
@@ -89,6 +90,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       projectGsd,
       `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
+    assert.equal(gsdProjectionRoot(worktreeBase), join(worktreeBase, ".gsd"));
   });
 
   test("returns project .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
@@ -116,6 +118,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       projectGsd,
       `Expected canonical project .gsd (${projectGsd}), got ${gsdResult}`,
     );
+    assert.equal(gsdProjectionRoot(worktreeBase), join(worktreeBase, ".gsd"));
 
     // Cleanup worktree
     spawnSync("git", ["worktree", "remove", "--force", worktreeBase], {

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

@@ -2,7 +2,7 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -105,6 +105,31 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice renders plan artifacts under worktree-local .gsd while using project DB', async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, '.gsd', 'worktrees', 'M001');
+  mkdirSync(join(worktree, '.gsd'), { recursive: true });
+  mkdirSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools'), { recursive: true });
+  writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-milestone.ts'), '// fixture\n', 'utf-8');
+  writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-task.ts'), '// fixture\n', 'utf-8');
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const result = await handlePlanSlice(validParams(), worktree);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const worktreePlan = join(worktree, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const projectPlan = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    assert.ok(existsSync(worktreePlan), 'slice plan should be rendered to worktree-local .gsd');
+    assert.ok(!existsSync(projectPlan), 'slice plan should not be rendered to project .gsd');
+    assert.equal(result.planPath, realpathSync(worktreePlan));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice advances DB-derived state out of planning immediately', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -8,8 +8,32 @@ import assert from "node:assert/strict";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
 import { AutoSession } from "../auto/session.ts";
 import { postUnitPreVerification } from "../auto-post-unit.ts";
+import {
+  _getAdapter,
+  closeDatabase,
+  getTask,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+
+const _require = createRequire(import.meta.url);
+
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require("node:sqlite") as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require("better-sqlite3") as SqliteCtor | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === "function" ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
 
 test("postUnitPreVerification rebuilds STATE.md after a completed unit", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-state-"));
@@ -47,3 +71,63 @@ test("postUnitPreVerification rebuilds STATE.md after a completed unit", async (
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("postUnitPreVerification refreshes DB before checking execute-task completion", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-db-refresh-"));
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap\n\n## Slices\n\n- [ ] **S01: Slice** `risk:low` `depends:[]`\n",
+    );
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      "# S01: Slice\n\n## Tasks\n\n- [ ] **T01: Do work** `est:30m`\n",
+    );
+    writeFileSync(
+      join(tasksDir, "T01-SUMMARY.md"),
+      "---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01\nDone.\n",
+    );
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Do work", status: "pending" });
+    const adapterBefore = _getAdapter();
+
+    const externalDb = openRawSqliteForTest(dbPath);
+    try {
+      externalDb.exec("UPDATE tasks SET status = 'complete', completed_at = '2026-05-14T00:00:00.000Z' WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'");
+    } finally {
+      externalDb.close();
+    }
+
+    const s = new AutoSession();
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentMilestoneId = "M001";
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    const result = await postUnitPreVerification({
+      s,
+      ctx: { ui: { notify() {} } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    }, { skipSettleDelay: true, skipWorktreeSync: true });
+
+    assert.equal(result, "continue");
+    assert.notEqual(_getAdapter(), adapterBefore, "post-unit flow must reopen the DB before deriving state");
+    assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
+    assert.equal(s.pendingVerificationRetry, null);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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/workflow-kernel.test.ts

@@ -165,6 +165,13 @@ test("decideFinalizeResult maps break results to stop decisions", () => {
   );
 });
 
+test("decideFinalizeResult maps step-wizard breaks to completed step exits", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "break", reason: "step-wizard" }),
+    { action: "complete-and-break" },
+  );
+});
+
 test("decideFinalizeResult maps continue and next results", () => {
   assert.deepEqual(
     decideFinalizeResult({ action: "continue" }),

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -27,7 +27,7 @@ import { logWarning } from "../workflow-logger.js";
 import { validatePlanningPathScope } from "../planning-path-scope.js";
 import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
 import type { TaskRow } from "../db-task-slice-rows.js";
-import { buildTaskFileName, gsdRoot, resolveTasksDir } from "../paths.js";
+import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 
 export interface PlanSliceTaskInput {
   taskId: string;
@@ -314,12 +314,11 @@ export async function handlePlanSlice(
   }
 
   try {
-    const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+    const tasksDir = join(gsdProjectionRoot(basePath), "milestones", params.milestoneId, "slices", params.sliceId, "tasks");
     for (const taskId of omittedTaskIds) {
-      if (!tasksDir) continue;
       const taskPlanPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
       if (existsSync(taskPlanPath)) rmSync(taskPlanPath, { force: true });
-      const artifactPath = relative(gsdRoot(basePath), taskPlanPath).replace(/\\/g, "/");
+      const artifactPath = relative(gsdProjectionRoot(basePath), taskPlanPath).replace(/\\/g, "/");
       deleteArtifactByPath(artifactPath);
     }
 

package/src/resources/extensions/ttsr/ttsr-manager.ts

@@ -109,6 +109,7 @@ const MAX_BUFFER_BYTES = 512 * 1024;
  * Prevents CPU spinning when deltas arrive faster than regex evaluation (#468).
  */
 const JS_FALLBACK_CHECK_INTERVAL_MS = 50;
+const JS_FALLBACK_THROTTLE_MIN_BUFFER_BYTES = 4 * 1024;
 
 const DEFAULT_SCOPE: TtsrScope = {
 	allowText: true,
@@ -383,7 +384,10 @@ export class TtsrManager {
 		// streams — regex on a growing buffer is O(rules × buffer_size) (#468).
 		const now = Date.now();
 		const lastCheck = this.#lastJsCheckAt.get(bufferKey) ?? 0;
-		if (now - lastCheck < JS_FALLBACK_CHECK_INTERVAL_MS) {
+		if (
+			nextBuffer.length >= JS_FALLBACK_THROTTLE_MIN_BUFFER_BYTES &&
+			now - lastCheck < JS_FALLBACK_CHECK_INTERVAL_MS
+		) {
 			stopTimer({ bufferSize: nextBuffer.length, throttled: true });
 			return [];
 		}