@opengsd/gsd-pi 1.4.0 → 1.5.0

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -186,6 +186,58 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
   }
 });
 
+test("uok gitops turn action commit defaults to child repositories in parent mode", () => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-uok-gitops-parent-commit-"));
+  try {
+    initRepo(root);
+    mkdirSync(join(root, ".gsd"), { recursive: true });
+    mkdirSync(join(root, "frontend"), { recursive: true });
+    mkdirSync(join(root, "backend"), { recursive: true });
+    initRepo(join(root, "frontend"));
+    initRepo(join(root, "backend"));
+    writeFileSync(join(root, ".gitignore"), "frontend/\nbackend/\n", "utf-8");
+    run("git add .gitignore", root);
+    run('git commit -m "chore: ignore nested repos"', root);
+    writeFileSync(join(root, ".gsd", "PREFERENCES.md"), `---
+version: 1
+workspace:
+  mode: parent
+  repositories:
+    frontend:
+      path: frontend
+    backend:
+      path: backend
+---
+`, "utf-8");
+    run("git add .gsd/PREFERENCES.md", root);
+    run('git commit -m "chore: configure parent workspace repos"', root);
+
+    const rootHeadBefore = run("git rev-parse HEAD", root);
+    writeFileSync(join(root, "frontend", "README.md"), "# frontend dirty\n", "utf-8");
+    writeFileSync(join(root, "backend", "README.md"), "# backend dirty\n", "utf-8");
+
+    const result = runTurnGitAction({
+      basePath: root,
+      action: "commit",
+      unitType: "execute-task",
+      unitId: "M001/S01/T-parent",
+    });
+
+    assert.equal(result.status, "ok");
+    assert.equal(result.commitMessages?.project, undefined);
+    assert.equal(typeof result.commitMessages?.frontend, "string");
+    assert.equal(typeof result.commitMessages?.backend, "string");
+    assert.equal(result.commitMessage, result.commitMessages?.frontend);
+    assert.equal(run("git rev-parse HEAD", root), rootHeadBefore);
+    assert.equal(run("git status --porcelain", join(root, "frontend")), "");
+    assert.equal(run("git status --porcelain", join(root, "backend")), "");
+    assert.ok(run("git log -1 --pretty=%B", join(root, "frontend")).includes("GSD-Unit: M001/S01/T-parent"));
+    assert.ok(run("git log -1 --pretty=%B", join(root, "backend")).includes("GSD-Unit: M001/S01/T-parent"));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("uok gitops turn action commit reuses the collected dirty status", () => {
   const repo = makeRepo();
   const wrapperDir = mkdtempSync(join(tmpdir(), "gsd-uok-git-wrapper-"));

package/src/resources/extensions/gsd/tests/validator-scope-parity.test.ts

@@ -23,7 +23,7 @@ import {
 
 function makeProjectDir(label = "gsd-vsp-"): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), label)));
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(dir, ".gsd", "phases", "01-m001"), { recursive: true });
   return dir;
 }
 
@@ -236,4 +236,56 @@ describe("validator-scope-parity: scope uses canonical projectRoot not worktree
       "verifyExpectedArtifactForScope should return false when artifact is absent",
     );
   });
