@cohortapp/agent-sdk 2.12.0 → 2.14.0

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

@@ -0,0 +1,318 @@
+/**
+ * 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 \}/);
+});

package/lib/design/fixtures/DESIGN.golden.md

@@ -0,0 +1,238 @@
+---
+name: "Northwind"
+version: "bv_01HQZ"
+generatedAt: "2026-09-08T12:00:00.000Z"
+source: "cohort · branding.getFoundation"
+colors:
+  ink: "#0d0d0d"
+  paper: "#ffffff"
+  primary-moss: "#2d5be3"
+  muted: "#6b7280"
+  accent-amber: "#c9851f"
+  line: "#e7e5e4"
+  primary: "#2d5be3"
+  accent: "#c9851f"
+  success: "#177245"
+  warning: "#c9851f"
+  danger: "#a11d1d"
+  neutral-100: "#f5f5f4"
+  neutral-500: "#78716c"
+  neutral-900: "#1c1917"
+colorsDark:
+  ink: "#f5f5f4"
+  paper: "#0b0b0c"
+  primary-moss: "#7ea0ff"
+  line: "#26262a"
+  primary: "#7ea0ff"
+typography:
+  display: "Outfit"
+  body: "Inter"
+  mono: "JetBrains Mono"
+  heading: "Outfit"
+  scale:
+    display: { size: "76px", weight: 600, leading: 1.05, tracking: -0.02 }
+    heading: { size: "38px", weight: 600, leading: 1.15, tracking: -0.01 }
+    body: { size: "14px", weight: 400, leading: 1.5 }
+    small: { size: "11.5px", weight: 500 }
+    caption: { size: "11px", weight: 500, leading: 1.4, tracking: 0.04 }
+rounded:
+  chip: "8px"
+  field: "9px"
+  card: "13px"
+  modal: "14px"
+  pill: "999px"
+spacing:
+  xs: "4px"
+  sm: "8px"
+  md: "12px"
+  lg: "16px"
+  xl: "22px"
+shadow:
+  sm: "0 1px 2px rgba(13,13,13,0.06)"
+  md: "0 18px 50px rgba(13,13,13,0.13)"
+border:
+  hairline: "1px solid #e7e5e4"
+  strong: "1px solid #d6d3d1"
+components:
+  button:
+    background: "{colors.primary}"
+    foreground: "{colors.paper}"
+    radius: "{rounded.pill}"
+    padding: "{spacing.sm} {spacing.lg}"
+    font: "{typography.body}"
+  card:
+    background: "{colors.paper}"
+    foreground: "{colors.ink}"
+    border: "{border.hairline}"
+    radius: "{rounded.card}"
+    padding: "{spacing.xl}"
+    shadow: "{shadow.md}"
+  input:
+    background: "{colors.paper}"
+    border: "{border.hairline}"
+    radius: "{rounded.field}"
+    padding: "{spacing.sm} {spacing.md}"
+    font: "{typography.body}"
+  surface:
+    background: "{colors.paper}"
+    foreground: "{colors.ink}"
+    muted: "{colors.muted}"
+    radius: "{rounded.modal}"
+---
+
+# Northwind — design system
+
+The frontmatter above is the token contract: it is generated from the workspace's
+saved brand foundation and is the source of truth for colour, type, radius and
+spacing. Read it before you pick a value. Component entries are written as
+`{group.key}` refs, so changing a token changes every component that names it.
+
+This file is GENERATED — edits here are overwritten on the next sync. To change
+the foundation itself, propose the change (`design_propose_change`); a human
+reviews and applies it, and the next sync brings it back down.
+
+## Palette
+
+- `{colors.ink}` — #0d0d0d (dark #f5f5f4)
+- `{colors.paper}` — #ffffff (dark #0b0b0c)
+- `{colors.primary-moss}` — #2d5be3 (dark #7ea0ff)
+- `{colors.muted}` — #6b7280
+- `{colors.accent-amber}` — #c9851f
+- `{colors.line}` — #e7e5e4 (dark #26262a)
+- `{colors.primary}` — #2d5be3 (dark #7ea0ff)
+- `{colors.accent}` — #c9851f
+- `{colors.success}` — #177245
+- `{colors.warning}` — #c9851f
+- `{colors.danger}` — #a11d1d
+- `{colors.neutral-100}` — #f5f5f4
+- `{colors.neutral-500}` — #78716c
+- `{colors.neutral-900}` — #1c1917
+
+## Typography
+
+- **display:** Outfit
+- **body:** Inter
+- **mono:** JetBrains Mono
+- **heading:** Outfit
+
+- `{typography.scale.display}` — 76px · weight 600 · leading 1.05 · tracking -0.02
+- `{typography.scale.heading}` — 38px · weight 600 · leading 1.15 · tracking -0.01
+- `{typography.scale.body}` — 14px · weight 400 · leading 1.5
+- `{typography.scale.small}` — 11.5px · weight 500
+- `{typography.scale.caption}` — 11px · weight 500 · leading 1.4 · tracking 0.04
+
+### Type rules
+
+One geometric face for structure, one humanist face for reading.
+
+- Display only above 32px.
+- Never set body copy below 13px.
+
+### Colour rules
+
+- One primary per view.
+- Semantic colour is for state, never decoration.
+
+## Visual language
+
+### Imagery
+
+- **Uses imagery:** yes
+- **Medium:** photography
+- **Secondary media:** diagram
+- **Grade:** natural
+- **Grain:** fine
+- **Crop:** wide
+- **Aspect ratios:** 16/9, 1/1
+- **Subjects:** hands at work, quiet rooms
+- **Mood:** calm, considered
+- **Composition:** off-centre, generous negative space
+- **Duotone:** shadow #12213f · highlight #f3ede1
+
+### Imagery (brand system)
+
+- **Medium:** documentary photography
+- **Style:** unstaged
+- **Treatment:** warm highlights, cool shadows
+- **Mood:** assured
+- **Subjects:** workshops, field crews
+- **Avoid:** stock handshakes, isolated laptops
+
+### Iconography
+
+- **Style:** line
+- **Weight:** 1.5px
+- **Corner:** rounded
+- **Grid:** 24
+
+### Motion
+
+- **Character:** settled
+- **Easing:** cubic-bezier(0.2, 0, 0, 1)
+- **Duration (ms):** 220
+- **Principles:** Move once, arrive., Never animate what a person is reading.
+
+### Texture
+
+- **Surfaces:** paper, frosted glass
+- **Background:** flat
+- **Notes:** No gradients behind text.
+
+### Guardrails
+
+Do:
+
+- Let type carry the page.
+- Use one accent per view.
+
+Do not:
+
+- No stock handshakes.
+- No drop shadows on text.
+
+### Generation seeds
+
+- **Prompt seed:** quiet rooms, natural light, fine grain
+- **Seed locked:** yes
+- **Negative seed:** neon, lens flare
+- **References:** moodboard/2026-03
+- **Source:** generated
+- **Schema version:** 2
+
+## Layout principles
+
+- Left-align everything that reads.
+- One idea per band.
+
+## Marks
+
+- `brandIcon` — set
+- `wordmark` — set
+
+Fetch the bytes with `design_export_kit`; never inline them here.
+
+## Additional tokens
+
+Keys the renderer does not model yet, carried through verbatim so nothing is
+lost between an hq that added a token and an SDK that has not learned it.
+
+```json
+{
+  "elevationCurve": {
+    "0": "none",
+    "1": "0 1px 2px rgba(0,0,0,0.05)"
+  },
+  "examples": {
+    "hero": "A crew at first light.",
+    "cta": "Start the walkthrough"
+  },
+  "gridUnit": 4
+}
+```
+
+## Provenance
+
+- **Version:** V2.7
+- **Version id:** bv_01HQZ
+- **Synced:** 2026-09-08T12:00:00.000Z
+- **Source:** cohort · branding.getFoundation

package/lib/design/fixtures/PRODUCT.golden.md

@@ -0,0 +1,67 @@
+---
+name: "Northwind"
+version: "bv_01HQZ"
+generatedAt: "2026-09-08T12:00:00.000Z"
+source: "cohort · branding.getFoundation"
+---
+
+# Northwind — product voice
+
+Generated from the workspace's saved brand foundation. It says how this
+product sounds; `DESIGN.md` beside it says how it looks. Read both before
+writing anything a customer sees. Edits here are overwritten on the next
+sync — propose foundation changes with `design_propose_change`.
+
+## Positioning
+
+The operating system for companies that run on agents as well as people.
+
+## Taglines
+
+- Work that runs itself.
+- One company, many hands.
+
+## Voice
+
+Concise, specific, accountable. Write like a capable peer — no hype, no emoji, no hedging.
+
+## Tone
+
+- Plain
+- Exact
+- Unhurried
+- Direct
+
+## Lexicon
+
+Say:
+
+- decide
+- ship
+- owe
+
+Avoid:
+
+- leverage
+- synergy
+- unlock
+
+## In practice
+
+Two invoices need a decision today. Both are under £5,000.
+
+## Motifs
+
+- A single hairline rule.
+- Numbers set in the mono face.
+
+## Iconography
+
+Line icons on a 24px grid, 1.5px stroke.
+
+## Provenance
+
+- **Version:** V2.7
+- **Version id:** bv_01HQZ
+- **Synced:** 2026-09-08T12:00:00.000Z
+- **Source:** cohort · branding.getFoundation