@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

package/src/resources/extensions/gsd/tests/skip-slice-cascades-tasks.test.ts

@@ -25,6 +25,7 @@ import {
   updateTaskStatus,
 } from "../gsd-db.ts";
 import { handleSkipSlice } from "../tools/skip-slice.ts";
+import { skipSliceCascade } from "../db/writers/cascades.ts";
 
 describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
   let dir: string;
@@ -122,4 +123,24 @@ describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
     assert.match(result.error!, /not found/i);
     assert.equal(result.errorCode, "slice_not_found");
   });
+
+  test("skipSliceCascade rejects a slice in the legacy 'closed' status without nulling completed_at", () => {
+    const completedAt = "2026-01-01T00:00:00.000Z";
+    updateSliceStatus("M001", "S03", "closed", completedAt);
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.deepEqual(outcome, { ok: false, reason: "slice-already-complete" });
+
+    const slice = getSlice("M001", "S03");
+    assert.equal(slice?.status, "closed", "closed slice must not be downgraded to skipped");
+    assert.equal(slice?.completed_at, completedAt, "completed_at must be preserved");
+  });
+
+  test("skipSliceCascade still re-skips an already-skipped slice (ok, wasAlreadySkipped)", () => {
+    updateSliceStatus("M001", "S03", "skipped");
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.equal(outcome.ok, true);
+    if (outcome.ok) assert.equal(outcome.wasAlreadySkipped, true);
+  });
 });

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

@@ -1618,6 +1618,58 @@ test("ADR-017 (#5705): in-sync ROADMAP and DB → no roadmap-divergence drift",
   );
 });
 
