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

package/src/resources/extensions/gsd/tests/reassess-handler.test.ts

@@ -210,6 +210,56 @@ test('handleReassessRoadmap succeeds when modifying only pending slices', async
   }
 });
 
+test('handleReassessRoadmap writes legacy-layout reassessment to S##-ASSESSMENT.md', async () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reassess-legacy-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M005-3qxqd7', 'slices', 'S04'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '05-3qxqd7-legacy-milestone'), { recursive: true });
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M005-3qxqd7', title: 'Legacy Milestone', status: 'active' });
+    insertSlice({
+      id: 'S04',
+      milestoneId: 'M005-3qxqd7',
+      title: 'Legacy Slice Four',
+      status: 'complete',
+      demo: 'Demo four.',
+    });
+
+    const result = await handleReassessRoadmap({
+      milestoneId: 'M005-3qxqd7',
+      completedSliceId: 'S04',
+      verdict: 'confirmed',
+      assessment: 'S04 completed successfully. Roadmap remains valid.',
+      sliceChanges: {
+        modified: [],
+        added: [],
+        removed: [],
+      },
+    }, base);
+
+    if ('error' in result) {
+      assert.fail(`unexpected error: ${result.error}`);
+    }
+
+    const correctPath = join(base, '.gsd', 'milestones', 'M005-3qxqd7', 'slices', 'S04', 'S04-ASSESSMENT.md');
+    const wrongFlatNameInLegacyDir = join(base, '.gsd', 'milestones', 'M005-3qxqd7', 'slices', 'S04', '05-04-ASSESSMENT.md');
+    const wrongFlatPhasePath = join(base, '.gsd', 'phases', '05-3qxqd7-legacy-milestone', '05-04-ASSESSMENT.md');
+    assert.match(
+      result.assessmentPath.replace(/\\/g, '/'),
+      /\/\.gsd\/milestones\/M005-3qxqd7\/slices\/S04\/S04-ASSESSMENT\.md$/,
+    );
+    assert.ok(existsSync(correctPath), 'legacy ASSESSMENT should use S## filename inside slices/S##/');
+    assert.equal(existsSync(wrongFlatNameInLegacyDir), false, 'legacy slice dir must not receive flat-phase assessment filename');
+    assert.equal(existsSync(wrongFlatPhasePath), false, 'legacy reassessment must not be diverted to a coexisting flat-phase dir');
+
+    const assessment = getAssessment('.gsd/milestones/M005-3qxqd7/slices/S04/S04-ASSESSMENT.md');
+    assert.ok(assessment, 'assessment row should use the legacy-layout path');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handleReassessRoadmap cache invalidation: getMilestoneSlices reflects mutations', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/register-hooks-loop-guard-auto.test.ts

@@ -6,8 +6,10 @@ import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
 import { autoSession } from "../auto-runtime-state.ts";
+import { postUnitPreVerification } from "../auto-post-unit.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 import { resetToolCallLoopGuard } from "../bootstrap/tool-call-loop-guard.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
 import { readUnitHarnessAbort } from "../unit-runtime.ts";
 
 type Handler = (event: any, ctx?: any) => Promise<any> | any;
@@ -166,6 +168,109 @@ test("register-hooks does not record normal product tool failures as harness abo
   assert.equal(abort, null);
 });
 
