@thedecipherist/claude-packs 1.0.0 → 1.1.0

package/packs/audio-core/hooks/param-id-lock.mjs

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
-// Locks parameter IDs: once seen, an ID may never disappear from the source.
+// Locks parameter IDs: once seen, an ID may never disappear from the source. The lock starts itself at the first id it sees (KF-15).
 //   node param-id-lock.mjs --init   create .claude/param-ids.lock.json from the current repo
+//   node param-id-lock.mjs --status exit 1, saying why, when the unit has parameters and the lock holds no ids (doctor runs it)
 //   (as PostToolUse hook)           fail (exit 2) if a locked ID is gone; add new IDs to the lock. Every route that
 //                                   writes is judged (Write, Edit, MultiEdit, NotebookEdit, and the shell's >, >>, tee,
 //                                   sed -i, cp, mv, rm, a heredoc; lib/writes.mjs): an id deleted by `sed -i` is gone too.
 //   node param-id-lock.mjs --selftest  proves it
 // Where IDs are read: .claude/param-ids.config.json, else layout.json "paramIds", else JUCE
 // ParameterID / AudioParameter* string literals. Both forms: { "extensions": "<regex>", "patterns": ["<regex with one group>"] }.
+// A pattern is a JavaScript regex, with ^ and $ matching at each line. One that cannot compile is reported by name, never a crash (KF-18).
+// The project's build output (layout.json "buildOutput") is never read: ids in a library's sources are not the unit's (KF-15).
 // A file is judged in its own checkout: an agent worktree is scanned, and keeps its lock, on its own.
 import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { matchesAny } from './lib/glob.mjs';
 import { readLayout } from './lib/layout.mjs';
 import { checkoutRoot, claudeRoot, insideProject } from './lib/project.mjs';
 import { writesOf } from './lib/writes.mjs';
@@ -19,28 +23,41 @@ import { asHook, isMain } from './lib/hook-log.mjs';
 
 const ROOT = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
 // .claude is skipped so the worktrees under .claude/worktrees/ never stand in for this checkout's code.
-const SKIP_DIRS = /(^|\/)(build|Builds|JuceLibraryCode|JUCE|node_modules|\.git|\.claude|cmake-build[^/]*)(\/|$)/;
+const SKIP_DIRS = /^out(\/|$)|(^|\/)(build|Builds|_deps|JuceLibraryCode|JUCE|node_modules|\.git|\.claude|cmake-build[^/]*)(\/|$)/;
+const PARAMETER_WORDS = /\b(?:ParameterID|AudioParameter(?:Float|Int|Bool|Choice)|AudioProcessorValueTreeState|addParameter)\b/;
+const CONFIG = join('.claude', 'param-ids.config.json');
 
 const DEFAULT_PATTERNS = [
   'ParameterID\\s*(?:[A-Za-z_]\\w*\\s*)?[({]\\s*"([^"]+)"',
   'AudioParameter(?:Float|Int|Bool|Choice)\\s*>?\\s*\\(\\s*"([^"]+)"',
 ];
 
+// The settings, or { error } saying what cannot be read and where.
 function loadConfig(root) {
-  const file = join(root, '.claude', 'param-ids.config.json');
-  const cfg = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : readLayout(root).paramIds ?? {};
-  return {
-    extensions: new RegExp(cfg.extensions ?? '\\.(cpp|h|hpp|cc|mm)$'),
-    patterns: (cfg.patterns ?? DEFAULT_PATTERNS).map((p) => new RegExp(p, 'g')),
-  };
+  const file = join(root, CONFIG);
+  try {
+    const cfg = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : readLayout(root).paramIds ?? {};
+    return {
+      extensions: new RegExp(cfg.extensions ?? '\\.(cpp|h|hpp|cc|mm)$'),
+      patterns: (cfg.patterns ?? DEFAULT_PATTERNS).map((p) => new RegExp(p, 'gm')),
+    };
+  } catch (e) {
+    return { error: `param-id-lock could not read its settings (${CONFIG}, or layout.json "paramIds"), so no parameter id was checked: ${e.message}\n` };
+  }
 }
 