+test("ADR-017 (#1370): roadmap-divergence skips completed milestone sharing active worktree phase", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-shared-phase-"));
+  const milestoneDir = join(base, ".gsd", "phases", "06-rlrbot-m006-rlrbot-tool-registry-and-command-sa");
+  const roadmapPath = join(milestoneDir, "06-ROADMAP.md");
+  mkdirSync(milestoneDir, { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M006"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M006-rlrbot"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M006", "M006-META.json"), "{}\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M006-rlrbot", "M006-rlrbot-META.json"), "{}\n");
+  const activeRoadmap = [
+    "# M006-rlrbot: Active worktree",
+    "",
+    "**Vision:** Keep the active worktree projection authoritative.",
+    "",
+    "## Slices",
+    "",
+    "- [ ] **S01: Shared slice** `risk:medium` `depends:[]`",
+    "  > After this: Active work remains pending.",
+    "",
+  ].join("\n");
+  writeFileSync(roadmapPath, activeRoadmap);
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M006", title: "Completed source", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M006", title: "Shared slice", status: "complete", risk: "medium", depends: [], demo: "Completed.", sequence: 1 });
+  insertMilestone({
+    id: "M006-rlrbot",
+    title: "Active worktree",
+    status: "active",
+    planning: { vision: "Keep the active worktree projection authoritative." },
+  });
+  insertSlice({ id: "S01", milestoneId: "M006-rlrbot", title: "Shared slice", status: "pending", risk: "medium", depends: [], demo: "Active work remains pending.", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M006-rlrbot", title: "Plan active work", status: "pending" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M006-rlrbot", title: "Active worktree" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    result.repaired.some((d) => d.kind === "roadmap-divergence"),
+    false,
+    "completed milestone sharing the phase dir must not trigger roadmap-divergence repair",
+  );
+  assert.equal(readFileSync(roadmapPath, "utf-8"), activeRoadmap);
+});
+
 // ─── #5706: missing-completion-timestamp drift ──────────────────────────────
 
 test("ADR-017 (#5706): task with SUMMARY but null completed_at → backfilled", async (t) => {

package/src/resources/extensions/gsd/tests/stop-notice.test.ts

@@ -7,6 +7,8 @@ import assert from "node:assert/strict";
 
 import {
   formatStopNoticePrefix,
+  formatVerdictRecordedNotice,
+  formatVerdictRejectedNotice,
   isBlockedStopReason,
   stopNoticeDisplayReason,
   stopNoticeKind,
@@ -14,6 +16,7 @@ import {
   isPauseNotice,
   isBlockedNoticeMessage,
   isManualResolutionNotice,
+  isInteractiveMenuUnavailableNotice,
   PAUSED_NOTICE_PREFIXES,
   TERMINAL_NOTICE_PREFIXES,
 } from "../stop-notice.js";
@@ -62,8 +65,42 @@ describe("emitter↔detector round-trip", () => {
     assert.ok(isBlockedNoticeMessage(message));
   });
 
+  test("verdict notices classify as terminal with rejected notices blocked", () => {
+    const recorded = formatVerdictRecordedNotice("Milestone M001 verdict: needs-attention -> pass").toLowerCase();
+    const rejected = formatVerdictRejectedNotice("No milestone validation found for M001.").toLowerCase();
+
+    assert.ok(isTerminalNotice(recorded));
+    assert.equal(isBlockedNoticeMessage(recorded), false);
+
+    assert.ok(isTerminalNotice(rejected));
+    assert.ok(isBlockedNoticeMessage(rejected));
+  });
+
+  test("un-showable menu notices classify as blocked (#1294)", () => {
+    // Emitted verbatim by notifyCommandMenuUnavailable (next-action-ui.ts / command-feedback.ts).
+    const menuUnavailable =
+      "gsd — m002: editorial hn menu could not be shown in this session.\nrun /gsd when ready.";
+    assert.ok(isInteractiveMenuUnavailableNotice(menuUnavailable));
+    assert.ok(isBlockedNoticeMessage(menuUnavailable));
+
+    // Emitted by notifyPickerCommandNeedsInteractiveMenu (command-feedback.ts).
+    const pickerGuidance = "/gsd did not start: milestone menu needs an interactive session";
+    assert.ok(isInteractiveMenuUnavailableNotice(pickerGuidance));
+    assert.ok(isBlockedNoticeMessage(pickerGuidance));
+
+    // Unrelated notices are not swept up.
+    assert.equal(isInteractiveMenuUnavailableNotice("auto-mode complete"), false);
+  });
+
   test("terminal prefixes cover the known stop vocabulary", () => {
-    for (const message of ["auto-mode stopped.", "auto-mode complete", "auto-mode idle", "no active milestone"]) {
+    for (const message of [
+      "auto-mode stopped.",
+      "auto-mode complete",
+      "auto-mode idle",
+      "no active milestone",
+      "verdict recorded: milestone m001 verdict: needs-attention -> pass",
+      "verdict rejected: unexpected argument: x",
+    ]) {
       assert.ok(TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix)), message);
     }
   });

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

@@ -174,3 +174,22 @@ test('sync-lock: contended fresh lock fails fast without honoring long sync time
     cleanupDir(base);
   }
 });
