@opengsd/gsd-pi 1.0.2-dev.867e002 → 1.0.2-dev.88c4dc5

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

@@ -0,0 +1,67 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyUnitSkillVisibility,
+  effectiveSkillNamesForUnit,
+  resolveVisibleSkillNames,
+  unitHasSkillManifest,
+} from "../skill-scope.ts";
+
+test("resolveVisibleSkillNames: none policy suppresses catalog", () => {
+  assert.deepEqual(resolveVisibleSkillNames("workflow-preferences"), []);
+  assert.equal(unitHasSkillManifest("workflow-preferences"), true);
+});
+
+test("resolveVisibleSkillNames: wildcard units use full catalog", () => {
+  assert.equal(resolveVisibleSkillNames("execute-task"), undefined);
+  assert.equal(unitHasSkillManifest("execute-task"), false);
+});
+
+test("unitHasSkillManifest: manifest unit types return true", () => {
+  assert.equal(unitHasSkillManifest("research-milestone"), true);
+  assert.equal(unitHasSkillManifest("plan-slice"), true);
+});
+
+test("unitHasSkillManifest: wildcard unit types return false", () => {
+  assert.equal(unitHasSkillManifest("execute-task"), false);
+  assert.equal(unitHasSkillManifest(undefined), false);
+  assert.equal(unitHasSkillManifest("unknown-unit"), false);
+});
+
+test("applyUnitSkillVisibility: sets manifest names for scoped units", () => {
+  let visible: string[] | undefined;
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      visible = names;
+    },
+  }, "research-milestone");
+
+  assert.ok(Array.isArray(visible));
+  assert.ok(visible!.includes("write-docs"));
+  assert.ok(visible!.length < 15);
+});
+
+test("applyUnitSkillVisibility: restores full catalog for wildcard units", () => {
+  let visible: string[] | undefined = ["stale"];
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      visible = names;
+    },
+  }, "execute-task");
+
+  assert.equal(visible, undefined);
+});
+
+test("effectiveSkillNamesForUnit: filters installed names by manifest", () => {
+  const installed = ["write-docs", "review", "frontend-design", "tdd"];
+  const scoped = effectiveSkillNamesForUnit("research-milestone", installed);
+  assert.ok(scoped.includes("write-docs"));
+  assert.ok(!scoped.includes("review"));
+  assert.ok(scoped.length < installed.length);
+});
+
+test("effectiveSkillNamesForUnit: pass-through for wildcard units", () => {
+  const installed = ["write-docs", "review"];
+  assert.deepEqual(effectiveSkillNamesForUnit("execute-task", installed), installed);
+});

package/src/resources/extensions/gsd/tests/skills.test.ts

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { Skill } from "@gsd/pi-coding-agent";
+import {
+  detectNewlyInstalledSkills,
+  getInstalledSkillNames,
+  getInstalledSkills,
+  normalizeSkillName,
+  resolveInstalledSkill,
+  snapshotInstalledSkillNames,
+} from "../skills.js";
+
+function makeSkill(name: string, filePath = `/tmp/${name}/SKILL.md`): Skill {
+  return {
+    name,
+    description: `Use for ${name}.`,
+    filePath,
+    baseDir: `/tmp/${name}`,
+    source: "user",
+    sourceInfo: {
+      path: filePath,
+      source: "local",
+      scope: "user",
+      origin: "top-level",
+      baseDir: `/tmp/${name}`,
+    },
+    disableModelInvocation: false,
+  };
+}
+
+test("normalizeSkillName lowercases and trims", () => {
+  assert.equal(normalizeSkillName("  React-Best  "), "react-best");
+});
+
+test("getInstalledSkills returns explicit override", () => {
+  const skills = [makeSkill("alpha"), makeSkill("beta")];
+  assert.deepEqual(getInstalledSkills(skills).map((s) => s.name), ["alpha", "beta"]);
+});
+
+test("snapshotInstalledSkillNames and detectNewlyInstalledSkills diff normalized names", () => {
+  const baseline = snapshotInstalledSkillNames([makeSkill("alpha")]);
+  const added = detectNewlyInstalledSkills(baseline, [makeSkill("alpha"), makeSkill("Beta")]);
+  assert.deepEqual(added, ["beta"]);
+});
+
+test("getInstalledSkillNames maps skill names", () => {
+  assert.deepEqual(getInstalledSkillNames([makeSkill("tdd")]), ["tdd"]);
+});
+
+test("resolveInstalledSkill matches installed catalog by name", () => {
+  const skills = [makeSkill("react", "/home/user/.gsd/agent/skills/react/SKILL.md")];
+  const result = resolveInstalledSkill("react", "/project", skills);
+  assert.equal(result.skill?.name, "react");
+  assert.equal(result.resolvedPath, "/home/user/.gsd/agent/skills/react/SKILL.md");
+});

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

