gsd-pi 2.77.0-dev.1d17f366c → 2.77.0-dev.2daa994b6

package/src/resources/extensions/gsd/tests/run-uat-composer.test.ts

@@ -0,0 +1,148 @@
+// GSD-2 — #4782 phase 3: run-uat migrated to compose context via manifest.
+// Regression test: prompt still carries the declared artifacts in the
+// expected shape after the migration.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildRunUatPrompt } from "../auto-prompts.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertSlice,
+  insertArtifact,
+} from "../gsd-db.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-runuat-composer-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function seed(base: string, mid: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: mid, title: "Test", status: "active", depends_on: [] });
+  upsertMilestonePlanning(mid, {
+    title: "Test Milestone",
+    status: "active",
+    vision: "Demo the composer migration",
+    successCriteria: ["Prompt compiles", "UAT passes"],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: mid,
+    title: "First",
+    status: "complete",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  // Seed PROJECT.md so inlineProjectFromDb resolves — the run-uat manifest
+  // declares "project" as the third inline artifact (#4925 review).
+  insertArtifact({
+    path: "PROJECT.md",
+    artifact_type: "project",
+    milestone_id: null,
+    slice_id: null,
+    task_id: null,
+    full_content: "# Project\n\nRun-UAT composer fixture project.\n",
+  });
+}
+
+test("#4782 phase 3: buildRunUatPrompt inlines slice UAT, slice summary, project via composer", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+
+  // Write UAT + SUMMARY files. Deliberately diverge the on-disk UAT body
+  // from the in-memory uatContent the caller passes — if the resolver
+  // ever re-reads disk (the bug fixed in fcf3bfbe), this test fails
+  // because the prompt would contain "stale on-disk body" instead of
+  // "fresh in-memory snapshot" (#4925 follow-up review).
+  const uatRel = ".gsd/milestones/M001/slices/S01/S01-UAT.md";
+  writeFileSync(join(base, uatRel), "# S01 UAT\n\n- stale on-disk body\n");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"),
+    "---\nid: S01\nparent: M001\n---\n# S01 Summary\n**One-liner**\n\n## What Happened\nShip.\n",
+  );
+
+  const uatContent = "# S01 UAT\n\n- Check X\n- Check Y\n  (fresh in-memory snapshot)\n";
+  const prompt = await buildRunUatPrompt("M001", "S01", uatRel, uatContent, base);
+
+  // Context wrapper present
+  assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+
+  // Artifacts from the manifest inline list, in declared order:
+  // slice-uat → slice-summary → project (#4925 review).
+  const uatIdx = prompt.indexOf("### S01 UAT");
+  const summaryIdx = prompt.indexOf("### S01 Summary");
+  const projectIdx = prompt.indexOf("### Project");
+  assert.ok(uatIdx > -1, "slice UAT block missing");
+  assert.ok(summaryIdx > -1, "slice summary block missing");
+  assert.ok(projectIdx > -1, "project block missing — manifest declares project as 3rd inline");
+  assert.ok(
+    uatIdx < summaryIdx && summaryIdx < projectIdx,
+    `manifest order violated: uat (${uatIdx}) < summary (${summaryIdx}) < project (${projectIdx})`,
+  );
+
+  // In-memory uatContent inlined — drift assertion: stale disk content
+  // must NOT appear, fresh snapshot MUST appear (#4925 follow-up review).
+  assert.match(prompt, /fresh in-memory snapshot/);
+  assert.ok(!prompt.includes("stale on-disk body"), "resolver re-read disk instead of using uatContent snapshot");
+
+  // Summary body content inlined
+  assert.match(prompt, /What Happened[\s\S]*Ship/);
+
+  // Project body content inlined
+  assert.match(prompt, /Run-UAT composer fixture project/);
+});
+
+test("#4782 phase 3: buildRunUatPrompt omits optional slice summary when file is missing", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+
+  const uatRel = ".gsd/milestones/M001/slices/S01/S01-UAT.md";
+  writeFileSync(join(base, uatRel), "# S01 UAT\n");
+  // No SUMMARY.md written — composer should skip the slice-summary key.
+
+  const prompt = await buildRunUatPrompt("M001", "S01", uatRel, "# S01 UAT\n", base);
+
+  // UAT still present
+  assert.match(prompt, /### S01 UAT/);
+  // No empty "S01 Summary" section — section body would be blank without a file
+  assert.ok(!prompt.includes("### S01 Summary"));
+  // Project still present (third inline artifact, not optional) and follows
+  // UAT directly with the skipped summary collapsed (#4925 review).
+  const uatIdx = prompt.indexOf("### S01 UAT");
+  const projectIdx = prompt.indexOf("### Project");
+  assert.ok(projectIdx > uatIdx, `project must follow UAT when summary is omitted (uat=${uatIdx}, project=${projectIdx})`);
+  // No double separator from a skipped block
+  assert.ok(!prompt.includes("---\n\n---"));
+});

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