+test("tool_execution_end latches a failed ScheduleWakeup across unrelated tool success", async (t) => {
+  const base = makeRuntimeBase();
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "discuss-milestone", id: "M001", startedAt: Date.now() };
+  t.after(() => {
+    closeDatabase();
+    autoSession.reset();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  const error = "`prompt` is required when `stop` is not true";
+
+  await emitToolExecutionEnd({
+    toolName: "ScheduleWakeup",
+    isError: true,
+    result: error,
+  });
+  assert.equal(autoSession.lastToolInvocationError, `ScheduleWakeup: ${error}`);
+
+  await emitToolExecutionEnd({
+    toolName: "read",
+    isError: false,
+    result: "file contents",
+  });
+  assert.equal(
+    autoSession.lastToolInvocationError,
+    `ScheduleWakeup: ${error}`,
+    "an unrelated success must not erase a failed continuation before the unit boundary",
+  );
+
+  await emitToolExecutionEnd({
+    toolName: "parse_payload",
+    isError: true,
+    result: "Unexpected end of JSON input",
+  });
+  assert.equal(
+    autoSession.lastToolInvocationError,
+    `ScheduleWakeup: ${error}`,
+    "a later invocation error must not replace the failed continuation",
+  );
+
+  let pauseCalled = false;
+  const notifications: Array<{ message: string; severity?: string }> = [];
+  const result = await postUnitPreVerification(
+    {
+      s: autoSession,
+      ctx: {
+        ui: {
+          notify: (message: string, severity?: string) => notifications.push({ message, severity }),
+        },
+      } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => { pauseCalled = true; },
+      updateProgressWidget: () => {},
+    },
+    { skipSettleDelay: true, skipWorktreeSync: true },
+  );
+
+  assert.equal(result, "dispatched");
+  assert.equal(pauseCalled, true);
+  assert.equal(autoSession.pendingVerificationRetry, null);
+  assert.ok(
+    notifications.some(({ message, severity }) => severity === "error" && message.includes(error)),
+    "the unit boundary must surface the rejected continuation",
+  );
+  assert.equal(autoSession.lastToolInvocationError, null);
+
+  await emitToolExecutionEnd({
+    toolName: "ScheduleWakeup",
+    isError: true,
+    result: error,
+  });
+  await emitToolExecutionEnd({
+    toolName: "ScheduleWakeup",
+    isError: false,
+    result: "Wakeup scheduled",
+  });
+  assert.equal(autoSession.lastToolInvocationError, null);
+});
+
+test("tool_execution_end ignores ScheduleWakeup-shaped business validation from other tools", async (t) => {
+  autoSession.reset();
+  autoSession.active = true;
+  t.after(() => autoSession.reset());
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "submit_review",
+    isError: true,
+    result: "`prompt` is required when `stop` is not true",
+  });
+
+  assert.equal(autoSession.lastToolInvocationError, null);
+});
+
 test("register-hooks does not classify normal gsd_uat_exec nonzero exits as harness aborts", async (t) => {
   const base = makeRuntimeBase();
   const startedAt = Date.now();

package/src/resources/extensions/gsd/tests/replan-task-handler.test.ts

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  upsertTaskPlanning,
+  getTask,
+  getReplanHistory,
+} from '../gsd-db.ts';
+import { handleReplanTask } from '../tools/replan-task.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-replan-task-'));
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+function seedTask(status = 'pending'): void {
+  insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'active', demo: 'Demo.' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Original Task', status });
+  upsertTaskPlanning('M001', 'S01', 'T01', {
+    description: 'Original task description.',
+    estimate: '30m',
+    files: ['src/original.ts'],
+    verify: 'node --test original.test.ts',
+    inputs: ['src/original.ts'],
+    expectedOutput: ['src/original.ts'],
+  });
+}
+
+function validReplanTaskParams() {
+  return {
+    milestoneId: 'M001',
+    sliceId: 'S01',
+    taskId: 'T01',
+    title: 'Replanned Task',
+    description: 'Updated task description with blocking rework scope.',
+    estimate: '45m',
+    files: ['src/replanned.ts'],
+    verify: 'node --test replanned.test.ts',
+    inputs: ['src/original.ts'],
+    expectedOutput: ['src/replanned.ts'],
+    reworkBriefRef: 'RB-001',
+  };
+}
+
+test('handleReplanTask updates one pending task plan and records a task-scoped replan history entry', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedTask('pending');
+
+    const result = await handleReplanTask(validReplanTaskParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const task = getTask('M001', 'S01', 'T01');
+    assert.ok(task, 'task should still exist');
+    assert.equal(task.title, 'Replanned Task');
+    assert.equal(task.description, 'Updated task description with blocking rework scope.');
+    assert.equal(task.verify, 'node --test replanned.test.ts');
+    assert.deepEqual(task.files, ['src/replanned.ts']);
+
+    const history = getReplanHistory('M001', 'S01');
+    assert.ok(history.some((row) => row['task_id'] === 'T01' && String(row['summary']).includes('RB-001')));
+
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-01-PLAN.md');
+    assert.ok(existsSync(planPath), 'slice plan projection should be rendered');
+    const planContent = readFileSync(planPath, 'utf-8');
+    assert.match(planContent, /Replanned Task/);
+    assert.match(planContent, /node --test replanned\.test\.ts/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReplanTask rejects completed tasks', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedTask('complete');
+
+    const result = await handleReplanTask(validReplanTaskParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /cannot replan completed task T01/i);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/rework-brief.test.ts

@@ -0,0 +1,197 @@
+import { createTestContext } from './test-helpers.ts';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+  type ReworkBriefFindingInput,
+} from '../gsd-db.ts';
+import { handleReworkBriefSave } from '../tools/rework-brief.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-rework-brief-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanup(dbPath: string): void {
+  closeDatabase();
+  try {
+    const dir = path.dirname(dbPath);
+    for (const f of fs.readdirSync(dir)) fs.unlinkSync(path.join(dir, f));
+    fs.rmdirSync(dir);
+  } catch {
+    // best effort
+  }
+}
+
+function finding(overrides: Partial<ReworkBriefFindingInput> = {}): ReworkBriefFindingInput {
+  return {
+    findingId: 'F1',
+    severity: 'blocking',
+    description: 'Compile regression',
+    requiredFix: 'Fix compile error',
+    verificationCommands: ['pnpm run typecheck:extensions'],
+    ...overrides,
+  };
+}
+
+const baseParams = {
+  briefId: 'RB-001',
+  milestoneId: 'M001',
+  sliceId: 'S01',
+  taskId: 'T01',
+};
+
+function findingRow(): { status: string; evidence: string; decision_ref: string } | undefined {
+  return _getAdapter()!
+    .prepare("SELECT status, evidence, decision_ref FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'")
+    .get() as { status: string; evidence: string; decision_ref: string } | undefined;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// rework-brief: a blocking finding saved as non-pending must carry the same
+// justification a reworkResolution would, otherwise it bypasses the
+// gsd_task_complete blocking gate (which only sees `pending` rows).
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== rework-brief: rejects blocking resolved finding without evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'resolved' })],
+  });
+
+  assertTrue('error' in result, 'blocking resolved finding without evidence should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /evidence is required/i, 'error should mention the evidence requirement');
+  }
+  const rows = _getAdapter()!.prepare('SELECT COUNT(*) AS n FROM rework_brief_findings').get() as { n: number };
+  assertEq(rows.n, 0, 'no finding rows should be persisted when validation fails');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: rejects blocking deferred-with-override without decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'deferred-with-override', evidence: 'Maintainer accepted temporary deferral.' })],
+  });
+
+  assertTrue('error' in result, 'deferred-with-override without decisionRef should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /decisionRef is required/i, 'error should mention the decisionRef requirement');
+  }
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: rejects invalid finding status ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'bogus' as unknown as ReworkBriefFindingInput['status'] })],
+  });
+
+  assertTrue('error' in result, 'an unknown status value should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /status must be/i, 'error should name the allowed statuses');
+  }
+
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// rework-brief: legitimate saves still succeed.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== rework-brief: blocking finding defaults to pending ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding()],
+  });
+
+  assertTrue(!('error' in result), 'a blocking finding without a status should be accepted');
+  assertEq(findingRow()?.status, 'pending', 'finding without status should default to pending');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: accepts blocking resolved finding with evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'resolved', evidence: 'Fixed compile error and reran pnpm run typecheck:extensions.' })],
+  });
+
+  assertTrue(!('error' in result), 'a resolved blocking finding with evidence should be accepted');
+  assertEq(findingRow()?.status, 'resolved', 'finding should persist as resolved when evidence is supplied');
+  assertMatch(findingRow()?.evidence ?? '', /Fixed compile error/, 'resolution evidence should be persisted');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: accepts blocking deferred-with-override with evidence and decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({
+      status: 'deferred-with-override',
+      evidence: 'Maintainer accepted temporary deferral.',
+      decisionRef: 'DEC-2026-07-07-rework-deferral',
+    })],
+  });
+
+  assertTrue(!('error' in result), 'a deferred-with-override finding with evidence and decisionRef should be accepted');
+  assertEq(findingRow()?.status, 'deferred-with-override', 'finding should persist the override status');
+  assertEq(findingRow()?.decision_ref, 'DEC-2026-07-07-rework-deferral', 'decision reference should be persisted');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: advisory resolved finding does not require evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  // Advisory findings never gate gsd_task_complete, so pre-resolving one
+  // without evidence is harmless and stays permitted.
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ severity: 'advisory', status: 'resolved' })],
+  });
+
+  assertTrue(!('error' in result), 'an advisory resolved finding should be accepted without evidence');
+  assertEq(findingRow()?.status, 'resolved', 'advisory finding status should be preserved');
+
+  cleanup(dbPath);
+}
+
+report();