@@ -15,6 +15,13 @@ function readGsdFile(relativePath: string): string {
   return readFileSync(resolve(gsdDir, relativePath), "utf-8");
 }
 
+function firstIndexOfAny(source: string, needles: string[]): number {
+  const indexes = needles
+    .map((needle) => source.indexOf(needle))
+    .filter((index) => index > -1);
+  return indexes.length > 0 ? Math.min(...indexes) : -1;
+}
+
 test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
   const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
   const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
@@ -145,7 +152,11 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
   const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
   const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
-  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
+  const enterMilestoneIdx = firstIndexOfAny(bootstrapBody, [
+    "buildLifecycle().enterMilestone",
+    "lifecycle.enterMilestone",
+    "lifecycle.adoptStrandedMilestone",
+  ]);
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
@@ -158,7 +169,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
   assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
   assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
-  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter or adopt milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",

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

@@ -17,6 +17,8 @@ import { randomUUID } from "node:crypto";
 import {
   openDatabase,
   closeDatabase,
+  _getAdapter,
+  insertArtifact,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -229,6 +231,175 @@ test("ADR-017 (#5700): classifyFailure recognizes ReconciliationFailedError", ()
   assert.match(result.remediation, /persistent or repair-failed drift kinds/);
 });
 
+test("ADR-017: terminal drift blockers return blockers instead of repair exceptions", async () => {
+  const record: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const handler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => [record],
+    blocker: () => "manual drift review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [handler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["manual drift review required"]);
+  assert.equal(result.repaired.length, 0);
+});
+
+test("ADR-017: terminal blockers return a state snapshot refreshed after co-occurring repairs", async () => {
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  let repaired = false;
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: (state) => (state.nextAction === "before repair" ? [repairDrift] : []),
+    repair: () => {
+      repaired = true;
+    },
+  };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: (state) => (state.nextAction === "before repair" ? [terminalDrift] : []),
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () =>
+      makeState({ nextAction: repaired ? "after repair" : "before repair" }),
+    registry: [repairHandler, terminalHandler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.stateSnapshot.nextAction, "after repair");
+  assert.equal(result.repaired.length, 1);
+  assert.deepEqual(result.blockers, ["manual completed-milestone review required"]);
+});
+
+test("ADR-017: terminal drift blockers take precedence over co-occurring repair failures", async () => {
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: () => [terminalDrift],
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => [repairDrift],
+    repair: () => {
+      throw new Error("simulated repair failure");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [repairHandler, terminalHandler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["manual completed-milestone review required"]);
+});
+
+test("ADR-017: terminal drift found after repair cap returns blockers", async () => {
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  let repairCount = 0;
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => (repairCount < 2 ? [repairDrift] : []),
+    repair: () => {
+      repairCount++;
+    },
+  };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: () => (repairCount >= 2 ? [terminalDrift] : []),
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [repairHandler, terminalHandler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.repaired.length, 2);
+  assert.deepEqual(result.blockers, ["manual completed-milestone review required"]);
+});
+
+test("ADR-017: final persistent drift mixed with blockers still fails closed", async () => {
+  const repairDrift: DriftRecord = { kind: "stale-sketch-flag", mid: "M001", sid: "S02" };
+  const terminalDrift: DriftRecord = {
+    kind: "completed-milestone-reopened",
+    milestoneId: "M001",
+    dbStatus: "active",
+  };
+  let repairCount = 0;
+  const repairHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () => [repairDrift],
+    repair: () => {
+      repairCount++;
+    },
+  };
+  const terminalHandler: DriftHandler = {
+    kind: "completed-milestone-reopened",
+    detect: () => (repairCount >= 2 ? [terminalDrift] : []),
+    blocker: () => "manual completed-milestone review required",
+    repair: () => {
+      throw new Error("repair should not run for terminal blockers");
+    },
+  };
+
+  await assert.rejects(
+    () =>
+      reconcileBeforeDispatch("/project", {
+        invalidateStateCache: () => {},
+        deriveState: async () => makeState(),
+        registry: [repairHandler, terminalHandler],
+      }),
+    (err: unknown) => {
+      assert.ok(err instanceof ReconciliationFailedError);
+      assert.deepEqual(err.persistentDrift.map((d) => d.kind).sort(), [
+        "completed-milestone-reopened",
+        "stale-sketch-flag",
+      ]);
+      return true;
+    },
+  );
+});
+
 // ─── #5701: merge-state drift ────────────────────────────────────────────────
 
 function makeGitBase(): string {
@@ -1052,6 +1223,138 @@ test("ADR-017 (#5706): repair is idempotent — re-running preserves the timesta
   assert.equal(getSlice("M001", "S01")?.completed_at, tsAfterFirst, "timestamp unchanged");
 });
 
