gsd-pi 2.71.0-dev.e17e0ce → 2.72.0-dev.3118184

package/src/resources/extensions/gsd/tests/format-shortcut.test.ts

@@ -82,3 +82,19 @@ test("shortcut-defs: formats shortcut pair using platform symbols", () => {
     assert.equal(pair, "Ctrl+Alt+N / Ctrl+Shift+N");
   }
 });
+
+test("shortcut-defs: parallel shortcut omits fallback (hasFallback: false)", () => {
+  const pair = formattedShortcutPair("parallel");
+  if (process.platform === "darwin") {
+    assert.equal(pair, "⌃⌥P", "parallel should only show primary combo");
+  } else {
+    assert.equal(pair, "Ctrl+Alt+P", "parallel should only show primary combo");
+  }
+  // Verify it does NOT contain the fallback separator
+  assert.ok(!pair.includes("/"), "parallel pair should not contain fallback separator");
+});
+
+test("shortcut-defs: dashboard shortcut includes fallback (hasFallback: true)", () => {
+  const pair = formattedShortcutPair("dashboard");
+  assert.ok(pair.includes("/"), "dashboard pair should contain fallback separator");
+});

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

@@ -186,4 +186,31 @@ describe("evaluating-gates phase", () => {
     insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
     assert.equal(getPendingSliceGateCount("M001", "S01"), 1);
   });
