@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.6ccd27b3

package/src/resources/extensions/gsd/tests/remote-notification-from-desktop.test.ts

@@ -5,103 +5,53 @@
  * as a fire-and-forget side-effect so that Telegram/Slack/Discord channels
  * receive the same events as native desktop notifications.
  *
- * Testing strategy (structural analysis):
- *   node:test does not support mock.module without --experimental-test-module-mocks,
- *   so we use the same source-code structural approach established in this codebase
- *   (see session-start-footer.test.ts). We read notifications.ts and assert that:
- *     1. It imports sendRemoteNotification from the remote-questions/notify module.
- *     2. The sendDesktopNotification function body calls sendRemoteNotification
- *        with title and message as arguments.
- *     3. The call uses the void fire-and-forget pattern with a .catch(() => {})
- *        suppressor so that async failures never break the synchronous caller.
+ * Testing strategy (behavioral):
+ *   Import sendDesktopNotification and the swappable remoteNotificationDispatcher.
+ *   Mock the dispatcher's send method, call sendDesktopNotification, and assert
+ *   that the dispatcher received the same title/message and that the call is
+ *   fire-and-forget (the function returns without awaiting).
  *
  * Relates to #4341.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const SOURCE = readFileSync(join(__dirname, "..", "notifications.ts"), "utf-8");
+import {
+  sendDesktopNotification,
+  remoteNotificationDispatcher,
+} from "../notifications.js";
 
