@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.9bb7453

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  buildProjectBrowserMcpServerConfig,
   ensureClaudeCodeMcpJsonServerEnabled,
   ensureProjectWorkflowMcpConfig,
   GSD_BROWSER_MCP_SERVER_NAME,
@@ -160,6 +161,37 @@ test("ensureProjectWorkflowMcpConfig can disable the default browser MCP server"
   }
 });
 
+test("buildProjectBrowserMcpServerConfig prefers newer gsd-browser on PATH", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-browser-"));
+
+  try {
+    const config = buildProjectBrowserMcpServerConfig(projectRoot, {
+      GSD_BROWSER_PATH_VERSION: "99.0.0",
+    });
+
+    assert.equal(config?.command, "gsd-browser");
+    assert.equal(config?.args?.[0], "mcp");
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("buildProjectBrowserMcpServerConfig keeps bundled browser when PATH version is older", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-browser-"));
+
+  try {
+    const config = buildProjectBrowserMcpServerConfig(projectRoot, {
+      GSD_BROWSER_PATH_VERSION: "0.0.1",
+    });
+
+    assert.equal(config?.command, process.execPath);
+    assert.match(config?.args?.[0] ?? "", /@opengsd[\/\\]gsd-browser[\/\\]bin[\/\\]gsd-browser/);
+    assert.equal(config?.args?.[1], "mcp");
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
 test("ensureProjectWorkflowMcpConfig is idempotent when config is already current", () => {
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
   mkdirSync(join(projectRoot, ".gsd"), { recursive: true });

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -341,6 +341,8 @@ describe("formatMcpInitResult", () => {
     assert.match(result, /created project mcp config/i);
     assert.match(result, /\/tmp\/project\/\.mcp\.json/);
     assert.match(result, /mcp-capable clients/i);
+    assert.match(result, /workflow and gsd-browser MCP servers/i);
+    assert.match(result, /Pi Providers use the managed gsd-browser engine/i);
     assert.doesNotMatch(result, /claude code/i);
   });
 

package/src/resources/extensions/gsd/tests/memory-maintenance.test.ts

@@ -11,6 +11,16 @@ import {
 import { createMemoryRelation, listRelationsFor } from '../memory-relations.ts';
 import { saveEmbedding, getEmbeddingForMemory } from '../memory-embeddings.ts';
 
+function markProcessedUnits(count = 21): void {
+  const now = Date.now();
+  for (let i = 0; i < count; i++) {
+    markUnitProcessed(`unit/${i}`, `file-${i}`);
+    _getAdapter()!
+      .prepare('UPDATE memory_processed_units SET processed_at = :ts WHERE unit_key = :key')
+      .run({ ':ts': new Date(now + i * 1000).toISOString(), ':key': `unit/${i}` });
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // enforceMemoryCap — cascade cleanup of embeddings and relations
 // ═══════════════════════════════════════════════════════════════════════════
@@ -71,14 +81,7 @@ test('memory-decay: returns decayed memory IDs', () => {
   openDatabase(':memory:');
 
   // Insert processed units — decayStaleMemories needs at least N rows.
-  const now = Date.now();
-  for (let i = 0; i < 21; i++) {
-    markUnitProcessed(`unit/${i}`, `file-${i}`);
-    // small spacing to create deterministic ordering
-    const row = _getAdapter()!
-      .prepare('UPDATE memory_processed_units SET processed_at = :ts WHERE unit_key = :key');
-    row.run({ ':ts': new Date(now + i * 1000).toISOString(), ':key': `unit/${i}` });
-  }
+  markProcessedUnits();
 
   // Create memory with updated_at in the distant past
   createMemory({ category: 'pattern', content: 'stale entry', confidence: 0.9 });
@@ -98,6 +101,34 @@ test('memory-decay: returns decayed memory IDs', () => {
   closeDatabase();
 });
 
+test('memory-decay: skips stale decision-sourced memories', () => {
+  openDatabase(':memory:');
+  markProcessedUnits();
+
+  createMemory({ category: 'pattern', content: 'stale working note', confidence: 0.9 });
+  createMemory({
+    category: 'architecture',
+    content: 'decision-backed architecture memory',
+    confidence: 0.85,
+    structuredFields: { sourceDecisionId: 'D001' },
+  });
+  _getAdapter()!
+    .prepare("UPDATE memories SET updated_at = '2000-01-01T00:00:00Z' WHERE id IN ('MEM001', 'MEM002')")
+    .run({});
+
+  const decayed = decayStaleMemories(20);
+  assert.ok(decayed.includes('MEM001'));
+  assert.ok(!decayed.includes('MEM002'));
+
+  const rows = _getAdapter()!
+    .prepare("SELECT id, confidence FROM memories WHERE id IN ('MEM001', 'MEM002') ORDER BY id")
+    .all() as Array<{ id: string; confidence: number }>;
+  assert.ok(rows.find((row) => row.id === 'MEM001')!.confidence < 0.9);
+  assert.equal(rows.find((row) => row.id === 'MEM002')!.confidence, 0.85);
+
+  closeDatabase();
+});
+
 test('memory-decay: returns empty when there are fewer processed units than the threshold', () => {
   openDatabase(':memory:');
   createMemory({ category: 'pattern', content: 'fresh' });

package/src/resources/extensions/gsd/tests/new-milestone-discuss-routing.test.ts

@@ -13,10 +13,10 @@ test("dispatchNewMilestoneDiscuss uses discuss.md only on greenfield projects",
 
   assert.match(fnBody, /findMilestoneIds\(basePath\)\.length === 0/);
   assert.match(fnBody, /prepareAndBuildDiscussPrompt/);
-  assert.match(fnBody, /loadPrompt\("guided-discuss-milestone"/);
+  assert.match(fnBody, /buildDiscussMilestonePrompt/);
   assert.match(
     fnBody,
-    /if \(isGreenfield\)[\s\S]*prepareAndBuildDiscussPrompt[\s\S]*loadPrompt\("guided-discuss-milestone"/,
+    /if \(isGreenfield\)[\s\S]*prepareAndBuildDiscussPrompt[\s\S]*buildDiscussMilestonePrompt/,
     "greenfield branch must precede guided-discuss-milestone branch",
   );
 });
@@ -24,7 +24,7 @@ test("dispatchNewMilestoneDiscuss uses discuss.md only on greenfield projects",
 test("dispatchNewMilestoneDiscuss uses milestone-specific preparation guidance", () => {
   const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
   const fnBody = extractSourceRegion(source, "async function dispatchNewMilestoneDiscuss(");
-  assert.match(fnBody, /buildDiscussPreparationContext\(ctx, basePath, "milestone"\)/);
+  assert.match(fnBody, /buildDiscussPreparationContext\(ctx, basePath, "milestone", true\)/);
 });
 
 test("launchNextMilestoneDiscuss routes through dispatchNewMilestoneDiscuss for normal path", () => {

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

@@ -83,6 +83,15 @@ test("plan-slice prompt: compact planning gates survive template substitution",
   assert.ok(!result.includes("{{"));
 });
 
+test("plan-slice prompt: absence checks use negated quiet searches", () => {
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
+  assert.ok(result.includes("For absence checks"));
+  assert.ok(result.includes("`! grep -q 'pattern' file`"));
+  assert.ok(result.includes("`! rg -q 'pattern' file`"));
+  assert.ok(result.includes("do not use `grep -c` or `rg -c`"));
+  assert.ok(result.includes("count commands exit 1 when they find zero matches"));
+});
+
 test("plan-slice prompt: footer references gsd_plan_slice tool, not direct write", () => {
   const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
   assert.ok(

package/src/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -11,6 +11,7 @@ import {
   resetHookState,
   isRetryPending,
   consumeRetryTrigger,
+  consumeGateBlock,
   resolveHookArtifactPath,
   runPreDispatchHooks,
   persistHookState,
@@ -20,6 +21,7 @@ import {
   formatHookStatus,
   triggerHookManually,
 } from "../post-unit-hooks.ts";
+import { invalidateAllCaches } from "../cache.ts";
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -29,6 +31,11 @@ function createFixtureBase(): string {
   return base;
 }
 
+function writeHookPreferences(base: string, hookYaml: string): void {
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), `---\npost_unit_hooks:\n${hookYaml}\n---\n`, "utf-8");
+  invalidateAllCaches();
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 1: Post-Unit Hook Tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -104,6 +111,156 @@ test('consumeRetryTrigger clears state', () => {
   assert.ok(!isRetryPending(), "no retry initially");
 });
 
+test('Advisory hook keeps artifact idempotency without verdict frontmatter', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: docs-hint
+    after:
+      - execute-task
+    prompt: Review docs
+    artifact: DOCS-HINT.md
+`);
+    writeFileSync(resolveHookArtifactPath(base, "M001/S01/T01", "DOCS-HINT.md"), "plain advisory note", "utf-8");
+
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.deepStrictEqual(result, null, "existing advisory artifact remains idempotent");
+    assert.deepStrictEqual(consumeGateBlock(), null, "advisory hook does not create gate block");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook skips only after passing frontmatter verdict', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: security-review
+    after:
+      - execute-task
+    prompt: Review security
+    artifact: SECURITY-REVIEW.md
+    criticality: blocking
+`);
+    writeFileSync(
+      resolveHookArtifactPath(base, "M001/S01/T01", "SECURITY-REVIEW.md"),
+      "---\nverdict: pass\n---\n\nNo blocking findings.\n",
+      "utf-8",
+    );
+
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.deepStrictEqual(result, null, "passing gate artifact is idempotent");
+    assert.deepStrictEqual(consumeGateBlock(), null, "passing gate does not block");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook reruns invalid artifact once then blocks at cycle budget', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: security-review
+    after:
+      - execute-task
+    prompt: Review security
+    artifact: SECURITY-REVIEW.md
+    criticality: blocking
+`);
+    writeFileSync(resolveHookArtifactPath(base, "M001/S01/T01", "SECURITY-REVIEW.md"), "partial output", "utf-8");
+
+    const dispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(dispatch, "invalid gate artifact dispatches the blocking hook");
+    assert.equal(dispatch.unitType, "hook/security-review");
+
+    const afterHook = checkPostUnitHooks("hook/security-review", "M001/S01/T01", base);
+    assert.deepStrictEqual(afterHook, null, "no further hook dispatch after max_cycles=1");
+    const block = consumeGateBlock();
+    assert.ok(block, "gate block is recorded");
+    assert.equal(block.hookName, "security-review");
+    assert.match(block.reason, /missing frontmatter verdict/);
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook restored from disk does not trust artifact without clean hook completion', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: security-review
+    after:
+      - execute-task
+    prompt: Review security
+    artifact: SECURITY-REVIEW.md
+    criticality: blocking
+    max_cycles: 2
+`);
+    const firstDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(firstDispatch, "gate dispatches first cycle");
+    persistHookState(base);
+
+    writeFileSync(
+      resolveHookArtifactPath(base, "M001/S01/T01", "SECURITY-REVIEW.md"),
+      "---\noutcome:\n  verdict: pass\n---\n",
+      "utf-8",
+    );
+
+    resetHookState();
+    restoreHookState(base);
+
+    const resumed = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(resumed, "persisted active gate reruns when clean hook completion was not observed");
+    assert.equal(resumed.unitType, "hook/security-review");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook needs-rework verdict requests trigger unit retry', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review task
+    artifact: REVIEW-DEBATE.md
+    criticality: blocking
+    max_cycles: 2
+    on_block:
+      action: retry-unit
+`);
+    const dispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(dispatch, "gate dispatches");
+    writeFileSync(
+      resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-DEBATE.md"),
+      "---\nverdict: needs-rework\n---\n\nRework required.\n",
+      "utf-8",
+    );
+
+    const afterHook = checkPostUnitHooks("hook/review-arbiter", "M001/S01/T01", base);
+    assert.deepStrictEqual(afterHook, null, "needs-rework routes via retry signal");
+    assert.ok(isRetryPending(), "retry is pending");
+    assert.deepStrictEqual(consumeRetryTrigger(), {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 // ─── Variable substitution in prompts ──────────────────────────────────────
 test('Variable substitution', () => {
   const base = "/project";

package/src/resources/extensions/gsd/tests/post-unit-retry-on-orchestrator-bridge.test.ts

@@ -8,6 +8,7 @@ import { mock } from "node:test";
 import { postUnitPostVerification, type PostUnitContext } from "../auto-post-unit.ts";
 import { AutoSession } from "../auto/session.ts";
 import { checkPostUnitHooks, resetHookState, resolveHookArtifactPath } from "../post-unit-hooks.ts";
+import { emitJournalEvent } from "../journal.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 import { invalidateAllCaches } from "../cache.ts";
 
@@ -28,6 +29,43 @@ post_unit_hooks:
   writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
 }
 
+function writeFailingHookPreferences(basePath: string): void {
+  const content = `---
+post_unit_hooks:
+  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review {taskId}
+    artifact: REVIEW-DEBATE.md
+    max_cycles: 1
+    enabled: true
+  - name: follow-up-review
+    after:
+      - execute-task
+    prompt: Follow-up review {taskId}
+    enabled: true
+---
+`;
+  writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
+}
+
+function writeBlockingPreferences(basePath: string): void {
+  const content = `---
+post_unit_hooks:
+  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review {taskId}
+    agent: arbiter
+    artifact: REVIEW-DEBATE.md
+    criticality: blocking
+    max_cycles: 2
+    enabled: true
+---
+`;
+  writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
+}
+
 test("post-unit retry_on marks trigger unit as retry in orchestrator before redispatch", async () => {
   const originalCwd = process.cwd();
   const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-retry-"));
@@ -91,3 +129,144 @@ test("post-unit retry_on marks trigger unit as retry in orchestrator before redi
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("failed post-unit hook pauses auto-mode even when its artifact exists", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-hook-failed-"));
+  const taskDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(taskDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    _clearGsdRootCache();
+    invalidateAllCaches();
+    resetHookState();
+    writeFailingHookPreferences(base);
+
+    const hookDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.equal(hookDispatch?.hookName, "review-arbiter");
+
+    const artifactPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-DEBATE.md");
+    writeFileSync(artifactPath, "partial review", "utf-8");
+    emitJournalEvent(base, {
+      ts: "2026-06-03T12:00:00.000Z",
+      flowId: "flow-hook-failed",
+      seq: 3,
+      eventType: "unit-end",
+      data: {
+        unitType: "hook/review-arbiter",
+        unitId: "M001/S01/T01",
+        status: "cancelled",
+        artifactVerified: false,
+      },
+    });
+
+    const pauseAuto = mock.fn(async () => {});
+    const notifications: string[] = [];
+    const s = new AutoSession();
+    s.basePath = base;
+    s.active = true;
+    s.currentUnit = { type: "hook/review-arbiter", id: "M001/S01/T01", startedAt: Date.now() };
+
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: {
+          notify: (message: string) => { notifications.push(message); },
+          setStatus: () => {},
+          setWidget: () => {},
+          setFooter: () => {},
+        },
+        model: { id: "test-model" },
+      } as any,
+      pi: { sendMessage: async () => {}, setModel: async () => true } as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto,
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "stopped");
+    assert.equal(pauseAuto.mock.callCount(), 1);
+    assert.ok(
+      notifications.some(message => message.includes("Post-unit hook review-arbiter failed")),
+      "pause notification should explain the failed hook",
+    );
+  } finally {
+    process.chdir(originalCwd);
+    resetHookState();
+    invalidateAllCaches();
+    _clearGsdRootCache();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("post-unit blocking gate pauses auto-mode on needs-attention verdict", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-gate-"));
+  const taskDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(taskDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    _clearGsdRootCache();
+    invalidateAllCaches();
+    resetHookState();
+    writeBlockingPreferences(base);
+
+    const hookDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(hookDispatch, "hook should dispatch for execute-task");
+
+    const artifactPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-DEBATE.md");
+    writeFileSync(artifactPath, "---\nverdict: needs-attention\n---\n\nManual review required.\n", "utf-8");
+
+    const pauseAuto = mock.fn(async () => {});
+    const s = new AutoSession();
+    s.basePath = base;
+    s.active = true;
+    s.currentUnit = { type: "hook/review-arbiter", id: "M001/S01/T01", startedAt: Date.now() };
+    s.orchestration = {
+      start: async () => ({ kind: "started" }),
+      advance: async () => ({ kind: "stopped", reason: "unused" }),
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "resumed" }),
+      stop: async (reason: string) => ({ kind: "stopped", reason }),
+      getStatus: () => ({ phase: "running", transitionCount: 0 }),
+    };
+
+    const notifications: string[] = [];
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: {
+          notify: (message: string) => { notifications.push(message); },
+          setStatus: () => {},
+          setWidget: () => {},
+          setFooter: () => {},
+        },
+        model: { id: "test-model" },
+      } as any,
+      pi: { sendMessage: async () => {}, setModel: async () => true } as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto,
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "stopped");
+    assert.equal(pauseAuto.mock.callCount(), 1);
+    assert.match(notifications.join("\n"), /Post-unit gate "review-arbiter" blocked execute-task M001\/S01\/T01/);
+    assert.match(notifications.join("\n"), /\/gsd status/);
+  } finally {
+    process.chdir(originalCwd);
+    resetHookState();
+    invalidateAllCaches();
+    _clearGsdRootCache();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -561,6 +561,35 @@ test("post-unit hook max_cycles clamping via validatePreferences", () => {
   assert.equal(p4.post_unit_hooks![0].max_cycles, 3, "valid value passes through");
 });
 
+test("post-unit hook criticality and on_block validation", () => {
+  const base = { name: "h", after: ["execute-task"], prompt: "do something", artifact: "REVIEW.md" };
+
+  const { preferences, errors } = validatePreferences({
+    post_unit_hooks: [{
+      ...base,
+      criticality: "blocking",
+      on_block: { action: "retry-unit", artifact: "NEEDS-REWORK.md" },
+    }],
+  } as any);
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.post_unit_hooks![0].criticality, "blocking");
+  assert.deepEqual(preferences.post_unit_hooks![0].on_block, {
+    action: "retry-unit",
+    artifact: "NEEDS-REWORK.md",
+  });
+
+  const missingArtifact = validatePreferences({
+    post_unit_hooks: [{ name: "blocking", after: ["execute-task"], prompt: "do something", criticality: "blocking" }],
+  } as any);
+  assert.match(missingArtifact.errors.join("\n"), /criticality blocking requires artifact/);
+  assert.equal(missingArtifact.preferences.post_unit_hooks, undefined);
+
+  const invalidAction = validatePreferences({
+    post_unit_hooks: [{ ...base, on_block: { action: "teleport" } }],
+  } as any);
+  assert.match(invalidAction.errors.join("\n"), /invalid on_block action/);
+});
+
 test("pre-dispatch hook action validation via validatePreferences", () => {
   const base = { name: "h", before: ["execute-task"] };
 

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

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "../tool-presentation-plan.ts";
 
 const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
 const templatesDir = join(process.cwd(), "src/resources/extensions/gsd/templates");
@@ -25,11 +26,15 @@ test("reactive-execute prompt keeps task summaries with subagents and avoids bat
 test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence", () => {
   const prompt = readPrompt("run-uat");
   assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`\{\{uatType\}\}`/);
-  assert.match(prompt, /uatType:\s*\{\{uatType\}\}/);
+  assert.match(prompt, /uatType:\s*"\{\{uatType\}\}"/);
+  assert.match(prompt, /gsd_uat_result_save/);
+  assert.match(prompt, /presentedTools/);
+  assert.match(prompt, /blockedTools/);
   assert.match(prompt, /live-runtime/);
   assert.match(prompt, /browser\/runtime\/network/i);
   assert.match(prompt, /NEEDS-HUMAN/);
   assert.doesNotMatch(prompt, /uatType:\s*artifact-driven/);
+  assert.doesNotMatch(prompt, /Call `gsd_summary_save`/);
 });
 
 test("run-uat prompt lists canonical gsd_uat_exec intent values", () => {
@@ -42,6 +47,22 @@ test("run-uat prompt lists canonical gsd_uat_exec intent values", () => {
   assert.match(prompt, /do not use `artifact`, `runtime`, or `human-follow-up` as `intent`/i);
 });
 
+test("run-uat prompt gives the complete UAT result-save presentation contract", () => {
+  const prompt = readPrompt("run-uat");
+  assert.match(prompt, /Call `gsd_uat_result_save` once after all checks are complete/);
+  assert.doesNotMatch(prompt, /Call `gsd_summary_save` with `artifact_type: "ASSESSMENT"`/);
+
+  for (const toolName of RUN_UAT_WORKFLOW_TOOL_NAMES) {
+    assert.ok(prompt.includes(`"${toolName}"`), `prompt should include required presented tool ${toolName}`);
+  }
+
+  for (const toolName of ["gsd_exec", "gsd_summary_save", "gsd_save_gate_result"] as const) {
+    assert.ok(prompt.includes(`name: "${toolName}"`), `prompt should include blocked tool ${toolName}`);
+  }
+
+  assert.ok(prompt.includes("forbidden during run-uat"), "prompt should explain blocked run-uat tools");
+});
+
 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);
@@ -475,6 +496,27 @@ test("reactive-execute prompt references tool calls instead of checkbox updates"
   assert.match(prompt, /completion tool calls/);
 });
 
+test("parallel subagent prompts forbid serialized tasks arrays", () => {
+  const expectations = [
+    { name: "reactive-execute", agent: "worker" },
+    { name: "parallel-research-slices", agent: "scout" },
+    { name: "gate-evaluate", agent: "tester" },
+  ] as const;
+
+  for (const { name, agent } of expectations) {
+    const prompt = readPrompt(name);
+    assert.match(prompt, /tasks:\s*\[\.\.\.\]/, `${name} must show the native array placeholder`);
+    assert.match(prompt, /native JSON array/i, `${name} must explicitly require a native JSON array`);
+    assert.match(prompt, /Do NOT JSON\.stringify/i, `${name} must forbid JSON.stringify on tasks`);
+    assert.match(prompt, /must be array/i, `${name} must mention the subagent validation failure`);
+    assert.match(
+      prompt,
+      new RegExp(`tasks:\\s*\\[\\{\\s*agent:\\s*"${agent}"`, "i"),
+      `${name} must show the concrete ${agent} task call shape`,
+    );
+  }
+});
+
 // ─── Project-shape classifier + 3-or-4-options-with-Other-hatch contract ──
 
 test("guided-discuss-project classifies project shape and persists the verdict to PROJECT.md", () => {

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -22,6 +22,20 @@ test("resolveExtensionDirFromCandidates prefers user-local dir when both trees a
   assert.equal(resolved, agentDir);
 });
 
+test("resolveExtensionDirFromCandidates prefers source checkout dir when both trees are valid", () => {
+  const moduleDir = "/repo/src/resources/extensions/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});
+
 test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
   const moduleDir = "/npm/global/gsd";
   const agentDir = "/home/user/.gsd/agent/extensions/gsd";