gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -24,6 +22,7 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
   return content.trim();
 }
 
+const { assertEq, assertTrue, report } = createTestContext();
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -162,7 +161,7 @@ Found a blocker.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.blocker_discovered, true, 'blocker_discovered: true (string) extracts as true');
+  assertEq(s.frontmatter.blocker_discovered, true, 'blocker_discovered: true (string) extracts as true');
 }
 
 console.log('\n=== parseSummary: blocker_discovered false (string) ===');
@@ -185,7 +184,7 @@ No blocker.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.blocker_discovered, false, 'blocker_discovered: false extracts as false');
+  assertEq(s.frontmatter.blocker_discovered, false, 'blocker_discovered: false extracts as false');
 }
 
 console.log('\n=== parseSummary: blocker_discovered missing (defaults to false) ===');
@@ -207,7 +206,7 @@ No blocker field at all.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.blocker_discovered, false, 'blocker_discovered missing defaults to false');
+  assertEq(s.frontmatter.blocker_discovered, false, 'blocker_discovered missing defaults to false');
 }
 
 console.log('\n=== parseSummary: blocker_discovered true (boolean from YAML) ===');
@@ -233,7 +232,7 @@ Blocker as boolean.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.blocker_discovered, true, 'blocker_discovered: true (YAML boolean) extracts as true');
+  assertEq(s.frontmatter.blocker_discovered, true, 'blocker_discovered: true (YAML boolean) extracts as true');
 }
 
 console.log('\n=== parseSummary: blocker_discovered with full frontmatter ===');
