gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/tui-header-lifecycle.test.ts

@@ -0,0 +1,330 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for the TUI header lifecycle fixes —
+// header is suppressed (zero lines) when auto-mode activates, the wizard
+// step status badge is cleared, the NEXT-mode footer hint renders when
+// step mode is active, and the health widget appends guidance for active
+// projects.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { visibleWidth } from "@gsd/pi-tui";
+
+import { setCompletionProgressWidget, updateProgressWidget } from "../auto-dashboard.ts";
+import type { GSDState } from "../types.ts";
+
+interface CapturedSetHeader {
+  factory: ((tui: unknown, theme: unknown) => { render(width: number): string[]; invalidate(): void }) | undefined;
+}
+
+function makeTempDir(prefix: string): string {
+  return join(
+    tmpdir(),
+    `gsd-tui-lifecycle-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+}
+
+const baseState: GSDState = {
+  phase: "executing",
+  activeMilestone: { id: "M001", title: "Milestone" },
+  activeSlice: { id: "S01", title: "Slice" },
+  activeTask: { id: "T01", title: "Task" },
+} as unknown as GSDState;
+
+const baseAccessors = {
+  getAutoStartTime: () => 0,
+  isStepMode: () => false,
+  getCmdCtx: () => null,
+  getBasePath: () => "/tmp",
+  isVerbose: () => false,
+  isSessionSwitching: () => false,
+  getCurrentDispatchedModelId: () => null,
+};
+
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
+// ── Header lifecycle ────────────────────────────────────────────────────
+
+test("updateProgressWidget installs an EMPTY-rendering header (not undefined) — addresses codex P1 finding that setHeader(undefined) restores the built-in logo+instructions header", (t) => {
+  const dir = makeTempDir("empty-header");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  const captured: CapturedSetHeader = { factory: undefined };
+  let setHeaderCallCount = 0;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget() {},
+        setHeader(factory: any) {
+          setHeaderCallCount++;
+          captured.factory = factory;
+        },
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.equal(setHeaderCallCount, 1, "setHeader must be called exactly once when widget installs");
+  assert.notEqual(captured.factory, undefined, "factory must NOT be undefined — undefined restores the built-in logo+instructions header (codex P1)");
+  assert.equal(typeof captured.factory, "function", "factory must be a component-creating function");
+
+  const component = captured.factory!(null, null);
+  const rendered = component.render(80);
+  assert.deepEqual(rendered, [], "empty header component must render zero lines so auto-mode actually suppresses the welcome banner");
+});
+
+test("updateProgressWidget clears the gsd-step wizard badge when auto-mode activates", (t) => {
+  const dir = makeTempDir("step-badge");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  const statusCalls: Array<[string, string | undefined]> = [];
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget() {},
+        setHeader() {},
+        setStatus(key: string, value: string | undefined) { statusCalls.push([key, value]); },
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.ok(
+    statusCalls.some(([key, value]) => key === "gsd-step" && value === undefined),
+    `expected setStatus("gsd-step", undefined) to be called; got ${JSON.stringify(statusCalls)}`,
+  );
+});
+
+test("updateProgressWidget gracefully no-ops when ctx.ui lacks setHeader/setStatus (RPC mode)", (t) => {
+  const dir = makeTempDir("rpc-mode");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  // ctx.ui without setHeader / setStatus — must not throw.
+  assert.doesNotThrow(() => {
+    updateProgressWidget(
+      {
+        hasUI: true,
+        ui: { setWidget() {} },
+      } as any,
+      "execute-task",
+      "M001/S01/T01",
+      baseState,
+      { ...baseAccessors, getBasePath: () => dir },
+    );
+  });
+});
+
+// ── NEXT-mode footer guidance ───────────────────────────────────────────
+
+test("auto-dashboard widget render output includes Ctrl+N guidance when isStepMode is true", (t) => {
+  const dir = makeTempDir("step-hint");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir, isStepMode: () => true },
+  );
+
+  assert.ok(widgetFactory, "widget factory must be installed");
+
+  const fakeTui = { requestRender() {} };
+  const fakeTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+  const component = widgetFactory!(fakeTui, fakeTheme);
+  const lines = component.render(120);
+
+  const hasStepHint = lines.some((line: string) => line.includes("Ctrl+N to advance"));
+  assert.ok(hasStepHint, `expected step-mode hint in render output; got:\n${lines.join("\n")}`);
+
+  if (component.dispose) component.dispose();
+});
+
+test("auto-dashboard widget render output omits Ctrl+N guidance when isStepMode is false", (t) => {
+  const dir = makeTempDir("no-step-hint");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir, isStepMode: () => false },
+  );
+
+  assert.ok(widgetFactory);
+
+  const fakeTui = { requestRender() {} };
+  const fakeTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+  const component = widgetFactory!(fakeTui, fakeTheme);
+  const lines = component.render(120);
+
+  const hasStepHint = lines.some((line: string) => line.includes("Ctrl+N to advance"));
+  assert.equal(hasStepHint, false, "step-mode hint must NOT appear when isStepMode is false");
+
+  if (component.dispose) component.dispose();
+});
+
+test("auto-dashboard widget render output fits common terminal widths", (t) => {
+  const dir = makeTempDir("width-safe");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.ok(widgetFactory);
+
+  const component = widgetFactory!(
+    { requestRender() {} },
+    {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    },
+  );
+  t.after(() => component.dispose?.());
+
+  for (const width of [40, 80, 120]) {
+    assertLinesFit(component.render(width), width);
+    component.invalidate();
+  }
+
+  if (component.dispose) component.dispose();
+});
+
+test("completion dashboard keeps final milestone roll-up in the progress widget", (t) => {
+  const dir = makeTempDir("completion-widget");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  setCompletionProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    {
+      milestoneId: "M003",
+      milestoneTitle: "Budget tracking",
+      oneLiner: "Added milestone budget warning output and provider roll-up details.",
+      successCriteriaResults: "Budget warnings appear at the end of milestone completion.",
+      requirementOutcomes: "Users can see what shipped without opening a fresh session.",
+      keyFiles: ["src/resources/extensions/gsd/auto-dashboard.ts", "src/resources/extensions/gsd/auto.ts"],
+      keyDecisions: ["Keep completion closeout in the same TUI surface."],
+      followUps: "None.",
+      reason: "Milestone M003 complete",
+      startedAt: Date.now() - 90_000,
+      totalCost: 21.29,
+      totalTokens: 1_000_000,
+      unitCount: 8,
+      cacheHitRate: 100,
+      contextPercent: 0.9,
+      contextWindow: 1_000_000,
+      completedSlices: 3,
+      totalSlices: 3,
+      basePath: dir,
+    },
+  );
+
+  assert.ok(widgetFactory, "completion widget factory must be installed");
+
+  const fakeTui = { requestRender() {} };
+  const fakeTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+  const component = widgetFactory!(fakeTui, fakeTheme);
+  const output = component.render(140).join("\n");
+
+  assert.match(output, /Milestone M003 roll-up/);
+  assert.match(output, /Budget tracking/);
+  assert.match(output, /Outcome/);
+  assert.match(output, /Added milestone budget warning output/);
+  assert.match(output, /What changed/);
+  assert.match(output, /Budget warnings appear/);
+  assert.match(output, /Users can see what shipped/);
+  assert.match(output, /Keep completion closeout/);
+  assert.match(output, /Verification/);
+  assert.match(output, /Files: src\/resources\/extensions\/gsd\/auto-dashboard\.ts/);
+  assert.match(output, /Run totals 3\/3 slices/);
+  assert.match(output, /100% cache hit/);
+  assert.match(output, /\$21\.29/);
+  assert.match(output, /1\.0M tokens/);
+  assert.match(output, /8 units/);
+  assert.doesNotMatch(output, /COMPLETE-MILESTONE/);
+
+  if (component.dispose) component.dispose();
+});

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

@@ -0,0 +1,66 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for shared GSD TUI render helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
+import {
+  padRightVisible,
+  renderFrame,
+  renderKeyHints,
+  renderProgressBar,
+  rightAlign,
+  safeLine,
+  wrapVisibleText,
+  type ThemeLike,
+} from "../tui/render-kit.ts";
+
+const theme: ThemeLike = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+function assertWidth(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
+describe("tui render kit", () => {
+  test("safeLine clamps visible width", () => {
+    assert.equal(visibleWidth(safeLine("abcdef", 4)), 4);
+    assert.equal(safeLine("abcdef", 0), "");
+  });
+
+  test("padRightVisible fills exact visible width", () => {
+    const line = padRightVisible("abc", 8);
+    assert.equal(visibleWidth(line), 8);
+  });
+
+  test("rightAlign keeps output within width", () => {
+    for (const width of [10, 40, 80]) {
+      assertWidth([rightAlign("left side with overflow", "right side", width)], width);
+    }
+  });
+
+  test("wrapVisibleText clamps long words and ansi-aware content", () => {
+    const lines = wrapVisibleText("https://example.com/" + "a".repeat(120), 24);
+    assert.ok(lines.length > 0);
+    assertWidth(lines, 24);
+  });
+
+  test("renderFrame keeps borders and rows within width", () => {
+    for (const width of [3, 40, 80]) {
+      assertWidth(renderFrame(theme, ["row", "long ".repeat(40)], width), width);
+    }
+  });
+
+  test("renderKeyHints and renderProgressBar fit caller budgets", () => {
+    assert.ok(visibleWidth(renderKeyHints(theme, ["↑↓ scroll", "esc close"], 12)) <= 12);
+    assert.equal(visibleWidth(renderProgressBar(theme, 2, 4, 16)), 16);
+  });
+});

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

@@ -21,12 +21,18 @@ import type {
   ComputedArtifactRegistry,
   UnitContextManifest,
 } from "../unit-context-manifest.ts";
-import { UNIT_MANIFESTS } from "../unit-context-manifest.ts";
-import { buildReassessRoadmapPrompt } from "../auto-prompts.ts";
+import { KNOWN_UNIT_TYPES, UNIT_MANIFESTS } from "../unit-context-manifest.ts";
+import {
+  buildExecuteTaskPrompt,
+  buildGateEvaluatePrompt,
+  buildReassessRoadmapPrompt,
+  buildWorkflowPreferencesPrompt,
+} from "../auto-prompts.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import {
   openDatabase,
   closeDatabase,
+  insertGateRow,
   insertMilestone,
   upsertMilestonePlanning,
   insertSlice,
@@ -121,7 +127,7 @@ test("Context Mode composer: standalone output starts with heading and includes
   assert.ok(out.startsWith("## Context Mode"));
   assert.match(out, /execution lane/i);
   assert.match(out, /`gsd_exec`/);
-  assert.match(out, /noisy commands/);
+  assert.match(out, /builds, tests, and diagnostics/);
   assert.match(out, /`gsd_exec_search`/);
   assert.match(out, /before reruns/);
   assert.match(out, /`gsd_resume`/);
@@ -136,7 +142,45 @@ test("Context Mode composer: nested output is compact single sentence", () => {
   assert.match(out, /`gsd_exec`/);
   assert.match(out, /`gsd_exec_search`/);
   assert.match(out, /`gsd_resume`/);
-  assert.ok(out.length < 180, `nested guidance should stay compact, got ${out.length} chars`);
+  assert.ok(out.length < 240, `nested guidance should stay compact, got ${out.length} chars`);
+});
+
+const laneLabelByMode: Record<string, string> = {
+  interview: "interview",
+  research: "research",
+  planning: "planning",
+  execution: "execution",
+  verification: "verification",
+  orchestration: "orchestration",
+  docs: "documentation",
+};
+
+test("Context Mode composer: every known eligible unit renders its configured lane and required tools", () => {
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    const manifest = UNIT_MANIFESTS[unitType];
+    assert.ok(manifest, `missing manifest for ${unitType}`);
+    const out = composeContextModeInstructions(unitType, { enabled: true, renderMode: "standalone" });
+    if (manifest.contextMode === "none") {
+      assert.strictEqual(out, "", `${unitType} should not render Context Mode`);
+      continue;
+    }
+    assert.ok(out.startsWith("## Context Mode"), `${unitType} should render standalone Context Mode heading`);
+    assert.match(out, new RegExp(`Lane: \\*\\*${laneLabelByMode[manifest.contextMode]} lane\\*\\*\\.`, "i"));
+    assert.match(out, /`gsd_exec`/, `${unitType} should mention gsd_exec`);
+    assert.match(out, /`gsd_exec_search`/, `${unitType} should mention gsd_exec_search`);
+    assert.match(out, /`gsd_resume`/, `${unitType} should mention gsd_resume`);
+  }
+});
+
+test("Context Mode composer: workflow-preferences and research-decision render no Context Mode block", () => {
+  assert.strictEqual(
+    composeContextModeInstructions("workflow-preferences", { enabled: true, renderMode: "standalone" }),
+    "",
+  );
+  assert.strictEqual(
+    composeContextModeInstructions("research-decision", { enabled: true, renderMode: "standalone" }),
+    "",
+  );
 });
 
 // ─── Integration: migrated buildReassessRoadmapPrompt ─────────────────────
@@ -220,6 +264,94 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
   assert.ok(!prompt.includes("Slice Context (from discussion)"));
 });
 
+test("Context Mode resume injection: eligible prompts include one bounded snapshot block above inlined context", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  writeFileSync(
+    join(base, ".gsd", "last-snapshot.md"),
+    "# GSD context snapshot\n\nResume evidence.\n",
+    "utf-8",
+  );
+
+  const prompt = await buildReassessRoadmapPrompt("M001", "Test", "S01", base);
+
+  assert.equal(prompt.match(/## Context Snapshot/g)?.length, 1);
+  assert.match(prompt, /Source: `\.gsd\/last-snapshot\.md`/);
+  assert.match(prompt, /Resume evidence/);
+  assert.ok(prompt.indexOf("## Context Mode") < prompt.indexOf("## Context Snapshot"));
+  assert.ok(prompt.indexOf("## Context Snapshot") < prompt.indexOf("## Inlined Context"));
+});
+
+test("Context Mode resume injection: missing snapshot does not add an empty block", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+
+  const prompt = await buildReassessRoadmapPrompt("M001", "Test", "S01", base);
+
+  assert.match(prompt, /## Context Mode/);
+  assert.doesNotMatch(prompt, /## Context Snapshot/);
+});
+
+test("Context Mode resume injection: disabled mode suppresses guidance and snapshot reads", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\ncontext_mode:\n  enabled: false\n---\n", "utf-8");
+  writeFileSync(join(base, ".gsd", "last-snapshot.md"), "# GSD context snapshot\n\nDo not inject.\n", "utf-8");
+
+  const prompt = await buildReassessRoadmapPrompt("M001", "Test", "S01", base);
+
+  assert.doesNotMatch(prompt, /## Context Mode/);
+  assert.doesNotMatch(prompt, /## Context Snapshot/);
+  assert.doesNotMatch(prompt, /Do not inject/);
+});
+
+test("Context Mode resume injection: none-mode units do not inject snapshots", async () => {
+  const base = makeFixtureBase();
+  try {
+    writeFileSync(join(base, ".gsd", "last-snapshot.md"), "# GSD context snapshot\n\nNo lane.\n", "utf-8");
+    const prompt = await buildWorkflowPreferencesPrompt(base);
+    assert.doesNotMatch(prompt, /## Context Mode/);
+    assert.doesNotMatch(prompt, /## Context Snapshot/);
+    assert.doesNotMatch(prompt, /No lane/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("Context Mode prompt suppression: disabled inlined, phase-anchor, and nested prompts omit Context Mode", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\ncontext_mode:\n  enabled: false\n---\n", "utf-8");
+  writeFileSync(join(base, ".gsd", "last-snapshot.md"), "# GSD context snapshot\n\nDo not inject.\n", "utf-8");
+
+  const inlinedPrompt = await buildReassessRoadmapPrompt("M001", "Test", "S01", base);
+  assert.doesNotMatch(inlinedPrompt, /## Context Mode|Context Mode \(|## Context Snapshot/);
+
+  const phaseAnchorPrompt = await buildExecuteTaskPrompt("M001", "S01", "First", "T01", "Task", base);
+  assert.doesNotMatch(phaseAnchorPrompt, /## Context Mode|Context Mode \(|## Context Snapshot/);
+
+  const nestedPrompt = await buildGateEvaluatePrompt("M001", "Test", "S01", "First", base);
+  assert.match(nestedPrompt, /Use this as the prompt for a `subagent` call/);
+  assert.doesNotMatch(nestedPrompt, /## Context Mode|Context Mode \(|## Context Snapshot/);
+});
+
 // ─── v2 surface (#4924) ───────────────────────────────────────────────────
 
 const fakeBase: BaseResolverContext = {

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

@@ -2,9 +2,6 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import {
   ARTIFACT_KEYS,
@@ -17,6 +14,10 @@ import {
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
 import { ALLOWED_PLANNING_DISPATCH_AGENTS } from "../bootstrap/write-gate.ts";
+import {
+  getRequiredWorkflowToolsForAutoUnit,
+  getRequiredWorkflowToolsForGuidedUnit,
+} from "../workflow-mcp.ts";
 
 // ─── Coverage: every known unit type has a manifest ──────────────────────
 
@@ -41,29 +42,11 @@ test("#4782 phase 1: every UNIT_MANIFESTS entry corresponds to a known unit type
 
 // ─── Coverage: every unitType stringly-typed in auto-dispatch.ts is known ─
 
-test("#4782 phase 1: every unitType string in auto-dispatch.ts has a manifest", () => {
-  // Source-only coverage check — read the dispatcher and enumerate its
-  // unitType literals. This is a CI guard against manifest drift: if a
-  // new dispatch rule is added without a corresponding manifest entry,
-  // this test fails loudly. Read-only check of source text; the cheapest
-  // way to enumerate declared unit types without running the dispatcher.
-  // allow-source-grep: enumerate unitType literals for CI coverage guard
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-  const matches = Array.from(dispatchSrc.matchAll(/unitType:\s*"([^"]+)"/g));
-  const seen = new Set<string>();
-  for (const m of matches) {
-    const t = m[1];
-    if (!t) continue;
-    seen.add(t);
-  }
-  const missing: string[] = [];
-  for (const t of seen) {
-    if (!UNIT_MANIFESTS[t as keyof typeof UNIT_MANIFESTS]) {
-      missing.push(t);
-    }
+test("#4782 phase 1: workflow tool policy maps are defined for every known unit type", () => {
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    assert.ok(Array.isArray(getRequiredWorkflowToolsForAutoUnit(unitType)));
+    assert.ok(Array.isArray(getRequiredWorkflowToolsForGuidedUnit(unitType)));
   }
-  assert.deepEqual(missing, [], `unit types dispatched in auto-dispatch.ts but missing from UNIT_MANIFESTS: ${missing.join(", ")}`);
 });
 
 // ─── Shape: every manifest conforms to the schema invariants ──────────────