package/src/resources/extensions/gsd/tests/service-tier.test.ts

@@ -35,6 +35,10 @@ describe("supportsServiceTier", () => {
     assert.equal(supportsServiceTier("gpt-5.5"), false);
   });
 
+  test("returns false for gpt-5.6 until service_tier payload support is verified", () => {
+    assert.equal(supportsServiceTier("gpt-5.6"), false);
+  });
+
   test("returns false for provider-only identifier without gpt-5.4 model suffix", () => {
     assert.equal(supportsServiceTier("vibeproxy-openai"), false);
   });

package/src/resources/extensions/gsd/tests/single-writer-v3-tool-surface.test.ts

@@ -7,8 +7,9 @@
  *      self-identify (Stream 2: actor identity passthrough).
  *
  *   2. The 3 reversibility handlers (reopen-task/slice/milestone) are
- *      registered as MCP tools with both canonical and alias names
- *      (Stream 3: reversibility tools).
+ *      registered as MCP tools under their canonical names, and additionally
+ *      under their alias names when GSD_ADVERTISE_TOOL_ALIASES=1 (plan 035
+ *      suppresses alias schemas by default) (Stream 3: reversibility tools).
  *
  *   3. The reopen tools accept the documented core params plus optional
  *      reason/actorName/triggerReason without rejecting valid payloads.