+
+  test("verifyExpectedArtifactForScope rejects zero-slice scoped plan-milestone roadmaps", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    writeFileSync(scope.roadmapFile(), [
+      "# M001: Placeholder",
+      "",
+      "## Slices",
+      "",
+      "_TBD_",
+      "",
+    ].join("\n"));
+
+    const ready = verifyExpectedArtifactForScope(scope, "plan-milestone", "M001");
+    assert.equal(
+      ready,
+      false,
+      "scoped plan-milestone verification must parse roadmap content, not only check existence",
+    );
+  });
+
+  test("verifyExpectedArtifactForScope verifies the scoped plan-milestone roadmap path", () => {
+    const ws = createWorkspace(base);
+    const realScope = scopeMilestone(ws, "M001");
+    const scopedRoadmap = join(base, "scoped-M001-ROADMAP.md");
+    const scope = {
+      ...realScope,
+      roadmapFile: () => scopedRoadmap,
+    };
+
+    writeFileSync(scopedRoadmap, [
+      "# M001: Scoped roadmap",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "  > After this: a real slice exists.",
+      "",
+    ].join("\n"));
+
+    assert.equal(
+      resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001"),
+      scopedRoadmap,
+      "scoped plan-milestone artifact path must come from scope.roadmapFile()",
+    );
+    assert.equal(
+      verifyExpectedArtifactForScope(scope, "plan-milestone", "M001"),
+      true,
+      "scoped plan-milestone verification must read the roadmap from scope.roadmapFile()",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -12,6 +12,7 @@ import {
   getArtifact,
   getAssessment,
   insertAssessment,
+  insertGateRow,
   insertMilestone,
   upsertRequirement,
   getAllMilestones,
@@ -21,6 +22,7 @@ import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.t
 import { deriveState, invalidateStateCache } from "../state.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { normalizeRealPath } from "../paths.ts";
+import { recordUnitHarnessAbort } from "../unit-runtime.ts";
 import { markApprovalGateVerified, markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot, setPendingGate } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
@@ -37,6 +39,11 @@ import {
   executeValidateMilestone,
   executeUatResultSave,
 } from "../tools/workflow-tool-executors.ts";
+import {
+  initNotificationStore,
+  readNotifications,
+  _resetNotificationStore,
+} from "../notification-store.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-workflow-executors-${randomUUID()}`);
@@ -910,6 +917,104 @@ test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone
   }
 });
 
+test("executeUatResultSave leaves UAT pending after a harness-aborted turn", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const worktreeExecDir = join(worktree, ".gsd", "exec");
+  const evidenceId = "harness-aborted-uat-evidence";
+  const startedAt = Date.now();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Milestone One");
+    seedSlice("M001", "S04", "complete");
+    mkdirSync(worktreeExecDir, { recursive: true });
+    writeFileSync(
+      join(worktreeExecDir, `${evidenceId}.meta.json`),
+      JSON.stringify({
+        id: evidenceId,
+        metadata: {
+          kind: "uat_exec",
+          milestoneId: "M001",
+          sliceId: "S04",
+          checkId: "UAT-01",
+          intent: "uat-runtime-check",
+        },
+      }),
+      "utf-8",
+    );
+    _getAdapter()!.prepare(
+      `INSERT INTO quality_gates (milestone_id, slice_id, gate_id, scope, task_id, status)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+    ).run("M001", "S04", "UAT", "slice", "", "pending");
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.currentUnit = { type: "run-uat", id: "M001/S04", startedAt, workspaceRoot: worktree };
+    recordUnitHarnessAbort(base, "run-uat", "M001/S04", startedAt, {
+      kind: "tool-loop-guard",
+      reason: "Tool loop detected (repeated tool): browser_click called 7 times this turn.",
+      toolName: "browser_click",
+      count: 7,
+    });
+
+    const result = await inProjectDir(worktree, () => executeUatResultSave({
+      milestoneId: "M001",
+      sliceId: "S04",
+      uatType: "runtime-executable",
+      verdict: "FAIL",
+      checks: [{
+        id: "UAT-01",
+        description: "Runtime behavior could not be fully evaluated before harness abort",
+        mode: "runtime",
+        result: "FAIL",
+        evidence: [{ kind: "gsd_uat_exec", ref: evidenceId }],
+        notes: "Partial failure should be retried because the harness aborted the turn.",
+      }],
+      presentation: {
+        surface: "mcp",
+        presentedTools: [
+          "gsd_uat_exec",
+          "gsd_uat_result_save",
+          "gsd_resume",
+          "gsd_milestone_status",
+          "gsd_journal_query",
+        ],
+        blockedTools: [
+          { name: "gsd_exec", reason: "forbidden during run-uat" },
+          { name: "gsd_summary_save", reason: "forbidden during run-uat" },
+          { name: "gsd_save_gate_result", reason: "forbidden during run-uat" },
+        ],
+      },
+      notes: "Partial UAT result after harness abort.",
+    }, worktree));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.operation, "save_uat_result");
+    assert.equal(result.details.error, "harness_aborted_needs_retry");
+    assert.equal(result.details.retryable, true);
+    assert.equal(result.details.harnessAbortKind, "tool-loop-guard");
+    assert.equal(
+      existsSync(join(base, ".gsd", "uat", "M001", "S04", "attempt-1.json")),
+      false,
+      "harness-aborted UAT should not persist an attempt artifact",
+    );
+    assert.equal(
+      existsSync(join(base, ".gsd", "phases", "01-m001", "01-04-ASSESSMENT.md")),
+      false,
+      "harness-aborted UAT should not write an ASSESSMENT verdict",
+    );
+    const row = _getAdapter()!.prepare(
+      "SELECT status, verdict FROM quality_gates WHERE milestone_id = ? AND slice_id = ? AND gate_id = ?",
+    ).get("M001", "S04", "UAT") as Record<string, unknown>;
+    assert.equal(row.status, "pending");
+    assert.equal(row.verdict, "");
+  } finally {
+    autoSession.reset();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeUatResultSave supplies canonical presentation and normalizes verdict casing", async () => {
   const base = makeTmpBase();
   const worktree = join(base, ".gsd", "worktrees", "M001");
@@ -1100,13 +1205,14 @@ test("executeUatResultSave merges canonical plan ID and read-only tools when pre
   }
 });
 
-test("executeUatResultSave surfaces the worktree validation path for NEEDS-HUMAN checks", async () => {
+test("executeUatResultSave surfaces the worktree validation path and notification for NEEDS-HUMAN checks", async () => {
   const base = makeTmpBase();
   const worktree = join(base, ".gsd", "worktrees", "M001");
   const worktreeExecDir = join(worktree, ".gsd", "exec");
   const evidenceId = "uat-human-validation-evidence";
   try {
     openTestDb(base);
+    initNotificationStore(base);
     seedMilestone("M001", "Milestone One");
     seedSlice("M001", "S07", "complete");
     mkdirSync(worktreeExecDir, { recursive: true });
@@ -1166,7 +1272,17 @@ test("executeUatResultSave surfaces the worktree validation path for NEEDS-HUMAN
     assert.match(assessment, /## Manual Validation/);
     assert.ok(assessment.includes(worktree), "assessment should include the worktree checkout path");
     assert.match(assessment, /git worktree/);
+
+    const notifications = readNotifications(base, { kind: "uat-needs-human", scope: "M001/S07" });
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0].severity, "warning");
+    assert.equal(notifications[0].source, "notify");
+    assert.equal(
+      notifications[0].message,
+      "UAT for M001/S07 has NEEDS-HUMAN checks awaiting human validation",
+    );
   } finally {
+    _resetNotificationStore();
     closeDatabase();
     cleanup(base);
   }
@@ -1757,6 +1873,97 @@ test("executeSaveGateResult validates inputs and persists verdicts", async () =>
   }
 });
 
+test("executeSaveGateResult leaves quality gates pending after a retryable tool error", async () => {
+  const base = makeTmpBase();
+  const startedAt = Date.now();
+  try {
+    openTestDb(base);
+    seedMilestone("M005", "Milestone Five");
+    seedSlice("M005", "S05", "pending");
+    insertGateRow({ milestoneId: "M005", sliceId: "S05", gateId: "Q3", scope: "slice" });
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.currentUnit = { type: "plan-slice", id: "M005/S05", startedAt };
+    recordUnitHarnessAbort(base, "plan-slice", "M005/S05", startedAt, {
+      kind: "tool-error",
+      reason: "Input validation error: selector is required",
+      toolName: "browser_click",
+    });
+
+    const result = await inProjectDir(base, () => executeSaveGateResult({
+      milestoneId: "M005",
+      sliceId: "S05",
+      gateId: "Q3",
+      verdict: "flag",
+      rationale: "Partial gate failure after harness abort.",
+      findings: "This should not be persisted as a product-quality finding.",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.operation, "save_gate_result");
+    assert.equal(result.details.error, "harness_aborted_needs_retry");
+    assert.equal(result.details.retryable, true);
+    assert.equal(result.details.harnessAbortKind, "tool-error");
+    const row = _getAdapter()!.prepare(
+      "SELECT status, verdict, rationale, findings FROM quality_gates WHERE milestone_id = ? AND slice_id = ? AND gate_id = ? AND task_id = ''",
+    ).get("M005", "S05", "Q3") as Record<string, unknown>;
+    assert.equal(row.status, "pending");
+    assert.equal(row.verdict, "");
+    assert.equal(row.rationale, "");
+    assert.equal(row.findings, "");
+  } finally {
+    autoSession.reset();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSaveGateResult leaves quality gates pending after a turn abort", async () => {
+  const base = makeTmpBase();
+  const startedAt = Date.now();
+  try {
+    openTestDb(base);
+    seedMilestone("M005", "Milestone Five");
+    seedSlice("M005", "S05", "pending");
+    insertGateRow({ milestoneId: "M005", sliceId: "S05", gateId: "Q3", scope: "slice" });
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.currentUnit = { type: "plan-slice", id: "M005/S05", startedAt };
+    recordUnitHarnessAbort(base, "plan-slice", "M005/S05", startedAt, {
+      kind: "turn-abort",
+      reason: "Agent turn aborted before the gate evaluation completed. origin=timeout stopReason=aborted",
+    });
+
+    const result = await inProjectDir(base, () => executeSaveGateResult({
+      milestoneId: "M005",
+      sliceId: "S05",
+      gateId: "Q3",
+      verdict: "flag",
+      rationale: "Partial gate failure after a turn abort.",
+      findings: "This should not be persisted as a product-quality finding.",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.operation, "save_gate_result");
+    assert.equal(result.details.error, "harness_aborted_needs_retry");
+    assert.equal(result.details.retryable, true);
+    assert.equal(result.details.harnessAbortKind, "turn-abort");
+    const row = _getAdapter()!.prepare(
+      "SELECT status, verdict, rationale, findings FROM quality_gates WHERE milestone_id = ? AND slice_id = ? AND gate_id = ? AND task_id = ''",
+    ).get("M005", "S05", "Q3") as Record<string, unknown>;
+    assert.equal(row.status, "pending");
+    assert.equal(row.verdict, "");
+    assert.equal(row.rationale, "");
+    assert.equal(row.findings, "");
+  } finally {
+    autoSession.reset();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSaveGateResult fails when no canonical gate row is updated", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/workspace.test.ts

@@ -8,6 +8,7 @@ import {
   rmSync,
   realpathSync,
   symlinkSync,
+  writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -118,17 +119,17 @@ describe("scopeMilestone path methods", () => {
     rmSync(projectDir, { recursive: true, force: true });
   });
 
-  test("produces correct paths for a known milestone ID", () => {
+  test("produces flat-phase paths for a known milestone ID", () => {
     const ws = createWorkspace(projectDir);
     const scope = scopeMilestone(ws, MID);
     const gsd = ws.contract.projectGsd;
 
     assert.equal(scope.milestoneId, MID);
-    assert.equal(scope.contextFile(), join(gsd, "milestones", MID, `${MID}-CONTEXT.md`));
-    assert.equal(scope.roadmapFile(), join(gsd, "milestones", MID, `${MID}-ROADMAP.md`));
+    assert.equal(scope.contextFile(), join(gsd, "phases", "01-m001", "01-CONTEXT.md"));
+    assert.equal(scope.roadmapFile(), join(gsd, "phases", "01-m001", "01-ROADMAP.md"));
     assert.equal(scope.stateFile(), join(gsd, "STATE.md"));
     assert.equal(scope.dbPath(), ws.contract.projectDb);
-    assert.equal(scope.milestoneDir(), join(gsd, "milestones", MID));
+    assert.equal(scope.milestoneDir(), join(gsd, "phases", "01-m001"));
     assert.equal(scope.metaJson(), join(gsd, `${MID}-META.json`));
   });
 
@@ -144,6 +145,19 @@ describe("scopeMilestone path methods", () => {
     assert.equal(scope1.milestoneDir(), scope2.milestoneDir());
     assert.equal(scope1.metaJson(), scope2.metaJson());
   });
+
+  test("uses legacy milestone paths when legacy content exists", () => {
+    const legacyDir = join(projectDir, ".gsd", "milestones", MID);
+    mkdirSync(legacyDir, { recursive: true });
+    writeFileSync(join(legacyDir, `${MID}-CONTEXT.md`), "# Legacy context\n");
+
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, MID);
+
+    assert.equal(scope.contextFile(), join(legacyDir, `${MID}-CONTEXT.md`));
+    assert.equal(scope.roadmapFile(), join(legacyDir, `${MID}-ROADMAP.md`));
+    assert.equal(scope.milestoneDir(), legacyDir);
+  });
 });
 
 describe("createWorkspace: contract.projectGsd is realpath-canonicalized when basePath is a symlink", () => {

package/src/resources/extensions/gsd/tests/worktree-journal-events.test.ts

@@ -107,7 +107,7 @@ function makeDeps(
   // real `getAutoWorktreePath` / `createAutoWorktree` / etc. and the
   // success/existing/failure branches won't fire as expected.
   const deps: LegacyTestDeps = {
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     worktreeProjection: new WorktreeStateProjection(),
     // ADR-016 phase 2 / C4 (#5627): GitServiceImpl constructor → factory.
     gitServiceFactory: () => ({}) as unknown as ReturnType<
@@ -283,7 +283,7 @@ describe("worktree journal events", () => {
 
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+      mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     });
     process.chdir(wt);
 
@@ -304,7 +304,7 @@ describe("worktree journal events", () => {
     const wt = setupMergeWorktree(tmp, "M001");
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
+      mergeMilestone: () => { throw new Error("conflict in main"); },
     });
     // Since #4380, mergeAndExit re-throws all errors after emitting the journal
     // event and restoring state. Lifecycle now wraps that throw in a typed
@@ -347,7 +347,7 @@ describe("worktree journal events", () => {
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     let attempt = 0;
     const deps = makeDeps({
-      mergeMilestoneToMain: () => {
+      mergeMilestone: () => {
         attempt += 1;
         throw new MergeConflictError(
           attempt === 1 ? ["src/a.ts"] : ["src/b.ts", "src/c.ts"],

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

@@ -46,7 +46,7 @@ function makeDeps(
 ): LegacyTestDeps & { calls: CallLog[] } {
   const calls: CallLog[] = [];
   // ADR-016 phase 2 / C-track close-out: WorktreeLifecycleDeps is now a
-  // 3-field bag (gitServiceFactory, worktreeProjection, mergeMilestoneToMain).
+  // 3-field bag (gitServiceFactory, worktreeProjection, mergeMilestone).
   // Tests still pass legacy override hooks via `LegacyTestDeps` — Lifecycle
   // ignores the extras structurally and reads them through the C1-healing
   // primitive-override pattern when stubs are needed.
@@ -73,7 +73,7 @@ function makeDeps(
     },
     autoWorktreeBranch: (mid: string) => `milestone/${mid}`,
     teardownAutoWorktree: () => {},
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     ...overrides,
   };
   return deps;

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -23,7 +23,7 @@
  *   - syncWorktreeStateBack skips non-standard milestone projection dir names
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -148,6 +148,36 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
+  // ─── 3c. artifact file/dir collisions preserve existing worktree files ─
+  console.log('\n=== 3c. artifact file/dir collisions preserve existing worktree files (#1157) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const mainSliceDir = join(mainBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      mkdirSync(join(mainSliceDir, 'S01-SUMMARY.md'), { recursive: true });
+      mkdirSync(join(mainSliceDir, 'S01-ASSESSMENT.md'), { recursive: true });
+
+      const wtSliceDir = join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      mkdirSync(wtSliceDir, { recursive: true });
+      writeFileSync(join(wtSliceDir, 'S01-SUMMARY.md'), '# Valid summary\n');
+      writeFileSync(join(wtSliceDir, 'S01-ASSESSMENT.md'), '---\nverdict: pass\n---\n# Valid assessment\n');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      const summaryPath = join(wtSliceDir, 'S01-SUMMARY.md');
+      const assessmentPath = join(wtSliceDir, 'S01-ASSESSMENT.md');
+      assert.ok(statSync(summaryPath).isFile(), 'existing SUMMARY.md stays a file');
+      assert.ok(statSync(assessmentPath).isFile(), 'existing ASSESSMENT.md stays a file');
+      assert.equal(readFileSync(summaryPath, 'utf-8'), '# Valid summary\n');
+      assert.equal(readFileSync(assessmentPath, 'utf-8'), '---\nverdict: pass\n---\n# Valid assessment\n');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
   // ─── 4. No-op when paths are equal ────────────────────────────────────
   console.log('\n=== 4. no-op when paths are equal ===');
   {

package/src/resources/extensions/gsd/tests/worktree-teardown-safety.test.ts

@@ -20,6 +20,7 @@ import {
   existsSync,
   realpathSync,
   readFileSync,
+  readdirSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -132,6 +133,37 @@ describe("worktree-teardown-safety", () => {
     );
   });
 
+  it("removeWorktree quarantines dirty worktree contents before forced cleanup", () => {
+    const tempDir = createTempRepo();
+    dirs.push(tempDir);
+
+    const wt = createWorktree(tempDir, "dirty-wt");
+    writeFileSync(join(wt.path, "generated-feature.ts"), "export const answer = 42;\n");
+    writeFileSync(join(wt.path, "README.md"), "# changed in worktree\n");
+
+    removeWorktree(tempDir, "dirty-wt", { deleteBranch: false });
+
+    assertTrue(!existsSync(wt.path), "original dirty worktree path removed after quarantine");
+    const quarantineRoot = join(tempDir, ".gsd", "quarantine", "worktrees");
+    const entries = readdirSync(quarantineRoot).filter((entry) => entry.startsWith("dirty-wt-"));
+    assertEq(entries.length, 1, "dirty worktree snapshot quarantined");
+    const quarantineDir = join(quarantineRoot, entries[0]!);
+    assertEq(
+      readFileSync(join(quarantineDir, "generated-feature.ts"), "utf-8"),
+      "export const answer = 42;\n",
+      "untracked source file survives in quarantine",
+    );
+    assertEq(
+      readFileSync(join(quarantineDir, "README.md"), "utf-8"),
+      "# changed in worktree\n",
+      "modified tracked file survives in quarantine",
+    );
+    assertTrue(
+      existsSync(join(quarantineDir, ".gsd-quarantine.json")),
+      "quarantine metadata written",
+    );
+  });
+
   it("worktreePath always returns paths under .gsd/worktrees/", () => {
     const tempDir = createTempRepo();
     dirs.push(tempDir);