+test("ADR-017: artifact/DB status divergence fails closed instead of importing completion artifacts", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-artifact-db-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"),
+    "# S01 Summary\n\nAlready done on disk.\n",
+  );
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
+  assert.equal(getSlice("M001", "S01")?.status, "pending", "DB status remains authoritative");
+});
+
+test("ADR-017: meaningful disk-only slice drift blocker includes repair guidance", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-disk-slice-guidance-"));
+  const diskOnlySliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S99");
+  t.after(() => cleanup(base));
+
+  mkdirSync(diskOnlySliceDir, { recursive: true });
+  writeFileSync(join(diskOnlySliceDir, "S99-PLAN.md"), "# Disk-only plan\n\nWork to review.\n");
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Known Slice", status: "pending" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  const message = result.blockers.join("\n");
+  assert.match(message, /Slice ID drift in M001/);
+  assert.match(message, /Review .*S99/);
+  assert.match(message, /move or delete/);
+  assert.match(message, /\.gsd\/quarantine\/milestones\/M001\/slices\/S99-manual-review/);
+  assert.match(message, /copy or merge/);
+  assert.match(message, /\/gsd doctor M001/);
+  assert.match(message, /\/gsd next or \/gsd auto/);
+});
+
+test("ADR-017: orphan task completion artifact fails closed", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orphan-task-artifact-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T99"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+  insertArtifact({
+    path: join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T99", "T99-SUMMARY.md"),
+    artifact_type: "SUMMARY",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T99",
+    full_content: "# T99 Summary\n\nStale artifact after replan.\n",
+  });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(result.blockers.join("\n"), /Artifact\/DB status drift/);
+});
+
+test("ADR-017: completed milestone dispatch history blocks accidental re-planning", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-completed-reopened-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  adapter.prepare(
+    `INSERT OR REPLACE INTO workers
+      (worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath)
+     VALUES ('w1', 'local', 1, '2026-05-30T00:00:00.000Z', 'test', '2026-05-30T00:00:00.000Z', 'stopped', :root)`,
+  ).run({ ":root": base });
+  adapter.prepare(
+    `INSERT INTO unit_dispatches
+      (trace_id, worker_id, milestone_lease_token, milestone_id, unit_type, unit_id, status, attempt_n, started_at, ended_at)
+     VALUES
+      ('trace', 'w1', 1, 'M001', 'complete-milestone', 'M001', 'completed', 1, '2026-05-30T00:00:00.000Z', '2026-05-30T00:01:00.000Z')`,
+  ).run();
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(result.blockers.join("\n"), /completed complete-milestone dispatch history/);
+});
+
+test("ADR-017: synthetic parallel-research slice directory is ignored", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-sentinel-drift-"));
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "parallel-research", "tasks"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState({ activeMilestone: { id: "M001", title: "Milestone" } }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(
+    existsSync(join(base, ".gsd", "milestones", "M001", "slices", "parallel-research")),
+    true,
+    "sentinel directory is left alone, not treated as a real disk-only slice",
+  );
+  assert.equal(result.repaired.some((record) => record.kind === "disk-slice-id-divergence"), false);
+});
+
 // ─── #5707: caller closure (reconcileBeforeSpawn) ────────────────────────────
 
 test("ADR-017 (#5707): reconcileBeforeSpawn returns ok=true on clean reconciliation", async () => {

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

@@ -6,6 +6,7 @@ import test from "node:test";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
 import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+import { applyUnitSkillVisibility } from "../skill-scope.ts";
 
 test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
   const result = buildMinimalGsdToolSet([
@@ -435,3 +436,21 @@ test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visib
   assert.deepEqual(visibleSkills, ["previous-skill"]);
   assert.equal(calls.filter((call) => call.kind === "skills").length, 2);
 });
+
+test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
+  const calls: Array<string[] | undefined> = [];
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      calls.push(names);
+    },
+  }, "plan-milestone");
+  assert.ok(Array.isArray(calls[0]));
+  assert.ok(calls[0]!.includes("tdd"));
+
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      calls.push(names);
+    },
+  }, "execute-task");
+  assert.equal(calls[1], undefined);
+});

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

