@event4u/agent-config 16.4.0 → 17.0.0

package/dist/agent-src/skills/storybook-workshop/scripts/story_contrast_floor.mjs

@@ -0,0 +1,99 @@
+// src/skills/storybook-workshop/scripts/story_contrast_floor.ts
+import * as fs from "node:fs";
+var AA_NORMAL = 4.5;
+var AA_LARGE = 3;
+var clamp01 = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
+var luminance = (hex) => {
+  const m = /^#?([0-9a-f]{6}|[0-9a-f]{3})$/i.exec(hex.trim());
+  if (m === null) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => `${c}${c}`).join("");
+  const channel = (pair) => {
+    const v = clamp01(parseInt(pair, 16) / 255);
+    return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+  };
+  const r = channel(h.slice(0, 2));
+  const g = channel(h.slice(2, 4));
+  const b = channel(h.slice(4, 6));
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+var contrastRatio = (fg, bg) => {
+  const a = luminance(fg);
+  const b = luminance(bg);
+  if (a === null || b === null) return null;
+  const [hi, lo] = a >= b ? [a, b] : [b, a];
+  return (hi + 0.05) / (lo + 0.05);
+};
+var declaredPairs = (source) => {
+  const out = [];
+  const exportRe = /export\s+const\s+([A-Za-z0-9_]+)\s*:[^=]*=\s*\{([\s\S]*?)\n\};/g;
+  for (const m of source.matchAll(exportRe)) {
+    const story = m[1];
+    const body = m[2];
+    const fg = /(?:color|fg|foreground)\s*:\s*['"](#[0-9a-fA-F]{3,6})['"]/.exec(body);
+    const bg = /(?:background|bg|backgroundColor)\s*:\s*['"](#[0-9a-fA-F]{3,6})['"]/.exec(body);
+    if (fg?.[1] !== void 0 && bg?.[1] !== void 0) {
+      out.push({ story, fg: fg[1], bg: bg[1] });
+    }
+  }
+  return out;
+};
+var checkStoryFile = (file, floor = AA_NORMAL) => {
+  let source = "";
+  try {
+    source = fs.readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const { story, fg, bg } of declaredPairs(source)) {
+    const ratio = contrastRatio(fg, bg);
+    if (ratio === null || ratio >= floor) continue;
+    out.push({
+      rule: "color-contrast",
+      // The story is the addressable unit here — there is no DOM to select into.
+      selector: `story:${story}`,
+      severity: "error",
+      ratio: Math.round(ratio * 100) / 100
+    });
+  }
+  return out;
+};
+var selfTest = () => {
+  let failed = 0;
+  const check = (label, cond) => {
+    if (!cond) {
+      process.stderr.write(`\u274C  ${label}
+`);
+      failed += 1;
+    }
+  };
+  const r = contrastRatio("#000000", "#ffffff");
+  check("black on white is the maximum 21:1", r !== null && Math.abs(r - 21) < 0.01);
+  check("a colour on itself is 1:1", Math.abs((contrastRatio("#777777", "#777777") ?? 0) - 1) < 0.01);
+  check("an unreadable colour is null, not 0", contrastRatio("nope", "#fff") === null);
+  check("shorthand hex is expanded", contrastRatio("#000", "#fff") !== null);
+  process.stdout.write(failed === 0 ? "\u2705  story_contrast_floor: self-test passed\n" : `\u274C  ${String(failed)} failure(s)
+`);
+  return failed === 0 ? 0 : 1;
+};
+var main = () => {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--self-test")) return selfTest();
+  const files = argv.filter((a) => !a.startsWith("--"));
+  const violations = files.flatMap((f) => checkStoryFile(f));
+  process.stdout.write(`${JSON.stringify({ violations }, null, 2)}
+`);
+  return violations.length > 0 ? 1 : 0;
+};
+if (process.argv[1] !== void 0 && process.argv[1].includes("story_contrast_floor")) {
+  process.exit(main());
+}
+export {
+  AA_LARGE,
+  AA_NORMAL,
+  checkStoryFile,
+  contrastRatio,
+  declaredPairs,
+  luminance
+};

package/dist/agent-src/skills/subagent-orchestration/SKILL.md

@@ -116,9 +116,9 @@ Rules:
   continues the parent's task under identical tools and constraints (it then
   reads the parent's cache on its first request); a named subagent is
   preferred the moment isolation, a different tool set, or nested dispatch is
-  needed — a fork cannot nest, and forking forces background mode, which
-  changes the tool set and invalidates the very prefix that motivated the
-  fork. `do-in-parallel`-shaped fan-out from one parent has this shape by
+  needed — a fork cannot nest. Where the host row says `fork_shares_cache:
+  true` a background fork keeps the parent's prefix and tools; elsewhere it
+  is unseen. `do-in-parallel`-shaped fan-out from one parent has this shape by
   construction (a known, unfixable upstream cost — see
   [`prompts/README.md`](prompts/README.md) § Prompt-cache discipline). NEVER
   encode "always fork" — that was proposed and cut (council 2026-07-30):
@@ -134,7 +134,7 @@ composition and activation **within** the form the static gate already
 picked — severity never overrides the form gate, the Iron Law, or any
 safety floor. Guidance, not a new object class (persona-catalog
 disposition). Severity→composition table + escalation rule →
-[`subagent-modes-detail` § Severity-conditioned team composition](../../agent-src/contexts/execution/subagent-modes-detail.md).
+[`subagent-modes-detail` § Severity-conditioned team composition](../../contexts/execution/subagent-modes-detail.md).
 
 ## The nine modes
 
@@ -146,12 +146,12 @@ model pairing. Defaults come from
 
 Descriptive lookup material (per-mode topology table, anti-drift default,
 glossary) lives in
-[`subagent-topologies`](../../agent-src/contexts/execution/subagent-topologies.md) —
+[`subagent-topologies`](../../contexts/execution/subagent-topologies.md) —
 pull it for capacity planning; it is metadata, not runtime-enforced.
 
 Per-mode decision rows (when to use / when not / model pairing) and the
 mode-2 stage-routing contract live in
-[`subagent-modes-detail` § Modes 1–6](../../agent-src/contexts/execution/subagent-modes-detail.md) —
+[`subagent-modes-detail` § Modes 1–6](../../contexts/execution/subagent-modes-detail.md) —
 pull them at dispatch time.
 
 ### 1. do-and-judge
@@ -202,7 +202,7 @@ leaks into the next. Use for a multi-step cross-wing chain (≥2 senior
 skills, each ≥30 min); not for fast iteration under 30 min (overhead
 dominates). Full handoff shape, example chain, competitive per-candidate
 isolation, and the no-auto-merge Hard Floor →
-[`subagent-modes-detail`](../../agent-src/contexts/execution/subagent-modes-detail.md) § Mode 7.
+[`subagent-modes-detail`](../../contexts/execution/subagent-modes-detail.md) § Mode 7.
 
 ### 8. do-with-live-app-judge (gated — UI-heavy tasks)
 
@@ -212,7 +212,7 @@ reading the diff. Use for UI-heavy change where "looks right in the diff"
 ≠ "works in the app"; not for backend/logic (a diff judge is cheaper).
 Experimental until `verdict_changed_outcome` telemetry proves it. Rubric,
 adoption gate, and the async-verifier future candidate →
-[`subagent-modes-detail`](../../agent-src/contexts/execution/subagent-modes-detail.md) § Mode 8.
+[`subagent-modes-detail`](../../contexts/execution/subagent-modes-detail.md) § Mode 8.
 
 ### 9. adversarial-verification-council (gated — opt-in, advisory)
 
@@ -226,7 +226,7 @@ Mode 6 it emits a **findings-union**, not a go/no-go verdict. **Advisory only
 never auto-gates (Hard Floor).** Default-off (`subagents.adversarial_council`);
 opt-in high-risk changes only; registered claim + high-risk tier need
 cross-*vendor* skeptics. Invariants, skeptic prompt, reconciliation, prove-or-drop
-gate → [`subagent-modes-detail`](../../agent-src/contexts/execution/subagent-modes-detail.md) § Mode 9
+gate → [`subagent-modes-detail`](../../contexts/execution/subagent-modes-detail.md) § Mode 9
 + [`prompts/adversarial-verification-council.md`](prompts/adversarial-verification-council.md)
 
 > **Disposition (2026-07-28, honest null).** The adversarial-council finding-
@@ -246,7 +246,7 @@ four statuses — `DONE` · `DONE_WITH_CONCERNS` · `NEEDS_CONTEXT` ·
 `BLOCKED` — no free-form alternatives; orchestrators route on status
 mechanically. Meaning/required-keys table, why-fixed rationale, and the
 `NEEDS_CONTEXT`-vs-`BLOCKED` distinction →
-[`subagent-modes-detail` § Status taxonomy](../../agent-src/contexts/execution/subagent-modes-detail.md).
+[`subagent-modes-detail` § Status taxonomy](../../contexts/execution/subagent-modes-detail.md).
 
 **The envelope is the ONLY return channel** (token-economy-dispatch
 Phase 6). A worker writes its full output to disk (runtime artifact dir,
@@ -267,7 +267,7 @@ Edits to a prompt do not bloat this skill against the 400-line sunset
 trigger. Eight prompt files cover modes 1–7 and 9 (the standalone judge
 reuses [`prompts/do-and-judge.md`](prompts/do-and-judge.md); mode 8's
 live-app rubric lives in
-[`subagent-modes-detail` § Mode 8](../../agent-src/contexts/execution/subagent-modes-detail.md));
+[`subagent-modes-detail` § Mode 8](../../contexts/execution/subagent-modes-detail.md));
 each prompt cites all four taxonomy statuses — see
 [`prompts/README.md`](prompts/README.md).
 
@@ -340,7 +340,7 @@ After every auto-dispatched run, write one audit-log-v1 line
 (`input_kind: "orchestration"`) via the `orchestration_record` recorder —
 never hand-author the JSON. Line shape, field semantics, recorder
 invocation, and `token_delta` sourcing priority →
-[`orchestration-telemetry` § Emit procedure](../../agent-src/contexts/execution/orchestration-telemetry.md).
+[`orchestration-telemetry` § Emit procedure](../../contexts/execution/orchestration-telemetry.md).
 Skip emit when `emergency.orchestration_halt` is set or `spawn_count == 0`
 (in-session run).
 
@@ -379,7 +379,7 @@ Skip emit when `emergency.orchestration_halt` is set or `spawn_count == 0`
 
 | Task                                 | Skill / command                      |
 |--------------------------------------|--------------------------------------|
-| Configuration reference              | [`subagent-configuration`](../../agent-src/contexts/execution/subagent-configuration.md) |
+| Configuration reference              | [`subagent-configuration`](../../contexts/subagent-configuration.md) |
 | Do-and-judge loop                    | Inline — see [`prompts/do-and-judge.md`](prompts/do-and-judge.md) |
 | Stepwise plan with judge gates       | Inline — see [`prompts/do-in-steps.md`](prompts/do-in-steps.md) |
 | Standalone judge on an existing diff | Inline — see judge prompt in [`prompts/do-and-judge.md`](prompts/do-and-judge.md) |

package/dist/agent-src/skills/subagent-orchestration/prompts/README.md

@@ -93,9 +93,10 @@ child continues the parent's task under identical tools and constraints (a
 fork inherits the parent's system prompt, tools, and conversation history
 exactly, so its first request reads the parent's cache). Prefer a **named
 subagent** when the child needs isolation, a different tool set, or nested
-dispatch — a fork cannot nest, and forking forces background mode, which
-changes the tool set and therefore invalidates the very prefix that
-motivated the fork in the first place. Never default to "always fork": that
+dispatch — a fork cannot nest. Forking forces background mode, which does
+not cost the prefix where the host row says `fork_shares_cache: true` (on
+Claude Code 2.1.302 a background fork read 99.8 % of its first call from the
+parent's cache and kept the parent's tool pool); elsewhere it is unobserved. Never default to "always fork": that
 option was considered and cut ([`../SKILL.md`](../SKILL.md) § Form gate)
 precisely because the cache-sharing benefit cannot be predicted before the
 fork happens, and background mode can erase it outright.

package/dist/agent-src/skills/svg-authoring/SKILL.md

@@ -0,0 +1,324 @@
+---
+model_tier: inherit
+name: svg-authoring
+description: "Hand-author or edit an SVG — icon, mark, illustration, diagram, animation, raster-to-vector — checked and rendered."
+domain: product
+personas:
+  - design-director
+workspaces:
+  - engineering
+packs:
+  - frontend-design
+  - ai-image
+  - ai-video
+  - engineering-base
+trust:
+  level: professional
+install:
+  removable: true
+scope:
+  write: []
+  verification_reason: "execution declares no handler, so this skill runs nothing of its own — every write is the calling agent's, under the rules that govern it. No command can prove a scope the skill never executes."
+execution:
+  type: manual
+---
+
+# svg-authoring
+
+> The one owner for SVG an agent writes by hand. Six lanes produce one — a
+> missing icon glyph, a geometric mark, an illustration, a diagram, an animated
+> asset, a wireframe canvas — and until this skill existed none of them had a
+> procedure or a check beyond the agent's own belief that the file looked right.
+
+## When to use
+
+- A glyph the incumbent icon set does not have (`iconography` first — the set wins).
+- A simple geometric mark, when `logo-generation` takes the true-vector path.
+- An illustration or a diagram authored as SVG rather than generated.
+- An animated asset: SMIL, CSS or WAAPI inside an `.svg` or an inline graphic.
+- A **surgical edit** to an existing SVG — "change only the hat", "remove the face".
+- A **raster converted to a vector** — "turn the logo in this PNG into a real vector".
+
+## When NOT to use
+
+- The icon exists in the set → `iconography`, and stop there.
+- A photoreal or illustrative raster → `image-generation`.
+- A full brand pipeline → `logo-generation` (which routes back here for the mark).
+- Motion design for video → `motion-choreographer`.
+
+## Procedure
+
+1. **Read the delivery mode first — it decides everything after it.** `inline`
+   in a host page, a standalone `document` opened directly, `img`, a CSS
+   background, or a deck. It decides what can animate, what can execute, and how
+   the graphic gets its accessible name. An **undeclared** mode is treated as
+   `inline`, the strictest.
+2. **Classify the asset** — `icon`, `mark`, `illustration`, `diagram`,
+   `animated`. The class picks the fill-ratio threshold and the geometry
+   tolerance; there is no global threshold, because a 24-grid icon's designed
+   padding reads as an under-filled viewBox against one.
+3. **Plan before attributes** — concept, then layout, then attributes.
+   Primitives before detail: a mark built from `rect`/`circle`/`polygon` is a
+   true vector and is often the right answer, not a lesser one.
+4. **Write with the invariants.**
+   - ids namespaced to the graphic — a bare `id="title"` names the second
+     inline graphic on the page after the first.
+   - the accessible name comes from the ARIA corpus, not from here: ground
+     `meaningful standalone svg chart graphic accessible name` against
+     `accessibility-auditor`'s `aria-patterns.csv` and follow the
+     **Meaningful standalone graphic** or **Decorative graphic** row.
+   - colour from the project's tokens or `currentColor`, never a loose hex.
+   - an explicit `font-family` with a fallback the target actually ships; a
+     `<text>` with none resolves to the platform serif.
+   - no `<script>`, no `on*`, no `javascript:`, no `foreignObject`, no external
+     `href` or `url()`, no internal DTD subset or `<!ENTITY` (a bare public
+     DOCTYPE is fine).
+5. **Run the static check** — `lint_svg_asset`, with the delivery mode declared:
+   ```bash
+   npx tsx node_modules/@event4u/agent-config/src/scripts/lint_svg_asset.ts \
+     --file path/to/asset.svg --delivery inline
+   ```
+6. **Run the witness** — the asset profile, which opens the file in a real engine:
+   ```bash
+   agent-config ui:render path/to/asset.svg --profile asset --class icon
+   ```
+7. **Look at the render.** Looking stays mandatory for *meaning*; it is never the
+   pass for *geometry*. Fix what both the checks and the look found.
+8. **Stop** at a clean witness or after three render passes, whichever comes
+   first. A stop **at the cap with error findings still open** reports
+   `unverified` with the reason `pass-cap-reached` and lists what is open —
+   never `verified`, and never done. That reason is yours to report: the render
+   manifest never carries it, because one invocation of `ui:render` cannot see
+   how many passes you have made.
+9. **Report** the renderer and the checks that actually ran — `verified`,
+   `static-only` or `unverified` — plus `goal: unassessed`, and name only
+   output files read back from disk. Where the renderer is **absent**, run the
+   static witness, report `static-only`, and name the missing capability in one
+   line; opening the file in a browser is never a step of this procedure or of
+   the user's.
+
+## Status — what each word is allowed to mean
+
+| Status | Allowed only when |
+|---|---|
+| `verified` | a render manifest from the asset profile exists **whose recorded file digest equals the delivered file's digest on disk**. A manifest from an earlier pass does not count. |
+| `static-only` | the static check ran and no render did. A parser pass (`xmllint --noout`) is this, never `verified` — a file can parse and still be the wrong picture. |
+| `unverified` | no browser resolved, or the pass cap was reached with error findings open (`pass-cap-reached`). Never a pass; never silently upgraded. |
+
+**A second axis, and it is not this table's.** Every status above is about
+whether a CHECK ran and what it found. Whether the graphic is *right* is a
+different question, and `verified` was being read as an answer to it. So every
+report carries `goal:` beside the status, and this skill writes exactly one
+value into it:
+
+| Goal | Written by |
+|---|---|
+| `unassessed` | **always, by this skill and by the renderer.** The default, and the only value either may write. |
+| `accepted` / `rejected` | an owner statement, or a pre-registered scenario witness. Never derived from a digest match, a clean witness, or a score. |
+
+## Editing an existing SVG — the baseline replaces the look
+
+Declare the ids the edit is allowed to touch, then let the readout decide:
+
+```bash
+npx tsx node_modules/@event4u/agent-config/src/scripts/lint_svg_asset.ts \
+  --file after.svg --baseline before.svg --allow hat,hat-band
+```
+
+Every element outside the allowed set that changed is reported with the attribute
+that changed, after number and whitespace canonicalisation. **No pixel diff
+decides this** — anti-aliasing and font metrics would make it a per-machine
+verdict.
+
+This applies **between the owner's own passes** too. A part the user already
+accepted joins the baseline and may not move by hand. A conversion pass that
+re-derives that part from the source instead **re-measures** it and re-checks
+the accepted property — a hole that was accepted as a hole stays a hole through
+a full re-trace.
+
+## Converting a raster to a vector — its own branch
+
+Drawing it from a look fails, and it fails the same way every time: the outlines
+"coincide within a few pixels" by eye and read 0.883 silhouette IoU when
+measured. The procedure below reached 0.984 with the same tools.
+
+### Trace to measure, construct to deliver
+
+**The trace is the underlay by default, not the deliverable.** Trace the source
+to measure and to align; then construct the deliverable over that underlay from
+few points, palette colours and named shapes. Keep a trace AS the deliverable
+only when the owner asks for maximum fidelity over editability, and say that is
+what they are getting.
+
+The reason is measured, not stylistic. In one session the traced mark scored
+0.989 region IoU against the constructed one's 0.935 — and the trace was sent
+back fifteen minutes after it was accepted, on criteria no score sees: a crown
+cut at the crop edge, hairlines between segments, an off-palette spot, jagged
+edges, 49 KB of edit-hostile points, and a face unreadable at 32 px. The
+rebuild was 4.5 KB with 14 shapes and about 180 points. **The score is the
+alignment check. It is never the acceptance.**
+
+**When the score stops applying.** Once the owner's goal becomes a redesign
+rather than a reproduction — different fingers, depth taken from a style
+reference — the source-fidelity number measures agreement with something
+nobody is still trying to match. Stop reporting it as progress and say why.
+
+1. **Crop the source region with a margin, and make that crop the coordinate
+   system.** Write every vector coordinate in the crop's pixel units; fit the
+   viewBox to the content at the end, not at the start. **Widen the crop
+   whenever source content touches its edge** — a trace takes the crop border
+   for a contour, and a comparison against that same crop cannot see the cut.
+   One session lost a crown that way: the crop started five pixels below it.
+   The engine's `geometry/source-cut-by-frame` reading is the check.
+2. **Derive geometry from the pixels, never by eye — then build over it.** One
+   traced silhouette that clips everything, then named regions split along an
+   edge map; smooth, resample and simplify each contour. The outer edge comes
+   from one contour and the holes come from the source. That trace is the
+   underlay; the shapes you ship are constructed on top of it. **A shape with
+   counters** (o, e, a, B, 8, an O-ring mark) declares its `fill-rule`, winds
+   its outer and inner contours in opposite directions, and runs overlap removal
+   only after both are settled — two same-direction contours under the default
+   `nonzero` paint the counter solid.
+3. **Fit colour, do not pick it.** Least-squares per region against that region's
+   own pixels; swap a linear gradient for a radial one only when the residual
+   actually drops.
+4. **Classify near-white inside the mark as hole or paint from the source**, and
+   check it on a dark background **before** the first report. Near-white paint
+   where the source shows a hole is invisible on white and obvious on black.
+5. **Keep text, wordmark and slogan out** unless they were asked for.
+6. **Score every pass and every candidate change**, and keep a change only when
+   the score improves — a tried-and-worse idea is dropped by the number, not by
+   taste. Use the two readings the geometry comparison produces: silhouette IoU
+   over saturated regions, and mean colour error plus the share of pixels off by
+   more than 40/255 — broken down per region, so the worst region is named. The
+   score ranks passes against the source; it does not decide acceptance, and it
+   stops meaning anything once the goal becomes a redesign.
+7. **Stop** at the declared tolerance, at the user's pass budget, or **on a
+   plateau** — whichever comes first. A plateau is two consecutive passes each
+   improving the score by less than 5 % relative: stop, report the residual's
+   cause, and offer the construct-or-redesign option instead of starting
+   another pass. An explicit pass budget from the user still wins when it is
+   smaller. Measured: twelve further scored passes took mean error 16.78 to
+   6.12 and the share off by 40 from 9.1 % to 1.5 %, and the owner said "still
+   unclean" twice; the plateau was named only after they brought a reference.
+8. **Snapshot every delivered pass** as `<name>.pass-<n>.svg`, and diff the next
+   pass against the last accepted snapshot with `lint_svg_asset --baseline`.
+   Report which accepted properties carried forward. Restoring "version 4" is
+   then a copy, not a reconstruction — one session lost the same accepted
+   detail twice between hand edits, and the owner had to supply the file back
+   from their own downloads.
+9. **Report the per-pass numbers, the cause of the remaining residual, and the
+   file size.** Fidelity costs bytes — one accepted conversion went 5.3 KB →
+   49.5 KB and nothing measured it. Each number carries the **registration**
+   it was taken against as `x,y,w,h` in the source's pixel frame, the
+   **scorer** that produced it (`ui:render`, or a named script) and the sample
+   resolution. Two scorers disagreed on one file by a factor of four and
+   neither number could be told from the other afterwards; a wordmark's frame
+   could not be recovered at all, and three plausible ones moved its IoU from
+   0.56 to 0.81.
+
+Any tracing tool the host has may do the deriving, and a host with none can
+write one. **The measurement is the procedure, not the tool.**
+
+## Deliver, re-open, re-render
+
+The last step reads every delivered file back **from its final path** in a fresh
+browser context (`file://`, every other request aborted) and re-renders it from
+there — not from the source text the agent wrote. Report path, byte size and
+digest. An `img` delivery is additionally loaded through a host `<img>` and must
+report a non-zero natural width.
+
+**A file that does not re-open is not delivered.**
+
+## Output format
+
+1. **Delivery mode and asset class** — declared, not assumed.
+2. **The file** — path, byte size, digest.
+3. **Checks that ran** — the static check's finding count, the witness's
+   readings, and the status word from the table above.
+4. **For a conversion** — the per-pass score table and the residual's cause,
+   each number carrying its **registration** (`x,y,w,h` in the source's pixel
+   frame), the scorer that produced it and the sample resolution, so a later
+   run can repeat the reading and no second scorer's number is quoted as the
+   first's.
+5. **Variants** — for a `mark`, the small-size variant when the 16 and 32 px
+   captures lose the detail, and a light-on-dark variant when the contrast
+   reading is low on a capture's ground. Built, or named as missing. Never
+   silent: one wordmark shipped in a dark violet that is unreadable on a dark
+   ground, and the dark variant was simply not mentioned.
+6. **Outlined lettering** — a word set from an installed font and converted to
+   outlines is reported with the font's name and whether its license allows
+   outlining into a distributed asset. An unknown license is reported as
+   unknown, never as permitted.
+7. **Cost** — the reading the manifest carries (`bytes`, `elements`, `paths`,
+   `gradients`, `coordinates`), beside the fidelity numbers. No threshold: none
+   was measured, and a gate on bytes would have refused a 195 KB trace and a
+   59 KB accepted figure alike.
+8. **What was looked at** — honestly, or nothing.
+
+## Gotcha
+
+- **A `<path>` is not evidence of a vector.** A raster embedded beside one dummy
+  path passes a presence-of-`<path>` check and is not a vector; a mark built
+  from `rect`/`circle` fails that check and is one.
+- **CSS cannot stop SMIL.** `svg * { animation: none !important }` under an
+  emulated `reduce` leaves an `<animate>` running. Route the animation itself.
+- **An `<img>`-delivered SVG never sees the OS motion preference.** The host
+  needs a `<picture>` with a `media="(prefers-reduced-motion: reduce)"` source
+  pointing at a static file.
+- **`screenshot({ animations: 'disabled' })` does not freeze SMIL.** Use
+  `pauseAnimations()` + `setCurrentTime()`.
+- **`transform-origin` without `transform-box` pivots against the view box**, not
+  the element — per element, so a correct sibling proves nothing about it.
+- **`keySplines` outside [0,1] stops the animation outright** rather than
+  clamping it.
+
+## Do NOT
+
+- Do NOT report `verified` on a look, a parser pass, or a render of an earlier
+  draft.
+- Do NOT say "matches" or "100 %" about a conversion without the two numbers and
+  the registration they were measured against.
+- Do NOT rename ids or simplify paths as a side effect of a surgical edit.
+- Do NOT restate motion, ARIA or render-security mechanism here — point at the
+  authority and let it own the rule.
+- Do NOT add a rasteriser, a tracing dependency, or an optimiser to the write path.
+
+## See also
+
+> Named rather than linked, and that is a correctness property rather than a
+> style one: this skill ships in four packs, so a relative link to an artifact
+> that lives in only one of them resolves for a consumer who installed that pack
+> and is dead for the other three. The names are stable; the paths are not
+> promises this skill can keep.
+
+- `iconography` — the set comes first; this skill is
+  for the glyph it lacks.
+- `logo-generation` — the brand pipeline that
+  routes a geometric mark here.
+- `type-design` — "the rest of the alphabet" / "make this a font": a
+  wordmark extended into a constructed font, reusing the trace and counter rule.
+- `image-provider-routing` — illustrative
+  vector art goes to a provider, not here.
+- `fe-design` § Motion — the motion authority, in
+  `references/design-patterns.md` § *Motion — decision-tree and rationale*. The
+  SVG mechanism lines are step **6b, "Which mechanism carries it inside an
+  SVG?"** — `transform-box`, `pathLength`, the `keySplines` range, path-morph
+  command equality, and delivery mode picking the reduced-motion route. Cited
+  here and never restated.
+- `frontend-render-security` § *The
+  patterns AI ships by default*, row **Untrusted SVG markup into an HTML sink**
+  — the sinks an SVG carries into a host origin, and what each delivery mode
+  can execute. Its § *Backstop greps* carries the grep that finds them.
+- `design-intelligence` — diagram layout; its
+  geometric pre-checks are witnessed by the asset profile now.
+- `accessibility-auditor` — the ARIA
+  corpus that answers what a graphic's accessible name has to be; its
+  `data/aria-patterns.csv` carries the **Meaningful standalone graphic** and
+  **Decorative graphic** rows this skill grounds against rather than copies.
+- `canvas-design`, `wireframe`
+  — the two lanes that use SVG as an execution surface.
+- `design-fidelity` — a provided artifact is
+  the spec; the baseline readout above is its surgical-edit witness.
+- `docs/contracts/design-artifact-verification.md` — `frame_seek` and the other
+  primitives the witness depends on.

package/dist/agent-src/skills/systematic-debugging/SKILL.md

@@ -278,7 +278,7 @@ If the root cause traces to a `agents/knowledge/` page that was
 followed while implementing (a documented convention was wrong, an
 API shape page was stale, a procedure was incomplete), append a
 `mistake_made` event to the knowledge intake — never rewrite the page
-mid-task (see [`knowledge-pages`](../../agent-src/templates/contexts/knowledge-pages.md)):
+mid-task (see [`knowledge-pages`](../../templates/contexts/knowledge-pages.md)):
 
 ```bash
 npx tsx node_modules/@event4u/agent-config/src/scripts/emit_knowledge_event.ts \
@@ -297,7 +297,7 @@ finds the new line.
 wrong right now (observed reality ≠ documented claim, not a one-off),
 this is the hybrid immediate-fix case instead — surface the proposed
 correction and ask before continuing (see
-[`knowledge-pages`](../../agent-src/templates/contexts/knowledge-pages.md)
+[`knowledge-pages`](../../templates/contexts/knowledge-pages.md)
 § Contested entries). Approved → isolated fix commit. Declined →
 `npx tsx node_modules/@event4u/agent-config/src/scripts/append_contested.ts` on that page, then still
 emit the `context_stale` event above it for the consolidation pass.

package/dist/agent-src/skills/tailwind-engineer/SKILL.md

@@ -201,8 +201,8 @@ Risks:          <arbitrary values, !important, dark-mode gaps>
   they read as auto-generated (catalog C1/C2). Reach for a single accent
   from the token map, or a duotone built from configured tokens.
 - **Anti-AI-slop: typography.** Unless audit-pinned, avoid surfacing
-  the system stack (`font-sans` fallback to Arial / Helvetica / Inter
-  via system defaults) as the *visible* body face. If `tailwind.config`
+  the default as the *visible* body face — Inter as a template webfont,
+  or `font-sans` (Arial / Helvetica). If `tailwind.config`
   pins a font family, use it; if not, treat the missing token as a
   gap to flag, not a license to ship the OS default.
 - **Anti-AI-slop: layout.** Unless audit-pinned, the centered hero +
@@ -217,7 +217,12 @@ When `DESIGN.md` declares `## Taste Dials`, honour them: Variance → layout-fam
 
 ## Security constraints
 
-`scripts/tailwind_config_gen.ts` is the only shipped script.
+`scripts/tailwind_config_gen.ts` is the only shipped script, started as:
+
+```bash
+node <skills-root>/tailwind-engineer/scripts/tailwind_config_gen.mjs \
+  [--framework react|vue|svelte|nextjs] [--output PATH] [--validate-only]
+```
 
 - **What it may touch** — exactly one file: `--output PATH`, or
   `tailwind.config.ts` / `.js` in the current working directory when no