gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

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

@@ -113,8 +113,9 @@ test("#4782 phase 3: buildCompleteSlicePrompt composes roadmap → plan → task
     "task summaries precede slice-summary template",
   );
 
-  // Task body inlined
-  assert.match(prompt, /Task one did the thing/);
+  // Task summary excerpt is inlined; full narrative remains on-demand.
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.doesNotMatch(prompt, /Task one did the thing/);
 });
 
 test("#4782 phase 3: buildCompleteSlicePrompt handles missing task summaries gracefully", async (t) => {

package/src/resources/extensions/gsd/tests/complete-task-normalize-lists.test.ts

@@ -9,46 +9,42 @@
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const completeTaskSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'complete-task.ts'),
-  'utf-8',
-);
-const roadmapSlicesSrc = readFileSync(
-  join(__dirname, '..', 'roadmap-slices.ts'),
-  'utf-8',
-);
+import { normalizeListParam } from "../tools/complete-task.ts";
+import { parseRoadmapSlices } from "../roadmap-slices.ts";
 
 describe('complete-task normalizeListParam (#3692)', () => {
-  test('normalizeListParam function is defined', () => {
-    assert.match(completeTaskSrc, /function normalizeListParam\(/,
-      'normalizeListParam function should be defined in complete-task.ts');
+  test('normalizes newline-delimited key file strings', () => {
+    assert.deepEqual(
+      normalizeListParam("- src/app.ts\n* tests/app.test.ts\n  docs/notes.md"),
+      ["src/app.ts", "tests/app.test.ts", "docs/notes.md"],
+    );
   });
 
-  test('normalizeListParam is applied to keyFiles', () => {
-    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyFiles\)/,
-      'normalizeListParam should be applied to keyFiles');
-  });
-
-  test('normalizeListParam is applied to keyDecisions', () => {
-    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyDecisions\)/,
-      'normalizeListParam should be applied to keyDecisions');
+  test('normalizes arrays and empty values', () => {
+    assert.deepEqual(normalizeListParam(["api", 42]), ["api", "42"]);
+    assert.deepEqual(normalizeListParam("   "), []);
+    assert.deepEqual(normalizeListParam(undefined), []);
   });
 });
 
 describe('roadmap-slices depColumnIndex detection (#3692)', () => {
-  test('depColumnIndex is detected from header row', () => {
-    assert.match(roadmapSlicesSrc, /depColumnIndex/,
-      'depColumnIndex variable should exist in roadmap-slices.ts');
-    assert.match(roadmapSlicesSrc, /headerCells/,
-      'headerCells should be parsed from the header row');
-    assert.match(roadmapSlicesSrc, /depends|deps|depend/i,
-      'header detection should match depends/deps/depend');
+  test('parses dependencies from the dependency table column only', () => {
+    const slices = parseRoadmapSlices([
+      "## Slices",
+      "| ID | Title | Risk | Depends | Status |",
+      "| -- | ----- | ---- | ------- | ------ |",
+      "| S01 | Foundation | low | none | Done |",
+      "| S02 | Title mentions S01 but no dependency | medium | none | Pending |",
+      "| S03 | Integration | high | S01, S02 | Pending |",
+    ].join("\n"));
+
+    assert.deepEqual(
+      slices.map((slice) => ({ id: slice.id, depends: slice.depends })),
+      [
+        { id: "S01", depends: [] },
+        { id: "S02", depends: [] },
+        { id: "S03", depends: ["S01", "S02"] },
+      ],
+    );
   });
 });

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -1,124 +1,61 @@
 /**
  * completed-units-metrics-sync.test.ts — Regression tests for #2313.
- *
- * 1. completed-units.json should be archived (not wiped) on milestone transition
- * 2. metrics.json should be in the worktree → project root sync file list
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-
-// ─── Bug 1: completed-units.json should be archived, not wiped ─────────────
-
-const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
-
-test("#2313: completed-units.json should not be blindly wiped to [] on milestone transition", () => {
-  // The milestone transition block should NOT write an empty array to completed-units.json
-  // without first archiving the existing data. Look for the archive/rename pattern.
-  const transitionIdx = phasesSrc.indexOf("Milestone transition");
-  assert.ok(transitionIdx !== -1, "Milestone transition section exists");
-
-  // Find the completed-units handling block
-  const completedUnitsIdx = phasesSrc.indexOf("completed-units", transitionIdx);
-  assert.ok(completedUnitsIdx !== -1, "completed-units handling exists in transition");
-
-  // Get a window around the completed-units handling (1200 chars to
-  // accommodate CRLF line endings on Windows which inflate byte offsets).
-  const windowStart = Math.max(0, completedUnitsIdx - 300);
-  const windowEnd = Math.min(phasesSrc.length, completedUnitsIdx + 900);
-  const window = phasesSrc.slice(windowStart, windowEnd).toLowerCase();
-
-  // Should archive/rename the old file before resetting
-  const hasArchive = window.includes("archive") ||
-    window.includes("rename") ||
-    window.includes("cpsync") ||
-    window.includes("safecopy") ||
-    window.includes("completed-units-");
-
-  assert.ok(
-    hasArchive,
-    "completed-units.json should be archived before reset during milestone transition",
-  );
-});
-
-// ─── Bug 2: metrics.json should be in the sync file lists ──────────────────
-
-test("#2313: syncStateToProjectRoot should sync metrics.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const syncSrc = readFileSync(syncSrcPath, "utf-8");
-
-  // syncStateToProjectRoot should copy metrics.json from worktree to project root
-  assert.ok(
-    syncSrc.includes("metrics.json"),
-    "auto-worktree.ts should reference metrics.json for sync",
-  );
-});
-
-test("syncStateToProjectRoot should back-sync completed-units.json", () => {
-  const syncSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const syncSrc = readFileSync(syncSrcPath, "utf-8");
-  const fnIdx = syncSrc.indexOf("export function syncStateToProjectRoot(");
-  assert.ok(fnIdx !== -1, "syncStateToProjectRoot exists");
-  const fnBlock = syncSrc.slice(fnIdx, syncSrc.indexOf("// ─── Resource Staleness", fnIdx));
-
-  assert.ok(
-    fnBlock.includes('"completed-units.json"'),
-    "syncStateToProjectRoot should copy completed-units.json back to the project root",
-  );
-});
-
-test("#2313: syncWorktreeStateBack should include metrics.json in ROOT_DIAGNOSTIC_FILES", () => {
-  const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
-
-  // Find the ROOT_DIAGNOSTIC_FILES constant used for worktree copy-back.
-  const constIdx = autoWorktreeSrc.indexOf("ROOT_DIAGNOSTIC_FILES");
-  assert.ok(constIdx !== -1, "ROOT_DIAGNOSTIC_FILES constant exists");
-
-  // Get the array content
-  const arrayStart = autoWorktreeSrc.indexOf("[", constIdx);
-  const arrayEnd = autoWorktreeSrc.indexOf("]", arrayStart);
-  const rootFilesBlock = autoWorktreeSrc.slice(arrayStart, arrayEnd);
-
-  assert.ok(
-    rootFilesBlock.includes("metrics.json"),
-    "metrics.json should be in ROOT_DIAGNOSTIC_FILES list",
-  );
+import { syncStateToProjectRoot } from "../auto-worktree.ts";
+
+test("#2313: syncStateToProjectRoot copies metrics and completed-units to the project root", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-sync-metrics-"));
+  const projectRoot = join(root, "project");
+  const worktree = join(root, "worktree");
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  writeFileSync(join(worktree, ".gsd", "metrics.json"), JSON.stringify({ tokens: 42 }));
+  writeFileSync(join(worktree, ".gsd", "completed-units.json"), JSON.stringify([{ id: "T01" }]));
+
+  try {
+    syncStateToProjectRoot(worktree, projectRoot, "M001");
+
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(projectRoot, ".gsd", "metrics.json"), "utf-8")),
+      { tokens: 42 },
+    );
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(projectRoot, ".gsd", "completed-units.json"), "utf-8")),
+      [{ id: "T01" }],
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
 });
 
-// ─── Functional test: completed-units archive ────────────────────────────────
-
 test("#2313: functional — completed-units archive creates milestone-specific file", () => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-completed-units-"));
   const gsdDir = join(tmpBase, ".gsd");
   mkdirSync(gsdDir, { recursive: true });
 
-  // Simulate existing completed-units.json with data
-  const existing = [
-    { type: "task", id: "T01" },
-    { type: "slice", id: "S01" },
-  ];
-  const completedKeysPath = join(gsdDir, "completed-units.json");
-  writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
-
-  // Simulate the archive behavior: copy to milestone-specific file
-  const milestoneId = "M001";
-  const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
-  cpSync(completedKeysPath, archivePath);
-
-  // Reset the main file
-  writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
-
-  // Verify archive exists with original data
-  assert.ok(existsSync(archivePath), "archive file should exist");
-  const archived = JSON.parse(readFileSync(archivePath, "utf-8"));
-  assert.deepEqual(archived, existing, "archived data should match original");
-
-  // Verify main file is reset
-  const current = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-  assert.deepEqual(current, [], "current completed-units should be empty after transition");
+  try {
+    const existing = [
+      { type: "task", id: "T01" },
+      { type: "slice", id: "S01" },
+    ];
+    const completedKeysPath = join(gsdDir, "completed-units.json");
+    writeFileSync(completedKeysPath, JSON.stringify(existing, null, 2));
+
+    const milestoneId = "M001";
+    const archivePath = join(gsdDir, `completed-units-${milestoneId}.json`);
+    cpSync(completedKeysPath, archivePath);
+    writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
+
+    assert.ok(existsSync(archivePath), "archive file should exist");
+    assert.deepEqual(JSON.parse(readFileSync(archivePath, "utf-8")), existing);
+    assert.deepEqual(JSON.parse(readFileSync(completedKeysPath, "utf-8")), []);
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/context-store.test.ts

@@ -1,3 +1,5 @@
+// GSD-2 + context-store.test.ts — Regression coverage for DB-backed context query helpers.
+
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -362,7 +364,11 @@ describe("context-store: sub-5ms query timing", () => {
 
     assert.strictEqual(decisions.length, 50, `got ${decisions.length} decisions (expected 50)`);
     assert.strictEqual(requirements.length, 50, `got ${requirements.length} requirements (expected 50)`);
-    assert.ok(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
+    const maxLatencyMs = process.env.NODE_V8_COVERAGE ? 15 : 5;
+    assert.ok(
+      elapsed < maxLatencyMs,
+      `query latency ${elapsed.toFixed(2)}ms should be < ${maxLatencyMs}ms`,
+    );
   });
 });
 

package/src/resources/extensions/gsd/tests/crash-handler-secondary.test.ts

@@ -13,11 +13,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:f
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { installEpipeGuard } from "../bootstrap/register-extension.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -25,13 +22,6 @@ function makeTmpBase(): string {
   return base;
 }
 
-// ─── register-extension source assertions ────────────────────────────────────
-
-const registerExtSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
-  'utf-8',
-);
-
 describe('register-extension crash handler secondary fixes (#3348)', () => {
   test('writeCrashLog is exported and writes a file to the crash directory', async () => {
     // Dynamic import so GSD_HOME can be pointed at a temp dir without polluting ~/.gsd
@@ -60,30 +50,44 @@ describe('register-extension crash handler secondary fixes (#3348)', () => {
   });
 
   test('_gsdRejectionGuard is registered for unhandledRejection', () => {
-    assert.match(
-      registerExtSrc,
-      /_gsdRejectionGuard/,
-      '_gsdRejectionGuard handler should be defined',
-    );
-    assert.match(
-      registerExtSrc,
-      /unhandledRejection/,
-      'installEpipeGuard should register an unhandledRejection handler',
+    installEpipeGuard();
+    const listener = process.listeners("unhandledRejection").find((candidate) =>
+      candidate.name === "_gsdRejectionGuard"
     );
+    assert.ok(listener, 'installEpipeGuard should register an unhandledRejection handler');
   });
 
-  test('_gsdEpipeGuard calls process.exit(1) for unrecoverable errors, not log-and-continue', () => {
-    // The original #3696 fix replaced "throw err" with a log-and-continue.
-    // The secondary fix replaces that with writeCrashLog + process.exit(1).
-    assert.ok(
-      !registerExtSrc.includes('process.stderr.write(`[gsd] uncaught extension error (non-fatal)'),
-      '_gsdEpipeGuard should NOT log errors as non-fatal and continue',
-    );
-    assert.match(
-      registerExtSrc,
-      /process\.exit\(1\)/,
-      '_gsdEpipeGuard should call process.exit(1) for unrecoverable errors',
+  test('_gsdEpipeGuard writes a crash log and exits for unrecoverable errors', () => {
+    installEpipeGuard();
+    const listener = process.listeners("uncaughtException").find((candidate) =>
+      candidate.name === "_gsdEpipeGuard"
     );
+    assert.ok(listener, '_gsdEpipeGuard should be registered');
+
+    const tmpHome = join(tmpdir(), `gsd-crash-exit-test-${randomUUID()}`);
+    const origHome = process.env.GSD_HOME;
+    const originalExit = process.exit;
+    let exitCode: number | string | null | undefined;
+    (process as any).exit = (code?: number | string | null | undefined): never => {
+      exitCode = code;
+      throw new Error("process.exit intercepted");
+    };
+    process.env.GSD_HOME = tmpHome;
+    try {
+      assert.throws(
+        () => listener(new Error("unrecoverable crash guard test"), "uncaughtException"),
+        /process\.exit intercepted/,
+      );
+      assert.equal(exitCode, 1);
+      const crashDir = join(tmpHome, "crash");
+      const logs = readdirSync(crashDir).filter((f) => f.endsWith(".log"));
+      assert.equal(logs.length, 1);
+      assert.match(readFileSync(join(crashDir, logs[0]), "utf-8"), /unrecoverable crash guard test/);
+    } finally {
+      (process as any).exit = originalExit;
+      process.env.GSD_HOME = origHome;
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
   });
 
   test('writeCrashLog never throws even when directory is unwritable', async () => {

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -192,7 +192,11 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => null,
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,

package/src/resources/extensions/gsd/tests/cwd-fallback-hardening.test.ts

@@ -0,0 +1,138 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for deleted-cwd fallback handling.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import { registerDynamicTools, ensureDbOpen, safeWorkspaceCwd } from "../bootstrap/dynamic-tools.ts";
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { registerJournalTools } from "../bootstrap/journal-tools.ts";
+import { registerMemoryTools } from "../bootstrap/memory-tools.ts";
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+
+async function withDeletedCwd(fn: (projectRoot: string) => Promise<void> | void): Promise<void> {
+  const previousCwd = process.cwd();
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-safe-cwd-project-"));
+  const removedCwd = mkdtempSync(join(tmpdir(), "gsd-removed-cwd-"));
+
+  process.env.GSD_PROJECT_ROOT = projectRoot;
+  process.chdir(removedCwd);
+  rmSync(removedCwd, { recursive: true, force: true });
+
+  try {
+    assert.throws(() => process.cwd(), /ENOENT/);
+    await fn(projectRoot);
+  } finally {
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+}
+
+function collectTools(register: (pi: any) => void): any[] {
+  const tools: any[] = [];
+  register({
+    registerTool(tool: any) {
+      tools.push(tool);
+    },
+  });
+  return tools;
+}
+
+test("safeWorkspaceCwd falls back to captured project root when cwd was removed", async () => {
+  await withDeletedCwd((projectRoot) => {
+    assert.equal(safeWorkspaceCwd(), projectRoot);
+  });
+});
+
+test("ensureDbOpen default path does not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    assert.equal(await ensureDbOpen(), false);
+  });
+});
+
+test("dynamic tools register when cwd was removed", async () => {
+  await withDeletedCwd(() => {
+    const tools = collectTools(registerDynamicTools);
+    assert.equal(tools.length, 4);
+  });
+});
+
+test("db-backed tool fallbacks return normal unavailable-db errors when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const tools = collectTools(registerDbTools);
+    const decisionSave = tools.find((tool) => tool.name === "gsd_decision_save");
+
+    const result = await decisionSave.execute(
+      "call-1",
+      {
+        scope: "test",
+        decision: "Handle deleted cwd",
+        choice: "Use captured project root",
+        rationale: "The worktree cwd may disappear during cleanup.",
+      },
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    assert.equal(result.details.error, "db_unavailable");
+  });
+});
+
+test("memory and query tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const memoryTools = collectTools(registerMemoryTools);
+    const queryTools = collectTools(registerQueryTools);
+
+    await assert.doesNotReject(() =>
+      memoryTools.find((tool) => tool.name === "memory_query").execute(
+        "call-1",
+        { query: "cwd fallback" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      queryTools.find((tool) => tool.name === "gsd_milestone_status").execute(
+        "call-2",
+        { milestoneId: "M001" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});
+
+test("journal and exec tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const journalTools = collectTools(registerJournalTools);
+    const execTools = collectTools(registerExecTools);
+
+    await assert.doesNotReject(() =>
+      journalTools.find((tool) => tool.name === "gsd_journal_query").execute(
+        "call-1",
+        { limit: 1 },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      execTools.find((tool) => tool.name === "gsd_resume").execute(
+        "call-2",
+        {},
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/dashboard-custom-engine.test.ts

@@ -1,21 +1,12 @@
 /**
- * dashboard-custom-engine.test.ts — Tests that the custom engine path
- * calls updateProgressWidget and that unitLabel handles "custom-step".
- *
- * Uses source-level assertions for the non-exported unitLabel function
- * and the updateProgressWidget call placement. Tests exported helpers
- * (unitVerb, unitPhaseLabel) directly.
+ * dashboard-custom-engine.test.ts — custom-step dashboard labels.
  */
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { unitVerb, unitPhaseLabel } from "../auto-dashboard.js";
-
-// ─── Tests ───────────────────────────────────────────────────────────────
+import { unitLabel } from "../dashboard-overlay.ts";
 
 describe("Dashboard custom-engine: unitLabel and related helpers", () => {
   it('unitVerb("custom-step") returns "executing workflow step"', () => {
@@ -26,62 +17,7 @@ describe("Dashboard custom-engine: unitLabel and related helpers", () => {
     assert.equal(unitPhaseLabel("custom-step"), "WORKFLOW");
   });
 
-  it('dashboard-overlay.ts contains a case for "custom-step" returning "Workflow Step"', () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const overlayPath = resolve(__filename, "../../dashboard-overlay.ts");
-    const source = readFileSync(overlayPath, "utf-8");
-    assert.ok(
-      source.includes('"custom-step"') && source.includes('"Workflow Step"'),
-      'dashboard-overlay.ts should contain case "custom-step": return "Workflow Step"',
-    );
-  });
-});
-
-describe("Dashboard custom-engine: updateProgressWidget in custom engine path", () => {
-  it("loop.ts custom engine path includes updateProgressWidget call before runGuards", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    // Find the custom engine block
-    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
-    assert.ok(customEngineStart > -1, "Should find custom engine path in loop.ts");
-
-    // The updateProgressWidget call should appear after the custom engine block start
-    // and before the runGuards call in that block
-    const afterCustomEngine = source.slice(customEngineStart);
-    const widgetCallIndex = afterCustomEngine.indexOf(
-      "deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state)",
-    );
-    const guardsCallIndex = afterCustomEngine.indexOf("runGuards(ic,");
-    assert.ok(widgetCallIndex > -1, "updateProgressWidget should be called in custom engine path");
-    assert.ok(
-      widgetCallIndex < guardsCallIndex,
-      "updateProgressWidget should be called before runGuards in custom engine path",
-    );
-  });
-
-  it("updateProgressWidget call is placed after iterData is built", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
-    const afterCustomEngine = source.slice(customEngineStart);
-
-    // Verify custom engine path has iterData built before the widget call
-    const iterDataIndex = afterCustomEngine.indexOf("buildCustomEngineIterationData({");
-    const widgetIndex = afterCustomEngine.indexOf("deps.updateProgressWidget");
-    assert.ok(iterDataIndex > -1 && widgetIndex > -1, "Both iterData and widget call should exist");
-    assert.ok(
-      iterDataIndex < widgetIndex,
-      "iterData should be built before updateProgressWidget is called",
-    );
-
-    // Verify the call uses iterData.state (which holds the derived GSD state)
-    assert.ok(
-      afterCustomEngine.includes("iterData.state"),
-      "Custom engine updateProgressWidget should reference iterData.state",
-    );
+  it('unitLabel("custom-step") returns "Workflow Step"', () => {
+    assert.equal(unitLabel("custom-step"), "Workflow Step");
   });
 });

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

@@ -20,6 +20,7 @@ import {
   clearPendingAutoStart,
   checkDeepProjectSetupAfterTurn,
   clearPendingDeepProjectSetup,
+  FOREGROUND_DEEP_SETUP_RULE_NAMES,
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
@@ -1013,15 +1014,9 @@ test("deep project setup: same project advances when agent_end session id change
 });
 
 test("deep project setup: foreground dispatcher does not probe research-project rule", () => {
-  const source = readFileSync(new URL("../guided-flow.ts", import.meta.url), "utf-8");
-  const match = source.match(/const FOREGROUND_DEEP_SETUP_RULE_NAMES = new Set\(\[([\s\S]*?)\]\);/);
-  assert.ok(match, "foreground deep setup rule allowlist should be present");
-  assert.doesNotMatch(
-    match![1]!,
-    /research-project/,
-    "foreground setup must not evaluate research-project because that rule claims the inflight marker",
-  );
-  assert.match(source, /research-project have dispatch-time side effects/);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT) → discuss-project"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no research decision) → research-decision"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT research) → research-project"), false);
 });
 
 test("deep project setup: project-level units verify their real artifacts", () => {