-function collectIds(root, { extensions, patterns }) {
-  const ids = new Set();
+function* sourcesOf(root, extensions) {
+  const output = readLayout(root).buildOutput ?? [];
   for (const entry of readdirSync(root, { recursive: true })) {
     const rel = String(entry);
-    if (SKIP_DIRS.test(rel) || !extensions.test(rel)) continue;
-    const text = readFileSync(join(root, rel), 'utf8');
+    if (!SKIP_DIRS.test(rel) && extensions.test(rel) && !matchesAny(rel, output)) yield join(root, rel);
+  }
+}
+
+function collectIds(root, { extensions, patterns }) {
+  const ids = new Set();
+  for (const file of sourcesOf(root, extensions)) {
+    const text = readFileSync(file, 'utf8');
     for (const re of patterns) {
       re.lastIndex = 0;
       let m;
@@ -52,10 +69,27 @@ function collectIds(root, { extensions, patterns }) {
 
 const lockFile = (root) => join(root, '.claude', 'param-ids.lock.json');
 const save = (root, ids) => writeFileSync(lockFile(root), JSON.stringify([...ids].sort(), null, 2) + '\n');
+const lockedIds = (root) => (existsSync(lockFile(root)) ? JSON.parse(readFileSync(lockFile(root), 'utf8')) : []);
+
+// KF-15: ids built from a table or a generator are invisible to the default patterns, and a lock with nothing in it protects nothing.
+function status(root) {
+  const config = loadConfig(root);
+  if (config.error) { console.log(config.error.trim()); return 1; }
+  if (lockedIds(root).length || collectIds(root, config).size) return 0;
+  for (const file of sourcesOf(root, config.extensions)) {
+    if (!PARAMETER_WORDS.test(readFileSync(file, 'utf8'))) continue;
+    console.log(`param-id-lock: ${relative(root, file)} makes parameters and the lock holds no ids, so it protects nothing. ` +
+      `Say where the ids are in ${CONFIG} ("extensions", "patterns"), then \`node .claude/hooks/param-id-lock.mjs --init\`.`);
+    return 1;
+  }
+  return 0;
+}
 
 function main(text) {
   if (process.argv.includes('--init')) {
-    const ids = collectIds(ROOT, loadConfig(ROOT));
+    const config = loadConfig(ROOT);
+    if (config.error) { process.stderr.write(config.error); return 2; }
+    const ids = collectIds(ROOT, config);
     save(ROOT, ids);
     console.log(`Locked ${ids.size} parameter IDs in ${relative(ROOT, lockFile(ROOT))}`);
     return 0;
@@ -74,6 +108,7 @@ function main(text) {
     const root = file ? checkoutRoot(file) : ROOT;
     if (seen.has(root)) continue;
     const config = loadConfig(file ? claudeRoot(file) : ROOT);
+    if (config.error) { process.stderr.write(config.error); return 2; }
     if (file && !config.extensions.test(file)) continue; // not a file ids are written in
     seen.add(root);
     const code = judge(root, config);
@@ -84,8 +119,11 @@ function main(text) {
 
 // The checkout's own lock only: main's lock may hold ids a worktree branch never had.
 function judge(root, config) {
-  if (!existsSync(lockFile(root))) return 0;
   const current = collectIds(root, config);
+  if (!existsSync(lockFile(root))) {
+    if (current.size) save(root, current);
+    return 0;
+  }
 
   const locked = new Set(JSON.parse(readFileSync(lockFile(root), 'utf8')));
   const missing = [...locked].filter((id) => !current.has(id));
@@ -108,7 +146,7 @@ function selftest() {
   const hook = fileURLToPath(import.meta.url);
   const params = (...ids) => ids.map((id) => `auto p_${id} = juce::ParameterID { "${id}", 1 };`).join('\n') + '\n';
   const dir = scratchProject({ 'src/params/Params.h': params('cutoff', 'res') }, { folders: {}, concepts: {} });
-  const unlocked = scratchProject({ 'src/params/Params.h': params('cutoff') });
+  const unlocked = scratchProject({ 'src/params/Params.h': params('cutoff') }, { folders: {}, concepts: {} });
   const file = join(dir, 'src/params/Params.h');
   const post = (text) => (put(file, text), runHook(hook, dir, writeOf(file, text)));
   const initStatus = runHook(hook, dir, null, ['--init']);
@@ -120,10 +158,15 @@ function selftest() {
     ['an id added', post(params('cutoff', 'res', 'drive')), 0],
     ['the new id joins the lock', locked().includes('drive'), true],
     ['a project with no lock', runHook(hook, unlocked, writeOf(join(unlocked, 'src/params/Params.h'))), 0],
+    ['the first id seen starts the lock', existsSync(join(unlocked, '.claude/param-ids.lock.json')), true],
     ['another project is not ours', runHook(hook, dir, writeOf(join(dirname(dir), 'elsewhere/Params.h'))), 0],
   ];
   return verdicts('param-id-lock', cases);
 }
 
 export const hook = main; // run-hooks.mjs calls it with the event's text (KWB-24)
-if (isMain(import.meta.url)) process.exit(process.argv.includes('--selftest') ? selftest() : process.argv.includes('--init') ? main('') : await asHook('param-id-lock', main));
+const BY_HAND = { '--selftest': selftest, '--status': () => status(ROOT), '--init': () => main('') };
+if (isMain(import.meta.url)) {
+  const byHand = Object.keys(BY_HAND).find((flag) => process.argv.includes(flag));
+  process.exit(byHand ? BY_HAND[byHand]() : await asHook('param-id-lock', main));
+}

package/packs/audio-core/pack.json

@@ -69,6 +69,11 @@
     "ui": [
       "app"
     ],
+    "look-analysis": [
+      "design/**",
+      "tools/*panel*",
+      "tools/*look*"
+    ],
     "bench": [
       "bench"
     ],

package/packs/audio-core/rules/a-control-is-proved-through-its-input.md

@@ -0,0 +1,26 @@
+---
+# concepts: ui
+paths:
+  - "placeholder"
+---
+
+# A control is proved through its own input path
+
+A gate that writes the parameter proves the parameter, never the control. On the MPX 500 every control passed such a gate, while a knob's mouse handling could be compiled out with its table row, class and binding all intact. Driving the real editor found five real bugs: the host's first sync written over the loaded program, a double click that did not go back, small wheel movements lost on every knob, an LED that never lit, and a drag thrown backwards by a modifier.
+
+<constraints>
+Always do:
+- Drive a control through its own input path: the real component in the real editor, at its peer, so the toolkit's own hit test, click counting and drag tracking decide what receives each gesture.
+- Read what the gesture moved at each end of the chain: the parameter or the machine's state, the pixels, and the audio.
+- Work every gesture the control has: press, release, drag, fine drag, wheel, a small wheel movement, double click.
+- Prove a press on its own: a recipe that also turns a knob moves the audio whatever the press did.
+- Prove the gate can fail: with one control's input handling taken out, the gate goes red while a gate that writes the parameter stays green. Keep both results.
+- Run a planted fault in each control in turn: one unhooked control leaves its row, class and binding intact, so nothing else sees it.
+
+Never do:
+- Call a control proved because its parameter moved when written, or because its row reads right.
+- Call a method on the component in place of a gesture: that goes round the hit test.
+</constraints>
+
+## Check
+Test: for each control kind, a gesture sent at the real editor's peer moves its parameter, its pixels and the audio, and the same test goes red with that control's input handling compiled out.

package/packs/audio-core/rules/cpu-worst-case-per-block.md

@@ -9,6 +9,8 @@ paths:
 <constraints>
 Always do:
 - Gate on p99, p99.9 and maximum block time, plus the count of blocks over their deadline (`numSamples / sampleRate`), at 1, 8, 32 and 96 voices, with the heaviest patch and every row of the matrix moving.
+- Include a program load (or any preset change) as its own case, at every sample rate: clearing delay memory on the audio thread overran every load at 96 kHz, and no steady-state block showed it.
+- On a shared machine, separate the code from the scheduler. A wall clock counts what the host and hypervisor take, and thread CPU time hides it. A deterministic engine repeats its own cost on the same block, so take the least time per block over a few passes. Run a control with no engine through the same clock, and read the engine's figure against it.
 - Include digital silence and "identical left and right" as their own cases. Silence can cost more than signal (denormals, gates).
 - Label every CPU figure with what it measures (callback duty, one core, or process CPU), sample rate, block size, and whether the editor was open.
 - Attribute cost before optimising: compare editor closed vs open, bypassed vs active, silence vs signal.
@@ -23,4 +25,4 @@ Never do:
 </constraints>
 
 ## Check
-Benchmark test, offline render: 96 voices at 48 kHz with 64-sample blocks. Pass (house choice): p99.9 under 50% of the deadline, and zero overruns.
+Benchmark test, offline render: 96 voices at 48 kHz with 64-sample blocks. Pass (house choice): p99.9 under 50% of the deadline, and zero overruns, by the least time per block where the machine is shared.

package/packs/audio-core/rules/house-control-behaviours.md

@@ -24,7 +24,7 @@ Always do:
   It never steps to the next value on a press. The ‹ › arrows beside a list may step, as their own controls.
 - Check a new or changed control against this list with the `new-panel-control` skill, and walk one control of each template through the real window in the behaviour gate.
 - Walk one control of each template in the real window, on a loaded patch and not only on INIT: it moves its value and the sound or
-  the picture, and a choice control opens its list. Prove the rest by a read, not a walk (`test-the-template-once`): a table check that every
+  the picture, and a choice control opens its list. Prove the rest by a read, not a walk (`test-the-template-once`), plus one cheap pass of every control through its real input path, since a read cannot see one unhooked (twelve controls on the MPX 500 were each caught only by working them): a table check that every
   control is built from its template and its binding reaches a live parameter, which is what catches a control wired to nothing. The gate is red on a planted control that does nothing and on a planted dropdown
   that steps instead of opening.
 - When a project's reference synth (Solera, MegaSynth) does a behaviour differently, copy it and write down what was copied.

package/packs/audio-core/rules/scoped-no-denormals.md

@@ -8,7 +8,7 @@ paths:
 
 <constraints>
 Always do:
-- Make `juce::ScopedNoDenormals noDenormals;` the first line of every `processBlock` (and `processBlockBypassed` if it processes audio).
+- Make `juce::ScopedNoDenormals noDenormals;` the first line of every `processBlock` (and `processBlockBypassed` if it processes audio). `host.readTransport` (`timing-from-synthcore`) comes second: it does no DSP, and the guard must already hold.
 
 - Use `ScopedNoDenormals` on *every* thread that runs DSP: worker threads that render voices, offline renders, and test and benchmark executables. The flag belongs to one thread only.
 - Define `JUCE_DSP_ENABLE_SNAP_TO_ZERO=0` in CMake. JUCE's `JUCE_SNAP_TO_ZERO` only does anything on Intel (it's a no-op on Arm), so `juce::dsp` filters otherwise give block-size-dependent output on x86 and not on Apple Silicon.

package/packs/audio-core/rules/straight-on-and-aligned.md

@@ -1,5 +1,5 @@
 ---
-# concepts: ui
+# concepts: ui, look-analysis
 ---
 
 # A UI is drawn straight on, and everything aligns: basic UX comes before the picture

package/packs/audio-core/rules/ui-matches-reference-look.md

@@ -12,6 +12,8 @@ Stellix's layers landed flat and without glow (B-161): the analysis measured pos
 Always do:
 - Analyse the reference into numbers before drawing anything, with the `analyse-reference-look` skill: layout, colours sampled by script, type, glow and its colour and radius, surfaces and gradients, every control's parts (track, arc, pointer, ticks, value placement), and the gaps between elements.
 - Gate the look: render off-screen at the reference's size and compare region by region (glow, colour, contrast, position, overlap) against the analysis, with a stated tolerance per measure. A knob count differs or a knob moves past tolerance: the gate fails. Plant a fault (bloom off, a value overlapping a label) and show it fail.
+- Check geometry exactly, on its own, from the drawn panel: rows, columns, spacing, sizes and shared centres. A whole-picture score is a likeness, and never a pass: the MPX 500 passed at 0.868 with its knobs on four rows.
+- Measure the render with the code that measured the target, and diff each planted fault against the unplanted result: an exit code proves nothing when the gate is already red.
 - Keep repeated components identical: one component, one size (cards, tabs, knobs). A component never shrinks to fit; the container scrolls.
 - Keep text readable: at least 4.5 : 1 contrast for small text, measured, on every fill it can sit on.
 - End every drawn page with the user's picture stop on the side by side. A page is not done before that.

package/packs/audio-core/skills/analyse-reference-look/SKILL.md

@@ -5,17 +5,31 @@ description: Use before building or rebuilding a page, panel or layer from a ref
 
 # Analyse a reference picture into numbers
 
-Write one analysis file per reference, beside it in the design reference folder. Measure by script, never by eye.
+Read `straight-on-and-aligned` first: it governs every decision below. Write one analysis file per reference, in the design reference folder, or in `design/analysis/` if that folder is git-ignored. Measure by script, never by eye.
 
-First, separate the object from the photograph. You are learning a design, to draw it flat and straight on (`straight-on-and-aligned`). List what belongs to the photograph: the camera's angle, the lens, the lighting, bends, wear and missing parts. A bend moves everything near it. Start from what is known of the object: a panel is a flat rectangle, controls of a kind are one size, what looks like a row is a row, ears mirror each other, text sits level. A measurement that disagrees with those belongs to the photograph.
+First, separate the object from the photograph. You are learning a design, to draw it flat and straight on. List what belongs to the photograph: the camera's angle, the lens, the lighting, bends, wear and missing parts, and note the camera. A bend moves everything near it. Start from what is known of the object, its true proportions from a specification if one exists, and rectify before measuring:
 
-1. **Layout:** every region and every control's centre and size as fractions of the picture. Then find the grid: which controls share a row or a column, which look grouped, and the one size of each kind. Snap to it, and record what the snap moved and why.
-2. **Colour:** sample background, panels, borders, text levels, accents, lit and unlit states.
-3. **Glow:** for every glowing part, the colour, radius and strength, measured from the falloff.
-4. **Surfaces:** gradients, edge glow, bevels, shadows, textures.
-5. **Type:** font, size, weight and letter spacing of every text style, and how they relate.
-6. **Controls:** each kind's parts (track ring, value arc, pointer, ticks, cap, skirt, scale numbers) and where its label and value sit.
-7. **Spacing:** the gaps between elements and rows, and the dividers.
-8. **Unclear:** what the picture leaves open, or shows damaged: decide from the object, and say so.
+- **Rectify against a known anchor:** something placed by a standard, not an edge that may be worn. Rack slots sit where EIA-310 puts them, and they took out a bias of 4 units that the panel's own edges left in.
+- **When sources disagree:** rank them, and record each one's reading. A flat, frontal photograph of the real unit outranks a drawing for places, since a guide's drawing can be wrong about layout while it looks authoritative. A specification outranks both for proportions. A drawing is good for what is even by design: pitch, and the ratio of parts. Where two independent sources agree against a third, the third is the outlier. Two pictures from one shoot are one source.
 
-Then list the tolerances the look gate will use for each measure, and mask what is damaged. The gate checks alignment, sizes and shared centres on their own, because a whole-picture score passes while every knob is wrong. Report the analysis file's path and the list of open items.
+For each measure, give **a control and a confidence**. The control is the same measurement on something whose answer is known. The confidence says how far to trust the number: a part that fills its search box exactly was not measured at all.
+
+1. **Layout:** every region and every control's centre and size as fractions of the picture. Then find the grid: which controls share a row or a column, which look grouped, and the one size of each kind. Snap to it, and record what the snap moved and why. A measured offset smaller than the design's own spacing is error.
+2. **Dark on dark:** a dark part on a dark panel cannot be found by a threshold. Give each one a seed box by hand, from the grid or the neighbouring parts, and measure inside it. Say which parts were seeded.
+3. **Colour:** sample background, panels, borders, text levels, accents, lit and unlit states. Read a colour against the photograph's own white and black, which takes out exposure and white balance.
+4. **Glow:** for every glowing part, the colour, radius and strength, measured from the falloff.
+5. **Surfaces:** gradients, edge glow, bevels, shadows, textures.
+6. **Type:** font, size, weight and letter spacing of every text style, and how they relate. The typeface is a stated item and a scored choice: render each candidate in the target's legends, score it against them, and record the scores and the licence. When the real face is not to be had, say so.
+7. **Controls:** each kind's parts (track ring, value arc, pointer, ticks, cap, skirt, scale numbers), where its label and value sit, and any shape's real ends: a band's end may be slanted or square, and the eye gets it wrong.
+8. **Spacing:** the gaps between elements and rows, and the dividers.
+9. **Unclear:** what the picture leaves open, or shows damaged: decide from the object, and say so.
+
+Then write the gate:
+
+- List the tolerances for each measure, and mask what is damaged.
+- Check geometry exactly, on its own: rows, columns, spacing, sizes and shared centres, read from the drawn panel. A whole-picture score passes while every knob is wrong, so it is never a pass: it is a likeness, to read beside the rest.
+- Measure the render with the same code that measured the target, so the gate compares like with like.
+- Plant a fault for each thing the gate claims, and diff each planted run against the unplanted result. An exit code proves nothing: the first run of the MPX 500's gate showed three plants "failing", and two had changed nothing, because the gate was already red.
+- A meter changed while the gate is red is suspect: say so, and show the thresholds stayed put.
+
+Report the analysis file's path and the list of open items.

package/packs/audio-core/skills/prove-control/SKILL.md

@@ -8,6 +8,8 @@ description: Use after adding, renaming, re-ranging or removing a control, or be
 ## Steps
 For the control's parameter ID, run each check through the real path and save the command plus its output as evidence. Use the project's own probes and tests (see CLAUDE.md, Project commands).
 
+Start with the real input path (`a-control-is-proved-through-its-input`): a gesture sent at the real editor's peer moves the parameter, the pixels and the audio. A gate that writes the parameter proves none of the control. Then see it red: with this control's input handling compiled out, the gate fails while the parameter's own tests stay green.
+
 1. **Host:** set the parameter by ID in an offline render, at its minimum, default and maximum. The render must change, and a null test against default must fail where it should and pass where it should.
 2. **Editor:** the widget is attached to that same ID. Moving it changes the parameter, and a host-set value shows in the widget with the same text as the host's value-to-text.
 3. **Patch:** save, load and compare. The value is bit-identical, and old patches without the ID load the spec default.

package/packs/base/checks/one-walk-per-template.json

@@ -1,6 +1,6 @@
 {
   "id": "one-walk-per-template",
-  "why": "A test that presses, clicks or drags every instance of one template repeats the same behaviour hundreds of times and proves nothing more than one press does. Walk one instance of each template and every one-off; prove the rest with a read of the table that each is built from its template and wired.",
+  "why": "A test that presses, clicks or drags every instance of one template repeats the same behaviour hundreds of times and proves nothing more than one press does. Walk one instance of each template and every one-off; prove the rest with a read of the table that each is built from its template and wired. One every-instance pass that only proves each is hooked through its input path is allowed, and is not this: name it so, apart from the walks.",
   "rule": ".claude/rules/test-the-template-once.md",
   "globs": [
     "**/gates/**",

package/packs/base/hooks/code-shape.mjs

@@ -27,15 +27,17 @@ function addedLines(before, after) {
   return after.split('\n').flatMap((l, i) => { const n = left.get(l) ?? 0; left.set(l, n - 1); return n > 0 ? [] : [i + 1]; });
 }
 
-function lineFault(lang, text, added, off, limits) {
+// Every line at fault at once: one a refusal cost a whole resend for each, the largest cost the kit added on the MPX 500 (37 of its 132 refusals).
+function lineFaults(lang, text, added, off, limits) {
   const code = lang.blank(text).split('\n');
   const perLine = statementsOf(text, lang).reduce((m, s) => m.set(s.line, (m.get(s.line) ?? 0) + 1), new Map());
+  const faults = [];
   for (const n of added.filter((x) => !off.has(x))) {
     const width = code[n - 1]?.trimEnd().length ?? 0;
-    if (width > limits.maxLineChars) return `line ${n} is ${width} columns of code (limit ${limits.maxLineChars}). Break it where it reads.`;
-    if ((perLine.get(n) ?? 0) > limits.maxStatementsPerLine) return `line ${n} holds ${perLine.get(n)} statements. One statement a line: a diff, a breakpoint and a coverage line then mean something, and the file's size is true.`;
+    if (width > limits.maxLineChars) faults.push(`line ${n} is ${width} columns of code (limit ${limits.maxLineChars}). Break it where it reads.`);
+    if ((perLine.get(n) ?? 0) > limits.maxStatementsPerLine) faults.push(`line ${n} holds ${perLine.get(n)} statements. One statement a line: a diff, a breakpoint and a coverage line then mean something, and the file's size is true.`);
   }
-  return null;
+  return faults;
 }
 
 function functionFault(before, after, off, limits) {
@@ -57,8 +59,8 @@ function judgeWrite(w, rel) {
   if (matchesAny(rel, layout.guards?.codeShape?.exclude ?? []) || isContent(rel, layout)) return null;
   const before = w.before ?? '';
   const off = oneOffLines(w.after);
-  const fault = lineFault(lang, w.after, addedLines(before, w.after), off, limits) ?? functionFault(functionsOf(before, ext), functionsOf(w.after, ext), off, limits);
-  return fault ? `${fault}\nIf this one truly must stay, say so above it: \`one-off: <reason>\`.\n` : null;
+  const faults = [...lineFaults(lang, w.after, addedLines(before, w.after), off, limits), functionFault(functionsOf(before, ext), functionsOf(w.after, ext), off, limits)].filter(Boolean);
+  return faults.length ? `${faults.join('\n')}\nIf one truly must stay, say so above it: \`one-off: <reason>\`.\n` : null;
 }
 
 const main = (text) => judgeEvent(text, { name: 'code-shape', write: judgeWrite });
@@ -76,6 +78,8 @@ function selftest() {
     ['too many parameters', w('src/b.cpp', 'void f(int a, int b, int c, int d, int e, int f, int g) {\n  run(a);\n}\n'), 2],
     ['a self parameter is not counted', w('src/b.py', 'def f(self, a, b, c, d, e, g):\n    run(a)\n'), 0],
     ['packed statements', w('src/c.cpp', 'void f() {\n  a(); b(); c();\n}\n'), 2],
+    ['a Python set comprehension is one statement (KF-14)', w('src/s.py', 'left = {keep(row) for row in rows} - {drop(row) for row in rows}\n'), 0],
+    ['a lambda in a list counts as in a call (KF-27)', w('src/l.cpp', 'void f()\n{\n    judge ("a", b, [&] { return g (1); }),\n    judge ("c", d, [&] { return g (2); }),\n}\n'), 0],
     ['a for header is one statement', w('src/d.cpp', 'void f() {\n  for (int i = 0; i < n; i++) total += v(i);\n}\n'), 0],
     ['a wide line', w('src/e.cpp', wide), 2],
     ['a wide comment is no code', w('src/f.cpp', `// ${'word '.repeat(50)}\nint x = 1;\n`), 0],

package/packs/base/hooks/dispatch-once.mjs

@@ -8,6 +8,7 @@
 import { readFileSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { blankCode } from './lib/cpp-scan.mjs';
+import { lookupMatches } from './lib/rust-scan.mjs';
 import { CODE, TESTS, codeFiles } from './lib/elements.mjs';
 import { matchesAny } from './lib/glob.mjs';
 import { readLayout } from './lib/layout.mjs';
@@ -17,55 +18,84 @@ import { judgeEvent } from './lib/writes.mjs';
 import { asHook, isMain } from './lib/hook-log.mjs';
 
 const SWITCH = /\bswitch\s*\(\s*([^()]*?(?:\([^()]*\))?)\s*\)\s*\{/g;
+const JUDGED = new Set([...CODE, '.rs']);
+const FIX = 'Give each kind its own object, table entry or class (rule: behaviour-lives-with-its-kind), and call it from both places,\n' +
+  'so a new kind is one new entry instead of an edit in every switch. In Rust, a table on an enum is a method on the enum.\n';
 
-// The kind a switch dispatches on: the last name in its expression (args.kind -> kind, p->mode() -> mode).
-export function kindsSwitched(text) {
+// The last word of each `case` label of the switch body that opens at `open`: `Kind::line` -> line, `'line'` -> line.
+function labelsOf(code, text, open) {
+  let depth = 0;
+  let close = open;
+  for (; close < code.length; close += 1) {
+    if (code[close] === '{') depth += 1;
+    else if (code[close] === '}' && --depth === 0) break;
+  }
+  const labels = new Set();
+  for (const m of code.slice(open, close).matchAll(/\bcase\s+([^:]*(?:::[^:]*)*?)\s*:(?!:)/g)) {
+    const at = open + m.index + m[0].indexOf(m[1]);
+    labels.add(text.slice(at, at + m[1].length).replace(/['"`]/g, '').split(/::|\./).pop().trim());
+  }
+  return labels;
+}
+
+// Each switch: the kind it dispatches on, the last name in its expression (args.kind -> kind, p->mode() -> mode), and its case labels.
+// Rust's `match` is held to every variant by the compiler, so only a lookup table on an enum counts there (lib/rust-scan.mjs).
+export function switchesOf(text, ext = '') {
+  if (ext === '.rs') return lookupMatches(text);
   const out = [];
-  for (const m of blankCode(text).matchAll(SWITCH)) {
-    const name = m[1].replace(/\(\s*\)$/, '').split(/\?\.|\.|->|::/).pop().trim();
-    if (/^[A-Za-z_$][\w$]{2,}$/.test(name)) out.push(name);
+  const code = blankCode(text);
+  for (const m of code.matchAll(SWITCH)) {
+    const kind = m[1].replace(/\(\s*\)$/, '').split(/\?\.|\.|->|::/).pop().trim();
+    if (/^[A-Za-z_$][\w$]{2,}$/.test(kind)) out.push({ kind, labels: labelsOf(code, text, m.index + m[0].length - 1) });
   }
   return out;
 }
 
-const count = (list) => list.reduce((m, k) => m.set(k, (m.get(k) ?? 0) + 1), new Map());
+// One kind or two? The bare word `kind` says little: a path step and an engine block both have one (KF-35). Two switches that share a case are on one
+// kind; two whose cases are all different are not; a switch with no case to read is judged by the name.
+const sameKind = (a, b) => a.kind === b.kind && (!a.labels.size || !b.labels.size || [...a.labels].some((l) => b.labels.has(l)));
+const count = (list) => list.reduce((m, s) => m.set(s.kind, (m.get(s.kind) ?? 0) + 1), new Map());
 
-// The kinds a write switches on more often than before.
-export function newKinds(before, after) {
-  const was = count(kindsSwitched(before));
-  return [...count(kindsSwitched(after))].filter(([k, n]) => n > (was.get(k) ?? 0)).map(([k]) => k);
+// The switches on a kind a write switches on more often than before.
+export function newSwitches(before, after, ext = '') {
+  const was = count(switchesOf(before, ext));
+  const now = switchesOf(after, ext);
+  const grown = new Set([...count(now)].filter(([k, n]) => n > (was.get(k) ?? 0)).map(([k]) => k));
+  return now.filter((s) => grown.has(s.kind));
 }
 
 // { kind -> [files] }: the other code files of the checkout that already switch on each kind.
-export function elsewhere(root, selfRel, kinds, layout = readLayout(root)) {
+export function elsewhere(root, selfRel, switches, layout = readLayout(root)) {
   const skip = [...TESTS, ...(layout.protected ?? [])];
   const found = new Map();
-  for (const rel of codeFiles(root, skip)) {
+  for (const rel of codeFiles(root, skip, JUDGED)) {
     if (rel === selfRel) continue;
-    const there = new Set(kindsSwitched(readFileSync(join(root, rel), 'utf8')));
-    for (const k of kinds) if (there.has(k)) found.set(k, [...(found.get(k) ?? []), rel]);
+    const there = switchesOf(readFileSync(join(root, rel), 'utf8'), extname(rel));
+    for (const s of switches) if (there.some((t) => sameKind(s, t)) && !found.get(s.kind)?.includes(rel)) found.set(s.kind, [...(found.get(s.kind) ?? []), rel]);
   }
   return found;
 }
 
 // One write: null when it adds no second place for a kind; else the refusal.
 function judgeWrite(w, rel) {
-  if (w.op === 'delete' || w.after === null || w.after === undefined || !CODE.has(extname(w.path)) || matchesAny(rel, TESTS)) return null;
-  const kinds = newKinds(w.before ?? '', w.after);
-  if (kinds.length === 0) return null;
-  const found = elsewhere(checkoutRoot(w.path), rel, kinds, readLayout(claudeRoot(w.path)));
+  if (w.op === 'delete' || w.after === null || w.after === undefined || !JUDGED.has(extname(w.path)) || matchesAny(rel, TESTS)) return null;
+  const added = newSwitches(w.before ?? '', w.after, extname(w.path)).filter((s) => !s.owned); // a method on the enum is where the table belongs
+  if (added.length === 0) return null;
+  const twice = added.find((s, i) => added.some((t, j) => i !== j && sameKind(s, t) && s.labels.size && t.labels.size));
+  if (twice) return `${rel} branches on "${twice.kind}" twice in this file.\n${FIX}`;
+  const found = elsewhere(checkoutRoot(w.path), rel, added, readLayout(claudeRoot(w.path)));
   if (found.size === 0) return null;
   const lines = [...found].map(([k, files]) => `  "${k}" is already switched on in: ${files.slice(0, 5).join(', ')}`).join('\n');
-  return `${rel} adds a second place that branches on the same kind.\n${lines}\n` +
-    'Give each kind its own object, table entry or class (rule: behaviour-lives-with-its-kind), and call it from both places,\n' +
-    'so a new kind is one new entry instead of an edit in every switch.\n';
+  return `${rel} adds a second place that branches on the same kind.\n${lines}\n${FIX}`;
 }
 
 const main = (text) => judgeEvent(text, { name: 'dispatch-once', write: judgeWrite });
 
 function selftest() {
   const hook = new URL(import.meta.url).pathname;
+  const rustTable = (kind, name) => `pub fn ${name}(s: &${kind}) -> u8 {\n    match s {\n        ${kind}::Open => 1,\n        ${kind}::Paid => 2,\n        ${kind}::Closed => 3,\n        ${kind}::Low => 4,\n        ${kind}::Mid => 5,\n    }\n}\n`;
   const dir = scratchProject({
+    'src/state.rs': `pub enum State { Open, Paid, Closed, Low, Mid }\n${rustTable('State', 'label')}`,
     'src/render.cpp': 'float draw (Shape& s) { switch (s.mode) { case Mode::line: return 1.0f; default: return 0.0f; } }\n',
     'tests/render_test.cpp': 'void t (Shape& s) { switch (s.format) { default: break; } }\n',
   });
@@ -79,7 +109,14 @@ function selftest() {
     ['a switch in a comment or string is not a switch', w('src/note.ts', '// switch (x.mode) {\nconst s = "switch (x.mode) {";\n'), 0],
     ['the kind is the last name in the expression', w('src/args.ts', 'function f(args) { switch (args?.shape.mode) { default: } }\n'), 2],
     ['a heredoc that adds a second switch', runHook(hook, dir, bashOf("cat > src/b.cpp <<'EOF'\nvoid b (Shape& s) { switch (s.mode) { default: break; } }\nEOF", dir)), 2],
+    ['a kind of the same name with other cases is another kind (KF-35)', w('src/path.cpp', 'void p (Step& s) { switch (s.mode) { case Pen::up: break; } }\n'), 0],
+    ['one case shared is the same kind', w('src/other.cpp', 'void o (Shape& s) { switch (s.mode) { case Mode::line: break; } }\n'), 2],
+    ['twice in one new file', w('src/twice.cpp', 'void a (S& s) { switch (s.pen) { case Pen::up: break; } }\nvoid b (S& s) { switch (s.pen) { case Pen::up: break; } }\n'), 2],
     ['another project is not ours', runHook(hook, dir, writeOf(join(dir, '..', 'elsewhere', 'x.cpp'), 'void x (S& s) { switch (s.mode) {} }\n')), 0],
+    ['Rust: a second lookup table on an enum, outside it', w('src/colour.rs', rustTable('State', 'colour')), 2],
+    ['Rust: the enum\'s own file keeps its tables', w('src/state2.rs', `pub enum Level { Low, Mid, High }\n${rustTable('Level', 'label')}${rustTable('Level', 'rank')}`), 0],
+    ['Rust: a match that does work is good Rust', w('src/step.rs', 'pub fn step(s: &State) {\n    match s {\n        State::Open => pay(),\n        State::Paid => ship(),\n        State::Closed => close(),\n    }\n}\n'), 0],
+    ['Rust: a table of true and false is a predicate', w('src/open.rs', 'pub fn open(s: &State) -> bool {\n    match s {\n        State::Open => true,\n        State::Paid => false,\n        State::Closed => false,\n    }\n}\n'), 0],
   ]);
 }
 

package/packs/base/hooks/folder-law.mjs

@@ -52,6 +52,7 @@ function selftest() {
   const w = (file) => runHook(hook, dir, writeOf(join(dir, file)));
   const sh = (cmd) => runHook(hook, dir, bashOf(cmd, dir));
   const ts = scratchProject({}, { folders: { api: { path: 'api/src', purpose: 'the API' } }, concepts: {}, sourceFiles: '\\.(ts|tsx)$' });
+  const plain = scratchProject({}, { folders: { src: { path: 'src', purpose: 'the code' } }, concepts: {}, sourceFiles: '\\.py$' });
   return verdicts('folder-law', [
     ['TypeScript is not source where the layout does not say so', w('stray/x.ts'), 0],
     ['a layout whose sourceFiles name TypeScript: a new .ts outside its folders (KWB-37)', runHook(hook, ts, writeOf(join(ts, 'stray/x.ts'))), 2],
@@ -59,6 +60,8 @@ function selftest() {
     ['a new file in a layout folder', w('src/core/Svf.cpp'), 0],
     ['a new file outside the layout', w('stray/New.cpp'), 2],
     ['a new file loose in src/', w('src/Loose.cpp'), 2],
+    ['a layout that names nothing inside src/: a file in src/ (KWB-78)', runHook(hook, plain, writeOf(join(plain, 'src/app.py'))), 0],
+    ['and a file outside it', runHook(hook, plain, writeOf(join(plain, 'stray/app.py'))), 2],
     ['an existing file outside the layout', w('stray/Old.cpp'), 0],
     ['an edit is never a new file', runHook(hook, dir, editOf(join(dir, 'stray/New.cpp'))), 0],
     ['a doc is not source', w('stray/notes.md'), 0],