+
+  test("Q8 (owned by complete-slice) does not block evaluating-gates phase", async () => {
+    // Regression: Q8 is stored with scope:"slice" but owned by the
+    // complete-slice turn. Before the gate registry landed, deriveState
+    // counted Q8 as a blocker for evaluating-gates while the gate-evaluate
+    // prompt silently dropped Q8 — an unrecoverable stall. After the
+    // registry change, deriveState filters by owner turn, so Q8 never
+    // blocks evaluating-gates.
+    planSlice(tmpDir);
+    await renderPlanFromDb(tmpDir, "M001", "S01");
+
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q8", scope: "slice" });
+
+    saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", verdict: "pass", rationale: "OK", findings: "" });
+    saveGateResult({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", verdict: "omitted", rationale: "N/A", findings: "" });
+    // Q8 deliberately left pending — it's complete-slice's problem.
+
+    invalidateStateCache();
+    const state = await deriveState(tmpDir);
+    assert.equal(
+      state.phase,
+      "executing",
+      `pending Q8 must not stall evaluating-gates — got phase=${state.phase}`,
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/gate-registry.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Gate registry tests — enforce that every declared GateId has a registry
+ * entry, that every owner-turn bucket is non-empty, and that coverage
+ * assertions fail loudly instead of silently skipping unknown gates.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  GATE_REGISTRY,
+  assertGateCoverage,
+  getGateDefinition,
+  getGateIdsForTurn,
+  getGatesForTurn,
+  getOwnerTurn,
+  type OwnerTurn,
+} from "../gate-registry.ts";
+import type { GateId } from "../types.ts";
+
+/** Authoritative list of GateIds as declared in types.ts. */
+const ALL_GATE_IDS: readonly GateId[] = [
+  "Q3", "Q4", "Q5", "Q6", "Q7", "Q8",
+  "MV01", "MV02", "MV03", "MV04",
+];
+
+const ALL_OWNER_TURNS: readonly OwnerTurn[] = [
+  "gate-evaluate",
+  "execute-task",
+  "complete-slice",
+  "validate-milestone",
+];
+
+describe("gate-registry", () => {
+  test("every declared GateId has a registry entry", () => {
+    for (const id of ALL_GATE_IDS) {
+      const def = GATE_REGISTRY[id];
+      assert.ok(def, `missing registry entry for gate ${id}`);
+      assert.equal(def.id, id);
+      assert.ok(def.question.length > 0, `${id} missing question`);
+      assert.ok(def.guidance.length > 0, `${id} missing guidance`);
+      assert.ok(def.promptSection.length > 0, `${id} missing promptSection`);
+    }
+  });
+
+  test("registry contains no extra gate entries", () => {
+    const registryIds = new Set(Object.keys(GATE_REGISTRY));
+    const declaredIds = new Set<string>(ALL_GATE_IDS);
+    for (const id of registryIds) {
+      assert.ok(declaredIds.has(id), `registry has unknown gate ${id}`);
+    }
+  });
+
+  test("every owner turn owns at least one gate", () => {
+    for (const turn of ALL_OWNER_TURNS) {
+      const gates = getGatesForTurn(turn);
+      assert.ok(
+        gates.length > 0,
+        `owner turn "${turn}" has no gates — likely a registry mistake`,
+      );
+    }
+  });
+
+  test("owner turn buckets are disjoint", () => {
+    const seen = new Set<string>();
+    for (const turn of ALL_OWNER_TURNS) {
+      for (const def of getGatesForTurn(turn)) {
+        assert.ok(!seen.has(def.id), `gate ${def.id} claimed by two turns`);
+        seen.add(def.id);
+      }
+    }
+    // Every gate should appear in exactly one bucket.
+    assert.equal(seen.size, ALL_GATE_IDS.length);
+  });
+
+  test("getOwnerTurn round-trips against GATE_REGISTRY", () => {
+    for (const id of ALL_GATE_IDS) {
+      const turn = getOwnerTurn(id);
+      const idsForTurn = getGateIdsForTurn(turn);
+      assert.ok(idsForTurn.has(id), `${id} not in ${turn} bucket`);
+    }
+  });
+
+  test("getGateDefinition returns undefined for unknown ids", () => {
+    assert.equal(getGateDefinition("Q99"), undefined);
+    assert.equal(getGateDefinition("not-a-gate"), undefined);
+  });
+});
+
+describe("assertGateCoverage", () => {
+  test("throws when a row is owned by a different turn", () => {
+    // Q8 is owned by complete-slice, not gate-evaluate — this used to be
+    // silently dropped by the old `if (!meta) continue;` filter, causing
+    // the evaluating-gates phase to stall.
+    assert.throws(
+      () => assertGateCoverage([{ gate_id: "Q8" }], "gate-evaluate"),
+      (err: Error) =>
+        err.message.includes("Q8") && err.message.includes("gate-evaluate"),
+    );
+  });
+
+  test("throws when a row has an unknown gate id", () => {
+    assert.throws(
+      () => assertGateCoverage([{ gate_id: "Q999" as GateId }], "gate-evaluate", { requireAll: false }),
+      (err: Error) => err.message.includes("Q999"),
+    );
+  });
+
+  test("throws when requireAll is true and an owned gate is missing", () => {
+    // gate-evaluate owns Q3 and Q4. Passing only Q3 should fail.
+    assert.throws(
+      () => assertGateCoverage([{ gate_id: "Q3" }], "gate-evaluate", { requireAll: true }),
+      (err: Error) => err.message.includes("Q4"),
+    );
+  });
+
+  test("passes when requireAll is false and only a subset is pending", () => {
+    // execute-task owns Q5/Q6/Q7, but a task with no external dependencies
+    // may only have Q7 seeded. That's still valid coverage.
+    assert.doesNotThrow(() =>
+      assertGateCoverage([{ gate_id: "Q7" }], "execute-task", { requireAll: false }),
+    );
+  });
+
+  test("passes when requireAll is true and every owned gate is pending", () => {
+    assert.doesNotThrow(() =>
+      assertGateCoverage(
+        [{ gate_id: "Q3" }, { gate_id: "Q4" }],
+        "gate-evaluate",
+        { requireAll: true },
+      ),
+    );
+  });
+
+  test("empty pending list passes when requireAll is false", () => {
+    assert.doesNotThrow(() =>
+      assertGateCoverage([], "complete-slice", { requireAll: false }),
+    );
+  });
+});

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

@@ -15,6 +15,7 @@ import {
   getRequirementById,
   getActiveDecisions,
   getActiveRequirements,
+  getTask,
   transaction,
   _getAdapter,
   _resetProvider,
@@ -43,6 +44,16 @@ function cleanup(dbPath: string): void {
   }
 }
 
+function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
+  const original = process.platform;
+  Object.defineProperty(process, 'platform', { value: platform });
+  try {
+    return fn();
+  } finally {
+    Object.defineProperty(process, 'platform', { value: original });
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // gsd-db tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -279,6 +290,26 @@ describe('gsd-db', () => {
     cleanup(dbPath);
   });
 
+  test('gsd-db: mmap stays disabled on darwin file-backed DBs', () => {
+    const darwinDbPath = tempDbPath();
+    withPlatform('darwin', () => {
+      openDatabase(darwinDbPath);
+      const adapter = _getAdapter()!;
+      const mmap = adapter.prepare('PRAGMA mmap_size').get();
+      assert.deepStrictEqual(mmap?.['mmap_size'], 0, 'darwin should leave mmap_size disabled');
+      cleanup(darwinDbPath);
+    });
+
+    const linuxDbPath = tempDbPath();
+    withPlatform('linux', () => {
+      openDatabase(linuxDbPath);
+      const adapter = _getAdapter()!;
+      const mmap = adapter.prepare('PRAGMA mmap_size').get();
+      assert.deepStrictEqual(mmap?.['mmap_size'], 67108864, 'non-darwin should still enable mmap_size');
+      cleanup(linuxDbPath);
+    });
+  });
+
   test('gsd-db: transaction rollback on error', () => {
     openDatabase(':memory:');
 
@@ -329,6 +360,79 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test('gsd-db: recreates missing verification evidence dedup index after removing duplicate rows', () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    let adapter = _getAdapter()!;
+    adapter.prepare("INSERT INTO milestones (id, created_at) VALUES (?, '')").run('M001');
+    adapter.prepare("INSERT INTO slices (milestone_id, id, created_at) VALUES (?, ?, '')").run('M001', 'S01');
+    adapter.prepare("INSERT INTO tasks (milestone_id, slice_id, id) VALUES (?, ?, ?)").run('M001', 'S01', 'T01');
+    adapter.exec('DROP INDEX IF EXISTS idx_verification_evidence_dedup');
+
+    const insertEvidence = adapter.prepare(
+      `INSERT INTO verification_evidence (
+        task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    insertEvidence.run('T01', 'S01', 'M001', 'npm test', 1, 'fail', 125, '2026-04-12T00:00:00.000Z');
+    insertEvidence.run('T01', 'S01', 'M001', 'npm test', 1, 'fail', 125, '2026-04-12T00:00:01.000Z');
+    insertEvidence.run('T01', 'S01', 'M001', 'npm run lint', 0, 'pass', 90, '2026-04-12T00:00:02.000Z');
+
+    closeDatabase();
+
+    assert.equal(openDatabase(dbPath), true, 'openDatabase should repair legacy duplicate evidence rows');
+
+    adapter = _getAdapter()!;
+    const countRow = adapter.prepare(
+      `SELECT count(*) as cnt
+       FROM verification_evidence
+       WHERE task_id = ? AND slice_id = ? AND milestone_id = ? AND command = ? AND verdict = ?`,
+    ).get('T01', 'S01', 'M001', 'npm test', 'fail');
+    assert.equal(countRow?.['cnt'], 1, 'duplicate verification evidence rows should be deduplicated before index creation');
+
+    const indexRow = adapter.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_verification_evidence_dedup'",
+    ).get();
+    assert.equal(indexRow?.['name'], 'idx_verification_evidence_dedup', 'dedup index should be recreated on reopen');
+
+    cleanup(dbPath);
+  });
+
+  test('gsd-db: rowToTask tolerates legacy comma-separated task arrays', () => {
+    openDatabase(':memory:');
+
+    const adapter = _getAdapter()!;
+    adapter.prepare("INSERT INTO milestones (id, created_at) VALUES (?, '')").run('M001');
+    adapter.prepare("INSERT INTO slices (milestone_id, id, created_at) VALUES (?, ?, '')").run('M001', 'S01');
+    adapter.prepare(
+      `INSERT INTO tasks (
+        milestone_id, slice_id, id, key_files, key_decisions, files, inputs, expected_output
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      'M001',
+      'S01',
+      'T01',
+      '[]',
+      '[]',
+      'tests/test_verify.py, config.yaml, configs/roster_2026-05-11.yaml',
+      'tests/test_verify.py',
+      'reports/summary.md, artifacts/output.json',
+    );
+
+    const task = getTask('M001', 'S01', 'T01');
+    assert.ok(task, 'task should load successfully from DB');
+    assert.deepEqual(task?.files, [
+      'tests/test_verify.py',
+      'config.yaml',
+      'configs/roster_2026-05-11.yaml',
+    ]);
+    assert.deepEqual(task?.inputs, ['tests/test_verify.py']);
+    assert.deepEqual(task?.expected_output, ['reports/summary.md', 'artifacts/output.json']);
+
+    closeDatabase();
+  });
+
   test('gsd-db: query wrappers return null/empty when DB unavailable', () => {
     // Ensure DB is closed
     closeDatabase();
@@ -347,15 +451,13 @@ describe('gsd-db', () => {
     assert.deepStrictEqual(ar, [], 'getActiveRequirements returns [] when DB closed');
   });
 
-  test('gsd-db: wasDbOpenAttempted tracks openDatabase calls', () => {
-    // wasDbOpenAttempted should return true once openDatabase has been called
-    // (previous tests in this suite already called openDatabase, so the flag is set)
+  test('gsd-db: closeDatabase resets wasDbOpenAttempted after an intentional close', () => {
+    openDatabase(':memory:');
     assert.ok(wasDbOpenAttempted(), 'wasDbOpenAttempted should be true after openDatabase was called');
 
-    // Verify the flag persists even after closeDatabase
     closeDatabase();
     assert.ok(!isDbAvailable(), 'DB should not be available after close');
-    assert.ok(wasDbOpenAttempted(), 'wasDbOpenAttempted should remain true after closeDatabase');
+    assert.ok(!wasDbOpenAttempted(), 'wasDbOpenAttempted should reset after closeDatabase');
   });
 
   // ─── Final Report ──────────────────────────────────────────────────────────

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

@@ -248,23 +248,25 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    13,
-    "exactly 13 runtime exclusion paths"
+    15,
+    "exactly 15 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
+    ".gsd/parallel/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
-    ".gsd/completed-units.json",
+    ".gsd/completed-units*.json",
+    ".gsd/state-manifest.json",
     ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm",
-    ".gsd/gsd.db-wal",
+    ".gsd/gsd.db*",
     ".gsd/journal/",
     ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
   ];
 

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -427,3 +427,66 @@ test("formatDoctorFindings shows findings with appropriate icons", () => {
   assert.ok(output.includes("1 warning"));
   assert.ok(output.includes("1 fixed"));
 });
+
+// ─── Regression #3891 — alibaba-coding-plan missing from PROVIDER_REGISTRY ───────
+//
+// Before this fix, `alibaba-coding-plan` was not in PROVIDER_REGISTRY, causing
+// `/gsd keys add alibaba-coding-plan` to silently fail (provider not found).
+// alibaba-dashscope is the new standalone provider added in the same PR.
+
+test("regression #3891 — alibaba-coding-plan is in PROVIDER_REGISTRY", () => {
+  const provider = findProvider("alibaba-coding-plan");
+  assert.ok(provider, "alibaba-coding-plan must be in PROVIDER_REGISTRY for /gsd keys add to work");
+  assert.equal(provider.id, "alibaba-coding-plan");
+  assert.equal(provider.category, "llm");
+  assert.equal(provider.envVar, "ALIBABA_API_KEY");
+});
+
+test("alibaba-dashscope is in PROVIDER_REGISTRY", () => {
+  const provider = findProvider("alibaba-dashscope");
+  assert.ok(provider, "alibaba-dashscope must be in PROVIDER_REGISTRY for /gsd keys add to work");
+  assert.equal(provider.id, "alibaba-dashscope");
+  assert.equal(provider.category, "llm");
+  assert.equal(provider.envVar, "DASHSCOPE_API_KEY");
+});
+
+test("alibaba-coding-plan and alibaba-dashscope are separate providers (different env vars)", () => {
+  const codingPlan = findProvider("alibaba-coding-plan");
+  const dashscope = findProvider("alibaba-dashscope");
+  assert.ok(codingPlan, "alibaba-coding-plan must exist");
+  assert.ok(dashscope, "alibaba-dashscope must exist");
+  assert.notEqual(
+    codingPlan.envVar,
+    dashscope.envVar,
+    "alibaba-coding-plan and alibaba-dashscope must use different env vars",
+  );
+});
+
+test("getAllKeyStatuses includes alibaba-coding-plan", () => {
+  const auth = makeAuth();
+  const statuses = getAllKeyStatuses(auth);
+  const found = statuses.find((s) => s.provider.id === "alibaba-coding-plan");
+  assert.ok(found, "getAllKeyStatuses must include alibaba-coding-plan");
+});
+
+test("getAllKeyStatuses includes alibaba-dashscope", () => {
+  const auth = makeAuth();
+  const statuses = getAllKeyStatuses(auth);
+  const found = statuses.find((s) => s.provider.id === "alibaba-dashscope");
+  assert.ok(found, "getAllKeyStatuses must include alibaba-dashscope");
+});
+
+test("getAllKeyStatuses detects DASHSCOPE_API_KEY for alibaba-dashscope (failure path: missing key shows not configured)", () => {
+  const saved = process.env.DASHSCOPE_API_KEY;
+  delete process.env.DASHSCOPE_API_KEY;
+  try {
+    const auth = makeAuth();
+    const statuses = getAllKeyStatuses(auth);
+    const found = statuses.find((s) => s.provider.id === "alibaba-dashscope");
+    assert.ok(found);
+    assert.equal(found.configured, false);
+    assert.equal(found.source, "none");
+  } finally {
+    if (saved !== undefined) process.env.DASHSCOPE_API_KEY = saved;
+  }
+});

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Regression tests for memory pressure monitoring (#3331) and
+ * stuck detection persistence (#3704) in auto/loop.ts.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
+
+describe("memory pressure monitoring (#3331)", () => {
+  test("checkMemoryPressure function exists", () => {
+    assert.match(loopSource, /function checkMemoryPressure/);
+  });
+
+  test("MEMORY_PRESSURE_THRESHOLD constant is defined", () => {
+    assert.match(loopSource, /MEMORY_PRESSURE_THRESHOLD\s*=\s*0\.\d+/);
+  });
+
+  test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
+    assert.match(loopSource, /iteration\s*%\s*MEMORY_CHECK_INTERVAL\s*===\s*0/);
+  });
+
+  test("memory pressure triggers graceful stopAuto", () => {
+    assert.match(loopSource, /mem\.pressured/);
+    assert.match(loopSource, /Stopping gracefully to prevent OOM/);
+  });
+});
+
+describe("stuck detection persistence (#3704)", () => {
+  test("loadStuckState function exists", () => {
+    assert.match(loopSource, /function loadStuckState/);
+  });
+
+  test("saveStuckState function exists", () => {
+    assert.match(loopSource, /function saveStuckState/);
+  });
+
+  test("loopState initialized from persisted state", () => {
+    assert.match(loopSource, /loadStuckState\(s\.basePath\)/);
+  });
+
+  test("stuck state saved after each iteration", () => {
+    assert.match(loopSource, /saveStuckState\(s\.basePath,\s*loopState\)/);
+  });
+
+  test("stuck state file path uses runtime directory", () => {
+    assert.match(loopSource, /stuck-state\.json/);
+  });
+});

package/src/resources/extensions/gsd/tests/plan-milestone-artifact-verification.test.ts

@@ -0,0 +1,62 @@
+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 { verifyExpectedArtifact } from "../auto-recovery.ts";
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-milestone-artifact-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeRoadmap(base: string, milestoneId: string, content: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, `${milestoneId}-ROADMAP.md`), content, "utf-8");
+}
+
+test("#3405: plan-milestone roadmap stub does not count as a verified artifact", () => {
+  const base = createFixtureBase();
+  try {
+    writeRoadmap(base, "M001", [
+      "# M001: Placeholder",
+      "",
+      "**Vision:** Stub only.",
+      "",
+      "## Slices",
+      "",
+      "_TBD_",
+      "",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-milestone", "M001", base);
+    assert.equal(result, false, "zero-slice roadmap stubs must fail verification");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("#3405: plan-milestone roadmap with real slices still passes artifact verification", () => {
+  const base = createFixtureBase();
+  try {
+    writeRoadmap(base, "M001", [
+      "# M001: Real roadmap",
+      "",
+      "**Vision:** Real work.",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "  > After this: a real slice exists.",
+      "",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-milestone", "M001", base);
+    assert.equal(result, true, "real roadmap slices should keep passing verification");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,34 @@
+/**
+ * Regression test for #3869: normal post-unit flow should rebuild STATE.md
+ * before syncing worktree state back to the project root.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(join(import.meta.dirname, "..", "auto-post-unit.ts"), "utf-8");
+
+test("auto-post-unit imports rebuildState", () => {
+  assert.ok(
+    source.includes('import { rebuildState } from "./doctor.js";'),
+    "auto-post-unit.ts should import rebuildState from doctor.ts",
+  );
+});
+
+test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
+  const fnStart = source.indexOf("export async function postUnitPreVerification");
+  assert.ok(fnStart > 0, "postUnitPreVerification should exist");
+
+  const section = source.slice(fnStart, fnStart + 8000);
+  const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
+  const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');
+
+  assert.ok(rebuildIdx > 0, "postUnitPreVerification should rebuild STATE.md after unit completion");
+  assert.ok(syncIdx > 0, "postUnitPreVerification should sync worktree state back to the project root");
+  assert.ok(
+    rebuildIdx < syncIdx,
+    "STATE.md rebuild should happen before worktree sync so synced state is fresh",
+  );
+});