+
+test('sync-lock: uncreatable lock path fails open instead of spinning forever', () => {
+  const base = tempDir();
+  try {
+    // `.gsd` is a dangling symlink to a missing target: the O_EXCL open lands
+    // on a missing parent and throws non-EEXIST on every attempt. Without the
+    // fail-open guard the retry loop spins forever, blocking the event loop.
+    fs.symlinkSync(path.join(base, 'missing-external-state'), path.join(base, '.gsd'), 'junction');
+
+    const startedAt = performance.now();
+    const result = acquireSyncLock(base, 0, 'write-gate.lock');
+    const elapsedMs = performance.now() - startedAt;
+
+    assert.strictEqual(result.acquired, false, 'uncreatable lock path must fail open, not acquire');
+    assert.ok(elapsedMs < 250, `must return promptly, not spin; elapsed=${elapsedMs.toFixed(1)}ms`);
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -4,7 +4,13 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { buildContextMessage, stripVolatileCodebaseMetadata } from "../bootstrap/system-context.ts";
+import {
+  buildContextMessage,
+  GSD_CONTEXT_MESSAGE_SENTINEL,
+  stripVolatileCodebaseMetadata,
+} from "../bootstrap/system-context.ts";
+
+const SENTINEL = `${GSD_CONTEXT_MESSAGE_SENTINEL}\n`;
 
 describe("stripVolatileCodebaseMetadata (#847 — KV cache stability)", () => {
   const map = [
@@ -63,7 +69,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result, "expected a context message");
     assert.equal(result.customType, "gsd-memory");
-    assert.equal(result.content, "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two");
+    assert.equal(result.content, `${SENTINEL}[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two`);
     assert.equal(result.display, false);
   });
 
@@ -75,7 +81,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[GUIDED]\nexecute T01");
+    assert.equal(result.content, `${SENTINEL}[GUIDED]\nexecute T01`);
   });
 
   test("forensics injection alone emits gsd-forensics", () => {
@@ -86,7 +92,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, "[FORENSICS]\ninvestigation context");
+    assert.equal(result.content, `${SENTINEL}[FORENSICS]\ninvestigation context`);
   });
 
   test("memory + guided injection: memory prepended, customType is gsd-guided-context", () => {
@@ -97,7 +103,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, `${markedMemory}\n\n[GUIDED]\nexecute T01`);
+    assert.equal(result.content, `${SENTINEL}${markedMemory}\n\n[GUIDED]\nexecute T01`);
   });
 
   test("memory + forensics: memory prepended, customType is gsd-forensics", () => {
@@ -108,7 +114,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, `${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
+    assert.equal(result.content, `${SENTINEL}${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
   });
 
   test("guided takes precedence over forensics when both are somehow present", () => {
@@ -122,6 +128,6 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[GUIDED]");
+    assert.equal(result.content, `${SENTINEL}[GUIDED]`);
   });
 });

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -17,6 +17,20 @@ test("#2309: 'terminated' errors should be classified as transient", () => {
   assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'terminated' should use 15s backoff");
 });
 
