gsd-pi 2.82.0-dev.3a3c6509d → 2.82.0-dev.57fd453e4

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/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 [];
 		}