@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -118,6 +118,37 @@ function makeRepoWithMultipleStrandedMilestones(): string {
   return base;
 }
 
+function makeRepoWithActiveMismatchAndStrandedTarget(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-targeted-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"worktree\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M002"]);
+  writeFileSync(join(base, "m002.txt"), "target stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M002 in progress"]);
+  runGit(base, ["checkout", "main"]);
+  runGit(base, ["worktree", "add", ".gsd/worktrees/M002", "milestone/M002"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Incorrect active milestone", status: "active" });
+  insertMilestone({ id: "M002", title: "Target stranded milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
 function makeRepoWithRecoveredCleanupAndStrandedMismatch(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-headless-stranded-bootstrap-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
@@ -321,6 +352,9 @@ test("headless bootstrap checks stranded work before recovered-complete shortcut
     const messages = notifications.map((entry) => entry.message).join("\n");
     assert.equal(ready, false);
     assert.match(messages, /Stranded work for M002 blocks auto-mode/);
+    assert.match(messages, /\/gsd auto M002/);
+    assert.match(messages, /\/gsd park M002 "reason"/);
+    assert.match(messages, /\/gsd rethink/);
     assert.doesNotMatch(messages, /all milestones complete/);
   } finally {
     if (previousHeadless === undefined) {
@@ -409,6 +443,9 @@ test("bootstrap blocks active stranded recovery when another open milestone also
     assert.equal(ready, false);
     assert.deepEqual(adoptCalls, []);
     assert.match(messages, /Stranded work for M002 blocks auto-mode before M001/);
+    assert.match(messages, /\/gsd auto M002/);
+    assert.match(messages, /\/gsd park M002 "reason"/);
+    assert.match(messages, /explicitly discard M002/);
   } finally {
     try {
       closeDatabase();
@@ -418,6 +455,102 @@ test("bootstrap blocks active stranded recovery when another open milestone also
   }
 });
 
+test("bootstrap honors explicit solo milestone lock when recovering stranded target worktree", async () => {
+  const base = makeRepoWithActiveMismatchAndStrandedTarget();
+  const previousCwd = process.cwd();
+  const previousLock = process.env.GSD_MILESTONE_LOCK;
+  const previousWorker = process.env.GSD_PARALLEL_WORKER;
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    delete process.env.GSD_PARALLEL_WORKER;
+    process.env.GSD_MILESTONE_LOCK = "M002";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: () => ({ ok: true, mode: "worktree", path: base }),
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, true);
+    assert.deepEqual(adoptCalls, [{ milestoneId: "M002", mode: "worktree" }]);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.match(messages, /Resuming saved milestone work for M002/);
+    assert.doesNotMatch(messages, /blocks auto-mode before M001/);
+    assert.doesNotMatch(messages, /Stranded work for in-progress milestone M002/);
+    assert.ok(
+      notifications.some((entry) => entry.level === "info" && entry.message.includes("Resuming saved milestone work for M002")),
+      "active recovery should be presented as an info-level resume",
+    );
+  } finally {
+    if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+    else process.env.GSD_MILESTONE_LOCK = previousLock;
+    if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+    else process.env.GSD_PARALLEL_WORKER = previousWorker;
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("bootstrap adopts stranded active branch even when isolation is none", async () => {
   const base = makeRepoWithStrandedActiveMilestone();
   const previousCwd = process.cwd();
@@ -496,7 +629,11 @@ test("bootstrap adopts stranded active branch even when isolation is none", asyn
     assert.equal(s.strandedRecoveryIsolationMode, "branch");
     assert.match(
       notifications.map((entry) => entry.message).join("\n"),
-      /Recovering stranded work for M001/,
+      /Resuming saved milestone work for M001/,
+    );
+    assert.ok(
+      notifications.every((entry) => entry.level !== "warning" || !entry.message.includes("Stranded work for in-progress milestone M001")),
+      "adopting the active milestone should not emit a scary stranded-work warning",
     );
   } finally {
     try {
@@ -585,7 +722,11 @@ test("bootstrap adopts stranded active branch before deep project setup", async
     assert.equal(s.strandedRecoveryIsolationMode, "branch");
     assert.match(
       notifications.map((entry) => entry.message).join("\n"),
-      /Recovering stranded work for M001/,
+      /Resuming saved milestone work for M001/,
+    );
+    assert.ok(
+      notifications.every((entry) => entry.level !== "warning" || !entry.message.includes("Stranded work for in-progress milestone M001")),
+      "adopting the active milestone should not emit a scary stranded-work warning",
     );
   } finally {
     try {

package/src/resources/extensions/gsd/tests/auto-start-project-milestone-reconcile.test.ts

@@ -4,13 +4,35 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { closeDatabase, getAllMilestones, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
-import { reconcileProjectMilestonesFromDisk } from "../auto-start.ts";
+import { closeDatabase, getAllMilestones, getMilestone, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
+import { reconcileMergedMilestonesFromJournal, reconcileProjectMilestonesFromDisk } from "../auto-start.ts";
+import { emitWorktreeMerged } from "../worktree-telemetry.ts";
 
 test.afterEach(() => {
   if (isDbAvailable()) closeDatabase();
 });
 
+test("bootstrap reconciliation treats a successful worktree merge as milestone closed", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-merged-reconcile-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Merged Milestone", status: "active" });
+
+    emitWorktreeMerged(base, "M001", { reason: "milestone-complete", conflict: false });
+
+    const closed = reconcileMergedMilestonesFromJournal(base);
+    const row = getMilestone("M001");
+
+    assert.equal(closed, 1);
+    assert.equal(row?.status, "complete");
+    assert.ok(row?.completed_at);
+  } finally {
+    if (isDbAvailable()) closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("#5389: bootstrap reconciles PROJECT.md milestones that are missing from DB", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-project-reconcile-"));
   try {

package/src/resources/extensions/gsd/tests/commands-dispatcher-validation-block.test.ts

@@ -40,10 +40,12 @@ function makeMockCtx(base: string): {
   calls: NotifyCall[];
   widgets: Array<[string, unknown]>;
   statuses: Array<[string, string | undefined]>;
+  newSessions: Array<{ workspaceRoot?: string }>;
 } {
   const calls: NotifyCall[] = [];
   const widgets: Array<[string, unknown]> = [];
   const statuses: Array<[string, string | undefined]> = [];
+  const newSessions: Array<{ workspaceRoot?: string }> = [];
   return {
     ctx: {
       cwd: base,
@@ -58,10 +60,15 @@ function makeMockCtx(base: string): {
           statuses.push([key, value]);
         },
       },
+      newSession: async (options?: { workspaceRoot?: string }) => {
+        newSessions.push(options ?? {});
+        return { cancelled: false };
+      },
     },
     calls,
     widgets,
     statuses,
+    newSessions,
   };
 }
 
@@ -77,7 +84,10 @@ function makeMockPi(): { pi: any; messages: SentMessage[] } {
   };
 }
 
-function seedValidationBlockedMilestone(base: string): void {
+function seedValidationBlockedMilestone(
+  base: string,
+  status: "needs-attention" | "needs-remediation" = "needs-attention",
+): void {
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M006", title: "Mark All Complete", status: "active" });
   insertSlice({
@@ -91,9 +101,9 @@ function seedValidationBlockedMilestone(base: string): void {
   insertAssessment({
     path: "milestones/M006/M006-VALIDATION.md",
     milestoneId: "M006",
-    status: "needs-attention",
+    status,
     scope: "milestone-validation",
-    fullContent: "verdict: needs-attention",
+    fullContent: `verdict: ${status}`,
   });
   invalidateStateCache();
 }
@@ -155,6 +165,31 @@ test("dispatcher blocks workflow-advancing aliases while validation is blocked",
   }
 });
 
+test("dispatcher allows reassess dispatch while validation needs remediation", async () => {
+  const base = makeBase();
+  try {
+    seedValidationBlockedMilestone(base, "needs-remediation");
+    const { ctx, calls, newSessions } = makeMockCtx(base);
+    const { pi, messages } = makeMockPi();
+
+    await handleGSDCommand("dispatch reassess", ctx, pi);
+
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].customType, "gsd-dispatch");
+    assert.equal(messages[0].display, false);
+    assert.match(messages[0].content, /UNIT: Reassess Roadmap/);
+    assert.ok(
+      calls.some((call) => call.kind === "info" && /Dispatching reassess-roadmap for M006\/S01/.test(call.message)),
+      `expected reassess dispatch notification, got: ${JSON.stringify(calls)}`,
+    );
+    assert.deepEqual(newSessions, [{ workspaceRoot: base }]);
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
 test("dispatcher still allows recovery commands while validation is blocked", async () => {
   const base = makeBase();
   try {

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -399,8 +399,12 @@ test("handleVerdict needs-remediation override with --rationale rewrites verdict
     assert.match(rewritten, /found missing slice/);
 
     assert.ok(
-      calls.some((c) => /gsd_reassess_roadmap/.test(c.message)),
-      "needs-remediation override should suggest gsd_reassess_roadmap follow-up",
+      calls.some((c) => /\/gsd dispatch reassess/.test(c.message)),
+      "needs-remediation override should suggest the reassess dispatch follow-up",
+    );
+    assert.ok(
+      calls.every((c) => !/gsd_reassess_roadmap/.test(c.message)),
+      "needs-remediation override should not expose the internal tool name",
     );
   } finally {
     closeDatabase();

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

@@ -868,6 +868,14 @@ describe('derive-state-db', async () => {
         dbState.blockers.some(b => b.includes('needs-remediation') && b.includes('M001')),
         'remediation-stuck-db: blocker message mentions milestone and verdict',
       );
+      assert.ok(
+        dbState.blockers.some(b => b.includes('/gsd dispatch reassess')),
+        'remediation-stuck-db: blocker message points users to the reassess command',
+      );
+      assert.ok(
+        dbState.blockers.every(b => !b.includes('gsd_reassess_roadmap')),
+        'remediation-stuck-db: blocker message does not expose the internal tool name',
+      );
 
       closeDatabase();
     } finally {

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -473,13 +473,13 @@ describe('derive-state-helpers', () => {
     }
   });
 
-	  test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
-	    const base = createFixtureBase();
-	    const previousLock = process.env.GSD_MILESTONE_LOCK;
-	    const previousWorker = process.env.GSD_PARALLEL_WORKER;
-	    try {
-	      process.env.GSD_MILESTONE_LOCK = 'M001';
-	      process.env.GSD_PARALLEL_WORKER = '1';
+  test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
+    const base = createFixtureBase();
+    const previousLock = process.env.GSD_MILESTONE_LOCK;
+    const previousWorker = process.env.GSD_PARALLEL_WORKER;
+    try {
+      process.env.GSD_MILESTONE_LOCK = 'M001';
+      process.env.GSD_PARALLEL_WORKER = '1';
       writeFile(base, 'milestones/M001/M001-PARKED.md', '# Parked on disk');
 
       openDatabase(':memory:');
@@ -487,12 +487,41 @@ describe('derive-state-helpers', () => {
 
       const id = await getActiveMilestoneId(base);
       assert.equal(id, 'M001', 'DB status remains authoritative despite PARKED projection');
-	    } finally {
-	      if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
-	      else process.env.GSD_MILESTONE_LOCK = previousLock;
-	      if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
-	      else process.env.GSD_PARALLEL_WORKER = previousWorker;
-	      closeDatabase();
+    } finally {
+      if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+      else process.env.GSD_MILESTONE_LOCK = previousLock;
+      if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+      else process.env.GSD_PARALLEL_WORKER = previousWorker;
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('deriveStateFromDb: solo milestone lock scopes state to the requested milestone', async () => {
+    const base = createFixtureBase();
+    const previousLock = process.env.GSD_MILESTONE_LOCK;
+    const previousWorker = process.env.GSD_PARALLEL_WORKER;
+    try {
+      delete process.env.GSD_PARALLEL_WORKER;
+      process.env.GSD_MILESTONE_LOCK = 'M002';
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Earlier', status: 'active' });
+      insertMilestone({ id: 'M002', title: 'Requested', status: 'active' });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+      const id = await getActiveMilestoneId(base);
+
+      assert.equal(state.activeMilestone?.id, 'M002', 'explicit lock chooses requested milestone');
+      assert.deepEqual(state.registry.map((entry) => entry.id), ['M002'], 'registry is scoped to requested milestone');
+      assert.equal(id, 'M002', 'active milestone helper honors solo lock');
+    } finally {
+      if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+      else process.env.GSD_MILESTONE_LOCK = previousLock;
+      if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+      else process.env.GSD_PARALLEL_WORKER = previousWorker;
+      closeDatabase();
       cleanup(base);
     }
   });
@@ -526,6 +555,14 @@ describe('derive-state-helpers', () => {
         state.blockers.some(b => b.includes('needs-remediation') && b.includes('M001')),
         'remediation-stuck: blocker message mentions milestone and verdict',
       );
+      assert.ok(
+        state.blockers.some(b => b.includes('/gsd dispatch reassess')),
+        'remediation-stuck: blocker message points users to the reassess command',
+      );
+      assert.ok(
+        state.blockers.every(b => !b.includes('gsd_reassess_roadmap')),
+        'remediation-stuck: blocker message does not expose the internal tool name',
+      );
     } finally {
       closeDatabase();
       cleanup(base);

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -19,6 +19,7 @@ import type { DispatchContext } from "../auto-dispatch.ts";
 import type { AutoSession } from "../auto/session.ts";
 import type { GSDState } from "../types.ts";
 import { enableDebug, disableDebug, getDebugLogPath } from "../debug-logger.ts";
+import { closeDatabase, insertMilestone, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
   return {
@@ -123,6 +124,29 @@ test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909"
     `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: closed milestone is not implicitly recovered or reopened", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-closed-dispatch-"));
+  t.after(() => {
+    if (isDbAvailable()) closeDatabase();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  if (isDbAvailable()) closeDatabase();
+  mkdirSync(join(tmp, ".gsd"), { recursive: true });
+  openDatabase(join(tmp, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M002", title: "Closed Milestone", status: "complete" });
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const result = await resolveDispatch(makeContext(tmp));
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /Milestone M002 is closed/);
+  assert.match(result.reason, /will not reopen or recover it implicitly/);
+});
+
 test("dispatch: present task plan proceeds to execute-task normally", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -141,6 +165,42 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
     `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: session milestone mismatch stops before missing-task-plan recovery", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-session-milestone-mismatch-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const ctx = makeContextFor(tmp, "M001", "S01", "T01", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M002",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /context mid "M001" does not match session\.currentMilestoneId "M002"/);
+});
+
+test("dispatch: worktree path mismatch stops before planning a different milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-path-milestone-mismatch-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const ctx = makeContextFor(worktreeRoot, "M001", "S01", "T01");
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "warning");
+  assert.match(result.reason, /context mid "M001" does not match basePath worktree "M002"/);
+});
+
 test("dispatch: executing recovery checks active milestone worktree task plans before re-dispatching plan-slice", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-6192-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -53,6 +53,24 @@ test('runExecSandbox: captures stdout, persists artifacts, returns digest', asyn
   }
 });
 
+test('runExecSandbox: persists optional request metadata', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      {
+        runtime: 'bash',
+        script: 'echo metadata-ok',
+        metadata: { kind: 'uat_exec', intent: 'uat-artifact-check' },
+      },
+      baseOpts(base),
+    );
+    const meta = JSON.parse(readFileSync(result.meta_path, 'utf-8')) as Record<string, unknown>;
+    assert.deepEqual(meta.metadata, { kind: 'uat_exec', intent: 'uat-artifact-check' });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('runExecSandbox: enforces stdout cap and marks truncation', async () => {
   const base = freshBase();
   try {

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

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { executeUatExec } from "../tools/exec-tool.ts";
+import type { ExecSandboxRequest, ExecSandboxResult } from "../exec-sandbox.ts";
+
+function makeExecResult(request: ExecSandboxRequest): ExecSandboxResult {
+  return {
+    id: "exec-1",
+    runtime: request.runtime,
+    exit_code: 0,
+    signal: null,
+    timed_out: false,
+    duration_ms: 1,
+    stdout_bytes: 12,
+    stderr_bytes: 0,
+    stdout_truncated: false,
+    stderr_truncated: false,
+    stdout_path: ".gsd/exec/exec-1.stdout",
+    stderr_path: ".gsd/exec/exec-1.stderr",
+    meta_path: ".gsd/exec/exec-1.meta.json",
+    digest: "check passed",
+  };
+}
+
+test("executeUatExec accepts evidence-mode aliases for intent", async () => {
+  const requests: ExecSandboxRequest[] = [];
+  const result = await executeUatExec(
+    {
+      milestoneId: "M001",
+      sliceId: "S01",
+      checkId: "UAT-PRE",
+      intent: "artifact",
+      runtime: "bash",
+      script: "printf ok",
+    },
+    {
+      baseDir: "/tmp/gsd-uat-exec-test",
+      preferences: null,
+      run: async (request) => {
+        requests.push(request);
+        return makeExecResult(request);
+      },
+    },
+  );
+
+  assert.equal(result.isError, false);
+  assert.equal(result.details?.operation, "gsd_uat_exec");
+  assert.equal(result.details?.intent, "uat-artifact-check");
+  assert.equal(requests[0]?.metadata?.intent, "uat-artifact-check");
+});
+
+test("registerExecTools exposes gsd_uat_exec intent as recoverable string schema", () => {
+  const tools: Array<{ name: string; parameters: any }> = [];
+  registerExecTools({
+    registerTool: (tool: { name: string; parameters: any }) => {
+      tools.push(tool);
+    },
+  } as any);
+
+  const tool = tools.find((registeredTool) => registeredTool.name === "gsd_uat_exec");
+  assert.ok(tool, "gsd_uat_exec should be registered");
+  const intentSchema = tool.parameters.properties.intent;
+  assert.equal(intentSchema.type, "string");
+  assert.equal("anyOf" in intentSchema, false);
+  assert.match(intentSchema.description, /uat-artifact-check/);
+  assert.match(intentSchema.description, /artifact/);
+});