@@ -36,6 +37,18 @@ function getTool(name: string) {
   return pi.tools.find((t: any) => t.name === name);
 }
 
+function withEnv(name: string, value: string | undefined, fn: () => void): void {
+  const previous = process.env[name];
+  if (value === undefined) delete process.env[name];
+  else process.env[name] = value;
+  try {
+    fn();
+  } finally {
+    if (previous === undefined) delete process.env[name];
+    else process.env[name] = previous;
+  }
+}
+
 function getRequiredProps(tool: any): string[] {
   return tool.parameters.required ?? [];
 }
@@ -78,7 +91,9 @@ for (const name of ACTOR_TOOLS) {
   });
 }
 
-// ─── Stream 3: reopen tools registered with canonical + alias names ─────────
+// ─── Stream 3: reopen tools registered under canonical names ────────────────
+// Plan 035 suppresses alias schemas by default; the canonical reopen tools are
+// always registered, and their aliases only when GSD_ADVERTISE_TOOL_ALIASES=1.
 
 const REOPEN_TOOLS = [
   { canonical: "gsd_task_reopen", alias: "gsd_reopen_task" },
@@ -87,13 +102,24 @@ const REOPEN_TOOLS = [
 ];
 
 for (const { canonical, alias } of REOPEN_TOOLS) {
-  test(`${canonical} — registered with alias ${alias}`, () => {
+  test(`${canonical} — registered under its canonical name, no alias by default`, () => {
     const canonicalTool = getTool(canonical);
-    const aliasTool = getTool(alias);
     assert.ok(canonicalTool, `${canonical} must be registered`);
-    assert.ok(aliasTool, `${alias} must be registered as alias`);
     assert.ok(typeof canonicalTool.execute === "function", `${canonical} must have an execute function`);
-    assert.ok(typeof aliasTool.execute === "function", `${alias} must have an execute function`);
+    assert.ok(!getTool(alias), `${alias} must not be registered by default (plan 035 alias suppression)`);
+  });
+
+  test(`${canonical} — registered with alias ${alias} when GSD_ADVERTISE_TOOL_ALIASES=1`, () => {
+    withEnv("GSD_ADVERTISE_TOOL_ALIASES", "1", () => {
+      const aliasPi = makeMockPi();
+      registerDbTools(aliasPi);
+      const canonicalTool = aliasPi.tools.find((t: any) => t.name === canonical);
+      const aliasTool = aliasPi.tools.find((t: any) => t.name === alias);
+      assert.ok(canonicalTool, `${canonical} must be registered`);
+      assert.ok(aliasTool, `${alias} must be registered as alias`);
+      assert.ok(typeof canonicalTool.execute === "function", `${canonical} must have an execute function`);
+      assert.ok(typeof aliasTool.execute === "function", `${alias} must have an execute function`);
+    });
   });
 }
 

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

@@ -56,6 +56,10 @@ function buildBlock(
   });
 }
 
+function expectedSkillRead(base: string, name: string): string {
+  return `Read the skill file at \`${join(base, "skills", name, "SKILL.md")}\``;
+}
+
 test("buildSkillActivationBlock does not auto-activate skills via broad context heuristic", () => {
   const base = makeTempBase();
   try {
@@ -92,7 +96,7 @@ test("buildSkillActivationBlock activates skills via prefer_skills when context
       prefer_skills: ["react"],
     });
 
-    assert.match(result, /Read the installed 'react' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "react")));
     assert.doesNotMatch(result, /swiftui/);
   } finally {
     cleanup(base);
@@ -111,7 +115,7 @@ test("buildSkillActivationBlock includes always_use_skills using read-based skil
 
     assert.equal(
       result,
-      "<skill_activation>Read the installed 'swift-testing' skill file from <available_skills>.</skill_activation>",
+      `<skill_activation>Read the skill file at \`${join(base, "skills", "swift-testing", "SKILL.md")}\`.</skill_activation>`,
     );
   } finally {
     cleanup(base);
@@ -140,8 +144,8 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
       skill_rules: [{ when: "prisma database schema", use: ["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>/);
+    assert.ok(result.includes(expectedSkillRead(base, "accessibility")));
+    assert.ok(result.includes(expectedSkillRead(base, "prisma")));
   } finally {
     cleanup(base);
   }
@@ -163,7 +167,7 @@ test("buildSkillActivationBlock matches skill_rules against exact unit type cont
       ],
     });
 
-    assert.match(result, /Read the installed 'complete-slice-policies' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "complete-slice-policies")));
     assert.doesNotMatch(result, /slice-broad/);
   } finally {
     cleanup(base);
@@ -267,8 +271,8 @@ test("buildSkillActivationBlock allows valid skill names and rejects invalid one
     });
 
     assert.match(result, /skill_activation/);