-test("notifications.ts imports sendRemoteNotification from remote-questions/notify", () => {
-  const hasImport =
-    SOURCE.includes('from "../remote-questions/notify.js"') ||
-    SOURCE.includes("from '../remote-questions/notify.js'");
-  assert.ok(
-    hasImport,
-    "notifications.ts must import from '../remote-questions/notify.js'",
-  );
-
-  const importLine = SOURCE.split("\n").find(
-    (line) =>
-      line.includes("sendRemoteNotification") &&
-      (line.includes("remote-questions/notify") || line.includes("remote-questions/notify.js")),
-  );
-  assert.ok(
-    importLine,
-    "The import statement must include sendRemoteNotification from the remote-questions/notify module",
-  );
-});
-
-test("sendDesktopNotification calls sendRemoteNotification(title, message)", () => {
-  // Extract the body of sendDesktopNotification — from its opening brace to the
-  // closing brace at the same indentation level.
-  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
-  assert.ok(fnStart > -1, "sendDesktopNotification must be present in notifications.ts");
+test("sendDesktopNotification calls sendRemoteNotification with title and message", async (t) => {
+  const sendMock = t.mock.method(remoteNotificationDispatcher, "send", async () => {});
 
-  // Find the next exported function/const after sendDesktopNotification to bound the search.
-  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
-  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
-
-  assert.ok(
-    fnBody.includes("sendRemoteNotification"),
-    "sendDesktopNotification must call sendRemoteNotification",
-  );
+  sendDesktopNotification("Test Title", "Test Message");
 
-  assert.ok(
-    fnBody.includes("sendRemoteNotification(title") || fnBody.includes("sendRemoteNotification(title,"),
-    "sendRemoteNotification must be called with title as first argument",
-  );
+  assert.equal(sendMock.mock.callCount(), 1);
+  assert.deepEqual(sendMock.mock.calls[0].arguments, ["Test Title", "Test Message"]);
 });
 
-test("sendRemoteNotification is invoked as void fire-and-forget with .catch(() => {})", () => {
-  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
-  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
-  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+test("sendDesktopNotification does not await the remote notification", async (t) => {
+  const sendMock = t.mock.method(remoteNotificationDispatcher, "send", async () => {});
 
-  assert.ok(
-    fnBody.includes("void sendRemoteNotification("),
-    "sendRemoteNotification must be called with void (fire-and-forget)",
-  );
+  const result = sendDesktopNotification("Async Title", "Async Message");
 
-  assert.ok(
-    fnBody.includes(".catch("),
-    "sendRemoteNotification call must be followed by .catch() to suppress unhandled-rejection warnings",
-  );
+  assert.equal(result, undefined, "sendDesktopNotification must return void");
+  assert.equal(sendMock.mock.callCount(), 1);
 });
 
-test("sendRemoteNotification call appears before shouldSendDesktopNotification guard", () => {
-  // Regression guard for the HIGH-severity bug where remote notifications were
-  // gated behind the desktop-notification preference check. Users who disable
-  // desktop notifications must still receive Telegram/Slack/Discord messages.
-  const fnStart = SOURCE.indexOf("export function sendDesktopNotification(");
-  assert.ok(fnStart > -1, "sendDesktopNotification must be present in notifications.ts");
-
-  const nextExportIdx = SOURCE.indexOf("\nexport ", fnStart + 1);
-  const fnBody = nextExportIdx > -1 ? SOURCE.slice(fnStart, nextExportIdx) : SOURCE.slice(fnStart);
+test("sendDesktopNotification fires remote notification even when desktop notifications are disabled", async (t) => {
+  const sendMock = t.mock.method(remoteNotificationDispatcher, "send", async () => {});
 
-  const remoteCallIdx = fnBody.indexOf("sendRemoteNotification(");
-  const guardIdx = fnBody.indexOf("shouldSendDesktopNotification(");
-
-  assert.ok(remoteCallIdx > -1, "sendRemoteNotification must be called inside sendDesktopNotification");
-  assert.ok(guardIdx > -1, "shouldSendDesktopNotification guard must be present inside sendDesktopNotification");
-
-  assert.ok(
-    remoteCallIdx < guardIdx,
-    `sendRemoteNotification (pos ${remoteCallIdx}) must appear BEFORE the shouldSendDesktopNotification guard (pos ${guardIdx}) so that remote channels fire even when desktop notifications are disabled`,
+  sendDesktopNotification(
+    "Remote Title",
+    "Remote Message",
+    "info",
+    "complete",
+    undefined,
+    { notifications: { enabled: false } },
   );
+
+  assert.equal(sendMock.mock.callCount(), 1);
+  assert.deepEqual(sendMock.mock.calls[0].arguments, ["Remote Title", "Remote Message"]);
 });

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -200,6 +200,74 @@ test("parseRoadmapSlices: checkbox slices with pipe characters do not switch to
   assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
 });
 
+test("parseRoadmapSlices: demo markdown table does not switch checkbox roadmap to table mode (#721)", () => {
+  const checkboxWithDemoTable = [
+    "# M004: Demo Table Repro",
+    "",
+    "## Slices",
+    "",
+    "- [x] **S01: First** `risk:low` `depends:[]`",
+    "  > After this: cli can render examples:",
+    "| Example | Meaning |",
+    "| --- | --- |",
+    "| S01 | Not a roadmap row |",
+    "- [ ] **S02: Second** `risk:medium` `depends:[S01]`",
+    "  > After this: cat file | sort returns stable output.",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(checkboxWithDemoTable);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "First");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+});
+
+test("parseRoadmapSlices: table preceded by intro prose still parsed as table (#722)", () => {
+  const tableWithIntro = [
+    "# M005: Intro Before Table",
+    "",
+    "## Slices",
+    "",
+    "This milestone is broken into the following slices:",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| --- | --- | --- | --- |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithIntro);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: table without markdown separator row still parsed as table (#722)", () => {
+  const tableWithoutSeparator = [
+    "# M006: No Separator",
+    "",
+    "## Slices",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithoutSeparator);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
 // --- Prose slice header completion marker tests (#1803) ---
 
 test("parseRoadmapSlices: prose headers with ✓ marker detected as done", () => {

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

@@ -6,7 +6,11 @@ import assert from "node:assert/strict";
 
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
-import { compileUnitContextContract, compileUnitToolContract } from "../tool-contract.js";
+import {
+  compileUnitContextContract,
+  compileUnitToolContract,
+  getUnitWorkflowDispatchReadinessError,
+} from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
@@ -63,7 +67,13 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
 
   assert.equal(result.ok, true);
   assert.equal(result.ok && result.contract.unitType, "execute-task");
-  assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, ["gsd_task_complete"]);
+  assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, [
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_capture_thought",
+  ]);
   assert.deepEqual(result.ok && result.contract.forbiddenWorkflowTools, []);
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
@@ -87,6 +97,20 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   });
 });
 
+test("Tool Contract derives dispatch readiness from Unit workflow tools", () => {
+  const error = getUnitWorkflowDispatchReadinessError({
+    provider: "claude-code",
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+  });
+
+  assert.equal(error, null);
+});
+
 test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
   const result = compileUnitContextContract("execute-task");
 
@@ -164,6 +188,7 @@ test("Recovery Classification covers ADR-015 failure families", () => {
   const cases = [
     ["invalid tool schema enum", "tool-schema", "stop"],
     ["Tool Contract failure: complete-slice cannot use gsd_uat_result_save", "tool-contract", "stop"],
+    ["No such tool available: mcp__gsd-workflow__gsd_uat_exec", "tool-unavailable", "retry"],
     ["deterministic policy rejection", "deterministic-policy", "stop"],
     ["cannot legally advance because required UAT Assessment artifact is missing", "lifecycle-progression", "stop"],
     ["stale worker lease", "stale-worker", "stop"],

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -266,3 +266,41 @@ test("safety-harness: planned changed file avoids unexpected-file warning", (t)
   assert.deepEqual(audit!.unexpectedFiles, [], "planned index.html must not be unexpected");
   assert.deepEqual(audit!.missingFiles, [], "planned index.html must not be missing");
 });
+
+// ─── External engine evidence (claude-code-cli pre-executed tools) ──────────
+// External engines skip beforeToolCall/tool_call, so register-hooks.ts records
+// evidence at tool_execution_start instead. These tests lock the collector
+// semantics that wiring relies on: idempotent recording by toolCallId, and
+// capitalized external tool names (Bash/Write/Edit) being recognized.
+
+test("safety-harness: recordToolCall is idempotent by toolCallId", () => {
+  resetEvidence();
+
+  // Native tools fire tool_execution_start AND tool_call — both record.
+  recordToolCall("tc-dup-1", "bash", { command: "npm test" });
+  recordToolCall("tc-dup-1", "bash", { command: "npm test" });
+
+  assert.equal(getEvidence().length, 1, "same toolCallId must not duplicate");
+});
+
+test("safety-harness: external capitalized Bash call records and resolves evidence", () => {
+  resetEvidence();
+
+  // tool_execution_start with Claude Code's native tool name
+  recordToolCall("ext-bash-1", "Bash", { command: "node /tmp/t01-verify.mjs" });
+  const entries = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(entries.length, 1, "capitalized Bash must be recognized as execution tool");
+  assert.equal(entries[0]!.command, "node /tmp/t01-verify.mjs");
+
+  // tool_execution_end fills the result
+  recordToolResult("ext-bash-1", "Bash", { content: [{ type: "text", text: "13 checks passed" }] }, false);
+  assert.equal(entries[0]!.exitCode, 0, "non-error external result resolves to exitCode 0");
+});
+
+test("safety-harness: external Write call records file evidence", () => {
+  resetEvidence();
+
+  recordToolCall("ext-write-1", "Write", { file_path: "/tmp/app/index.html" });
+  const writes = getEvidence().filter((e) => e.kind === "write");
+  assert.equal(writes.length, 1, "capitalized Write must record file evidence");
+});

package/src/resources/extensions/gsd/tests/session-switch-clears-pending-autostart.test.ts

@@ -0,0 +1,108 @@
+// gsd-pi — A fresh conversation (/clear, /new) must clear pending auto-start.
+//
+// The discuss→auto handoff entry lives in-memory and is consumed on agent_end
+// of the live interview. Once the milestone CONTEXT artifact is saved, the
+// guided-flow staleness heuristic (which requires the CONTEXT file to be
+// absent) can never fire — so a discussion interrupted by /clear left an
+// immortal entry and every subsequent /gsd dead-ended on "Discussion already
+// in progress — answer the question above" with no question above.
+//
+// session_switch with reason "new" means the conversation that contained the
+// interview is gone; the entry must go with it. Reason "resume" restores the
+// interview transcript, so the entry must survive.
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  _getPendingAutoStart,
+} from "../pending-auto-start.ts";
+
+function makeProjectDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-switch-pas-"));
+  const milestoneDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  // The post-CONTEXT state that made the entry immortal before the fix.
+  writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# M001 Context\n");
+  return dir;
+}
+
+function fakeCtx(base: string): any {
+  return {
+    cwd: base,
+    ui: {
+      notify: () => undefined,
+      setWidget: () => undefined,
+      setStatus: () => undefined,
+    },
+  };
+}
+
+function armPendingAutoStart(base: string): void {
+  setPendingAutoStart(base, {
+    basePath: base,
+    milestoneId: "M001",
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  });
+}
+
+describe("session_switch clears pending auto-start on conversation reset", () => {
+  let base: string;
+  const handlers = new Map<string, Function>();
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    base = makeProjectDir();
+    handlers.clear();
+    registerHooks({ on(event: string, handler: Function) { handlers.set(event, handler); } } as any, []);
+  });
+
+  afterEach(() => {
+    clearPendingAutoStart();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  async function fireSessionSwitch(reason: "new" | "resume"): Promise<void> {
+    const handler = handlers.get("session_switch");
+    assert.ok(handler, "session_switch handler should be registered");
+    try {
+      await handler({ type: "session_switch", reason, previousSessionFile: undefined }, fakeCtx(base));
+    } catch {
+      // The handler also performs session plumbing (MCP prep, service tier
+      // sync) that may throw against the minimal fake ctx. Pending auto-start
+      // is cleared before that plumbing runs, so the assertions below remain
+      // valid either way.
+    }
+  }
+
+  it('reason "new" (/clear, /new) drops the entry even after CONTEXT was saved', async () => {
+    armPendingAutoStart(base);
+    assert.ok(_getPendingAutoStart(base), "entry should be armed");
+
+    await fireSessionSwitch("new");
+
+    assert.equal(
+      _getPendingAutoStart(base),
+      null,
+      "a fresh conversation destroyed the interview — the handoff entry must not outlive it",
+    );
+  });
+
+  it('reason "resume" keeps the entry (the interview transcript is restored)', async () => {
+    armPendingAutoStart(base);
+
+    await fireSessionSwitch("resume");
+
+    assert.ok(
+      _getPendingAutoStart(base),
+      "resuming restores the interview — the in-flight handoff must survive",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/single-writer-invariant.test.ts

@@ -24,10 +24,24 @@ import { join, relative } from "node:path";
 
 const gsdDir = join(process.cwd(), "src/resources/extensions/gsd");
 
-const ALLOWLIST = new Set([
-  "gsd-db.ts",
-  "unit-ownership.ts",
-]);
+// The single-writer invariant is enforced on a directory layer, not a single
+// filename. Write SQL may live only in:
+//   - db/engine.ts — connection lifecycle, schema/migrations (DDL), and the
+//     BEGIN/COMMIT transaction primitives. The shared handle every writer reads.
+//   - db/writers/**.ts — the Single Writer Layer: one cohesive write subsystem
+//     per file (hierarchy, memory, gates, escalation, reconcile, manifest,
+//     legacy-import, cascades).
+//   - gsd-db.ts — the barrel that re-exports the layer (still holds wrappers
+//     mid-migration).
+//   - unit-ownership.ts — a separate .gsd/unit-claims.db, intentionally outside.
+// db/queries.ts is explicitly NOT allowed write SQL (asserted separately below).
+function isSingleWriterFile(rel: string): boolean {
+  const norm = rel.split("\\").join("/");
+  if (norm === "gsd-db.ts" || norm === "unit-ownership.ts") return true;
+  if (norm === "db/engine.ts") return true;
+  if (norm.startsWith("db/writers/") && norm.endsWith(".ts")) return true;
+  return false;
+}
 
 /** Walk the gsd extension dir and return all .ts files outside tests/. */
 function walkTsFiles(root: string): string[] {
@@ -106,8 +120,7 @@ test("no module outside gsd-db.ts issues raw write SQL against the engine DB", (
 
   for (const abs of files) {
     const rel = relative(gsdDir, abs);
-    const base = rel.split("/").pop()!;
-    if (ALLOWLIST.has(base)) continue;
+    if (isSingleWriterFile(rel)) continue;
 
     let content: string;
     try {
@@ -154,6 +167,30 @@ test("no module outside gsd-db.ts issues raw write SQL against the engine DB", (
   }
 });
 
+test("db/queries.ts (the Query Module) is read-only — contains no write SQL", () => {
+  // The read seam is separate from the single-writer layer. queries.ts holds
+  // SELECT-only wrappers so read-only callers depend on a read seam, not the
+  // write surface. (test 1 above also forbids this, since queries.ts is not in
+  // db/writers/ — this is the explicit, positive statement of intent.)
+  const queriesPath = join(gsdDir, "db", "queries.ts");
+  const content = readFileSync(queriesPath, "utf-8");
+  const lines = content.split("\n");
+  const violations: Violation[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = PREPARE_WRITE_RE.exec(line) ?? EXEC_WRITE_RE.exec(line);
+    if (m) {
+      violations.push({ file: "db/queries.ts", line: i + 1, snippet: line.trim(), kind: m[1].toUpperCase() });
+    }
+  }
+  assert.equal(
+    violations.length,
+    0,
+    `db/queries.ts must contain no write SQL — move write wrappers to db/writers/:\n` +
+      violations.map((v) => `  db/queries.ts:${v.line} [${v.kind}] — ${v.snippet}`).join("\n"),
+  );
+});
+
 test("gsd-db.ts exports the expected single-writer wrappers", async () => {
   // Positive assertion — fail loudly if the module layout changes so this
   // structural test can't silently become a no-op.

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -92,14 +92,14 @@ test("buildSkillActivationBlock activates skills via prefer_skills when context
       prefer_skills: ["react"],
     });
 
-    assert.match(result, /Call Skill\(\{ skill: 'react' \}\)/);
+    assert.match(result, /Read the installed 'react' skill file from <available_skills>/);
     assert.doesNotMatch(result, /swiftui/);
   } finally {
     cleanup(base);
   }
 });
 
-test("buildSkillActivationBlock includes always_use_skills from preferences using exact Skill tool format", () => {
+test("buildSkillActivationBlock includes always_use_skills using read-based skill loading", () => {
   const base = makeTempBase();
   try {
     writeSkill(base, "swift-testing", "Use for Swift Testing assertions and verification patterns.");
@@ -109,7 +109,10 @@ test("buildSkillActivationBlock includes always_use_skills from preferences usin
       always_use_skills: ["swift-testing"],
     });
 
-    assert.equal(result, "<skill_activation>Call Skill({ skill: 'swift-testing' }).</skill_activation>");
+    assert.equal(
+      result,
+      "<skill_activation>Read the installed 'swift-testing' skill file from <available_skills>.</skill_activation>",
+    );
   } finally {
     cleanup(base);
   }
@@ -137,8 +140,8 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
       skill_rules: [{ when: "prisma database schema", use: ["prisma"] }],
     });
 
-    assert.match(result, /Call Skill\(\{ skill: 'accessibility' \}\)/);
-    assert.match(result, /Call Skill\(\{ skill: 'prisma' \}\)/);
+    assert.match(result, /Read the installed 'accessibility' skill file from <available_skills>/);
+    assert.match(result, /Read the installed 'prisma' skill file from <available_skills>/);
   } finally {
     cleanup(base);
   }
@@ -160,7 +163,7 @@ test("buildSkillActivationBlock matches skill_rules against exact unit type cont
       ],
     });
 
-    assert.match(result, /Call Skill\(\{ skill: 'complete-slice-policies' \}\)/);
+    assert.match(result, /Read the installed 'complete-slice-policies' skill file from <available_skills>/);
     assert.doesNotMatch(result, /slice-broad/);
   } finally {
     cleanup(base);
@@ -264,8 +267,8 @@ test("buildSkillActivationBlock allows valid skill names and rejects invalid one
     });
 
     assert.match(result, /skill_activation/);
-    assert.match(result, /Call Skill\(\{ skill: 'react' \}\)/);
-    assert.match(result, /Call Skill\(\{ skill: 'good-skill-2' \}\)/);
+    assert.match(result, /Read the installed 'react' skill file from <available_skills>/);
+    assert.match(result, /Read the installed 'good-skill-2' skill file from <available_skills>/);
     assert.doesNotMatch(result, /bad'name/);
   } finally {
     cleanup(base);
@@ -289,8 +292,8 @@ test("buildSkillActivationBlock: explicit always_use_skills bypass the unit-type
       always_use_skills: ["write-docs", "swiftui"],
     });
 
-    assert.match(result, /Call Skill\(\{ skill: 'write-docs' \}\)/);
-    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+    assert.match(result, /Read the installed 'write-docs' skill file from <available_skills>/);
+    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
   } finally {
     cleanup(base);
   }
@@ -307,7 +310,7 @@ test("buildSkillActivationBlock falls through to all skills for unknown unit typ
     });
 
     // Unknown unit type = wildcard fallback (pre-manifest behavior).
-    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
   } finally {
     cleanup(base);
   }
@@ -324,7 +327,7 @@ test("buildSkillActivationBlock without unitType preserves pre-manifest behavior
       always_use_skills: ["swiftui"],
     });
 
-    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
   } finally {
     cleanup(base);
   }
@@ -341,12 +344,12 @@ test("milestone prompt builders propagate always_use_skills through buildSkillAc
     loadOnlyTestSkills(base);
 
     const researchPrompt = await buildResearchMilestonePrompt("M001", "Test", base);
-    assert.match(researchPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
-    assert.match(researchPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+    assert.match(researchPrompt, /Read the installed 'write-docs' skill file from <available_skills>/);
+    assert.match(researchPrompt, /Read the installed 'swiftui' skill file from <available_skills>/);
 
     const planPrompt = await buildPlanMilestonePrompt("M001", "Test", base);
-    assert.match(planPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
-    assert.match(planPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+    assert.match(planPrompt, /Read the installed 'write-docs' skill file from <available_skills>/);
+    assert.match(planPrompt, /Read the installed 'swiftui' skill file from <available_skills>/);
   } finally {
     cleanup(base);
   }
@@ -377,7 +380,7 @@ test("complete-slice prompt propagates always_use_skills through buildSkillActiv
 
     const prompt = await buildCompleteSlicePrompt("M001", "Test", "S01", "Slice", base);
 
-    assert.match(prompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(prompt, /Read the installed 'write-docs' skill file from <available_skills>/);
   } finally {
     cleanup(base);
   }

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

@@ -339,7 +339,7 @@ test("resume path only hard-exits on blocked stop, not blocked pause (#6154)", (
   );
 });
 
-test("prepareForUnit skips worktree safety when isolation is not worktree (#6154)", () => {
+test("prepareForUnit enforces worktree safety for all isolation modes (#6154)", () => {
   const orchSrc = readGsdFile("auto/orchestrator.ts");
   const prepareForUnitIdx = orchSrc.indexOf("private async prepareWorktreeForUnit(");
   const prepareForUnitBody = orchSrc.slice(prepareForUnitIdx, orchSrc.indexOf("private classifyAndRecover(", prepareForUnitIdx));
@@ -350,8 +350,12 @@ test("prepareForUnit skips worktree safety when isolation is not worktree (#6154
     "prepareForUnit should resolve the effective isolation mode once",
   );
   assert.ok(
-    prepareForUnitBody.includes('if (isolationMode !== "worktree")'),
-    "prepareForUnit should bypass worktree safety validation outside worktree isolation mode",
+    prepareForUnitBody.includes('const writeScope ='),
+    "prepareForUnit should classify the unit's write scope before validating",
+  );
+  assert.ok(
+    !prepareForUnitBody.includes('if (isolationMode !== "worktree")'),
+    "prepareForUnit must not bypass worktree safety outside worktree isolation mode",
   );
 });