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

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -7,6 +7,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   checkToolCallLoop,
+  configureToolCallLoopGuard,
   recordToolCallLoopMutation,
   resetToolCallLoopGuard,
   disableToolCallLoopGuard,
@@ -251,6 +252,99 @@ console.log('\n── Loop guard: mutation progress decays per-tool counts (#109
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Successful shell/exec progress decays per-tool counts (#1206)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: successful shell/exec progress decays per-tool counts (#1206) ──');
+
+{
+  // A local model debugging a UAT scenario runs many varied bg_shell /
+  // gsd_uat_exec calls (restart server, npm install, curl an endpoint). Each
+  // successful call is state progression, so Guard 2 must decay and never
+  // block the productive turn — even past the repeatable cap.
+  for (const execTool of ['bg_shell', 'gsd_uat_exec', 'bash', 'gsd_exec']) {
+    resetToolCallLoopGuard();
+
+    for (let i = 1; i <= 20; i++) {
+      const result = checkToolCallLoop(execTool, { command: `step ${i}` });
+      assert.ok(result.block === false, `${execTool} call ${i} after exec progress should be allowed`);
+      assert.deepStrictEqual(getToolCallCountForTool(execTool), 1, `${execTool} count should decay before call ${i}`);
+
+      // A successful (non-error) exec call records progress, like a file mutation.
+      recordToolCallLoopMutation(execTool);
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Failing exec loops still trip the per-tool cap (#783 vs #1206)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: failing exec loop (no progress recorded) still trips the cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // The improvisation loop from #783: the model retries a missing tool through
+  // varied bash commands. Those fail (non-zero exit → isError), so the caller
+  // never records progress and the per-tool cap must still trip.
+  for (let i = 1; i <= 15; i++) {
+    const result = checkToolCallLoop('bash', { command: `try-missing-tool ${i}` });
+    assert.ok(result.block === false, `failing bash call ${i} should be allowed up to the cap`);
+    // No recordToolCallLoopMutation — the command errored.
+  }
+  const blocked = checkToolCallLoop('bash', { command: 'try-missing-tool 16' });
+  assert.ok(blocked.block === true, '16th failing bash call should be blocked by the per-tool cap');
+  assert.ok(blocked.reason?.includes('repeated tool'), 'reason should identify the per-tool guard');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// bg_shell/async_bash false-success must not decay the per-tool cap (#783)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: bg_shell failed run/start does not decay the cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 1; i <= 15; i++) {
+    const result = checkToolCallLoop('bg_shell', { action: 'run', command: `try-missing-tool ${i}` });
+    assert.ok(result.block === false, `failing bg_shell run ${i} should be allowed up to the cap`);
+    recordToolCallLoopMutation('bg_shell', { action: 'run', exitCode: 1, timedOut: false });
+  }
+  const blocked = checkToolCallLoop('bg_shell', { action: 'run', command: 'try-missing-tool 16' });
+  assert.ok(blocked.block === true, '16th failing bg_shell run should be blocked by the per-tool cap');
+}
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 1; i <= 15; i++) {
+    checkToolCallLoop('bg_shell', { action: 'start', command: `bad-server ${i}` });
+    recordToolCallLoopMutation('bg_shell', {
+      action: 'start',
+      process: { alive: false, exitCode: 1 },
+    });
+  }
+  const blocked = checkToolCallLoop('bg_shell', { action: 'start', command: 'bad-server 16' });
+  assert.ok(blocked.block === true, '16th dead bg_shell start should be blocked by the per-tool cap');
+}
+
+console.log('\n── Loop guard: async_bash job registration does not decay the cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('async_bash', { command: `try-missing-tool ${i}` });
+    assert.ok(result.block === false, `async_bash call ${i} should be allowed up to the cap`);
+    recordToolCallLoopMutation('async_bash');
+  }
+  const blocked = checkToolCallLoop('async_bash', { command: 'try-missing-tool 7' });
+  assert.ok(blocked.block === true, '7th async_bash call should be blocked by the per-tool cap');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Distinct read-only navigation calls are context gathering, not repeated-tool loops.
 // ═══════════════════════════════════════════════════════════════════════════
@@ -385,3 +479,168 @@ console.log('\n── Loop guard: block reasons tell model to respond in text
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Distinct-arg browser-automation calls are a legitimate UAT, not a loop (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct-arg browser automation calls are not capped by per-tool count (#1120) ──');
+
+{
+  // A browser-backed UAT legitimately calls one browser verb many times with
+  // DIFFERENT arguments (read a validation message, count staged edits, inspect
+  // a control card, …). Guard 1's identical-signature streak never trips because
+  // the args vary; Guard 2's arg-independent per-tool cap must NOT block it.
+  for (const toolName of ['browser_evaluate', 'browser_act', 'browser_find']) {
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 12; i++) {
+      const result = checkToolCallLoop(toolName, { script: `step ${i}` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+  }
+
+  // MCP-prefixed browser tools canonicalize to `browser_*` and are exempt too.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 12; i++) {
+    const result = checkToolCallLoop('mcp__agent-browser__browser_evaluate', { script: `step ${i}` });
+    assert.ok(result.block === false, `distinct MCP-prefixed browser_evaluate call ${i} should be allowed`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Identical-arg browser loops are STILL caught by Guard 1 (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: identical-arg browser loops are still caught by Guard 1 (#1120) ──');
+
+{
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    const result = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+    assert.ok(result.block === false, `identical browser_evaluate call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+  assert.ok(blocked.block === true, '5th identical browser_evaluate call should be blocked by Guard 1');
+  assert.ok(blocked.reason?.includes('identical args'), 'identical browser loops should be caught by Guard 1, not Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// The browser exemption must NOT widen to other non-exempt tools (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: browser exemption does not widen to other tools (#1120) ──');
+
+{
+  // Negative invariant: an arbitrary non-exempt, non-browser tool called past
+  // the default cap with varied args must still be blocked by Guard 2.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('some_workflow_tool', { arg: `v${i}` });
+    assert.ok(result.block === false, `non-exempt tool call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('some_workflow_tool', { arg: 'v7' });
+  assert.ok(blocked.block === true, '7th varied-arg non-exempt call must still trip Guard 2');
+  assert.ok(blocked.reason?.includes('repeated tool'), 'non-exempt overflow should be caught by Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Configurable thresholds (#1198)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: master switch disables both guards (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ enabled: false });
+  resetToolCallLoopGuard();
+  // Neither identical-args nor per-tool cap should ever trip while disabled.
+  for (let i = 1; i <= 30; i++) {
+    const result = checkToolCallLoop('gsd_complete_milestone', { same: 'args' });
+    assert.ok(result.block === false, `disabled guard should allow call ${i}`);
+  }
+  // Restore defaults for subsequent tests.
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: repeated_tool disabled keeps identical-args protection (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ repeated_tool: { enabled: false } });
+  resetToolCallLoopGuard();
+  // Per-tool cap is off: many varied-arg calls are allowed.
+  for (let i = 1; i <= 20; i++) {
+    const result = checkToolCallLoop('gsd_exec', { cmd: `run-${i}` });
+    assert.ok(result.block === false, `repeated_tool disabled should allow varied call ${i}`);
+  }
+  // Identical-args guard is still active.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    assert.ok(checkToolCallLoop('gsd_exec', { cmd: 'same' }).block === false);
+  }
+  const blocked = checkToolCallLoop('gsd_exec', { cmd: 'same' });
+  assert.ok(blocked.block === true, 'identical-args guard should still trip when repeated_tool is off');
+  assert.ok(blocked.reason?.includes('identical args'));
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: raised caps allow more repeated calls (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ repeated_tool: { default_cap: 10 } });
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 10; i++) {
+    const result = checkToolCallLoop('gsd_complete_milestone', { arg: `v${i}` });
+    assert.ok(result.block === false, `raised-cap call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('gsd_complete_milestone', { arg: 'v11' });
+  assert.ok(blocked.block === true, '11th call should trip the raised cap of 10');
+  assert.ok(blocked.reason?.includes('cap 10'), 'block message should mention the active cap');
+  assert.ok(blocked.reason?.includes('tool_call_loop_guard'), 'block message should mention the config key');
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: user-added exempt tools bypass the per-tool cap (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ repeated_tool: { exempt_tools: ['ctx_execute'] } });
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 30; i++) {
+    const result = checkToolCallLoop('ctx_execute', { arg: `v${i}` });
+    assert.ok(result.block === false, `exempt tool call ${i} should be allowed`);
+  }
+  // Built-in exempt defaults are preserved alongside the user-added tool.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 30; i++) {
+    assert.ok(checkToolCallLoop('read', { path: `f${i}` }).block === false, 'built-in exempt read should remain exempt');
+  }
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: identical-args max is configurable (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ identical_args: { max_consecutive_calls: 2 } });
+  resetToolCallLoopGuard();
+  assert.ok(checkToolCallLoop('web_search', { q: 'x' }).block === false, 'call 1 allowed');
+  assert.ok(checkToolCallLoop('web_search', { q: 'x' }).block === false, 'call 2 allowed');
+  const blocked = checkToolCallLoop('web_search', { q: 'x' });
+  assert.ok(blocked.block === true, '3rd identical call should trip lowered max of 2');
+  assert.ok(blocked.reason?.includes('max 2'), 'block message should mention active max');
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: env overrides win over preferences (#1198) ──');
+
+{
+  process.env.GSD_TOOL_LOOP_REPEATED_DEFAULT_CAP = '2';
+  configureToolCallLoopGuard({ repeated_tool: { default_cap: 6 } });
+  resetToolCallLoopGuard();
+  assert.ok(checkToolCallLoop('gsd_complete_milestone', { a: '1' }).block === false, 'call 1 allowed');
+  assert.ok(checkToolCallLoop('gsd_complete_milestone', { a: '2' }).block === false, 'call 2 allowed');
+  const blocked = checkToolCallLoop('gsd_complete_milestone', { a: '3' });
+  assert.ok(blocked.block === true, 'env override cap of 2 should win over preference cap of 6');
+  delete process.env.GSD_TOOL_LOOP_REPEATED_DEFAULT_CAP;
+  configureToolCallLoopGuard(null);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Reset restores default guard state after configuration tests
+// ═══════════════════════════════════════════════════════════════════════════
+resetToolCallLoopGuard();

package/src/resources/extensions/gsd/tests/uat-stuck-loop-orphaned-worktree.test.ts

@@ -30,7 +30,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
+import { syncProjectRootToWorktree } from "../auto-worktree-sync.ts";
 import {
   createWorktree,
   removeWorktree,

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -268,7 +268,7 @@ test("#4934: every manifest declares a tools policy", () => {
 });
 
 test("#4934: tools.mode is one of the declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification"]);
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs", "verification", "workflow-only"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -327,23 +327,71 @@ test("#5453: complete-milestone uses all tools so bash verification is not plann
   }
 });
 
-test("#5731: validate-milestone and complete-slice use all tools so closeout verification is not planning-dispatch blocked", () => {
-  for (const unitType of ["validate-milestone", "complete-slice"] as const) {
-    const manifest = UNIT_MANIFESTS[unitType];
-    assert.strictEqual(manifest.tools.mode, "all");
-    const result = shouldBlockPlanningUnit(
-      "bash",
-      "go test -short -count=1 ./...",
-      process.cwd(),
-      unitType,
-      manifest.tools,
-    );
-    assert.strictEqual(
-      result.block,
-      false,
-      `${unitType} must allow verification bash commands: ${result.reason}`,
-    );
-  }
+test("#5731: complete-slice uses all tools so closeout verification is not planning-dispatch blocked", () => {
+  const manifest = UNIT_MANIFESTS["complete-slice"];
+  assert.strictEqual(manifest.tools.mode, "all");
+  const result = shouldBlockPlanningUnit(
+    "bash",
+    "go test -short -count=1 ./...",
+    process.cwd(),
+    "complete-slice",
+    manifest.tools,
+  );
+  assert.strictEqual(
+    result.block,
+    false,
+    `complete-slice must allow verification bash commands: ${result.reason}`,
+  );
+});
+
+test("#1157: validate-milestone uses workflow-only tools and blocks manual artifact writes", () => {
+  const manifest = UNIT_MANIFESTS["validate-milestone"];
+  assert.strictEqual(manifest.tools.mode, "workflow-only");
+  assert.deepEqual(resolveSubagentPermissionContract("validate-milestone"), {
+    allowed: true,
+    allowedSubagents: ["reviewer", "security", "tester"],
+    toolsMode: "workflow-only",
+  });
+
+  const validationWrite = shouldBlockPlanningUnit(
+    "write",
+    ".gsd/milestones/M001/M001-VALIDATION.md",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(validationWrite.block, true);
+  assert.match(validationWrite.reason!, /workflow-only/);
+  assert.match(validationWrite.reason!, /direct artifact writes are disabled/);
+
+  const bash = shouldBlockPlanningUnit(
+    "bash",
+    "npm test",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(bash.block, true);
+  assert.match(bash.reason!, /bash is not permitted/);
+
+  const validateTool = shouldBlockPlanningUnit(
+    "gsd_validate_milestone",
+    "",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+  assert.strictEqual(validateTool.block, false);
+
+  const reviewer = shouldBlockPlanningUnit(
+    "subagent",
+    "",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+    ["reviewer"],
+  );
+  assert.strictEqual(reviewer.block, false, reviewer.reason);
 });
 
 test("#5843: run-uat uses verification tools policy so build/test commands can run", () => {

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

@@ -7,6 +7,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 
 import {
   KNOWN_UNIT_TYPES,
@@ -15,6 +17,8 @@ import {
   SECTION_CLOSE_GATE_UNIT_TYPES,
   getUnitDescriptor,
   getUnitPhaseChain,
+  getUnitPromptTemplate,
+  getUnitPromptTemplates,
 } from "../unit-registry.ts";
 import {
   AUTO_UNIT_SCOPED_TOOLS,
@@ -96,6 +100,40 @@ const EXPECTED_PHASE_CHAINS: Record<string, string[] | undefined> = {
   "no-such-unit": undefined,
 };
 
+const EXPECTED_DIRECT_PROMPT_TEMPLATES: Record<string, string> = {
+  "research-milestone": "research-milestone",
+  "plan-milestone": "plan-milestone",
+  "validate-milestone": "validate-milestone",
+  "complete-milestone": "complete-milestone",
+  "research-slice": "research-slice",
+  "plan-slice": "plan-slice",
+  "refine-slice": "refine-slice",
+  "replan-slice": "replan-slice",
+  "complete-slice": "complete-slice",
+  "reassess-roadmap": "reassess-roadmap",
+  "execute-task": "execute-task",
+  "reactive-execute": "reactive-execute",
+  "run-uat": "run-uat",
+  "gate-evaluate": "gate-evaluate",
+  "rewrite-docs": "rewrite-docs",
+  "workflow-preferences": "guided-workflow-preferences",
+  "discuss-project": "guided-discuss-project",
+  "discuss-requirements": "guided-discuss-requirements",
+  "research-decision": "guided-research-decision",
+  "research-project": "guided-research-project",
+};
+
+const EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES = [
+  "discuss-slice",
+  "execute-task-simple",
+  "triage-captures",
+  "quick-task",
+];
+
+const EXPECTED_CONDITIONAL_PROMPT_TEMPLATES: Record<string, string[]> = {
+  "discuss-milestone": ["discuss", "discuss-headless", "guided-discuss-milestone"],
+};
+
 // ─── Derived-view parity ──────────────────────────────────────────────────
 
 test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
@@ -134,6 +172,49 @@ test("phaseChainForUnit matches the pre-registry switch for every known input",
   }
 });
 
+test("direct prompt-template associations live on the Unit Registry", () => {
+  for (const [unitType, promptTemplate] of Object.entries(EXPECTED_DIRECT_PROMPT_TEMPLATES)) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      promptTemplate,
+      `prompt template for ${unitType}`,
+    );
+    assert.ok(
+      existsSync(join(process.cwd(), "src/resources/extensions/gsd/prompts", `${promptTemplate}.md`)),
+      `prompt template file must exist for ${unitType}: ${promptTemplate}`,
+    );
+  }
+
+  for (const unitType of EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      undefined,
+      `${unitType} prompt association is conditional or not verified yet`,
+    );
+  }
+});
+
+test("conditional prompt-template associations live on the Unit Registry without pretending to be direct", () => {
+  for (const [unitType, promptTemplates] of Object.entries(EXPECTED_CONDITIONAL_PROMPT_TEMPLATES)) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      undefined,
+      `${unitType} must not expose a single direct prompt template`,
+    );
+    assert.deepEqual(
+      getUnitPromptTemplates(unitType),
+      promptTemplates,
+      `prompt templates for ${unitType}`,
+    );
+    for (const promptTemplate of promptTemplates) {
+      assert.ok(
+        existsSync(join(process.cwd(), "src/resources/extensions/gsd/prompts", `${promptTemplate}.md`)),
+        `prompt template file must exist for ${unitType}: ${promptTemplate}`,
+      );
+    }
+  }
+});
+
 test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
   for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
     assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);

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

@@ -6,7 +6,9 @@ import {
   formatExecuteTaskRecoveryStatus,
   inspectExecuteTaskDurability,
   isInFlightRuntimePhase,
+  readUnitHarnessAbort,
   readUnitRuntimeRecord,
+  recordUnitHarnessAbort,
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
 import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
@@ -41,6 +43,34 @@ console.log("\n=== runtime record write/read/update ===");
   assert.deepStrictEqual(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
 }
 
+console.log("\n=== runtime harness abort preservation and explicit clear ===");
+{
+  const startedAt = 3000;
+  recordUnitHarnessAbort(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    kind: "tool-error",
+    reason: "Tool execution failed before the unit could complete its gate evaluation.",
+    toolName: "browser_click",
+  });
+
+  const preserved = writeUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    phase: "wrapup-warning-sent",
+  });
+  assert.equal(preserved.harnessAbort?.kind, "tool-error", "ordinary same-run updates preserve harness abort");
+
+  const cleared = writeUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt, {
+    phase: "recovered",
+    harnessAbort: undefined,
+  });
+  assert.equal(cleared.harnessAbort, undefined, "explicit clear removes stale harness abort");
+  assert.equal(
+    readUnitHarnessAbort(base, "gate-evaluate", "M100/S02/gates+Q3", startedAt),
+    null,
+    "cleared harness abort no longer blocks result saves",
+  );
+
+  clearUnitRuntimeRecord(base, "gate-evaluate", "M100/S02/gates+Q3");
+}
+
 console.log("\n=== execute-task durability inspection ===");
 {
   let status = await inspectExecuteTaskDurability(base, "M100/S02/T09");

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

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

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

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