-    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.ok(result.includes(expectedSkillRead(base, "react")));
+    assert.ok(result.includes(expectedSkillRead(base, "good-skill-2")));
     assert.doesNotMatch(result, /bad'name/);
   } finally {
     cleanup(base);
@@ -292,8 +296,8 @@ test("buildSkillActivationBlock: explicit always_use_skills bypass the unit-type
       always_use_skills: ["write-docs", "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>/);
+    assert.ok(result.includes(expectedSkillRead(base, "write-docs")));
+    assert.ok(result.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -310,7 +314,7 @@ test("buildSkillActivationBlock falls through to all skills for unknown unit typ
     });
 
     // Unknown unit type = wildcard fallback (pre-manifest behavior).
-    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -327,7 +331,7 @@ test("buildSkillActivationBlock without unitType preserves pre-manifest behavior
       always_use_skills: ["swiftui"],
     });
 
-    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -344,12 +348,12 @@ test("milestone prompt builders propagate always_use_skills through buildSkillAc
     loadOnlyTestSkills(base);
 
     const researchPrompt = await buildResearchMilestonePrompt("M001", "Test", base);
-    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>/);
+    assert.ok(researchPrompt.includes(expectedSkillRead(base, "write-docs")));
+    assert.ok(researchPrompt.includes(expectedSkillRead(base, "swiftui")));
 
     const planPrompt = await buildPlanMilestonePrompt("M001", "Test", base);
-    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>/);
+    assert.ok(planPrompt.includes(expectedSkillRead(base, "write-docs")));
+    assert.ok(planPrompt.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -380,7 +384,7 @@ test("complete-slice prompt propagates always_use_skills through buildSkillActiv
 
     const prompt = await buildCompleteSlicePrompt("M001", "Test", "S01", "Slice", base);
 
-    assert.match(prompt, /Read the installed 'write-docs' skill file from <available_skills>/);
+    assert.ok(prompt.includes(expectedSkillRead(base, "write-docs")));
   } finally {
     cleanup(base);
   }