@@ -276,10 +275,10 @@ Major deviation from plan.
 `;
 
   const s = parseSummary(content);
-  assert.deepStrictEqual(s.frontmatter.blocker_discovered, true, 'blocker_discovered true with full frontmatter');
-  assert.deepStrictEqual(s.frontmatter.id, 'T05', 'other fields still parse correctly alongside blocker_discovered');
-  assert.deepStrictEqual(s.frontmatter.duration, '15min', 'duration still parsed');
-  assert.deepStrictEqual(s.frontmatter.provides[0], 'something', 'provides still parsed');
+  assertEq(s.frontmatter.blocker_discovered, true, 'blocker_discovered true with full frontmatter');
+  assertEq(s.frontmatter.id, 'T05', 'other fields still parse correctly alongside blocker_discovered');
+  assertEq(s.frontmatter.duration, '15min', 'duration still parsed');
+  assertEq(s.frontmatter.provides[0], 'something', 'provides still parsed');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -295,11 +294,11 @@ console.log('\n=== deriveState: blocker found, no REPLAN → replanning-slice ==
   writeTaskSummary(base, 'M001', 'S01', 'T01', makeTaskSummary('T01', true));
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'replanning-slice', 'phase is replanning-slice when blocker found and no REPLAN.md');
-  assert.ok(state.nextAction.includes('T01'), 'nextAction mentions blocker task T01');
-  assert.ok(state.nextAction.includes('blocker_discovered'), 'nextAction mentions blocker_discovered');
-  assert.deepStrictEqual(state.activeTask?.id, 'T02', 'activeTask is still T02 (the next incomplete task)');
-  assert.ok(state.blockers.length > 0, 'blockers array is non-empty');
+  assertEq(state.phase, 'replanning-slice', 'phase is replanning-slice when blocker found and no REPLAN.md');
+  assertTrue(state.nextAction.includes('T01'), 'nextAction mentions blocker task T01');
+  assertTrue(state.nextAction.includes('blocker_discovered'), 'nextAction mentions blocker_discovered');
+  assertEq(state.activeTask?.id, 'T02', 'activeTask is still T02 (the next incomplete task)');
+  assertTrue(state.blockers.length > 0, 'blockers array is non-empty');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -313,8 +312,8 @@ console.log('\n=== deriveState: blocker found + REPLAN exists → executing (loo
   writeReplanFile(base, 'M001', 'S01', '# Replan\n\nAlready replanned.');
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'executing', 'phase is executing when REPLAN.md exists (loop protection)');
-  assert.deepStrictEqual(state.activeTask?.id, 'T02', 'activeTask is T02');
+  assertEq(state.phase, 'executing', 'phase is executing when REPLAN.md exists (loop protection)');
+  assertEq(state.activeTask?.id, 'T02', 'activeTask is T02');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -327,8 +326,8 @@ console.log('\n=== deriveState: no blocker in completed tasks → executing ==='
   writeTaskSummary(base, 'M001', 'S01', 'T01', makeTaskSummary('T01', false));
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'executing', 'phase is executing when no blocker found');
-  assert.deepStrictEqual(state.activeTask?.id, 'T02', 'activeTask is T02');
+  assertEq(state.phase, 'executing', 'phase is executing when no blocker found');
+  assertEq(state.activeTask?.id, 'T02', 'activeTask is T02');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -342,9 +341,9 @@ console.log('\n=== deriveState: multiple completed tasks, one blocker → replan
   writeTaskSummary(base, 'M001', 'S01', 'T02', makeTaskSummary('T02', true));
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'replanning-slice', 'phase is replanning-slice when T02 has blocker');
-  assert.ok(state.nextAction.includes('T02'), 'nextAction mentions blocker task T02');
-  assert.deepStrictEqual(state.activeTask?.id, 'T03', 'activeTask is T03 (next incomplete)');
+  assertEq(state.phase, 'replanning-slice', 'phase is replanning-slice when T02 has blocker');
+  assertTrue(state.nextAction.includes('T02'), 'nextAction mentions blocker task T02');
+  assertEq(state.activeTask?.id, 'T03', 'activeTask is T03 (next incomplete)');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -357,7 +356,7 @@ console.log('\n=== deriveState: completed task with no summary file → executin
   // No summary file written for T01
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'executing', 'phase is executing when completed task has no summary');
+  assertEq(state.phase, 'executing', 'phase is executing when completed task has no summary');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -377,11 +376,11 @@ console.log('\n=== prompt: replan-slice template loads and substitutes variables
     inlinedContext: '## Inlined Context\n\nTest context here.',
   });
 
-  assert.ok(prompt.includes('M001'), 'prompt contains milestoneId');
-  assert.ok(prompt.includes('S01'), 'prompt contains sliceId');
-  assert.ok(prompt.includes('Test Slice'), 'prompt contains sliceTitle');
-  assert.ok(prompt.includes('.gsd/milestones/M001/slices/S01/S01-PLAN.md'), 'prompt contains planPath');
-  assert.ok(prompt.includes('Test context here'), 'prompt contains inlined context');
+  assertTrue(prompt.includes('M001'), 'prompt contains milestoneId');
+  assertTrue(prompt.includes('S01'), 'prompt contains sliceId');
+  assertTrue(prompt.includes('Test Slice'), 'prompt contains sliceTitle');
+  assertTrue(prompt.includes('.gsd/milestones/M001/slices/S01/S01-PLAN.md'), 'prompt contains planPath');
+  assertTrue(prompt.includes('Test context here'), 'prompt contains inlined context');
 }
 
 console.log('\n=== prompt: replan-slice contains preserve-completed-tasks instruction ===');
@@ -398,10 +397,10 @@ console.log('\n=== prompt: replan-slice contains preserve-completed-tasks instru
     inlinedContext: '',
   });
 
-  assert.ok(prompt.includes('Do NOT renumber or remove completed tasks'), 'prompt contains preserve-completed-tasks instruction');
-  assert.ok(prompt.includes('[x]'), 'prompt mentions [x] checkmarks');
-  assert.ok(prompt.includes('REPLAN'), 'prompt references replan output path');
-  assert.ok(prompt.includes('blocker_discovered'), 'prompt mentions blocker_discovered');
+  assertTrue(prompt.includes('Do NOT renumber or remove completed tasks'), 'prompt contains preserve-completed-tasks instruction');
+  assertTrue(prompt.includes('[x]'), 'prompt mentions [x] checkmarks');
+  assertTrue(prompt.includes('REPLAN'), 'prompt references replan output path');
+  assertTrue(prompt.includes('blocker_discovered'), 'prompt mentions blocker_discovered');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -422,8 +421,8 @@ console.log('\n=== dispatch: diagnoseExpectedArtifact returns REPLAN.md path ===
   writeTaskSummary(base, 'M001', 'S01', 'T01', makeTaskSummary('T01', true));
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'replanning-slice', 'dispatch: state routes to replanning-slice when blocker found');
-  assert.ok(state.activeSlice?.id === 'S01', 'dispatch: activeSlice is S01');
+  assertEq(state.phase, 'replanning-slice', 'dispatch: state routes to replanning-slice when blocker found');
+  assertTrue(state.activeSlice?.id === 'S01', 'dispatch: activeSlice is S01');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -444,8 +443,8 @@ console.log('\n=== display: replan-slice prompt template has correct unit header
     inlinedContext: '',
   });
 
-  assert.ok(prompt.includes('UNIT: Replan Slice'), 'prompt has Replan Slice unit header');
-  assert.ok(prompt.includes('Slice S01 replanned'), 'prompt has completion message');
+  assertTrue(prompt.includes('UNIT: Replan Slice'), 'prompt has Replan Slice unit header');
+  assertTrue(prompt.includes('Slice S01 replanned'), 'prompt has completion message');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -453,6 +452,8 @@ console.log('\n=== display: replan-slice prompt template has correct unit header
 // ═══════════════════════════════════════════════════════════════════════════
 
 import { runGSDDoctor } from '../doctor.ts';
+import { createTestContext } from './test-helpers.ts';
+
 // (a) blocker + no REPLAN.md → issue emitted
 console.log('\n=== doctor: blocker + no REPLAN.md → blocker_discovered_no_replan issue ===');
 {
@@ -463,10 +464,10 @@ console.log('\n=== doctor: blocker + no REPLAN.md → blocker_discovered_no_repl
 
   const report = await runGSDDoctor(base, { fix: false, scope: 'M001/S01' });
   const blockerIssues = report.issues.filter(i => i.code === 'blocker_discovered_no_replan');
-  assert.ok(blockerIssues.length > 0, 'doctor emits blocker_discovered_no_replan when blocker + no REPLAN');
-  assert.ok(blockerIssues[0]?.message.includes('T01'), 'issue message mentions the blocker task T01');
-  assert.deepStrictEqual(blockerIssues[0]?.severity, 'warning', 'blocker_discovered_no_replan is warning severity');
-  assert.deepStrictEqual(blockerIssues[0]?.scope, 'slice', 'blocker_discovered_no_replan has slice scope');
+  assertTrue(blockerIssues.length > 0, 'doctor emits blocker_discovered_no_replan when blocker + no REPLAN');
+  assertTrue(blockerIssues[0]?.message.includes('T01'), 'issue message mentions the blocker task T01');
+  assertEq(blockerIssues[0]?.severity, 'warning', 'blocker_discovered_no_replan is warning severity');
+  assertEq(blockerIssues[0]?.scope, 'slice', 'blocker_discovered_no_replan has slice scope');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -481,7 +482,7 @@ console.log('\n=== doctor: blocker + REPLAN.md exists → no blocker_discovered_
 
   const report = await runGSDDoctor(base, { fix: false, scope: 'M001/S01' });
   const blockerIssues = report.issues.filter(i => i.code === 'blocker_discovered_no_replan');
-  assert.deepStrictEqual(blockerIssues.length, 0, 'no blocker_discovered_no_replan when REPLAN.md exists');
+  assertEq(blockerIssues.length, 0, 'no blocker_discovered_no_replan when REPLAN.md exists');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -495,7 +496,7 @@ console.log('\n=== doctor: no blocker → no blocker_discovered_no_replan issue
 
   const report = await runGSDDoctor(base, { fix: false, scope: 'M001/S01' });
   const blockerIssues = report.issues.filter(i => i.code === 'blocker_discovered_no_replan');
-  assert.deepStrictEqual(blockerIssues.length, 0, 'no blocker_discovered_no_replan when no blocker');
+  assertEq(blockerIssues.length, 0, 'no blocker_discovered_no_replan when no blocker');
   rmSync(base, { recursive: true, force: true });
 }
 
@@ -505,45 +506,48 @@ console.log('\n=== doctor: no blocker → no blocker_discovered_no_replan issue
 
 import { resolveExpectedArtifactPath, verifyExpectedArtifact } from '../auto-recovery.ts';
 
-
-describe('replan-slice', () => {
-test('artifact: resolveExpectedArtifactPath returns REPLAN.md path for replan-slice', () => {
+console.log('\n=== artifact: resolveExpectedArtifactPath returns REPLAN.md path for replan-slice ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
 
   const path = resolveExpectedArtifactPath('replan-slice', 'M001/S01', base);
-  assert.ok(path !== null, 'resolveExpectedArtifactPath returns non-null for replan-slice');
-  assert.ok(path!.endsWith('S01-REPLAN.md'), 'path ends with S01-REPLAN.md');
+  assertTrue(path !== null, 'resolveExpectedArtifactPath returns non-null for replan-slice');
+  assertTrue(path!.endsWith('S01-REPLAN.md'), 'path ends with S01-REPLAN.md');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
-test('artifact: verifyExpectedArtifact fails when REPLAN.md missing (#858)', () => {
+console.log('\n=== artifact: verifyExpectedArtifact fails when REPLAN.md missing (#858) ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
 
   const result = verifyExpectedArtifact('replan-slice', 'M001/S01', base);
-  assert.deepStrictEqual(result, false, 'verifyExpectedArtifact returns false when REPLAN.md is missing');
+  assertEq(result, false, 'verifyExpectedArtifact returns false when REPLAN.md is missing');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
-test('artifact: verifyExpectedArtifact passes when REPLAN.md exists (#858)', () => {
+console.log('\n=== artifact: verifyExpectedArtifact passes when REPLAN.md exists (#858) ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
   writeReplanFile(base, 'M001', 'S01', '# Replan\n\nBlocker addressed.');
 
   const result = verifyExpectedArtifact('replan-slice', 'M001/S01', base);
-  assert.deepStrictEqual(result, true, 'verifyExpectedArtifact returns true when REPLAN.md exists');
+  assertEq(result, true, 'verifyExpectedArtifact returns true when REPLAN.md exists');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // REPLAN-TRIGGER.md detection (triage-initiated replan, #1701)
 // ═══════════════════════════════════════════════════════════════════════════
+
 // (a) REPLAN-TRIGGER.md exists + no REPLAN.md → replanning-slice
-test('deriveState: REPLAN-TRIGGER.md exists, no REPLAN → replanning-slice (#1701)', async () => {
+console.log('\n=== deriveState: REPLAN-TRIGGER.md exists, no REPLAN → replanning-slice (#1701) ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
@@ -552,16 +556,17 @@ test('deriveState: REPLAN-TRIGGER.md exists, no REPLAN → replanning-slice (#17
   writeReplanTrigger(base, 'M001', 'S01', '# Replan Trigger\n\n**Source:** Capture C001\n');
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'replanning-slice', 'phase is replanning-slice when REPLAN-TRIGGER.md exists');
-  assert.ok(state.blockers.length > 0, 'blockers array is non-empty for triage replan trigger');
-  assert.ok(state.nextAction.includes('Triage replan'), 'nextAction mentions triage replan');
-  assert.deepStrictEqual(state.activeSlice?.id, 'S01', 'activeSlice is S01');
-  assert.deepStrictEqual(state.activeTask?.id, 'T02', 'activeTask is T02 (next incomplete task)');
+  assertEq(state.phase, 'replanning-slice', 'phase is replanning-slice when REPLAN-TRIGGER.md exists');
+  assertTrue(state.blockers.length > 0, 'blockers array is non-empty for triage replan trigger');
+  assertTrue(state.nextAction.includes('Triage replan'), 'nextAction mentions triage replan');
+  assertEq(state.activeSlice?.id, 'S01', 'activeSlice is S01');
+  assertEq(state.activeTask?.id, 'T02', 'activeTask is T02 (next incomplete task)');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
 // (b) REPLAN-TRIGGER.md + REPLAN.md both exist → executing (loop protection)
-test('deriveState: REPLAN-TRIGGER.md + REPLAN.md → executing (loop protection, #1701)', async () => {
+console.log('\n=== deriveState: REPLAN-TRIGGER.md + REPLAN.md → executing (loop protection, #1701) ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
@@ -570,25 +575,27 @@ test('deriveState: REPLAN-TRIGGER.md + REPLAN.md → executing (loop protection,
   writeReplanFile(base, 'M001', 'S01', '# Replan\n\nAlready replanned.');
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'executing', 'phase is executing when REPLAN.md exists (loop protection)');
-  assert.deepStrictEqual(state.activeTask?.id, 'T02', 'activeTask is T02');
+  assertEq(state.phase, 'executing', 'phase is executing when REPLAN.md exists (loop protection)');
+  assertEq(state.activeTask?.id, 'T02', 'activeTask is T02');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
 // (c) No REPLAN-TRIGGER.md, no blocker → executing (no false positive)
-test('deriveState: no REPLAN-TRIGGER.md, no blocker → executing (#1701)', async () => {
+console.log('\n=== deriveState: no REPLAN-TRIGGER.md, no blocker → executing (#1701) ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
   writeTaskSummary(base, 'M001', 'S01', 'T01', makeTaskSummary('T01', false));
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'executing', 'phase is executing when no trigger and no blocker');
+  assertEq(state.phase, 'executing', 'phase is executing when no trigger and no blocker');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
 // (d) blocker_discovered takes priority over REPLAN-TRIGGER.md
-test('deriveState: blocker_discovered takes priority over REPLAN-TRIGGER.md (#1701)', async () => {
+console.log('\n=== deriveState: blocker_discovered takes priority over REPLAN-TRIGGER.md (#1701) ===');
+{
   const base = createFixtureBase();
   writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
   writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
@@ -596,10 +603,10 @@ test('deriveState: blocker_discovered takes priority over REPLAN-TRIGGER.md (#17
   writeReplanTrigger(base, 'M001', 'S01', '# Replan Trigger\n\n**Source:** Capture C001\n');
 
   const state = await deriveState(base);
-  assert.deepStrictEqual(state.phase, 'replanning-slice', 'phase is replanning-slice');
+  assertEq(state.phase, 'replanning-slice', 'phase is replanning-slice');
   // blocker_discovered path should fire first (blockerTaskId is set, so REPLAN-TRIGGER check is skipped)
-  assert.ok(state.nextAction.includes('T01'), 'nextAction mentions blocker task T01 (blocker path, not trigger path)');
+  assertTrue(state.nextAction.includes('T01'), 'nextAction mentions blocker task T01 (blocker path, not trigger path)');
   rmSync(base, { recursive: true, force: true });
-});
+}
 
-});
+report();

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -1,11 +1,13 @@
-import { describe, test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { repoIdentity, externalGsdRoot, ensureGsdSymlink, validateProjectId, readRepoMeta, isInheritedRepo } from "../repo-identity.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 /**
  * Normalize a path for reliable comparison on Windows CI runners.
  * `os.tmpdir()` may return the 8.3 short-path form (e.g. `C:\Users\RUNNER~1`)
@@ -21,15 +23,11 @@ function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
 
-describe('repo-identity-worktree', () => {
-  let base: string;
-  let stateDir: string;
-  let worktreePath: string;
-  let expectedExternalState: string;
+async function main(): Promise<void> {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-repo-identity-")));
+  const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-")));
 
-  before(() => {
-    base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-repo-identity-")));
-    stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-")));
+  try {
     process.env.GSD_STATE_DIR = stateDir;
 
     run("git init -b main", base);
@@ -40,69 +38,57 @@ describe('repo-identity-worktree', () => {
     run("git add README.md", base);
     run('git commit -m "chore: init"', base);
 
-    worktreePath = join(base, ".gsd", "worktrees", "M001");
+    const worktreePath = join(base, ".gsd", "worktrees", "M001");
     run(`git worktree add -b milestone/M001 ${worktreePath}`, base);
 
-    expectedExternalState = externalGsdRoot(base);
-  });
-
-  after(() => {
-    delete process.env.GSD_PROJECT_ID;
-    delete process.env.GSD_STATE_DIR;
-    rmSync(base, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
-  });
-
-test('ensureGsdSymlink points worktree at main repo external state dir', () => {
+    console.log("\n=== ensureGsdSymlink points worktree at main repo external state dir ===");
+    const expectedExternalState = externalGsdRoot(base);
     const mainState = ensureGsdSymlink(base);
-    assert.deepStrictEqual(mainState, realpathSync(join(base, ".gsd")), "ensureGsdSymlink(base) returns the current main repo .gsd target");
+    assertEq(mainState, realpathSync(join(base, ".gsd")), "ensureGsdSymlink(base) returns the current main repo .gsd target");
     const worktreeState = ensureGsdSymlink(worktreePath);
-    assert.deepStrictEqual(worktreeState, expectedExternalState, "worktree symlink target matches main repo external state dir");
-    assert.ok(existsSync(join(worktreePath, ".gsd")), "worktree .gsd exists");
-    assert.ok(lstatSync(join(worktreePath, ".gsd")).isSymbolicLink(), "worktree .gsd is a symlink");
-    assert.deepStrictEqual(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "worktree .gsd symlink resolves to main repo external state dir");
-});
+    assertEq(worktreeState, expectedExternalState, "worktree symlink target matches main repo external state dir");
+    assertTrue(existsSync(join(worktreePath, ".gsd")), "worktree .gsd exists");
+    assertTrue(lstatSync(join(worktreePath, ".gsd")).isSymbolicLink(), "worktree .gsd is a symlink");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "worktree .gsd symlink resolves to main repo external state dir");
 
-test('ensureGsdSymlink heals stale worktree symlinks', () => {
+    console.log("\n=== ensureGsdSymlink heals stale worktree symlinks ===");
     const staleState = join(stateDir, "projects", "stale-worktree-state");
     mkdirSync(staleState, { recursive: true });
     rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });
     symlinkSync(staleState, join(worktreePath, ".gsd"), "junction");
     const healedState = ensureGsdSymlink(worktreePath);
-    assert.deepStrictEqual(healedState, expectedExternalState, "stale worktree symlink is repaired to canonical external state dir");
-    assert.deepStrictEqual(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "healed worktree symlink resolves to canonical external state dir");
-});
+    assertEq(healedState, expectedExternalState, "stale worktree symlink is repaired to canonical external state dir");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "healed worktree symlink resolves to canonical external state dir");
 
-test('ensureGsdSymlink preserves worktree .gsd directories', () => {
+    console.log("\n=== ensureGsdSymlink preserves worktree .gsd directories ===");
     rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });
     mkdirSync(join(worktreePath, ".gsd", "milestones"), { recursive: true });
     writeFileSync(join(worktreePath, ".gsd", "milestones", "stale.txt"), "stale\n", "utf-8");
     const preservedDirState = ensureGsdSymlink(worktreePath);
-    assert.deepStrictEqual(preservedDirState, join(worktreePath, ".gsd"), "worktree .gsd directory is left in place for sync-based refresh");
-    assert.ok(lstatSync(join(worktreePath, ".gsd")).isDirectory(), "worktree .gsd directory remains a directory");
-    assert.ok(existsSync(join(worktreePath, ".gsd", "milestones", "stale.txt")), "existing worktree .gsd directory contents remain available for sync logic");
-});
+    assertEq(preservedDirState, join(worktreePath, ".gsd"), "worktree .gsd directory is left in place for sync-based refresh");
+    assertTrue(lstatSync(join(worktreePath, ".gsd")).isDirectory(), "worktree .gsd directory remains a directory");
+    assertTrue(existsSync(join(worktreePath, ".gsd", "milestones", "stale.txt")), "existing worktree .gsd directory contents remain available for sync logic");
 
-test('GSD_PROJECT_ID overrides computed repo hash', () => {
+    console.log("\n=== GSD_PROJECT_ID overrides computed repo hash ===");
     process.env.GSD_PROJECT_ID = "my-project";
-    assert.deepStrictEqual(repoIdentity(base), "my-project", "repoIdentity returns GSD_PROJECT_ID when set");
-    assert.deepStrictEqual(externalGsdRoot(base), join(stateDir, "projects", "my-project"), "externalGsdRoot uses GSD_PROJECT_ID");
+    assertEq(repoIdentity(base), "my-project", "repoIdentity returns GSD_PROJECT_ID when set");
+    assertEq(externalGsdRoot(base), join(stateDir, "projects", "my-project"), "externalGsdRoot uses GSD_PROJECT_ID");
     delete process.env.GSD_PROJECT_ID;
-});
 
-test('GSD_PROJECT_ID falls back to hash when unset', () => {
+    console.log("\n=== GSD_PROJECT_ID falls back to hash when unset ===");
     const hashIdentity = repoIdentity(base);
-    assert.ok(/^[0-9a-f]{12}$/.test(hashIdentity), "repoIdentity returns 12-char hex hash when GSD_PROJECT_ID is unset");
-});
+    assertTrue(/^[0-9a-f]{12}$/.test(hashIdentity), "repoIdentity returns 12-char hex hash when GSD_PROJECT_ID is unset");
 
-test('readRepoMeta returns null for malformed metadata', () => {
+    console.log("\n=== readRepoMeta returns null for malformed metadata ===");
+    {
       const malformedPath = join(stateDir, "projects", "malformed");
       mkdirSync(malformedPath, { recursive: true });
       writeFileSync(join(malformedPath, "repo-meta.json"), JSON.stringify({ version: 1 }) + "\n", "utf-8");
-      assert.deepStrictEqual(readRepoMeta(malformedPath), null, "malformed repo-meta.json is treated as unknown metadata");
-});
+      assertEq(readRepoMeta(malformedPath), null, "malformed repo-meta.json is treated as unknown metadata");
+    }
 
-test('ensureGsdSymlink refreshes repo-meta gitRoot after repo move with fixed project id', () => {
+    console.log("\n=== ensureGsdSymlink refreshes repo-meta gitRoot after repo move with fixed project id ===");
+    {
       const moveRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-repo-identity-move-")));
       run("git init -b main", moveRepo);
       run('git config user.name "Pi Test"', moveRepo);
@@ -114,25 +100,26 @@ test('ensureGsdSymlink refreshes repo-meta gitRoot after repo move with fixed pr
       process.env.GSD_PROJECT_ID = "fixed-project";
       const fixedExternal = ensureGsdSymlink(moveRepo);
       const before = readRepoMeta(fixedExternal);
-      assert.ok(before !== null, "repo metadata exists before repo move");
-      assert.deepStrictEqual(normalizePath(before!.gitRoot), normalizePath(moveRepo), "repo metadata tracks current git root before move");
+      assertTrue(before !== null, "repo metadata exists before repo move");
+      assertEq(normalizePath(before!.gitRoot), normalizePath(moveRepo), "repo metadata tracks current git root before move");
 
       const movedBaseRaw = join(tmpdir(), `gsd-repo-identity-moved-${Date.now()}-${Math.random().toString(36).slice(2)}`);
       renameSync(moveRepo, movedBaseRaw);
       const movedBase = realpathSync(movedBaseRaw);
       const movedExternal = ensureGsdSymlink(movedBase);
-      assert.deepStrictEqual(realpathSync(movedExternal), realpathSync(fixedExternal), "fixed project id keeps the same external state dir");
+      assertEq(realpathSync(movedExternal), realpathSync(fixedExternal), "fixed project id keeps the same external state dir");
 
       const after = readRepoMeta(movedExternal);
-      assert.ok(after !== null, "repo metadata exists after repo move");
-      assert.deepStrictEqual(normalizePath(after!.gitRoot), normalizePath(movedBase), "repo metadata gitRoot is refreshed to moved repo path");
-      assert.deepStrictEqual(after!.createdAt, before!.createdAt, "repo metadata preserves createdAt on refresh");
+      assertTrue(after !== null, "repo metadata exists after repo move");
+      assertEq(normalizePath(after!.gitRoot), normalizePath(movedBase), "repo metadata gitRoot is refreshed to moved repo path");
+      assertEq(after!.createdAt, before!.createdAt, "repo metadata preserves createdAt on refresh");
 
       rmSync(movedBase, { recursive: true, force: true });
       delete process.env.GSD_PROJECT_ID;
-});
+    }
 
-test('isInheritedRepo detects subdirectory of parent repo without .gsd (#1639)', () => {
+    console.log("\n=== isInheritedRepo detects subdirectory of parent repo without .gsd (#1639) ===");
+    {
       const parentRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-inherited-parent-")));
       run("git init -b main", parentRepo);
       run('git config user.name "Pi Test"', parentRepo);
@@ -141,26 +128,31 @@ test('isInheritedRepo detects subdirectory of parent repo without .gsd (#1639)',
       run("git add README.md", parentRepo);
       run('git commit -m "init"', parentRepo);
 
+      // Create a subdirectory — no .gsd at parent
       const subdir = join(parentRepo, "newproject");
       mkdirSync(subdir, { recursive: true });
-      assert.ok(isInheritedRepo(subdir), "subdirectory of parent repo without .gsd is inherited");
+      assertTrue(isInheritedRepo(subdir), "subdirectory of parent repo without .gsd is inherited");
 
+      // After adding .gsd at parent, subdirectory is a legitimate child
       mkdirSync(join(parentRepo, ".gsd"), { recursive: true });
-      assert.ok(!isInheritedRepo(subdir), "subdirectory of parent repo WITH .gsd is NOT inherited");
+      assertTrue(!isInheritedRepo(subdir), "subdirectory of parent repo WITH .gsd is NOT inherited");
 
-      assert.ok(!isInheritedRepo(parentRepo), "git root is not inherited");
+      // The git root itself is never inherited
+      assertTrue(!isInheritedRepo(parentRepo), "git root is not inherited");
 
+      // A standalone repo (not a subdir) is not inherited
       const standaloneRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-inherited-standalone-")));
       run("git init -b main", standaloneRepo);
       run('git config user.name "Pi Test"', standaloneRepo);
       run('git config user.email "pi@example.com"', standaloneRepo);
-      assert.ok(!isInheritedRepo(standaloneRepo), "standalone repo is not inherited");
+      assertTrue(!isInheritedRepo(standaloneRepo), "standalone repo is not inherited");
 
       rmSync(parentRepo, { recursive: true, force: true });
       rmSync(standaloneRepo, { recursive: true, force: true });
-});
+    }
 
-test('subdirectory of parent repo gets unique identity after git init (#1639)', () => {
+    console.log("\n=== subdirectory of parent repo gets unique identity after git init (#1639) ===");
+    {
       const parentRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-identity-parent-")));
       run("git init -b main", parentRepo);
       run('git config user.name "Pi Test"', parentRepo);
@@ -173,27 +165,38 @@ test('subdirectory of parent repo gets unique identity after git init (#1639)',
       const subdir = join(parentRepo, "childproject");
       mkdirSync(subdir, { recursive: true });
 
+      // Before git init, subdirectory shares parent's identity
       const parentIdentity = repoIdentity(parentRepo);
       const subdirIdentityBefore = repoIdentity(subdir);
-      assert.deepStrictEqual(subdirIdentityBefore, parentIdentity, "subdirectory shares parent identity before its own git init");
+      assertEq(subdirIdentityBefore, parentIdentity, "subdirectory shares parent identity before its own git init");
 
+      // After git init, subdirectory gets its own identity
       run("git init -b main", subdir);
       const subdirIdentityAfter = repoIdentity(subdir);
-      assert.ok(subdirIdentityAfter !== parentIdentity, "subdirectory gets unique identity after git init");
+      assertTrue(subdirIdentityAfter !== parentIdentity, "subdirectory gets unique identity after git init");
 
       rmSync(parentRepo, { recursive: true, force: true });
-});
+    }
 
-test('validateProjectId rejects invalid values', () => {
+    console.log("\n=== validateProjectId rejects invalid values ===");
     for (const invalid of ["has spaces", "path/traversal", "dot..dot", "back\\slash"]) {
-      assert.ok(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);
+      assertTrue(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);
     }
-});
 
-test('validateProjectId accepts valid values', () => {
+    console.log("\n=== validateProjectId accepts valid values ===");
     for (const valid of ["my-project", "foo_bar", "abc123", "A-Z_0-9"]) {
-      assert.ok(validateProjectId(valid), `validateProjectId accepts valid value: "${valid}"`);
+      assertTrue(validateProjectId(valid), `validateProjectId accepts valid value: "${valid}"`);
     }
-});
+  } finally {
+    delete process.env.GSD_PROJECT_ID;
+    delete process.env.GSD_STATE_DIR;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+    report();
+  }
+}
 
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });