@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

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-db-integration.test.ts

@@ -17,7 +17,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import { worktreePath } from "../worktree-manager.ts";
 import {
   copyWorktreeDb,

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

@@ -17,7 +17,7 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { syncProjectRootToWorktree } from '../auto-worktree.ts';
+import { syncProjectRootToWorktree } from '../auto-worktree-sync.ts';
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 

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

@@ -18,9 +18,7 @@ import {
   reconcileWorktreeDb,
   insertDecision,
 } from "../gsd-db.ts";
-import {
-  _shouldReconcileWorktreeDb,
-} from "../auto-worktree.ts";
+import { _shouldReconcileWorktreeDb } from "../auto-worktree-sync.ts";
 import { isInfrastructureError } from "../auto/infra-errors.ts";
 
 describe("#2823: reconcileWorktreeDb same-file guard", () => {

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

@@ -6,7 +6,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 
-import { _isExpectedWorktreeUnlinkError } from "../auto-worktree.ts";
+import { _isExpectedWorktreeUnlinkError } from "../auto-worktree-path-utils.ts";
 import { resolveGitDir } from "../worktree-manager.ts";
 
 describe("worktree expected-condition warning suppression (#3665)", () => {

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

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { _gitPathspecForWorktreePath } from "../auto-worktree.ts";
+import { _gitPathspecForWorktreePath } from "../auto-worktree-path-utils.ts";
 
 function run(cmd: string, args: string[], cwd: string): string {
   return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();

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-main-branch.test.ts

@@ -3,7 +3,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveAutoWorktreeStartPoint } from "../auto-worktree.ts";
+import { _resolveAutoWorktreeStartPoint } from "../auto-worktree-branch-lifecycle.ts";
 
 test("auto-worktree start point prefers milestone integration branch", () => {
   const startPoint = _resolveAutoWorktreeStartPoint(

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

@@ -26,7 +26,7 @@ import { tmpdir } from "node:os";
 import {
   syncGsdStateToWorktree,
   syncWorktreeStateBack,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-sync.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────
 

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

@@ -13,7 +13,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { createAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
 import { reenterActiveWorktreeIfNeeded } from "../worktree-reentry.ts";
 
 // Safe: all inputs below are hardcoded test strings, not user input.

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

@@ -23,12 +23,15 @@
  *   - 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';
 
-import { syncProjectRootToWorktree } from '../auto-worktree.ts';
-import { syncGsdStateToWorktree, syncWorktreeStateBack } from '../auto-worktree.ts';
+import {
+  syncGsdStateToWorktree,
+  syncProjectRootToWorktree,
+  syncWorktreeStateBack,
+} from '../auto-worktree-sync.ts';
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -148,6 +151,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-sync-overwrite-loop.test.ts

@@ -25,7 +25,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
+import { syncProjectRootToWorktree } from "../auto-worktree-sync.ts";
 
 function createBase(name: string): string {
   const base = mkdtempSync(join(tmpdir(), `gsd-wt-1886-${name}-`));

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

@@ -18,7 +18,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `gsd-sync-test-${prefix}-`));

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);

package/src/resources/extensions/gsd/tool-contract.ts

@@ -85,6 +85,18 @@ export interface UnitWorkflowDispatchReadinessInput {
   activeTools?: string[];
 }
 
+export interface WorkflowDispatchModelContext {
+  provider?: string;
+  baseUrl?: string;
+}
+
+export interface UnitWorkflowDispatchReadinessForModelInput
+  extends Omit<UnitWorkflowDispatchReadinessInput, "provider" | "authMode" | "baseUrl"> {
+  model?: WorkflowDispatchModelContext | null;
+  fallbackModel?: WorkflowDispatchModelContext | null;
+  getProviderAuthMode?: (provider: string) => WorkflowCapabilityOptions["authMode"] | undefined;
+}
+
 export function compileUnitContextContract(unitType: string): UnitContextContractResult {
   const manifest = resolveManifest(unitType);
   if (!manifest) {
@@ -115,6 +127,23 @@ export function getUnitWorkflowDispatchReadinessError(
   );
 }
 
+export function getUnitWorkflowDispatchReadinessErrorForModel(
+  input: UnitWorkflowDispatchReadinessForModelInput,
+): string | null {
+  const provider = input.model?.provider ?? input.fallbackModel?.provider;
+  const baseUrl = input.model?.baseUrl ?? input.fallbackModel?.baseUrl;
+  return getUnitWorkflowDispatchReadinessError({
+    provider,
+    unitType: input.unitType,
+    projectRoot: input.projectRoot,
+    env: input.env,
+    surface: input.surface,
+    authMode: provider ? input.getProviderAuthMode?.(provider) : undefined,
+    baseUrl,
+    activeTools: input.activeTools,
+  });
+}
+
 export function compileUnitToolContract(unitType: string): ToolContractResult {
   const manifest = resolveManifest(unitType);
   const surfaceContract = getUnitToolSurfaceContract(unitType);