+test("#1364: provider abort stop reasons should be classified as transient", () => {
+  const result = classifyError("Unhandled stop reason: abort");
+  assert.equal(isTransient(result), true, "'abort' provider errors should be transient");
+  assert.equal(result.kind, "connection", "'abort' matches connection");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'abort' should use 15s backoff");
+});
+
+test("#1364: provider unknown stop reasons should be classified as transient", () => {
+  const result = classifyError("Unhandled stop reason: unknown");
+  assert.equal(isTransient(result), true, "'unknown' provider stop reasons should be transient");
+  assert.equal(result.kind, "connection", "'unknown' stop reasons match connection");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'unknown' should use 15s backoff");
+});
+
 test("#2309: 'connection reset by peer' errors should be classified as transient (network)", () => {
   const result = classifyError("connection reset by peer");
   assert.equal(isTransient(result), true, "'connection reset by peer' should be transient");

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -47,6 +47,7 @@ describe("#2883: tool invocation error tracking on AutoSession", () => {
 import {
   isDeterministicPolicyError,
   isPendingUserApprovalGateError,
+  isScheduleWakeupContinuationError,
   isToolInvocationError,
   isToolUnavailableError,
   isQueuedUserMessageSkip,
@@ -118,6 +119,24 @@ describe("#2883: isToolInvocationError classification", () => {
     assert.equal(isToolInvocationError("Invalid arguments for tool gsd_slice_complete"), true);
   });
 
+  test("scopes conditional required-field validation to ScheduleWakeup", () => {
+    const error = "`prompt` is required when `stop` is not true";
+
+    assert.equal(isToolInvocationError(error), false);
+    assert.equal(
+      isScheduleWakeupContinuationError("ScheduleWakeup", error),
+      true,
+    );
+    assert.equal(isScheduleWakeupContinuationError("read", error), false);
+    assert.equal(
+      isScheduleWakeupContinuationError(
+        "ScheduleWakeup",
+        "`evidence` is required when `status` is blocking",
+      ),
+      false,
+    );
+  });
+
   test("detects 'No such tool available' error", () => {
     assert.equal(isToolInvocationError("No such tool available: mcp__gsd-workflow__memory_query"), true);
   });

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

@@ -25,8 +25,16 @@ function makeMockPi() {
 
 console.log('\n── Tool naming: registration count ──');
 
+// Aliases are hidden from the model-facing surface by default (plan 035);
+// opt in here so this file can keep exercising alias-registration behavior.
+const previousAdvertiseAliases = process.env.GSD_ADVERTISE_TOOL_ALIASES;
+process.env.GSD_ADVERTISE_TOOL_ALIASES = "1";
+
 const pi = makeMockPi();
 registerDbTools(pi);
+
+if (previousAdvertiseAliases === undefined) delete process.env.GSD_ADVERTISE_TOOL_ALIASES;
+else process.env.GSD_ADVERTISE_TOOL_ALIASES = previousAdvertiseAliases;
 const toolByName = new Map<string, any>(pi.tools.map((tool: any) => [tool.name, tool]));
 const registeredCanonicalNames = new Set<string>(
   WORKFLOW_TOOL_CONTRACTS

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

@@ -43,7 +43,10 @@ import {
   insertMilestone,
   upsertMilestonePlanning,
   insertSlice,
+  insertTask,
+  saveReworkBrief,
 } from "../gsd-db.ts";
+import { clearGSDPreferencesCache, getProjectGSDPreferencesPath } from "../preferences.ts";
 
 // ─── Pure composer tests ──────────────────────────────────────────────────
 
@@ -416,6 +419,44 @@ test("Tool Surface composer: planning-dispatch lists allowed subagents", () => {
   assert.match(out, /\*\*planner\*\*/);
 });
 
+test("Tool Surface composer: planning_subagents updates plan-milestone dispatch guidance", (t) => {
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-tool-surface-planning-subagents-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-tool-surface-planning-subagents-home-"));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  });
+
+  process.env.GSD_HOME = tempGsdHome;
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  clearGSDPreferencesCache();
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      "---",
+      "version: 1",
+      "planning_subagents:",
+      "  plan-milestone:",
+      "    allowed: [security]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const out = composeToolSurfaceInstructions("plan-milestone", {
+    renderMode: "standalone",
+    basePath: tempProject,
+  });
+  assert.match(out, /Dispatch subagents only to \*\*security\*\*/);
+  assert.doesNotMatch(out, /Do not dispatch subagents/);
+});
+
 test("Tool Surface composer: execute-task warns against slice/milestone closeout tools", () => {
   const out = composeToolSurfaceInstructions("execute-task", { renderMode: "nested" });
   assert.match(out, /^Tool surface: /);
@@ -518,6 +559,38 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
   assert.ok(!prompt.includes("Slice Context (from discussion)"));
 });
 
+
+test("execute-task prompt injects unresolved blocking rework findings", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+  saveReworkBrief({
+    briefId: "RB-001",
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T01",
+    findings: [{
+      findingId: "F1",
+      severity: "blocking",
+      description: "Compile regression",
+      requiredFix: "Restore typecheck",
+      verificationCommands: ["pnpm run typecheck:extensions"],
+    }],
+  });
+
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "First", "T01", "Task", base);
+
+  assert.match(prompt, /Blocking Rework Findings \(non-optional\)/);
+  assert.match(prompt, /F1/);
+  assert.match(prompt, /Compile regression/);
+  assert.match(prompt, /pnpm run typecheck:extensions/);
+  assert.match(prompt, /reworkResolution/);
+});
+
 test("execute-task prompt omits on-demand slice research when the artifact is absent", async (t) => {
   const base = makeFixtureBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -239,6 +239,98 @@ test("plan-v2 ensure rejects empty executable graph", () => {
   assert.equal(isEmptyPlanV2GraphResult(compiled), true);
 });
 
+function seedMultiSliceRows(): void {
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  const slices: Array<[string, number, Array<[string, number]>]> = [
+    ["S01", 1, [["T01", 1], ["T02", 2]]],
+    ["S02", 2, [["T03", 1], ["T04", 2]]],
+  ];
+  for (const [sid, sseq, tasks] of slices) {
+    insertSlice({ id: sid, milestoneId: MILESTONE_ID, title: `Slice ${sid}`, status: "in_progress", sequence: sseq });
+    for (const [tid, tseq] of tasks) {
+      insertTask({
+        id: tid,
+        milestoneId: MILESTONE_ID,
+        sliceId: sid,
+        title: `Task ${tid}`,
+        status: "pending",
+        keyFiles: [`src/${tid}.ts`],
+        sequence: tseq,
+      });
+    }
+  }
+}
+
+test("plan-v2 batched compile preserves node ids, order, and count", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, true);
+
+  const graph = JSON.parse(readFileSync(compiled.graphPath ?? "", "utf-8")) as {
+    nodes: Array<{ id: string }>;
+  };
+  assert.deepEqual(
+    graph.nodes.map((n) => n.id),
+    [
+      "execute-task:M001:S01:T01",
+      "execute-task:M001:S01:T02",
+      "complete-slice:M001:S01",
+      "execute-task:M001:S02:T03",
+      "execute-task:M001:S02:T04",
+      "complete-slice:M001:S02",
+    ],
+  );
+});
+
+test("plan-v2 skips the disk write when the graph is unchanged", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(first.ok, true);
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+
+  // Backdate mtime so a rewrite is detectable even within the same millisecond.
+  utimesSync(graphPath, 1000, 1000);
+  const backdatedMtime = statSync(graphPath).mtimeMs;
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.equal(statSync(graphPath).mtimeMs, backdatedMtime, "identical state must not rewrite the graph");
+  assert.equal(readFileSync(graphPath, "utf-8"), before);
+});
+
+test("plan-v2 rewrites the graph when it changes", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+  utimesSync(graphPath, 1000, 1000);
+
+  insertTask({
+    id: "T05",
+    milestoneId: MILESTONE_ID,
+    sliceId: "S02",
+    title: "Added task",
+    status: "pending",
+    keyFiles: ["src/T05.ts"],
+    sequence: 3,
+  });
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.notEqual(statSync(graphPath).mtimeMs, 1000000, "changed graph must rewrite");
+  assert.notEqual(readFileSync(graphPath, "utf-8"), before);
+});
+
 test("plan-v2 allows empty graph for milestone terminal phases", () => {
   const basePath = createBasePath();
   writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");

package/src/resources/extensions/gsd/tests/validate-milestone-prompt-verification-classes.test.ts

@@ -22,3 +22,10 @@ test("validate-milestone prompt routes verification class analysis into verifica
   assert.match(prompt, /If Reviewer C omitted a planned class, reconstruct the missing row/i);
   assert.match(prompt, /Do not call `gsd_validate_milestone` with a partial `verificationClasses` table/i);
 });
+
+test("validate-milestone prompt forbids reading phase directories as files", () => {
+  assert.match(prompt, /find \.gsd -type f/i);
+  assert.match(prompt, /\.gsd\/phases\/<NN>-<slug>\/` is a directory, not an artifact/i);
+  assert.match(prompt, /never pass a phase, slice, `tasks\/`, or `slices\/` directory/i);
+  assert.doesNotMatch(prompt, /Read a full SUMMARY under `\.gsd\/milestones\/\{\{milestoneId\}\}\/slices\/`/i);
+});

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

@@ -94,6 +94,8 @@ test("complete-slice requires status, closeout, and execution handoff tools", ()
     "gsd_slice_complete",
     "gsd_task_reopen",
     "gsd_replan_slice",
+    "gsd_replan_task",
+    "gsd_rework_brief_save",
     "gsd_requirement_update",
     "gsd_summary_save",
   ];