@@ -235,12 +235,16 @@ test("gsd_task_complete — enrichment arrays are optional", () => {
     "milestoneId",
     "oneLiner",
     "narrative",
-    "verification",
   ];
   for (const field of coreRequired) {
     assert.ok(required.has(field), `core field "${field}" must be required`);
   }
 
+  assert.ok(
+    !required.has("verification"),
+    "verification must be optional at the schema layer so step-mode can recover when verificationEvidence is present",
+  );
+
   // Enrichment fields must be optional
   const enrichmentFields = [
     "keyFiles",
@@ -272,6 +276,25 @@ test("gsd_task_complete — validates with only core params", () => {
   assert.strictEqual(errors.length, 0, `Minimal params should validate but got errors: ${errors.join(", ")}`);
 });
 
+test("gsd_task_complete — accepts evidence-only verification at schema layer", () => {
+  const tool = getTool("gsd_task_complete");
+  assert.ok(tool, "gsd_task_complete must be registered");
+
+  const params = {
+    taskId: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    oneLiner: "Implemented the feature",
+    narrative: "Created the module and wired it up.",
+    verificationEvidence: [
+      { command: "npm test", exitCode: 0, verdict: "pass", durationMs: 1234 },
+    ],
+  };
+
+  const errors = validateSchema(tool, params);
+  assert.strictEqual(errors.length, 0, `Evidence-only params should validate but got errors: ${errors.join(", ")}`);
+});
+
 // ─── gsd_complete_milestone: enrichment arrays must be optional ──────────────
 
 test("gsd_complete_milestone — enrichment arrays are optional", () => {

package/src/resources/extensions/gsd/tests/tui-border-assertions.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
+
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+function stripAnsi(text: string): string {
+  return text.replace(ANSI_PATTERN, "");
+}
+
+export function assertFullOuterBorder(lines: string[], width: number): void {
+  assert.ok(lines.length >= 2, "dialog must include top and bottom borders");
+
+  for (const [index, line] of lines.entries()) {
+    assert.equal(visibleWidth(line), width, `line ${index} must fill dialog width`);
+  }
+
+  const top = stripAnsi(lines[0] ?? "");
+  const bottom = stripAnsi(lines.at(-1) ?? "");
+  assert.match(top, /^[╭┌].*[╮┐]$/, `top border missing full corners: ${top}`);
+  assert.match(bottom, /^[╰└].*[╯┘]$/, `bottom border missing full corners: ${bottom}`);
+
+  for (let index = 1; index < lines.length - 1; index++) {
+    const line = stripAnsi(lines[index] ?? "");
+    assert.match(line, /^[│┃├]/, `line ${index} missing left border: ${line}`);
+    assert.match(line, /[│┃┤]$/, `line ${index} missing right border: ${line}`);
+  }
+}

package/src/resources/extensions/gsd/tests/tui-render-kit.test.ts

@@ -5,8 +5,10 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
 import { visibleWidth } from "@gsd/pi-tui";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 import {
   padRightVisible,
+  renderDialogFrame,
   renderFrame,
   renderKeyHints,
   renderPanel,
@@ -60,6 +62,18 @@ describe("tui render kit", () => {
     }
   });
 
+  test("renderDialogFrame draws a full titled modal border with footer", () => {
+    const lines = renderDialogFrame(theme, "Dialog", ["row", "long ".repeat(40)], 40, {
+      footer: renderKeyHints(theme, ["esc close"], 36),
+    });
+    assertWidth(lines, 40);
+    assertFullOuterBorder(lines, 40);
+    assert.match(lines[0] ?? "", /^╭─ Dialog ─+╮$/);
+    assert.ok(lines.some((line) => line.startsWith("│") && line.endsWith("│")));
+    assert.ok(lines.some((line) => line.startsWith("├") && line.endsWith("┤")));
+    assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
+  });
+
   test("renderPanel stays within width and draws no vertical borders", () => {
     for (const width of [3, 40, 80]) {
       const lines = renderPanel(theme, "Title", ["row", "long ".repeat(40)], width);

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

@@ -14,6 +14,7 @@ import {
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
+import { resolveSkillManifest } from "../skill-manifest.ts";
 import {
   ALLOWED_PLANNING_DISPATCH_AGENTS,
   shouldBlockPlanningUnit,
@@ -148,6 +149,23 @@ test("#4782 phase 1: skills policy shapes are valid discriminated-union members"
   }
 });
 
+test("#4782 phase 1b: allowlist skills policy matches skill-manifest resolver", () => {
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    const manifest = UNIT_MANIFESTS[unitType];
+    const allowlist = resolveSkillManifest(unitType);
+    if (allowlist) {
+      assert.strictEqual(manifest.skills.mode, "allowlist", unitType);
+      assert.deepEqual(
+        [...(manifest.skills as Extract<SkillsPolicy, { mode: "allowlist" }>).skills].sort(),
+        [...allowlist].sort(),
+        unitType,
+      );
+    } else {
+      assert.notStrictEqual(manifest.skills.mode, "allowlist", unitType);
+    }
+  }
+});
+
 // ─── Lookup helper ────────────────────────────────────────────────────────
 
 test("#4782 phase 1: resolveManifest returns null for an unknown unit type", () => {

package/src/resources/extensions/gsd/tests/user-input-boundary.test.ts

@@ -0,0 +1,26 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import * as userInputBoundary from "../user-input-boundary.ts";
+
+test("lastAssistantText extracts the latest assistant text block content", () => {
+  const lastAssistantText = (userInputBoundary as {
+    lastAssistantText?: (messages: unknown[] | null | undefined) => string;
+  }).lastAssistantText;
+
+  assert.equal(typeof lastAssistantText, "function");
+  assert.equal(
+    lastAssistantText?.([
+      { role: "assistant", content: "Older message" },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "First line" },
+          { type: "text", text: "Second line" },
+        ],
+      },
+    ]),
+    "First line\nSecond line",
+  );
+  assert.equal(lastAssistantText?.(null), "");
+});