gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/sync-layer-scope.test.ts

@@ -0,0 +1,434 @@
+// GSD-2 + Sync-layer scope variants: tests for ByScope wrappers in auto-worktree.ts
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  realpathSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+import {
+  syncProjectRootToWorktree,
+  syncProjectRootToWorktreeByScope,
+  syncStateToProjectRoot,
+  syncStateToProjectRootByScope,
+  syncGsdStateToWorktree,
+  syncGsdStateToWorktreeByScope,
+} from "../auto-worktree.ts";
+// Phase C: reconcilePlanCheckboxesByScope was deleted along with the
+// underlying reconcilePlanCheckboxes (auto-worktree.ts). Worktrees no
+// longer maintain a parallel .gsd/ projection that needs reconciliation.
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+const MID = "M001-abc123";
+
+/**
+ * Build a minimal project+worktree layout in a temp dir.
+ *
+ * Layout:
+ *   <root>/
+ *     .gsd/
+ *       milestones/<MID>/
+ *         <MID>-CONTEXT.md
+ *       metrics.json
+ *       completed-units.json
+ *       runtime/units/
+ *     .gsd/worktrees/<MID>/
+ *       .gsd/           ← worktree-local .gsd projection
+ *         milestones/<MID>/
+ *
+ * Returns { projectDir, worktreeDir }.
+ */
+function makeProjectAndWorktree(base: string): {
+  projectDir: string;
+  worktreeDir: string;
+} {
+  const projectDir = realpathSync(base);
+
+  // Project .gsd layout
+  mkdirSync(join(projectDir, ".gsd", "milestones", MID), { recursive: true });
+  mkdirSync(join(projectDir, ".gsd", "runtime", "units"), { recursive: true });
+  writeFileSync(join(projectDir, ".gsd", "milestones", MID, `${MID}-CONTEXT.md`), "context");
+  writeFileSync(join(projectDir, ".gsd", "metrics.json"), '{"tokens":0}');
+  writeFileSync(join(projectDir, ".gsd", "completed-units.json"), "[]");
+
+  // Worktree directory inside .gsd/worktrees/<MID> so isGsdWorktreePath recognises it
+  const worktreeDir = join(projectDir, ".gsd", "worktrees", MID);
+  mkdirSync(join(worktreeDir, ".gsd", "milestones", MID), { recursive: true });
+  mkdirSync(join(worktreeDir, ".gsd", "runtime", "units"), { recursive: true });
+
+  return { projectDir, worktreeDir };
+}
+
+// ─── Suite: identity check (throws on mismatched workspace) ─────────────────
+
+describe("ByScope variants: mismatched-workspace identity assertion", () => {
+  let tmpA: string;
+  let tmpB: string;
+
+  beforeEach(() => {
+    tmpA = mkdtempSync(join(tmpdir(), "gsd-sync-scope-a-"));
+    tmpB = mkdtempSync(join(tmpdir(), "gsd-sync-scope-b-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpA, { recursive: true, force: true });
+    rmSync(tmpB, { recursive: true, force: true });
+  });
+
+  test("syncProjectRootToWorktreeByScope throws when identityKeys differ", () => {
+    mkdirSync(join(tmpA, ".gsd"), { recursive: true });
+    mkdirSync(join(tmpB, ".gsd"), { recursive: true });
+    const wsA = createWorkspace(tmpA);
+    const wsB = createWorkspace(tmpB);
+    const scopeA = scopeMilestone(wsA, MID);
+    const scopeB = scopeMilestone(wsB, MID);
+
+    assert.throws(
+      () => syncProjectRootToWorktreeByScope(scopeA, scopeB),
+      /scope identity mismatch/,
+    );
+  });
+
+  test("syncStateToProjectRootByScope throws when identityKeys differ", () => {
+    mkdirSync(join(tmpA, ".gsd"), { recursive: true });
+    mkdirSync(join(tmpB, ".gsd"), { recursive: true });
+    const wsA = createWorkspace(tmpA);
+    const wsB = createWorkspace(tmpB);
+    const scopeA = scopeMilestone(wsA, MID);
+    const scopeB = scopeMilestone(wsB, MID);
+
+    assert.throws(
+      () => syncStateToProjectRootByScope(scopeA, scopeB),
+      /scope identity mismatch/,
+    );
+  });
+
+  test("syncGsdStateToWorktreeByScope throws when identityKeys differ", () => {
+    mkdirSync(join(tmpA, ".gsd"), { recursive: true });
+    mkdirSync(join(tmpB, ".gsd"), { recursive: true });
+    const wsA = createWorkspace(tmpA);
+    const wsB = createWorkspace(tmpB);
+    const scopeA = scopeMilestone(wsA, MID);
+    const scopeB = scopeMilestone(wsB, MID);
+
+    assert.throws(
+      () => syncGsdStateToWorktreeByScope(scopeA, scopeB),
+      /scope identity mismatch/,
+    );
+  });
+
+  // Phase C: reconcilePlanCheckboxesByScope identity-mismatch test
+  // removed along with the deleted function.
+});
+
+// ─── Suite: same-milestone, same-workspace path identity ────────────────────
+
+describe("ByScope variants: same-workspace produces same paths regardless of scope side", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "gsd-sync-scope-id-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("rootScope.workspace.identityKey equals worktreeScope.workspace.identityKey for same project", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+
+    assert.equal(
+      rootWs.identityKey,
+      worktreeWs.identityKey,
+      "both scopes from same project must share identityKey",
+    );
+  });
+
+  test("rootScope paths and worktreeScope.workspace.projectRoot resolve to the same project root", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+
+    assert.equal(
+      rootWs.projectRoot,
+      worktreeWs.projectRoot,
+      "projectRoot must be identical for root and worktree scopes",
+    );
+  });
+});
+
+// ─── Suite: disk-effect parity (scope variants == legacy path variants) ─────
+
+describe("syncProjectRootToWorktreeByScope: disk-effect parity with legacy", () => {
+  let tmp1: string;
+  let tmp2: string;
+
+  beforeEach(() => {
+    tmp1 = mkdtempSync(join(tmpdir(), "gsd-sync-legacy-"));
+    tmp2 = mkdtempSync(join(tmpdir(), "gsd-sync-scope-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp1, { recursive: true, force: true });
+    rmSync(tmp2, { recursive: true, force: true });
+  });
+
+  test("scope variant copies milestone dir into worktree identical to legacy variant", () => {
+    const { projectDir: proj1, worktreeDir: wt1 } = makeProjectAndWorktree(tmp1);
+    const { projectDir: proj2, worktreeDir: wt2 } = makeProjectAndWorktree(tmp2);
+
+    // Add a source file in project root milestone dir (not yet in worktree)
+    const srcFile = "extra-artifact.md";
+    writeFileSync(join(proj1, ".gsd", "milestones", MID, srcFile), "artifact");
+    writeFileSync(join(proj2, ".gsd", "milestones", MID, srcFile), "artifact");
+
+    // Remove destination files so something needs to be copied
+    rmSync(join(wt1, ".gsd", "milestones", MID, `${MID}-CONTEXT.md`), { force: true });
+    rmSync(join(wt2, ".gsd", "milestones", MID, `${MID}-CONTEXT.md`), { force: true });
+
+    // Run legacy on tmp1, scope variant on tmp2
+    syncProjectRootToWorktree(proj1, wt1, MID);
+
+    const rootWs2 = createWorkspace(proj2);
+    const worktreeWs2 = createWorkspace(wt2);
+    const rootScope2 = scopeMilestone(rootWs2, MID);
+    const worktreeScope2 = scopeMilestone(worktreeWs2, MID);
+    syncProjectRootToWorktreeByScope(rootScope2, worktreeScope2);
+
+    // Both worktrees should now have the CONTEXT.md
+    assert.ok(
+      existsSync(join(wt1, ".gsd", "milestones", MID, `${MID}-CONTEXT.md`)),
+      "legacy: CONTEXT.md should be copied into worktree",
+    );
+    assert.ok(
+      existsSync(join(wt2, ".gsd", "milestones", MID, `${MID}-CONTEXT.md`)),
+      "scope: CONTEXT.md should be copied into worktree",
+    );
+  });
+});
+
+describe("syncStateToProjectRootByScope: disk-effect parity with legacy", () => {
+  let tmp1: string;
+  let tmp2: string;
+
+  beforeEach(() => {
+    tmp1 = mkdtempSync(join(tmpdir(), "gsd-sync-stpr-legacy-"));
+    tmp2 = mkdtempSync(join(tmpdir(), "gsd-sync-stpr-scope-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp1, { recursive: true, force: true });
+    rmSync(tmp2, { recursive: true, force: true });
+  });
+
+  test("scope variant copies metrics.json from worktree to project root identical to legacy variant", () => {
+    const { projectDir: proj1, worktreeDir: wt1 } = makeProjectAndWorktree(tmp1);
+    const { projectDir: proj2, worktreeDir: wt2 } = makeProjectAndWorktree(tmp2);
+
+    // Write metrics.json into each worktree .gsd
+    const metricsContent = '{"tokens":42}';
+    writeFileSync(join(wt1, ".gsd", "metrics.json"), metricsContent);
+    writeFileSync(join(wt2, ".gsd", "metrics.json"), metricsContent);
+
+    // Run legacy on tmp1, scope variant on tmp2
+    syncStateToProjectRoot(wt1, proj1, MID);
+
+    const rootWs2 = createWorkspace(proj2);
+    const worktreeWs2 = createWorkspace(wt2);
+    const rootScope2 = scopeMilestone(rootWs2, MID);
+    const worktreeScope2 = scopeMilestone(worktreeWs2, MID);
+    syncStateToProjectRootByScope(worktreeScope2, rootScope2);
+
+    // Both project roots should now have the updated metrics.json
+    assert.ok(
+      existsSync(join(proj1, ".gsd", "metrics.json")),
+      "legacy: metrics.json should be synced to project root",
+    );
+    assert.ok(
+      existsSync(join(proj2, ".gsd", "metrics.json")),
+      "scope: metrics.json should be synced to project root",
+    );
+  });
+});
+
+describe("syncGsdStateToWorktreeByScope: disk-effect parity with legacy", () => {
+  let tmp1: string;
+  let tmp2: string;
+
+  beforeEach(() => {
+    tmp1 = mkdtempSync(join(tmpdir(), "gsd-sync-gsd-legacy-"));
+    tmp2 = mkdtempSync(join(tmpdir(), "gsd-sync-gsd-scope-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp1, { recursive: true, force: true });
+    rmSync(tmp2, { recursive: true, force: true });
+  });
+
+  test("scope variant syncs root state files into worktree identical to legacy variant", () => {
+    const { projectDir: proj1, worktreeDir: wt1 } = makeProjectAndWorktree(tmp1);
+    const { projectDir: proj2, worktreeDir: wt2 } = makeProjectAndWorktree(tmp2);
+
+    // Add a root state file in each project .gsd (not yet in worktree)
+    writeFileSync(join(proj1, ".gsd", "DECISIONS.md"), "decisions");
+    writeFileSync(join(proj2, ".gsd", "DECISIONS.md"), "decisions");
+
+    // Run legacy on tmp1, scope variant on tmp2
+    syncGsdStateToWorktree(proj1, wt1);
+
+    const rootWs2 = createWorkspace(proj2);
+    const worktreeWs2 = createWorkspace(wt2);
+    const rootScope2 = scopeMilestone(rootWs2, MID);
+    const worktreeScope2 = scopeMilestone(worktreeWs2, MID);
+    syncGsdStateToWorktreeByScope(rootScope2, worktreeScope2);
+
+    // Both worktrees should now have DECISIONS.md
+    assert.ok(
+      existsSync(join(wt1, ".gsd", "DECISIONS.md")),
+      "legacy: DECISIONS.md should be copied into worktree",
+    );
+    assert.ok(
+      existsSync(join(wt2, ".gsd", "DECISIONS.md")),
+      "scope: DECISIONS.md should be copied into worktree",
+    );
+  });
+});
+
+// ─── Suite: direction tests ──────────────────────────────────────────────────
+
+describe("sync direction: project→worktree variants only write to worktree side", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "gsd-sync-dir-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("syncProjectRootToWorktreeByScope: new file appears in worktree, not duplicated to project root", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+
+    // New file in project root milestone — not yet in worktree
+    const marker = "direction-test.md";
+    writeFileSync(join(projectDir, ".gsd", "milestones", MID, marker), "marker");
+
+    // Remove from worktree so we can detect it being added
+    const wtDst = join(worktreeDir, ".gsd", "milestones", MID, marker);
+    rmSync(wtDst, { force: true });
+
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+    const rootScope = scopeMilestone(rootWs, MID);
+    const worktreeScope = scopeMilestone(worktreeWs, MID);
+
+    syncProjectRootToWorktreeByScope(rootScope, worktreeScope);
+
+    // File should now be in worktree
+    assert.ok(existsSync(wtDst), "marker file should appear in worktree after project→worktree sync");
+
+    // The original in project root should still be there (not removed)
+    assert.ok(
+      existsSync(join(projectDir, ".gsd", "milestones", MID, marker)),
+      "project root marker file should not be removed",
+    );
+  });
+
+  test("syncStateToProjectRootByScope: new file appears in project root from worktree", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+
+    // Write a runtime unit file into worktree
+    const unitFile = "some-unit-M001.json";
+    writeFileSync(join(worktreeDir, ".gsd", "runtime", "units", unitFile), '{"status":"done"}');
+
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+    const rootScope = scopeMilestone(rootWs, MID);
+    const worktreeScope = scopeMilestone(worktreeWs, MID);
+
+    syncStateToProjectRootByScope(worktreeScope, rootScope);
+
+    // Unit file should now be in project root
+    assert.ok(
+      existsSync(join(projectDir, ".gsd", "runtime", "units", unitFile)),
+      "runtime unit file should appear in project root after worktree→root sync",
+    );
+
+    // Worktree side should still have the file (not removed)
+    assert.ok(
+      existsSync(join(worktreeDir, ".gsd", "runtime", "units", unitFile)),
+      "worktree runtime unit file should not be removed",
+    );
+  });
+});
+
+// ─── Suite: milestoneId mismatch guard ───────────────────────────────────────
+
+describe("ByScope variants: milestoneId mismatch throws for milestone-aware wrappers", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "gsd-sync-mid-mismatch-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("syncProjectRootToWorktreeByScope throws when milestoneIds differ", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+    // Same workspace identity, different milestoneId
+    const rootScope = scopeMilestone(rootWs, "M001-abc123");
+    const worktreeScope = scopeMilestone(worktreeWs, "M002-def456");
+
+    assert.throws(
+      () => syncProjectRootToWorktreeByScope(rootScope, worktreeScope),
+      /milestoneId mismatch/,
+    );
+  });
+
+  test("syncStateToProjectRootByScope throws when milestoneIds differ", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+    const rootScope = scopeMilestone(rootWs, "M001-abc123");
+    const worktreeScope = scopeMilestone(worktreeWs, "M002-def456");
+
+    assert.throws(
+      () => syncStateToProjectRootByScope(worktreeScope, rootScope),
+      /milestoneId mismatch/,
+    );
+  });
+
+  // Phase C: reconcilePlanCheckboxesByScope milestoneId-mismatch test
+  // removed along with the deleted function.
+
+  test("syncGsdStateToWorktreeByScope does NOT throw when milestoneIds differ (workspace-only wrapper)", () => {
+    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
+    const rootWs = createWorkspace(projectDir);
+    const worktreeWs = createWorkspace(worktreeDir);
+    // Different milestoneIds — syncGsdStateToWorktreeByScope must not guard milestoneId
+    const rootScope = scopeMilestone(rootWs, "M001-abc123");
+    const worktreeScope = scopeMilestone(worktreeWs, "M002-def456");
+
+    assert.doesNotThrow(
+      () => syncGsdStateToWorktreeByScope(rootScope, worktreeScope),
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/teardown-chdir-failure-clears-registry.test.ts

@@ -0,0 +1,162 @@
+// GSD-2 + Regression test: teardownAutoWorktree clears activeWorkspace even when process.chdir throws
+
+/**
+ * Regression (H3 broadened scope): `teardownAutoWorktree` must clear `activeWorkspace`
+ * (and therefore `getAutoWorktreeOriginalBase()` / `getActiveAutoWorktreeContext()`)
+ * unconditionally — regardless of where in the function body an error occurs.
+ *
+ * The original H3 fix (d1276b021) wrapped only `removeWorktree(...)` in a
+ * try/finally. But `process.chdir(originalBasePath)` at the top of the function
+ * can throw a GSDError if the target directory no longer exists. In that case
+ * execution exits the function before ever reaching the inner try/finally, leaving
+ * `activeWorkspace` stale.
+ *
+ * The fix: a single outer try/finally wraps the entire teardown body so
+ * `setActiveWorkspace(null)` runs regardless of which step throws.
+ *
+ * Test strategy:
+ *   1. Populate the registry via `createAutoWorktree` on a real temp git repo.
+ *   2. Delete the repo directory so `process.chdir(originalBasePath)` throws.
+ *   3. Assert `teardownAutoWorktree` re-throws (chdir failure still propagates).
+ *   4. Assert `getActiveWorkspace()` is null — the broadened finally caught it.
+ *   5. Regression: success path still clears activeWorkspace (same guarantee).
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  mkdtempSync,
+  writeFileSync,
+  rmSync,
+  realpathSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  teardownAutoWorktree,
+  getAutoWorktreeOriginalBase,
+  getActiveAutoWorktreeContext,
+  _resetAutoWorktreeOriginalBaseForTests,
+} from "../auto-worktree.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function git(args: string[], cwd: string): void {
+  execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-chdir-fail-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@gsd.test"], dir);
+  git(["config", "user.name", "Test"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+function seedMilestone(repoDir: string, milestoneId: string): void {
+  const msDir = join(repoDir, ".gsd", "milestones", milestoneId);
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "CONTEXT.md"), `# ${milestoneId} Context\n`);
+  git(["add", "."], repoDir);
+  git(["commit", "-m", `add ${milestoneId}`], repoDir);
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("teardown chdir failure clears registry", () => {
+  const savedCwd = process.cwd();
+  let repoDir: string;
+
+  beforeEach(() => {
+    _resetAutoWorktreeOriginalBaseForTests();
+    process.chdir(savedCwd);
+    repoDir = "";
+  });
+
+  afterEach(() => {
+    _resetAutoWorktreeOriginalBaseForTests();
+    process.chdir(savedCwd);
+    if (repoDir && existsSync(repoDir)) {
+      rmSync(repoDir, { recursive: true, force: true });
+    }
+    repoDir = "";
+  });
+
+  // ── chdir failure path (the new coverage) ──────────────────────────────────
+
+  test("registry is null after teardown throws due to chdir failure (H3 broadened scope)", () => {
+    repoDir = createTempRepo();
+    seedMilestone(repoDir, "M001");
+
+    // Populate the registry by entering the worktree
+    createAutoWorktree(repoDir, "M001");
+
+    assert.strictEqual(
+      getAutoWorktreeOriginalBase(),
+      repoDir,
+      "registry is populated after createAutoWorktree",
+    );
+    assert.notStrictEqual(
+      getActiveAutoWorktreeContext(),
+      null,
+      "context is non-null after createAutoWorktree",
+    );
+
+    // Move back to a safe cwd so we can delete the repo dir
+    process.chdir(savedCwd);
+
+    // Delete the repo directory — process.chdir(repoDir) inside teardown will throw
+    const capturedRepoDir = repoDir;
+    rmSync(repoDir, { recursive: true, force: true });
+    repoDir = ""; // afterEach cleanup no longer needed
+
+    // teardownAutoWorktree must throw (chdir to deleted dir fails)
+    assert.throws(
+      () => teardownAutoWorktree(capturedRepoDir, "M001"),
+      "teardownAutoWorktree should throw when originalBasePath does not exist",
+    );
+
+    // The broadened outer finally must have cleared the registry despite the throw
+    assert.strictEqual(
+      getAutoWorktreeOriginalBase(),
+      null,
+      "getAutoWorktreeOriginalBase() is null after chdir-failure teardown (H3)",
+    );
+    assert.strictEqual(
+      getActiveAutoWorktreeContext(),
+      null,
+      "getActiveAutoWorktreeContext() is null after chdir-failure teardown (H3)",
+    );
+  });
+
+  // ── Success path (regression guard) ───────────────────────────────────────
+
+  test("registry is null after successful teardown (success path regression)", () => {
+    repoDir = createTempRepo();
+    seedMilestone(repoDir, "M002");
+
+    // Confirm baseline
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry null before entering worktree");
+
+    createAutoWorktree(repoDir, "M002");
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), repoDir, "registry set after createAutoWorktree");
+    assert.notStrictEqual(getActiveAutoWorktreeContext(), null, "context non-null after createAutoWorktree");
+
+    // Normal teardown — finally block must still clear registry
+    teardownAutoWorktree(repoDir, "M002");
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry null after successful teardown");
+    assert.strictEqual(getActiveAutoWorktreeContext(), null, "context null after successful teardown");
+  });
+});

package/src/resources/extensions/gsd/tests/teardown-cleanup-parity.test.ts

@@ -0,0 +1,98 @@
+/**
+ * GSD Auto-Worktree -- teardown-cleanup-parity.test.ts
+ *
+ * Regression test: teardownAutoWorktree (abort path) must call
+ * clearProjectRootStateFiles, removing STATE.md, auto.lock, and
+ * {MID}-META.json from the project root .gsd/ dir.
+ *
+ * Prior to the fix these files were left behind on disk after abort teardown.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  mkdtempSync,
+  writeFileSync,
+  existsSync,
+  rmSync,
+  realpathSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { teardownAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+
+function git(args: string[], cwd: string): void {
+  execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-teardown-parity-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@gsd.test"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "README.md"], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+describe("teardownAutoWorktree cleanup parity", () => {
+  let repoDir: string;
+
+  beforeEach(() => {
+    repoDir = createTempRepo();
+    _resetAutoWorktreeOriginalBaseForTests();
+  });
+
+  afterEach(() => {
+    rmSync(repoDir, { recursive: true, force: true });
+    _resetAutoWorktreeOriginalBaseForTests();
+  });
+
+  test("STATE.md and M001-META.json are removed after abort teardown", () => {
+    // Phase C pt 2: auto.lock no longer exists as a file — it migrated
+    // to the workers + unit_dispatches tables. clearProjectRootStateFiles
+    // still removes STATE.md and {MID}-META.json on teardown.
+    const gsdDir = join(repoDir, ".gsd");
+    const milestonesDir = join(gsdDir, "milestones", "M001");
+    mkdirSync(milestonesDir, { recursive: true });
+
+    const stateMd = join(gsdDir, "STATE.md");
+    const metaJson = join(milestonesDir, "M001-META.json");
+
+    writeFileSync(stateMd, "# State\nactive\n");
+    writeFileSync(metaJson, JSON.stringify({ milestoneId: "M001" }));
+
+    assert.ok(existsSync(stateMd), "STATE.md exists before teardown");
+    assert.ok(existsSync(metaJson), "M001-META.json exists before teardown");
+
+    // teardownAutoWorktree may throw when git worktree removal fails
+    // (no actual worktree was created), but clearProjectRootStateFiles
+    // runs before removeWorktree so the state files must be gone regardless.
+    try {
+      teardownAutoWorktree(repoDir, "M001");
+    } catch {
+      // git teardown may fail in a minimal test repo — that is acceptable
+    }
+
+    assert.ok(!existsSync(stateMd), "STATE.md removed by teardownAutoWorktree");
+    assert.ok(!existsSync(metaJson), "M001-META.json removed by teardownAutoWorktree");
+  });
+
+  test("teardown is non-fatal when state files do not exist", () => {
+    // No state files created — teardown should not throw due to missing files
+    // (clearProjectRootStateFiles tolerates ENOENT).
+    try {
+      teardownAutoWorktree(repoDir, "M001");
+    } catch {
+      // git teardown may fail — acceptable
+    }
+
+    // Reaching here means clearProjectRootStateFiles did not throw for missing files.
+    assert.ok(true, "teardown with missing state files did not throw from clearProjectRootStateFiles");
+  });
+});