@@ -31,6 +31,10 @@ describe("supportsServiceTier", () => {
     assert.equal(supportsServiceTier("vibeproxy-openai/gpt-5.4"), true);
   });
 
+  test("returns false for gpt-5.5 until service_tier payload support is verified", () => {
+    assert.equal(supportsServiceTier("gpt-5.5"), 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/sidecar-queue.test.ts

@@ -11,6 +11,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
@@ -52,7 +53,7 @@ test("SidecarItem type is exported from session.ts", () => {
 test("SidecarItem has required kind field with hook/triage/quick-task union", () => {
   const source = getSessionTsSource();
   const ifaceIdx = source.indexOf("export interface SidecarItem");
-  const ifaceBlock = source.slice(ifaceIdx, ifaceIdx + 500);
+  const ifaceBlock = extractSourceRegion(source, "export interface SidecarItem");
   assert.ok(
     ifaceBlock.includes('"hook"') && ifaceBlock.includes('"triage"') && ifaceBlock.includes('"quick-task"'),
     "SidecarItem.kind must be a union of 'hook' | 'triage' | 'quick-task'",
@@ -77,7 +78,7 @@ test("AutoSession resets sidecarQueue in reset()", () => {
   const source = getSessionTsSource();
   const resetIdx = source.indexOf("reset(): void");
   assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
-  const resetBlock = source.slice(resetIdx, resetIdx + 3000);
+  const resetBlock = extractSourceRegion(source, "reset(): void");
   assert.ok(
     resetBlock.includes("sidecarQueue"),
     "reset() must clear sidecarQueue",

package/src/resources/extensions/gsd/tests/silent-catch-diagnostics.test.ts

@@ -6,6 +6,13 @@
  * Two tests:
  * 1. Auto-mode files must have zero empty catch blocks (fully migrated).
  * 2. All GSD files must not use raw stderr/console in catch blocks.
+ *
+ * Implementation note (#4836): the previous implementation walked every
+ * `{` / `}` character in the source to infer catch-block boundaries. That
+ * ignored string literals, template interpolations, regexes, and comments,
+ * producing both false positives and false negatives. The current
+ * implementation uses the TypeScript compiler API to walk real
+ * `CatchClause` nodes, so lexical accidents cannot flip the verdict.
  */
 
 import { describe, test } from "node:test";
@@ -13,6 +20,7 @@ import assert from "node:assert/strict";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join, dirname, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import ts from "typescript";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
@@ -73,12 +81,6 @@ const MIGRATED_FILES = new Set([
   "auto-verification.ts",
 ]);
 
-/** Patterns that indicate a catch block already uses workflow-logger */
-const LOGGER_PATTERNS = [
-  /logWarning\s*\(/,
-  /logError\s*\(/,
-];
-
 function getAutoModeFiles(): string[] {
   const files: string[] = [];
 
@@ -124,103 +126,61 @@ function getGsdSourceFiles(): string[] {
   return files;
 }
 
-/**
- * Scan a file for empty catch blocks — catches whose body contains
- * only whitespace and/or comments but no executable statements.
- */
-function findEmptyCatches(filePath: string): Array<{ line: number; text: string }> {
+function parseSourceFile(filePath: string): ts.SourceFile {
   const content = readFileSync(filePath, "utf-8");
-  const lines = content.split("\n");
-  const results: Array<{ line: number; text: string }> = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-
-    // Match catch block opening
-    if (!/\}\s*catch\s*(\([^)]*\))?\s*\{/.test(line)) continue;
-
-    // Inline single-line catch: } catch { ... }
-    const inlineMatch = line.match(/\}\s*catch\s*(\([^)]*\))?\s*\{(.*)\}\s*;?\s*$/);
-    if (inlineMatch) {
-      const body = inlineMatch[2].trim();
-      const stripped = body.replace(/\/\*.*?\*\//g, "").replace(/\/\/.*/g, "").trim();
-      if (!stripped) {
-        results.push({ line: i + 1, text: line.trim() });
-      }
-      continue;
-    }
-
-    // Multi-line catch — scan until matching }
-    let j = i + 1;
-    let depth = 1;
-    const bodyLines: string[] = [];
-    while (j < lines.length && depth > 0) {
-      for (const ch of lines[j]) {
-        if (ch === "{") depth++;
-        else if (ch === "}") depth--;
-      }
-      bodyLines.push(lines[j].trim());
-      j++;
-    }
+  return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, /*setParentNodes*/ true, ts.ScriptKind.TS);
+}
 
-    const meaningful = bodyLines.slice(0, -1).filter(
-      (l) => l && !l.startsWith("//") && !l.startsWith("/*") && !l.startsWith("*") && l !== "}",
-    );
+function forEachCatchClause(sf: ts.SourceFile, visit: (cc: ts.CatchClause) => void): void {
+  const walk = (node: ts.Node): void => {
+    if (ts.isCatchClause(node)) visit(node);
+    ts.forEachChild(node, walk);
+  };
+  walk(sf);
+}
 
-    if (meaningful.length === 0) {
-      results.push({ line: i + 1, text: line.trim() });
+/**
+ * A catch block is "empty" if its Block has zero statements. Comments
+ * inside the block are trivia and are not Statement nodes, so a
+ * comment-only body still counts as empty — matching the intent of the
+ * old regex check but without its lexical blind spots.
+ */
+function findEmptyCatches(filePath: string): Array<{ line: number }> {
+  const sf = parseSourceFile(filePath);
+  const results: Array<{ line: number }> = [];
+  forEachCatchClause(sf, (cc) => {
+    if (cc.block.statements.length === 0) {
+      const { line } = sf.getLineAndCharacterOfPosition(cc.getStart(sf));
+      results.push({ line: line + 1 });
     }
-  }
-
+  });
   return results;
 }
 
 /**
- * Scan a file for catch blocks that use raw process.stderr.write or
- * console.error/warn instead of workflow-logger.
+ * A catch block uses "raw stderr/console" if its body text calls
+ * process.stderr.write or console.error/warn *and* does NOT also call
+ * logWarning / logError.
+ *
+ * We test against the block's statement subtree text — derived from the
+ * AST node range, not a naive substring of the whole file — so string
+ * literals outside the block can never leak into the decision.
  */
-function findRawStderrCatches(filePath: string): Array<{ line: number; text: string }> {
-  const content = readFileSync(filePath, "utf-8");
-  const lines = content.split("\n");
-  const results: Array<{ line: number; text: string }> = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!/\}\s*catch\s*(\([^)]*\))?\s*\{/.test(line)) continue;
-
-    // Inline single-line catch
-    const inlineMatch = line.match(/\}\s*catch\s*(\([^)]*\))?\s*\{(.*)\}\s*;?\s*$/);
-    if (inlineMatch) {
-      const body = inlineMatch[2];
-      if (!LOGGER_PATTERNS.some((p) => p.test(body))) {
-        if (/process\.stderr\.write/.test(body) || /console\.(error|warn)/.test(body)) {
-          results.push({ line: i + 1, text: line.trim() });
-        }
-      }
-      continue;
+function findRawStderrCatches(filePath: string): Array<{ line: number }> {
+  const sf = parseSourceFile(filePath);
+  const results: Array<{ line: number }> = [];
+  forEachCatchClause(sf, (cc) => {
+    const bodyText = cc.block.getText(sf);
+    const usesLogger = /\blogWarning\s*\(|\blogError\s*\(/.test(bodyText);
+    if (usesLogger) return;
+    if (
+      /\bprocess\.stderr\.write\b/.test(bodyText) ||
+      /\bconsole\.(?:error|warn)\b/.test(bodyText)
+    ) {
+      const { line } = sf.getLineAndCharacterOfPosition(cc.getStart(sf));
+      results.push({ line: line + 1 });
     }
-
-    // Multi-line catch
-    let j = i + 1;
-    let depth = 1;
-    const bodyLines: string[] = [];
-    while (j < lines.length && depth > 0) {
-      for (const ch of lines[j]) {
-        if (ch === "{") depth++;
-        else if (ch === "}") depth--;
-      }
-      bodyLines.push(lines[j]);
-      j++;
-    }
-
-    const bodyText = bodyLines.slice(0, -1).join("\n");
-    if (!LOGGER_PATTERNS.some((p) => p.test(bodyText))) {
-      if (/process\.stderr\.write/.test(bodyText) || /console\.(error|warn)/.test(bodyText)) {
-        results.push({ line: i + 1, text: line.trim() });
-      }
-    }
-  }
-
+  });
   return results;
 }
 
@@ -248,7 +208,7 @@ describe("workflow-logger coverage (#3348)", () => {
 
       const empties = findEmptyCatches(file);
       for (const empty of empties) {
-        violations.push(`${rel}:${empty.line} — ${empty.text}`);
+        violations.push(`${rel}:${empty.line}`);
       }
     }
 
@@ -271,7 +231,7 @@ describe("workflow-logger coverage (#3348)", () => {
 
       const issues = findRawStderrCatches(file);
       for (const issue of issues) {
-        violations.push(`${rel}:${issue.line} — ${issue.text}`);
+        violations.push(`${rel}:${issue.line}`);
       }
     }
 

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

@@ -4,7 +4,13 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { loadSkills } from "@gsd/pi-coding-agent";
-import { buildSkillActivationBlock } from "../auto-prompts.js";
+import {
+  buildPlanMilestonePrompt,
+  buildResearchMilestonePrompt,
+  buildSkillActivationBlock,
+} from "../auto-prompts.js";
+import { warnIfManifestHasMissingSkills } from "../skill-manifest.js";
+import { _resetLogs, drainLogs, setStderrLoggingEnabled } from "../workflow-logger.js";
 import type { GSDPreferences } from "../preferences.js";
 
 function makeTempBase(): string {
@@ -25,6 +31,11 @@ function loadOnlyTestSkills(base: string): void {
   loadSkills({ cwd: base, includeDefaults: false, skillPaths: [join(base, "skills")] });
 }
 
+function writeProjectPreferences(base: string, preferences: string): void {
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), `---\n${preferences}---\n`);
+}
+
 function buildBlock(
   base: string,
   params: Partial<Parameters<typeof buildSkillActivationBlock>[0]> = {},
@@ -231,3 +242,111 @@ test("buildSkillActivationBlock allows valid skill names and rejects invalid one
     cleanup(base);
   }
 });
+
+// ─── Per-unit-type skill manifest (RFC #4779) ─────────────────────────────────
+
+test("buildSkillActivationBlock: explicit always_use_skills bypass the unit-type manifest", () => {
+  const base = makeTempBase();
+  try {
+    // write-docs is in the research-milestone manifest; swiftui is not.
+    // Both are in always_use_skills — a user-explicit source — so BOTH
+    // should activate regardless of the manifest. User intent wins over
+    // unit-type defaults. See RFC #4779 and skill-manifest.ts rationale.
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { unitType: "research-milestone" }, {
+      always_use_skills: ["write-docs", "swiftui"],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock falls through to all skills for unknown unit type", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { unitType: "unknown-unit-type" }, {
+      always_use_skills: ["swiftui"],
+    });
+
+    // Unknown unit type = wildcard fallback (pre-manifest behavior).
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock without unitType preserves pre-manifest behavior", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    // No unitType param — filter should no-op.
+    const result = buildBlock(base, {}, {
+      always_use_skills: ["swiftui"],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("milestone prompt builders propagate always_use_skills through buildSkillActivationBlock", async () => {
+  const base = makeTempBase();
+  try {
+    // Both skills are in always_use_skills — explicit user intent bypasses
+    // the unit-type manifest, so both activate in both milestone flows.
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    writeProjectPreferences(base, "always_use_skills:\n  - write-docs\n  - swiftui\n");
+    loadOnlyTestSkills(base);
+
+    const researchPrompt = await buildResearchMilestonePrompt("M001", "Test", base);
+    assert.match(researchPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(researchPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+
+    const planPrompt = await buildPlanMilestonePrompt("M001", "Test", base);
+    assert.match(planPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(planPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("skill manifest strict warnings require GSD_SKILL_MANIFEST_STRICT=1", (t) => {
+  const previousStrict = process.env.GSD_SKILL_MANIFEST_STRICT;
+  const previousStderr = setStderrLoggingEnabled(false);
+  t.after(() => {
+    if (previousStrict === undefined) {
+      delete process.env.GSD_SKILL_MANIFEST_STRICT;
+    } else {
+      process.env.GSD_SKILL_MANIFEST_STRICT = previousStrict;
+    }
+    setStderrLoggingEnabled(previousStderr);
+    _resetLogs();
+  });
+
+  process.env.GSD_SKILL_MANIFEST_STRICT = "0";
+  _resetLogs();
+  warnIfManifestHasMissingSkills("research-milestone", new Set());
+  assert.equal(drainLogs().length, 0, "strict=0 must preserve silent behavior");
+
+  process.env.GSD_SKILL_MANIFEST_STRICT = "1";
+  _resetLogs();
+  warnIfManifestHasMissingSkills("research-milestone", new Set());
+  const logs = drainLogs();
+  assert.ok(
+    logs.some(log => log.message.includes("skill-manifest: references uninstalled skill")),
+    "strict=1 should warn about missing manifest entries",
+  );
+});

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

@@ -0,0 +1,112 @@
+// GSD2 + skill-manifest.test — unit coverage for the skill manifest resolver
+//
+// Focused tests for `resolveSkillManifest` and `filterSkillsByManifest`.
+// Covers the wildcard semantics, the newly seeded unit-type entries
+// (complete-milestone, validate-milestone, reassess-roadmap, research-slice,
+// plan-slice, refine-slice, replan-slice, run-uat), and the deliberate
+// wildcard fallback for the execute-task hot path (RFC #4779).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveSkillManifest,
+  filterSkillsByManifest,
+} from "../skill-manifest.js";
+
+const NEWLY_WIRED_UNIT_TYPES = [
+  "complete-milestone",
+  "validate-milestone",
+  "reassess-roadmap",
+  "research-slice",
+  "plan-slice",
+  "refine-slice",
+  "replan-slice",
+  "run-uat",
+] as const;
+
+test("resolveSkillManifest returns null for undefined unit type (wildcard)", () => {
+  assert.equal(resolveSkillManifest(undefined), null);
+});
+
+test("resolveSkillManifest returns null for unknown unit types (wildcard fallback)", () => {
+  assert.equal(resolveSkillManifest("nonexistent-unit-type"), null);
+});
+
+test("resolveSkillManifest returns null for execute-task (intentional wildcard)", () => {
+  // execute-task is the implementation hot path; allowlisting it requires
+  // per-task skill hints from task-plan frontmatter. Documented in
+  // skill-manifest.ts — regression guard.
+  assert.equal(resolveSkillManifest("execute-task"), null);
+});
+
+for (const unitType of NEWLY_WIRED_UNIT_TYPES) {
+  test(`resolveSkillManifest returns a non-empty allowlist for '${unitType}'`, () => {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(allowlist !== null, `${unitType} should resolve to an allowlist, not wildcard`);
+    assert.ok(allowlist.length > 0, `${unitType} allowlist should not be empty`);
+    // Every entry must be lowercase (normalized).
+    for (const name of allowlist) {
+      assert.equal(name, name.toLowerCase(), `${unitType} entry '${name}' should be lowercase`);
+    }
+  });
+}
+
+test("resolveSkillManifest: slice-level manifests include decompose-into-slices", () => {
+  // Planning-shaped slice flows all benefit from the decomposition skill.
+  // Sanity-check a representative entry from each.
+  for (const unitType of ["research-slice", "plan-slice", "refine-slice", "replan-slice"] as const) {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(
+      allowlist?.includes("decompose-into-slices"),
+      `${unitType} should list decompose-into-slices`,
+    );
+  }
+});
+
+test("resolveSkillManifest: validation / completion flows include verify-before-complete", () => {
+  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat"] as const) {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(
+      allowlist?.includes("verify-before-complete"),
+      `${unitType} should list verify-before-complete`,
+    );
+  }
+});
+
+test("filterSkillsByManifest: pass-through when unit type is unknown", () => {
+  const skills = [{ name: "swiftui" }, { name: "solidity-security" }];
+  const result = filterSkillsByManifest(skills, "nonexistent-unit-type");
+  assert.deepEqual(result, skills);
+});
+
+test("filterSkillsByManifest: pass-through when unitType is undefined", () => {
+  const skills = [{ name: "swiftui" }];
+  const result = filterSkillsByManifest(skills, undefined);
+  assert.deepEqual(result, skills);
+});
+
+test("filterSkillsByManifest: restricts to allowlisted names for known unit type", () => {
+  // research-slice allowlists include decompose-into-slices but not swiftui.
+  const skills = [
+    { name: "decompose-into-slices" },
+    { name: "swiftui" },
+    { name: "write-docs" },
+  ];
+  const result = filterSkillsByManifest(skills, "research-slice");
+  const names = result.map(s => s.name);
+  assert.ok(names.includes("decompose-into-slices"));
+  assert.ok(names.includes("write-docs"));
+  assert.ok(!names.includes("swiftui"));
+});
+
+test("filterSkillsByManifest: matching is case-insensitive via normalize", () => {
+  const skills = [
+    { name: "Write-Docs" }, // different case from manifest entry
+    { name: "SWIFTUI" },
+  ];
+  const result = filterSkillsByManifest(skills, "research-milestone");
+  const names = result.map(s => s.name);
+  assert.ok(names.includes("Write-Docs"));
+  assert.ok(!names.includes("SWIFTUI"));
+});