@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/comms.test.mjs

@@ -1,41 +0,0 @@
-/**
- * comms.test.mjs — tests for the archetype communication-profile resolver.
- * Run: `node --test lib/comms.test.mjs`
- * @module comms.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveCommsProfile, CHANNEL_STRATEGY, REGISTER_BY_ALTITUDE, listCommsFunctions } from "./comms.mjs";
-
-test("comms profile carries altitude register + function channel strategy + voice modes", async () => {
-  const p = await resolveCommsProfile({ function: "compliance-officer", altitude: "c-suite" });
-  assert.equal(p.register, REGISTER_BY_ALTITUDE["c-suite"]);
-  assert.deepEqual(p.channelStrategy, CHANNEL_STRATEGY["compliance-officer"]);
-  assert.ok(p.channelStrategy.includes("filings-portal"));
-  assert.ok(p.voiceModes.length >= 4);
-  assert.ok(["high", "medium", "relaxed"].includes(p.formality));
-  assert.equal(p.styleRef, "policies/communication-style.md");
-});
-
-test("function changes the channel strategy (technical → github; commercial → linkedin)", async () => {
-  const tech = await resolveCommsProfile({ function: "technical-leader", altitude: "vp" });
-  const comm = await resolveCommsProfile({ function: "commercial-leader", altitude: "vp" });
-  assert.ok(tech.channelStrategy.includes("github"));
-  assert.ok(comm.channelStrategy.includes("linkedin"));
-  assert.notDeepEqual(tech.channelStrategy, comm.channelStrategy);
-});
-
-test("altitude changes the register (founder direct vs c-suite board-ready)", async () => {
-  const founder = await resolveCommsProfile({ function: "executive-operator", altitude: "founder" });
-  const cSuite = await resolveCommsProfile({ function: "executive-operator", altitude: "c-suite" });
-  assert.match(founder.register, /direct/i);
-  assert.match(cSuite.register, /board-ready/i);
-  assert.ok(founder.channelStrategy.includes("whatsapp") || founder.channelStrategy.includes("voice"));
-});
-
-test("listCommsFunctions covers the seven functions (incl. finance-leader)", () => {
-  assert.equal(listCommsFunctions().length, 7);
-});

package/lib/cost/ledger-row.test.mjs

@@ -1,183 +0,0 @@
-/**
- * lib/cost/ledger-row.test.mjs — the measured / unmeasured / non-LLM contract.
- *
- * The bug these lock down: an absent token count and a genuine zero used to
- * produce identical rows, and every reader summed both as $0. That is what made
- * the budget governor unable to trip.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  classifyRow,
-  billableUsd,
-  summariseRows,
-  imputeUnmeasured,
-  MEASURED,
-  UNKNOWN,
-  NON_LLM,
-  INVALID,
-} from "./ledger-row.mjs";
-
-// A real dispatcher row copied from the live ledger (2026-08-12). Note the
-// shape that broke the old estimator: 16 uncached input tokens against 553k
-// cache reads, and an authoritative cost 7x the token-table estimate.
-const REAL_ROW = {
-  ts: "2026-08-12T00:09:36.073Z", cadence: "inbox", source: "dispatcher",
-  model: "sonnet", duration_ms: 64728, input_tokens: 16, output_tokens: 5000,
-  exit_code: 0, cache_read_input_tokens: 553181,
-  estimated_usd: 0.075048, total_cost_usd: 0.533412,
-};
-
-test("classifyRow: explicit measurement wins", () => {
-  assert.equal(classifyRow({ measurement: "measured", input_tokens: 1 }), MEASURED);
-  assert.equal(classifyRow({ measurement: "unknown", input_tokens: null }), UNKNOWN);
-  assert.equal(classifyRow({ measurement: "n/a" }), NON_LLM);
-  assert.equal(classifyRow(null), INVALID);
-  assert.equal(classifyRow("nope"), INVALID);
-});
-
-test("classifyRow: legacy rows are inferred without a migration", () => {
-  // Real dispatcher row, no `measurement` field.
-  assert.equal(classifyRow(REAL_ROW), MEASURED);
-  // Real messaging attribution row: no model, zero tokens => not a session.
-  assert.equal(
-    classifyRow({ source: "messaging", model: null, input_tokens: 0, output_tokens: 0, estimated_usd: 0 }),
-    NON_LLM
-  );
-  // Null tokens on both sides => unmeasured.
-  assert.equal(classifyRow({ model: "sonnet", input_tokens: null, output_tokens: null }), UNKNOWN);
-});
-
-test("classifyRow: a real session that used zero output tokens is still MEASURED", () => {
-  // The distinction that matters: a model ran and produced nothing is a
-  // measurement; it must not be confused with "we never looked".
-  assert.equal(classifyRow({ model: "sonnet", input_tokens: 120, output_tokens: 0 }), MEASURED);
-});
-
-test("billableUsd: authoritative CLI cost beats the local estimate", () => {
-  const { usd, basis } = billableUsd(REAL_ROW);
-  assert.equal(basis, "authoritative");
-  assert.equal(usd, 0.533412);
-  // The whole point: the old path would have billed the estimate.
-  assert.notEqual(usd, REAL_ROW.estimated_usd);
-});
-
-test("billableUsd: falls back to the estimate and says so", () => {
-  const { usd, basis } = billableUsd({ ...REAL_ROW, total_cost_usd: undefined });
-  assert.equal(basis, "estimated");
-  assert.equal(usd, 0.075048);
-});
-
-test("billableUsd: an unmeasured session costs NULL, not zero", () => {
-  const { usd, basis } = billableUsd({ measurement: "unknown", input_tokens: null, output_tokens: null });
-  assert.equal(usd, null);
-  assert.equal(basis, "unmeasured");
-});
-
-test("billableUsd: usage with no price is UNPRICED — a distinct bug from unmeasured, and still not free", () => {
-  const { usd, basis, cls } = billableUsd({ model: "sonnet", input_tokens: 5, output_tokens: 5 });
-  assert.equal(usd, null, "never 0 — a pricing outage must not read as a free session");
-  assert.equal(basis, "unpriced", "the telemetry worked; the PRICING did not");
-  assert.equal(cls, UNKNOWN);
-});
-
-test("billableUsd: a $0 price on a row that named a model is unpriceable, not free", () => {
-  // lib/model-router/ledger.mjs used to default `estimated_usd` to 0 whenever
-  // estimateCost returned null (a model missing from the catalog), and that 0
-  // billed as a measured free session. Both zeroes now fall through.
-  const zeroed = billableUsd({ model: "opus", input_tokens: 900, output_tokens: 40, total_cost_usd: 0, estimated_usd: 0 });
-  assert.equal(zeroed.usd, null);
-  assert.equal(zeroed.basis, "unpriced");
-});
-
-test("billableUsd: a zero-model attribution row is a real $0, not a gap", () => {
-  const { usd, basis } = billableUsd({ source: "messaging", model: null, input_tokens: 0, output_tokens: 0 });
-  assert.equal(usd, 0);
-  assert.equal(basis, "non_llm");
-});
-
-test("summariseRows: separates sessions from attribution rows", () => {
-  const s = summariseRows([
-    REAL_ROW,
-    { ...REAL_ROW, total_cost_usd: 1 },
-    { source: "messaging", model: null, input_tokens: 0, output_tokens: 0 },
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-  ]);
-  assert.equal(s.sessions, 3, "2 measured + 1 unmeasured; the send is not a session");
-  assert.equal(s.measured, 2);
-  assert.equal(s.unmeasured, 1);
-  assert.equal(s.nonLlmRows, 1);
-  assert.equal(s.measuredUsd, 1.533412);
-  assert.equal(s.blind, false);
-});
-
-test("summariseRows: blind only when sessions ran and NONE were measured", () => {
-  assert.equal(summariseRows([]).blind, false, "an empty ledger is quiet, not blind");
-  assert.equal(
-    summariseRows([{ source: "messaging", model: null, input_tokens: 0, output_tokens: 0 }]).blind,
-    false,
-    "attribution rows alone must not arm the alarm"
-  );
-  assert.equal(
-    summariseRows([{ measurement: "unknown", input_tokens: null, output_tokens: null }]).blind,
-    true
-  );
-});
-
-test("summariseRows: every degradation is reported, never swallowed", () => {
-  const s = summariseRows([
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-    { ...REAL_ROW, total_cost_usd: undefined },
-    "malformed",
-  ]);
-  assert.equal(s.degradations.length, 3);
-  assert.match(s.degradations.join(" | "), /recorded NO token counts/);
-  assert.match(s.degradations.join(" | "), /no authoritative total_cost_usd/);
-  assert.match(s.degradations.join(" | "), /malformed/);
-});
-
-test("imputeUnmeasured: unmeasured sessions cost the day's mean, not zero", () => {
-  const s = summariseRows([
-    { ...REAL_ROW, total_cost_usd: 2 },
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-    { measurement: "unknown", input_tokens: null, output_tokens: null },
-  ]);
-  const imp = imputeUnmeasured(s);
-  assert.equal(imp.basis, "day_mean");
-  assert.equal(imp.perSessionUsd, 2);
-  assert.equal(imp.imputedUsd, 4);
-});
-
-test("imputeUnmeasured: a blind day imputes from the PERIOD mean when the day has nothing", () => {
-  // The anti-starvation property, without a magic number. The old fallback was a
-  // hard-coded $0.25/session — ~8x below this fleet's observed $1.95 mean — so a
-  // total outage on a day that really cost $68.40 (274% of a $25 cap) imputed
-  // $8.75 and reported band 0. Under-imputing is the silent-governor bug.
-  const s = summariseRows([{ measurement: "unknown", input_tokens: null, output_tokens: null }]);
-  const imp = imputeUnmeasured(s, { fallbackPerSessionUsd: 1.95 });
-  assert.equal(imp.basis, "period_mean");
-  assert.equal(imp.perSessionUsd, 1.95);
-  assert.equal(imp.imputedUsd, 1.95);
-  assert.equal(imp.unpriceable, false);
-});
-
-test("imputeUnmeasured: with NO evidence at any horizon it refuses to invent a price", () => {
-  // And says so. The caller (lib/budget-guard.dailyStatus) floors the band at
-  // DEGRADE on `unpriceable`, which needs no price table: we cannot measure,
-  // therefore we degrade. Returning a made-up dollar figure here is what let a
-  // $68 day read as band 0.
-  const s = summariseRows([{ measurement: "unknown", input_tokens: null, output_tokens: null }]);
-  const imp = imputeUnmeasured(s);
-  assert.equal(imp.basis, "unpriceable");
-  assert.equal(imp.imputedUsd, 0);
-  assert.equal(imp.unpriceable, true);
-  assert.equal(s.blind, true, "the signal the band floor keys off");
-});
-
-test("imputeUnmeasured: nothing unmeasured means nothing imputed", () => {
-  const imp = imputeUnmeasured(summariseRows([REAL_ROW]));
-  assert.equal(imp.imputedUsd, 0);
-  assert.equal(imp.basis, "none");
-});

package/lib/design/design-md.test.mjs

@@ -1,318 +0,0 @@
-/**
- * design-md.test.mjs — the foundation → DESIGN.md / PRODUCT.md renderer
- * (WP-M7 mechanic 4).
- *
- * The centrepiece is a GOLDEN FILE pair rendered from a realistic foundation
- * fixture. A golden is the right instrument here because the output is a
- * contract with things this repo cannot import: the google-labs-code/design.md
- * frontmatter shape that vendored design skills parse, and the `{colors.primary}`
- * ref grammar they resolve. Assertions on a handful of substrings would let a
- * reshuffle of the frontmatter — the one edit that actually breaks a consumer —
- * pass green.
- *
- * Regenerate deliberately, never reflexively:
- *   node -e 'import("./lib/design/design-md.mjs").then(async m => {
- *     const { readFileSync, writeFileSync } = await import("node:fs");
- *     const f = JSON.parse(readFileSync("lib/design/fixtures/foundation.json","utf8"));
- *     const o = { name: "Northwind", generatedAt: "2026-09-08T12:00:00.000Z", versionId: "bv_01HQZ", versionLabel: "V2.7" };
- *     writeFileSync("lib/design/fixtures/DESIGN.golden.md", m.renderDesignMd(f, o));
- *     writeFileSync("lib/design/fixtures/PRODUCT.golden.md", m.renderProductMd(f, o));
- *   })'
- * — and read the diff. A changed golden is a changed contract with every design
- * skill on every seat.
- *
- * The rest of the file pins the properties a golden cannot state: purity,
- * tolerance of unknown keys, and graceful degradation on an empty foundation.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  renderDesignMd,
-  renderProductMd,
-  renderDesignBundle,
-  additionalTokens,
-  colorTokens,
-  scaleTokens,
-  typographyTokens,
-  componentRefs,
-  tokenRef,
-  slugToken,
-  KNOWN_FOUNDATION_KEYS,
-  KNOWN_SYSTEM_KEYS,
-  KNOWN_VISUAL_LANGUAGE_KEYS,
-} from "./design-md.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const FIXTURES = join(HERE, "fixtures");
-const fixture = () => JSON.parse(readFileSync(join(FIXTURES, "foundation.json"), "utf8"));
-const golden = (name) => readFileSync(join(FIXTURES, name), "utf8");
-
-/** The injected options the goldens were rendered with. Nothing ambient. */
-const OPTS = {
-  name: "Northwind",
-  generatedAt: "2026-09-08T12:00:00.000Z",
-  versionId: "bv_01HQZ",
-  versionLabel: "V2.7",
-};
-
-test("DESIGN.md matches the golden, byte for byte", () => {
-  assert.equal(renderDesignMd(fixture(), OPTS), golden("DESIGN.golden.md"));
-});
-
-test("PRODUCT.md matches the golden, byte for byte", () => {
-  assert.equal(renderProductMd(fixture(), OPTS), golden("PRODUCT.golden.md"));
-});
-
-test("renderDesignBundle is the two files, at their relative paths", () => {
-  const bundle = renderDesignBundle(fixture(), OPTS);
-  assert.deepEqual(bundle.map((f) => f.rel), ["DESIGN.md", "PRODUCT.md"]);
-  assert.equal(bundle[0].content, golden("DESIGN.golden.md"));
-  assert.equal(bundle[1].content, golden("PRODUCT.golden.md"));
-});
-
-test("the renderer is pure — same input, same bytes, and the input is not mutated", () => {
-  const f = fixture();
-  const snapshot = JSON.stringify(f);
-  const a = renderDesignMd(f, OPTS);
-  const b = renderDesignMd(f, OPTS);
-  assert.equal(a, b);
-  assert.equal(JSON.stringify(f), snapshot, "the foundation object is untouched");
-
-  // And nothing ambient leaks in: no timestamp appears unless one was injected.
-  const noStamp = renderDesignMd(f, { ...OPTS, generatedAt: undefined });
-  assert.ok(!noStamp.includes("generatedAt:"), "no clock is read when none is given");
-  assert.ok(!noStamp.includes("**Synced:**"));
-});
-
-test("frontmatter carries the design.md spec's blocks, with {group.key} component refs", () => {
-  const md = renderDesignMd(fixture(), OPTS);
-  const fm = md.slice(0, md.indexOf("\n---\n", 4) + 5);
-  for (const block of ["colors:", "typography:", "rounded:", "spacing:", "components:"]) {
-    assert.ok(fm.includes(`\n${block}`) || fm.startsWith(block), `frontmatter has ${block}`);
-  }
-  assert.match(fm, /button:\n {4}background: "\{colors\.primary\}"/);
-  assert.match(fm, /card:\n {4}background: "\{colors\.paper\}"/);
-  // Every component value is a ref, never a literal — that is what makes a
-  // token change propagate without rewriting the component block.
-  const componentBlock = fm.slice(fm.indexOf("components:"));
-  for (const line of componentBlock.split("\n").filter((l) => /^ {4}\w+: /.test(l))) {
-    assert.match(line, /"\{[a-z]+\.[a-z0-9-]+\}( \{[a-z]+\.[a-z0-9-]+\})?"$/, `component ref: ${line}`);
-  }
-});
-
-test("an unknown foundation key lands in Additional tokens rather than vanishing", () => {
-  const f = fixture();
-  f.blurRamp = { sm: "4px", lg: "24px" };
-  f.brandedNoiseSeed = "spruce-11";
-  const md = renderDesignMd(f, OPTS);
-
-  assert.match(md, /## Additional tokens/);
-  assert.match(md, /"blurRamp"/);
-  assert.match(md, /"brandedNoiseSeed": "spruce-11"/);
-  assert.match(md, /"lg": "24px"/, "the nested value survives, not just the key name");
-
-  // The property in one line: nothing the foundation carried is absent.
-  assert.deepEqual(
-    additionalTokens(f).map(([k]) => k),
-    ["blurRamp", "brandedNoiseSeed", "elevationCurve", "examples", "gridUnit"],
-    "unmodelled keys, sorted, all of them",
-  );
-  for (const key of Object.keys(f)) {
-    const modelled = KNOWN_FOUNDATION_KEYS.includes(key);
-    if (!modelled) assert.ok(md.includes(`"${key}"`), `${key} appears verbatim`);
-  }
-});
-
-test("a foundation with only modelled keys says so, instead of an empty section", () => {
-  const f = fixture();
-  delete f.elevationCurve;
-  delete f.gridUnit;
-  delete f.examples;
-  assert.deepEqual(additionalTokens(f), []);
-  assert.match(renderDesignMd(f, OPTS), /_None — every key in the foundation is modelled above\._/);
-});
-
-test("an empty / absent / malformed foundation renders a valid, honest file", () => {
-  for (const input of [{}, null, undefined, "not an object", 7, []]) {
-    const md = renderDesignMd(input, {});
-    assert.ok(md.startsWith("---\nname: \"Workspace\"\n"), "still valid frontmatter");
-    assert.equal(md.split("\n---\n").length, 2, "exactly one closing fence");
-    assert.match(md, /colors:\n {2}\{\}/, "an empty block is `{}`, not a dangling key");
-    assert.match(md, /_No palette in the foundation\._/);
-    assert.ok(md.endsWith("\n"), "ends with exactly one newline");
-    assert.ok(!md.endsWith("\n\n"));
-
-    const pm = renderProductMd(input, {});
-    assert.match(pm, /## Nothing set yet/);
-    assert.ok(pm.endsWith("\n"));
-  }
-});
-
-test("colour ROLE aliases resolve so {colors.primary} always points somewhere", () => {
-  // The palette names its shades ("Primary · Moss"); a component ref must still
-  // be able to say `{colors.primary}`.
-  const { light, dark } = colorTokens({ colors: [{ name: "Primary · Moss", value: "#2d5be3", dark: "#7ea0ff" }] });
-  assert.equal(light["primary-moss"], "#2d5be3");
-  assert.equal(light.primary, "#2d5be3", "aliased from the shade name");
-  assert.equal(dark.primary, "#7ea0ff");
-
-  // system.color.roles outranks nothing it would overwrite, but fills a gap.
-  const withRole = colorTokens({
-    colors: [{ name: "Ink", value: "#000" }],
-    system: { color: { roles: { primary: { value: "#123456" } } } },
-  });
-  assert.equal(withRole.light.primary, "#123456");
-});
-
-test("a semantic colour that collides with a palette name is kept under semantic-*", () => {
-  const { light } = colorTokens({
-    colors: [{ name: "Danger", value: "#ff0000" }],
-    system: { color: { semantic: { danger: "#a11d1d" } } },
-  });
-  assert.equal(light.danger, "#ff0000", "the palette wins the plain key");
-  assert.equal(light["semantic-danger"], "#a11d1d", "and the semantic token is still not lost");
-});
-
-test("tokenRef prefers a named key, falls back to the first, and returns null on empty", () => {
-  assert.equal(tokenRef("rounded", { chip: "8px", pill: "999px" }, ["pill"]), "{rounded.pill}");
-  assert.equal(tokenRef("rounded", { chip: "8px" }, ["pill"]), "{rounded.chip}");
-  assert.equal(tokenRef("rounded", {}, ["pill"]), null);
-});
-
-test("a component field whose group is empty is omitted, never emitted as a dead ref", () => {
-  const comps = componentRefs({ colors: { primary: "#000", paper: "#fff", ink: "#111" }, rounded: {}, spacing: {}, shadow: {}, border: {}, faces: {} });
-  const flat = comps.flatMap(([, fields]) => fields.map(([k]) => k));
-  assert.ok(flat.includes("background"));
-  assert.ok(!flat.includes("radius"), "no rounded tokens → no radius field");
-  assert.ok(!flat.includes("padding"), "no spacing tokens → no padding field");
-  for (const [, fields] of comps) for (const [, v] of fields) assert.ok(v && !v.includes("{undefined"), v);
-});
-
-test("scaleTokens turns numbers into px and passes strings through", () => {
-  assert.deepEqual(scaleTokens([{ name: "sm", value: 8 }, { name: "hairline", value: "1px solid #eee" }]), {
-    sm: "8px",
-    hairline: "1px solid #eee",
-  });
-  assert.deepEqual(scaleTokens(null), {});
-  assert.deepEqual(scaleTokens([null, 3, { name: "", value: 4 }, { name: "ok" }]), {});
-});
-
-test("typographyTokens falls back to system.typography.families for a face fonts lacks", () => {
-  const { faces, scale } = typographyTokens({
-    fonts: { body: "Inter" },
-    system: { typography: { families: { heading: { family: "Outfit" } } } },
-    type: [{ role: "Body", size: 14, weight: 400 }, { role: "Body", size: 99, weight: 100 }],
-  });
-  assert.deepEqual(faces, { body: "Inter", heading: "Outfit" });
-  assert.equal(scale.length, 1, "a duplicate role is taken once — first wins");
-  assert.equal(scale[0].size, "14px");
-});
-
-test("slugToken makes a YAML/ref-safe key out of anything", () => {
-  assert.equal(slugToken("Primary · Moss"), "primary-moss");
-  assert.equal(slugToken("2xl"), "2xl");
-  assert.equal(slugToken("  Café  "), "cafe");
-  assert.equal(slugToken(""), "");
-  assert.equal(slugToken(null), "");
-});
-
-test("KNOWN_FOUNDATION_KEYS lists what the renderer EMITS, not what it recognises", () => {
-  // Kept in step by hand with src/lib/branding/foundation.ts#brandFoundationSchema
-  // in the hq repo. If hq gains a key, the renderer parks it in "Additional
-  // tokens" until someone models it — which is the tolerant behaviour, not a bug.
-  assert.deepEqual([...KNOWN_FOUNDATION_KEYS].sort(), [
-    "border", "colors", "fonts", "logos", "positioning", "radii",
-    "shadow", "space", "system", "taglines", "toneTraits", "type", "v",
-    "visualLanguage", "voice",
-  ]);
-  // `examples` is hq's (`z.any()`), and NOTHING here renders it — so it must
-  // not be on the list. A key listed as known that no renderer emits is
-  // dropped in silence, which is the one failure this module exists to prevent.
-  assert.ok(!KNOWN_FOUNDATION_KEYS.includes("examples"));
-});
-
-// ── the nested blocks: silence is the failure mode ──────────────────────────
-
-test("`examples` is not modelled anywhere, so it lands in Additional tokens verbatim", () => {
-  const f = fixture();
-  f.examples = { hero: "zzz-hero-marker", cta: "zzz-cta-marker" };
-  const md = renderDesignMd(f, OPTS);
-  assert.match(md, /## Additional tokens/);
-  assert.match(md, /"zzz-hero-marker"/);
-  assert.match(md, /"zzz-cta-marker"/);
-  assert.deepEqual(additionalTokens(f).find(([k]) => k === "examples")[1], f.examples);
-});
-
-test("system.imagery is rendered — it is a different block from visualLanguage.imagery, and both appear", () => {
-  const md = renderDesignMd(fixture(), OPTS);
-  assert.match(md, /### Imagery\n/, "the art-direction block");
-  assert.match(md, /### Imagery \(brand system\)\n/, "and the brand system's own");
-  assert.match(md, /- \*\*Treatment:\*\* warm highlights, cool shadows/, "a field only system.imagery has");
-  assert.match(md, /- \*\*Avoid:\*\* stock handshakes, isolated laptops/);
-  // And the pair visualLanguage.imagery carries that nothing used to emit.
-  assert.match(md, /- \*\*Duotone:\*\* shadow #12213f · highlight #f3ede1/);
-});
-
-test("visualLanguage's generation seeds and provenance are emitted, not swallowed", () => {
-  const md = renderDesignMd(fixture(), OPTS);
-  assert.match(md, /- \*\*Prompt seed:\*\* quiet rooms, natural light, fine grain/);
-  assert.match(md, /- \*\*Seed locked:\*\* yes/);
-  assert.match(md, /- \*\*Negative seed:\*\* neon, lens flare/);
-  assert.match(md, /- \*\*References:\*\* moodboard\/2026-03/);
-});
-
-test("an unmodelled SUB-key of system / visualLanguage lands in Additional tokens too", () => {
-  const f = fixture();
-  f.system.holography = { medium: "zzz-system-marker" };
-  f.visualLanguage.parallax = "zzz-vl-marker";
-  const md = renderDesignMd(f, OPTS);
-  assert.deepEqual(
-    additionalTokens(f).map(([k]) => k),
-    ["elevationCurve", "examples", "gridUnit", "system.holography", "visualLanguage.parallax"],
-    "dotted paths, one level into the two blocks hq actually grows",
-  );
-  assert.match(md, /"zzz-system-marker"/);
-  assert.match(md, /"zzz-vl-marker"/);
-});
-
-test("every sub-key the fixture carries is claimed by a renderer, so nothing rides on the fold", () => {
-  // The fold is a safety net for an hq that grows a block. It must not be
-  // load-bearing for anything shipping today: if a sub-key of these two blocks
-  // shows up in "Additional tokens" for the realistic fixture, a renderer was
-  // meant to emit it and does not.
-  const f = fixture();
-  assert.deepEqual(additionalTokens(f).map(([k]) => k).filter((k) => k.includes(".")), []);
-  for (const k of Object.keys(f.system)) assert.ok(KNOWN_SYSTEM_KEYS.includes(k), `system.${k}`);
-  for (const k of Object.keys(f.visualLanguage)) assert.ok(KNOWN_VISUAL_LANGUAGE_KEYS.includes(k), `visualLanguage.${k}`);
-});
-
-test("leading and tracking come from system.typography.scale — foundation.type never carries them", () => {
-  // hq's typeRoleSchema is {role, size, weight}, full stop. Reading leading off
-  // it was dead code; the tuned values live in a different array keyed by the
-  // same role names.
-  const { scale } = typographyTokens({
-    type: [{ role: "Display", size: 76, weight: 600 }],
-    system: { typography: { scale: [{ role: "Display", size: 9, weight: 100, leading: 1.05, tracking: -0.02 }] } },
-  });
-  assert.deepEqual(scale, [{ key: "display", size: "76px", weight: "600", leading: "1.05", tracking: "-0.02" }]);
-
-  // A role only the system scale names is still rendered, not lost.
-  const { scale: extra } = typographyTokens({
-    type: [{ role: "Body", size: 14, weight: 400 }],
-    system: { typography: { scale: [{ role: "Caption", size: 11, weight: 500, leading: 1.4 }] } },
-  });
-  assert.deepEqual(extra.map((r) => r.key), ["body", "caption"]);
-  assert.equal(extra[1].leading, "1.4");
-
-  // And a value put on `type` where hq never puts one is ignored rather than
-  // quietly inventing a leading no surface can produce.
-  const { scale: bogus } = typographyTokens({ type: [{ role: "Body", size: 14, weight: 400, leading: 9 }] });
-  assert.equal(bogus[0].leading, "");
-
-  assert.match(renderDesignMd(fixture(), OPTS), /display: \{ size: "76px", weight: 600, leading: 1\.05, tracking: -0\.02 \}/);
-});