@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/state-reconciliation/drift/roadmap.ts

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from "node:fs";
 import {
   getMilestone,
   getMilestoneSlices,
+  getSliceTasks,
   isDbAvailable,
 } from "../../gsd-db.js";
 import { renderRoadmapFromDb } from "../../markdown-renderer.js";
@@ -30,6 +31,19 @@ function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
   return true;
 }
 
+function getSlicesReadyForDivergenceCheck(
+  milestoneId: string,
+  dbSlices: ReturnType<typeof getMilestoneSlices>,
+): Set<string> {
+  const ready = new Set<string>();
+  for (const slice of dbSlices) {
+    if (isClosedStatus(slice.status) || getSliceTasks(milestoneId, slice.id).length > 0) {
+      ready.add(slice.id);
+    }
+  }
+  return ready;
+}
+
 function milestoneHasDivergence(
   basePath: string,
   milestoneId: string,
@@ -46,6 +60,10 @@ function milestoneHasDivergence(
 
   const dbSlices = getMilestoneSlices(milestoneId);
   const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+  const readySliceIds = getSlicesReadyForDivergenceCheck(milestoneId, dbSlices);
+  if (dbSlices.length > 0 && readySliceIds.size === 0) {
+    return false;
+  }
   const roadmapSliceIds = new Set<string>();
 
   for (let i = 0; i < roadmap.slices.length; i++) {
@@ -54,11 +72,13 @@ function milestoneHasDivergence(
     const expectedSequence = i + 1;
     const dbSlice = dbSliceMap.get(roadmapSlice.id);
     if (!dbSlice) return true; // Roadmap has a slice the DB doesn't.
+    if (!readySliceIds.has(dbSlice.id)) continue;
     if (dbSlice.sequence !== expectedSequence) return true;
     if (!arraysEqual(dbSlice.depends, roadmapSlice.depends)) return true;
     if (isClosedStatus(dbSlice.status) !== roadmapSlice.done) return true;
   }
   for (const dbSlice of dbSlices) {
+    if (!readySliceIds.has(dbSlice.id)) continue;
     if (!roadmapSliceIds.has(dbSlice.id)) return true;
   }
   return false;

package/src/resources/extensions/gsd/state-reconciliation/index.ts

@@ -6,6 +6,7 @@ import {
   deriveState as defaultDeriveState,
   invalidateStateCache as defaultInvalidate,
 } from "../state.js";
+import { clearParseCache as defaultClearParseCache } from "../files.js";
 import type { GSDState } from "../types.js";
 
 import {
@@ -37,6 +38,7 @@ const MAX_PASSES = 2;
 const defaultDeps: ReconciliationDeps = {
   invalidateStateCache: defaultInvalidate,
   deriveState: defaultDeriveState,
+  clearParseCache: defaultClearParseCache,
 };
 
 /**
@@ -58,6 +60,7 @@ export async function reconcileBeforeDispatch(
   deps: ReconciliationDeps = defaultDeps,
 ): Promise<ReconciliationResult> {
   const registry = deps.registry ?? DRIFT_REGISTRY;
+  const clearParseCache = deps.clearParseCache ?? defaultClearParseCache;
   const repaired: DriftRecord[] = [];
 
   for (let pass = 0; pass < MAX_PASSES; pass++) {
@@ -103,6 +106,9 @@ export async function reconcileBeforeDispatch(
       }
     }
 
+    if (repairedThisPass) {
+      clearParseCache();
+    }
     if (blockers.length > 0) {
       let blockerState = stateSnapshot;
       if (repairedThisPass) {

package/src/resources/extensions/gsd/state-reconciliation/types.ts

@@ -101,6 +101,7 @@ export interface ReconciliationDeps {
     basePath: string,
     opts?: DeriveStateOptions,
   ) => Promise<GSDState>;
+  clearParseCache?: () => void;
   /**
    * Override of the drift handler catalog. Defaults to DRIFT_REGISTRY. Each
    * handler is parameterized over its own DriftRecord variant; the union of

package/src/resources/extensions/gsd/state.ts

@@ -83,7 +83,7 @@ function formatNeedsRemediationBlocker(milestoneId: string): string {
   return [
     `Milestone ${milestoneId} is blocked because milestone validation returned needs-remediation, but all slices are complete.`,
     `Fix options:`,
-    `1. Add remediation slices with \`gsd_reassess_roadmap\`, then run \`/gsd auto\``,
+    `1. Run \`/gsd dispatch reassess\` to add remediation slices, then run \`/gsd auto\``,
     `2. If the finding is acceptable, override it: \`/gsd verdict pass --rationale "why this is okay"\``,
     `3. If this should wait, defer it explicitly: \`/gsd park ${milestoneId}\``,
   ].join("\n");

package/src/resources/extensions/gsd/tests/auto-dashboard.test.ts

@@ -16,11 +16,13 @@ import {
   buildPhaseHandoffOutcome,
   updateProgressWidget,
   setAutoOutcomeWidget,
+  setAutoActiveStatus,
   setCompletionProgressWidget,
   getRoadmapSlicesSync,
   clearSliceProgressCache,
   getWidgetMode,
   cycleWidgetMode,
+  setWidgetMode,
   _resetWidgetModeForTests,
   _resetLastCommitCacheForTests,
   _refreshLastCommitForTests,
@@ -78,6 +80,26 @@ test("unitVerb handles hook types", () => {
   assert.equal(unitVerb("hook/"), "hook: ");
 });
 
+test("setAutoActiveStatus clears stale outcome surfaces", () => {
+  const statusCalls: Array<[string, string]> = [];
+  const widgetCalls: Array<[string, unknown]> = [];
+
+  setAutoActiveStatus({
+    hasUI: true,
+    ui: {
+      setStatus: (key: string, value: string) => {
+        statusCalls.push([key, value]);
+      },
+      setWidget: (key: string, value: unknown) => {
+        widgetCalls.push([key, value]);
+      },
+    },
+  } as any, "next");
+
+  assert.deepEqual(statusCalls, [["gsd-auto", "next"]]);
+  assert.deepEqual(widgetCalls, [["gsd-outcome", undefined]]);
+});
+
 // ─── unitPhaseLabel ───────────────────────────────────────────────────────
 
 test("unitPhaseLabel maps known types to labels", () => {
@@ -571,14 +593,21 @@ test("updateProgressWidget refreshes slice progress cache immediately", (t) => {
 test("updateProgressWidget full mode keeps footer-owned signals out of auto deck", (t) => {
   const dir = makeTempDir("command-deck");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
   let widget: { render(width: number): string[]; dispose?: () => void } | null = null;
 
   t.after(() => {
     widget?.dispose?.();
+    _resetWidgetModeForTests();
     clearSliceProgressCache();
     cleanup(dir);
   });
 
+  _resetWidgetModeForTests();
+  setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+
   updateProgressWidget(
     {
       hasUI: true,
@@ -812,3 +841,25 @@ test("widget mode respects project preference precedence and persists there", (t
   assert.match(projectPrefs, /widget_mode:\s*min/);
   assert.match(globalPrefs, /widget_mode:\s*off/);
 });
+
+test("widget mode defaults to small when preferences do not set it", (t) => {
+  const homeDir = makeTempDir("home-no-widget-pref");
+  const projectDir = makeTempDir("project-no-widget-pref");
+  const globalPrefsPath = join(homeDir, ".gsd", "preferences.md");
+  const projectPrefsPath = join(projectDir, ".gsd", "preferences.md");
+
+  mkdirSync(join(homeDir, ".gsd"), { recursive: true });
+  mkdirSync(join(projectDir, ".gsd"), { recursive: true });
+  writeFileSync(globalPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+
+  t.after(() => {
+    cleanup(homeDir);
+    cleanup(projectDir);
+    _resetWidgetModeForTests();
+  });
+
+  _resetWidgetModeForTests();
+
+  assert.equal(getWidgetMode(projectPrefsPath, globalPrefsPath), "small");
+});

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

@@ -531,8 +531,13 @@ test("bootstrap honors explicit solo milestone lock when recovering stranded tar
     assert.equal(ready, true);
     assert.deepEqual(adoptCalls, [{ milestoneId: "M002", mode: "worktree" }]);
     assert.equal(s.currentMilestoneId, "M002");
-    assert.match(messages, /Recovering stranded work for 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;
@@ -624,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 {
@@ -713,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/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

@@ -555,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/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/);
+});

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -22,23 +22,31 @@ import { tmpdir } from "node:os";
 
 import { loadSkills } from "@gsd/pi-coding-agent";
 import {
-  buildResearchSlicePrompt,
+  buildCompleteSlicePrompt,
   buildParallelResearchSlicesPrompt,
+  buildResearchSlicePrompt,
 } from "../auto-prompts.ts";
 
 const SKILL_NAME = "testskill";
+const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
 const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
+const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${COMPLETE_SLICE_SKILL_NAME}' })`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
-function setupProjectWithSkill(): string {
+function setupProjectWithSkill(options: {
+  skillName?: string;
+  preferencesLines?: string[];
+} = {}): string {
+  const skillName = options.skillName ?? SKILL_NAME;
   const base = mkdtempSync(join(tmpdir(), "gsd-worker-skill-int-"));
   tmpDirs.push(base);
 
   // Milestone roadmap — buildResearchSlicePrompt inlines the roadmap excerpt.
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
-  mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+  const sliceOneDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceOneDir, "tasks"), { recursive: true });
   mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
   writeFileSync(
     join(milestoneDir, "M001-ROADMAP.md"),
@@ -55,27 +63,41 @@ function setupProjectWithSkill(): string {
     ].join("\n"),
     "utf-8",
   );
+  writeFileSync(
+    join(sliceOneDir, "S01-PLAN.md"),
+    [
+      "# S01: Alpha",
+      "",
+      "**Goal:** Verify worker x skill prompt plumbing.",
+      "**Demo:** Rendered prompts include the skill activation block.",
+      "",
+      "## Tasks",
+      "- [x] **T01: Task** `est:10m`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
 
   // Project preferences — buildSkillActivationBlock picks these up via
   // loadEffectiveGSDPreferences(), which reads from `${cwd}/.gsd/PREFERENCES.md`.
   writeFileSync(
     join(base, ".gsd", "PREFERENCES.md"),
-    ["---", `always_use_skills:`, `  - ${SKILL_NAME}`, "---", ""].join("\n"),
+    ["---", ...(options.preferencesLines ?? [`always_use_skills:`, `  - ${skillName}`]), "---", ""].join("\n"),
     "utf-8",
   );
 
   // Project-scoped skill — resolveSkillReference scans `${cwd}/.agents/skills/`.
-  const skillDir = join(base, ".agents", "skills", SKILL_NAME);
+  const skillDir = join(base, ".agents", "skills", skillName);
   mkdirSync(skillDir, { recursive: true });
   writeFileSync(
     join(skillDir, "SKILL.md"),
     [
       "---",
-      `name: ${SKILL_NAME}`,
+      `name: ${skillName}`,
       `description: Integration-test skill for worker × skill prompt plumbing.`,
       "---",
       "",
-      `# ${SKILL_NAME}`,
+      `# ${skillName}`,
       "",
       "Test skill body.",
     ].join("\n"),
@@ -122,6 +144,31 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
   );
 });
 
+test("complete-slice prompt includes <skill_activation> from unit-specific skill_rules", async () => {
+  const base = setupProjectWithSkill({
+    skillName: COMPLETE_SLICE_SKILL_NAME,
+    preferencesLines: [
+      "skill_rules:",
+      "  - when: complete-slice",
+      "    use:",
+      `      - ${COMPLETE_SLICE_SKILL_NAME}`,
+    ],
+  });
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildCompleteSlicePrompt("M001", "Test Milestone", "S01", "Alpha", base, "minimal");
+
+  assert.ok(
+    prompt.includes("<skill_activation>"),
+    "complete-slice prompt should contain a <skill_activation> block",
+  );
+  assert.ok(
+    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
+  );
+});
+
 test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skill_activation> into each embedded per-slice section", async () => {
   const base = setupProjectWithSkill();
   savedCwd = process.cwd();

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -32,6 +32,16 @@ test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence"
   assert.doesNotMatch(prompt, /uatType:\s*artifact-driven/);
 });
 
+test("run-uat prompt lists canonical gsd_uat_exec intent values", () => {
+  const prompt = readPrompt("run-uat");
+  assert.match(prompt, /`uat-artifact-check`/);
+  assert.match(prompt, /`uat-runtime-check`/);
+  assert.match(prompt, /`uat-browser-check`/);
+  assert.match(prompt, /`uat-service-start`/);
+  assert.match(prompt, /`uat-log-inspection`/);
+  assert.match(prompt, /do not use `artifact`, `runtime`, or `human-follow-up` as `intent`/i);
+});
+
 test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {
   const prompt = readPrompt("workflow-start");
   assert.match(prompt, /Keep moving by default/i);

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -17,7 +17,10 @@ import {
   shouldDeferTransientErrorToCoreRetry,
   suppressTerminalDeletedWorktreeMessageEnd,
 } from "../bootstrap/agent-end-recovery.ts";
-import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
+import {
+  _buildCancelledUnitStopReason,
+  _classifyZeroToolProviderMessageForTest,
+} from "../auto/phases.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -53,6 +56,20 @@ test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)"
   assert.equal(result.kind, "rate-limit");
 });
 
+test("zero-tool provider classifier treats Claude session-limit wording as transient rate-limit (#371)", () => {
+  const result = _classifyZeroToolProviderMessageForTest("Claude Code session limit reached. Limit resets at 5 PM.");
+  assert.ok(result, "session-limit wording should be recognized");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
+test("zero-tool provider classifier treats weekly limit wording as transient rate-limit (#371)", () => {
+  const result = _classifyZeroToolProviderMessageForTest("You've reached your weekly limit. Try again later.");
+  assert.ok(result, "weekly limit wording should be recognized");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
 test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
   const result = classifyError("You are out of extra usage. Please wait before retrying.");
   assert.ok(isTransient(result));

package/src/resources/extensions/gsd/tests/reactive-executor.test.ts

@@ -17,6 +17,10 @@ import { validatePreferences } from "../preferences-validation.ts";
 import type { ReactiveExecutionState } from "../types.ts";
 import { parseUnitId } from "../unit-id.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
+import {
+  _getPlannedKeyFilesForTest,
+  _parseReactiveBatchTaskIdsForTest,
+} from "../auto-post-unit.ts";
 
 // ─── Preference Validation ────────────────────────────────────────────────
 
@@ -71,6 +75,38 @@ test("reactive_execution validation warns on unknown keys", () => {
   assert.ok(result.warnings.some((w) => w.includes("unknown_thing")));
 });
 
+test("reactive batch unit ids are parsed and deduped for commit context", () => {
+  assert.deepEqual(
+    _parseReactiveBatchTaskIdsForTest("M001/S01/reactive+T01,t02,T01"),
+    ["T01", "T02"],
+  );
+  assert.deepEqual(_parseReactiveBatchTaskIdsForTest("M001/S01/T01"), []);
+});
+
+test("reactive commit context key files include planned output, files, and key_files once", () => {
+  const result = _getPlannedKeyFilesForTest([
+    {
+      expected_output: ["src/new.ts", "src/shared.ts"],
+      files: ["src/input.ts", "src/shared.ts"],
+      key_files: ["src/key.ts"],
+    },
+    {
+      expected_output: ["src/new.ts"],
+      files: ["src/other.ts"],
+      key_files: ["src/key.ts", "src/final.ts"],
+    },
+  ]);
+
+  assert.deepEqual(result, [
+    "src/new.ts",
+    "src/shared.ts",
+    "src/input.ts",
+    "src/key.ts",
+    "src/other.ts",
+    "src/final.ts",
+  ]);
+});
+
 // ─── Dispatch Rule Matching Logic ─────────────────────────────────────────
 
 test("reactive dispatch requires enabled config and multiple ready tasks", async () => {