@event4u/agent-config 16.5.0 → 17.0.0

package/dist/scripts/_lib/svg_filled_counter.js

@@ -0,0 +1,285 @@
+/**
+ * `svg-structure-filled-counter` — step 3.2 of `road-to-type-with-a-witness`.
+ *
+ * A letter with a counter (o, e, a, B, 8) or an O-ring mark is one path with an
+ * outer and an inner contour. Under `fill-rule="nonzero"`, the default, the
+ * counter stays open only when the inner contour winds the OTHER way: a
+ * same-direction inner contour adds to the winding number and the counter
+ * paints. Measured on the repo's Chromium: two same-direction circles of radius
+ * 250 and 160 painted 196,282 px, the ring they should be 115,940.
+ *
+ * The check flattens each subpath to a polygon, sums the winding signs of the
+ * subpaths that contain a subpath's every vertex, and reports the subpath when
+ * that sum is nonzero and shares its own sign — it sits in a painted region and
+ * deepens it instead of cutting it out. It is advisory (decision A8): `warning`, never `error`, until
+ * the false-positive census of step 3.3 says otherwise.
+ *
+ * Limits, stated rather than guessed around: a transform does not change a
+ * winding sign unless it mirrors, and a mirror flips both contours alike, so
+ * transforms are ignored; `fill-rule` set from a stylesheet selector is not
+ * read — an attribute or inline style, on the path or an ancestor, is.
+ */
+import { tokenisePath } from './svg_geometry.js';
+const CURVE_STEPS = 12;
+const MAX_SUBPATHS = 400;
+function styleProp(el, prop) {
+    const direct = el.attrs[prop];
+    if (direct !== undefined)
+        return direct.trim();
+    const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, 'i').exec(el.attrs['style'] ?? '');
+    return m?.[1]?.trim();
+}
+function arcPoints(from, args) {
+    const [rxIn, ryIn, rotDeg, large, sweep, x, y] = args;
+    const [x1, y1] = from;
+    let rx = Math.abs(rxIn);
+    let ry = Math.abs(ryIn);
+    if (rx === 0 || ry === 0 || (x1 === x && y1 === y))
+        return [[x, y]];
+    const phi = (rotDeg * Math.PI) / 180;
+    const cos = Math.cos(phi);
+    const sin = Math.sin(phi);
+    const dx = (x1 - x) / 2;
+    const dy = (y1 - y) / 2;
+    const xp = cos * dx + sin * dy;
+    const yp = -sin * dx + cos * dy;
+    const lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
+    if (lambda > 1) {
+        rx *= Math.sqrt(lambda);
+        ry *= Math.sqrt(lambda);
+    }
+    const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+    const den = rx * rx * yp * yp + ry * ry * xp * xp;
+    const coef = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den));
+    const cxp = (coef * rx * yp) / ry;
+    const cyp = (-coef * ry * xp) / rx;
+    const cx = cos * cxp - sin * cyp + (x1 + x) / 2;
+    const cy = sin * cxp + cos * cyp + (y1 + y) / 2;
+    const angle = (ux, uy, vx, vy) => {
+        const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+        return a;
+    };
+    const t1 = angle(1, 0, (xp - cxp) / rx, (yp - cyp) / ry);
+    let dt = angle((xp - cxp) / rx, (yp - cyp) / ry, (-xp - cxp) / rx, (-yp - cyp) / ry);
+    if (!sweep && dt > 0)
+        dt -= 2 * Math.PI;
+    if (sweep && dt < 0)
+        dt += 2 * Math.PI;
+    const out = [];
+    for (let k = 1; k <= CURVE_STEPS; k++) {
+        const t = t1 + (dt * k) / CURVE_STEPS;
+        const ex = rx * Math.cos(t);
+        const ey = ry * Math.sin(t);
+        out.push([cos * ex - sin * ey + cx, sin * ex + cos * ey + cy]);
+    }
+    return out;
+}
+function bezier(p0, p1, p2, p3) {
+    const out = [];
+    for (let k = 1; k <= CURVE_STEPS; k++) {
+        const t = k / CURVE_STEPS;
+        const u = 1 - t;
+        out.push([
+            u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
+            u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1],
+        ]);
+    }
+    return out;
+}
+/** Each subpath of `d` as a flattened polygon, or `null` when `d` does not parse. */
+export function subpathPolygons(d) {
+    const tokens = tokenisePath(d);
+    if (tokens === null)
+        return null;
+    const ARGS = { m: 2, l: 2, t: 2, h: 1, v: 1, c: 6, s: 4, q: 4, a: 7, z: 0 };
+    const polys = [];
+    let poly = [];
+    let cur = [0, 0];
+    let start = [0, 0];
+    let lastCtrl = null;
+    let lastQuad = null;
+    let i = 0;
+    let cmd = '';
+    const flush = () => {
+        if (poly.length >= 3)
+            polys.push(poly);
+        poly = [];
+    };
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (/^[a-zA-Z]$/.test(tok)) {
+            cmd = tok;
+            i += 1;
+            if (cmd.toLowerCase() === 'z') {
+                cur = start;
+                lastCtrl = lastQuad = null;
+                flush();
+                continue;
+            }
+            if (i >= tokens.length)
+                break;
+            continue;
+        }
+        const lower = cmd.toLowerCase();
+        const n = ARGS[lower];
+        if (n === undefined || n === 0)
+            return null;
+        const a = tokens.slice(i, i + n).map(Number);
+        if (a.length < n || a.some((v) => !Number.isFinite(v)))
+            return null;
+        i += n;
+        const rel = cmd !== cmd.toUpperCase();
+        const ox = rel ? cur[0] : 0;
+        const oy = rel ? cur[1] : 0;
+        const at = (k) => [a[k] + ox, a[k + 1] + oy];
+        let next = cur;
+        let pts = [];
+        let ctrl = null;
+        let quad = null;
+        switch (lower) {
+            case 'm':
+                flush();
+                next = at(0);
+                start = next;
+                pts = [next];
+                // Further pairs after a moveto are implicit linetos.
+                cmd = rel ? 'l' : 'L';
+                break;
+            case 'l':
+                next = at(0);
+                pts = [next];
+                break;
+            case 'h':
+                next = [a[0] + ox, cur[1]];
+                pts = [next];
+                break;
+            case 'v':
+                next = [cur[0], a[0] + oy];
+                pts = [next];
+                break;
+            case 'c':
+                ctrl = at(2);
+                next = at(4);
+                pts = bezier(cur, at(0), ctrl, next);
+                break;
+            case 's': {
+                const c1 = lastCtrl ? [2 * cur[0] - lastCtrl[0], 2 * cur[1] - lastCtrl[1]] : cur;
+                ctrl = at(0);
+                next = at(2);
+                pts = bezier(cur, c1, ctrl, next);
+                break;
+            }
+            case 'q':
+            case 't': {
+                const q = lower === 'q' ? at(0) : lastQuad ? [2 * cur[0] - lastQuad[0], 2 * cur[1] - lastQuad[1]] : cur;
+                next = lower === 'q' ? at(2) : at(0);
+                quad = q;
+                const c1 = [cur[0] + (2 / 3) * (q[0] - cur[0]), cur[1] + (2 / 3) * (q[1] - cur[1])];
+                const c2 = [next[0] + (2 / 3) * (q[0] - next[0]), next[1] + (2 / 3) * (q[1] - next[1])];
+                pts = bezier(cur, c1, c2, next);
+                break;
+            }
+            case 'a':
+                next = [a[5] + ox, a[6] + oy];
+                pts = arcPoints(cur, [a[0], a[1], a[2], a[3], a[4], next[0], next[1]]);
+                break;
+        }
+        poly.push(...pts);
+        cur = next;
+        lastCtrl = ctrl;
+        lastQuad = quad;
+        if (polys.length > MAX_SUBPATHS)
+            return polys;
+    }
+    flush();
+    return polys;
+}
+function signedArea(poly) {
+    let s = 0;
+    for (let k = 0; k < poly.length; k++) {
+        const [x1, y1] = poly[k];
+        const [x2, y2] = poly[(k + 1) % poly.length];
+        s += x1 * y2 - x2 * y1;
+    }
+    return s / 2;
+}
+function inside(pt, poly) {
+    let hit = false;
+    for (let k = 0, j = poly.length - 1; k < poly.length; j = k++) {
+        const [xi, yi] = poly[k];
+        const [xj, yj] = poly[j];
+        if (yi > pt[1] !== yj > pt[1] && pt[0] < ((xj - xi) * (pt[1] - yi)) / (yj - yi) + xi)
+            hit = !hit;
+    }
+    return hit;
+}
+/**
+ * Every `<path>` painted under `nonzero` whose subpath sits in a painted region
+ * of the same path and winds with it. One entry per inner subpath; `outer` is
+ * the smallest subpath containing it.
+ */
+export function filledCounters(elements) {
+    const out = [];
+    // The fill rule and fill each element inherits, by an open-element stack.
+    const stack = [];
+    for (const el of elements) {
+        if (el.closing) {
+            const at = stack.map((s) => s.name).lastIndexOf(el.name);
+            if (at >= 0)
+                stack.length = at;
+            continue;
+        }
+        const parent = stack[stack.length - 1];
+        const rule = styleProp(el, 'fill-rule') ?? parent?.rule;
+        const fill = styleProp(el, 'fill') ?? parent?.fill;
+        if (!el.selfClosing)
+            stack.push({ name: el.name, rule, fill });
+        if (el.name !== 'path')
+            continue;
+        if ((rule ?? 'nonzero').toLowerCase() === 'evenodd' || (fill ?? '').toLowerCase() === 'none')
+            continue;
+        const polys = subpathPolygons(el.attrs['d'] ?? '');
+        if (polys === null || polys.length < 2 || polys.length > MAX_SUBPATHS)
+            continue;
+        const areas = polys.map(signedArea);
+        for (let inner = 0; inner < polys.length; inner++) {
+            const ia = areas[inner];
+            if (Math.abs(ia) < 1e-9)
+                continue;
+            // The winding number around the inner contour, from every subpath
+            // that contains it — not from one outer, or an island inside a
+            // counter reads as a filled counter.
+            let around = 0;
+            let nearest = -1;
+            for (let outer = 0; outer < polys.length; outer++) {
+                if (outer === inner)
+                    continue;
+                const oa = areas[outer];
+                if (Math.abs(oa) <= Math.abs(ia))
+                    continue;
+                const op = polys[outer];
+                if (!polys[inner].every((p) => inside(p, op)))
+                    continue;
+                around += Math.sign(oa);
+                if (nearest < 0 || Math.abs(oa) < Math.abs(areas[nearest]))
+                    nearest = outer;
+            }
+            if (around !== 0 && Math.sign(around) === Math.sign(ia)) {
+                out.push({ element: el, inner: inner + 1, outer: nearest + 1 });
+            }
+        }
+    }
+    return out;
+}
+/** The rule as `scanSvg` runs it: one advisory finding per filled counter. */
+export function ruleFilledCounter(elements, file) {
+    return filledCounters(elements).map((c) => ({
+        rule: 'svg-structure-filled-counter',
+        file,
+        line: c.element.line,
+        snippet: `<path> subpath ${c.inner} sits inside subpath ${c.outer} with the same winding under nonzero, so ` +
+            'the counter paints — wind the inner contour the other way, or declare fill-rule="evenodd"',
+        severity: 'warning',
+    }));
+}
+//# sourceMappingURL=svg_filled_counter.js.map

package/dist/scripts/_lib/svg_rules.js

@@ -28,6 +28,7 @@
  * every existing import keeps resolving.
  */
 import { attrsOf, parseDocument, tagEnd } from './svg_dom.js';
+import { ruleFilledCounter } from './svg_filled_counter.js';
 import { cssUnescape, isActiveUrl, localName, rawAttrs, resolvedUrl, svgPrefixes, URL_ATTRS } from './svg_urls.js';
 import { elementExtent, pathDataError, pathExtent, pointsExtent, staticBox, tokenisePath, } from './svg_geometry.js';
 export { elementExtent, pathDataError, pathExtent, pointsExtent, staticBox, tokenisePath };
@@ -1092,6 +1093,7 @@ export function scanSvg(content, relPath, opts = {}) {
         ...ruleMissingXmlns(elements, relPath),
         ...ruleOutsideViewBox(elements, relPath),
         ...ruleUnparseablePath(elements, relPath),
+        ...ruleFilledCounter(elements, relPath),
         ...ruleUnusedDefs(text, elements, relPath),
         ...ruleDanglingReference(text, elements, relPath),
         ...ruleActiveContent(text, elements, relPath, mode),

package/dist/scripts/_lib/ui_surface.js

@@ -86,4 +86,23 @@ export function isUiTreePath(p) {
         return false;
     return UI_PATH_FRAGMENTS.some((fragment) => normalized.includes(fragment));
 }
+/**
+ * The file-shaped triggers of `design-fidelity` — the ONE list every handover
+ * carrier reads (`isArtifactRead`, `isHandoverPath`, `HANDOVER_TRIGGERS`).
+ * Three hand copies drifted: one lacked `*.dc.html`. `design_pass.test.ts`
+ * pins this list to the rule's frontmatter in both directions.
+ */
+export const HANDOVER_SHAPES = [
+    { file_pattern: '*design.html' },
+    { file_pattern: '*.dc.html' },
+    { path_prefix: '.claude/design-system/' },
+    { path_prefix: '.design-sync/' },
+];
+/** True when `file` has a handover shape. Direction-agnostic, case-insensitive. */
+export function isHandoverShape(file) {
+    if (!file)
+        return false;
+    const normalized = file.replace(/\\/g, '/').toLowerCase();
+    return HANDOVER_SHAPES.some((s) => 'path_prefix' in s ? normalized.includes(s.path_prefix) : normalized.endsWith(s.file_pattern.slice(1)));
+}
 //# sourceMappingURL=ui_surface.js.map

package/dist/scripts/_lib/verification_command.js

@@ -0,0 +1,364 @@
+/**
+ * The verification-command selector — one predicate, two importers.
+ *
+ * It first moved here byte-identical out of `hooks/turn_end_gate_hook.ts` so
+ * that `_lib/verification_evidence.ts` could read it without importing a hook
+ * that imports the evidence module straight back. That cycle resolves at
+ * runtime today and breaks the day either side grows a module-level constant
+ * reading the other, which is a failure nobody would trace to an import line.
+ *
+ * The hook re-exports the name, so every existing consumer — including both
+ * pinning test files — addresses it at the path it always did.
+ *
+ * WHY IT STOPPED BEING A REGEX (2026-09-30).
+ * The tree carried TWO expressions answering "did this command verify
+ * anything", and they disagreed in both directions:
+ *
+ * - `_VERIFY_RE` here matched a verification token **anywhere on the line**, so
+ *   `ls tests`, `cat build.log`, `git checkout main`, `mkdir build` and
+ *   `git commit -m "fix ci"` all cleared detector C — the exact case this
+ *   header claimed to reject. Measured at the pin: all six returned `true`.
+ * - `_VERIFICATION_RE` in `before_complete_hook.ts` was head-anchored to a
+ *   fixed vendor list and refused `npx vitest run`, `tsc --noEmit` and every
+ *   `./scripts-run src/scripts/lint_*` — commands this project runs constantly.
+ *   Measured at the pin: all three returned `false`.
+ *
+ * Both accepted `npm test || true`, where the shell discards the failure.
+ *
+ * The audited allowlist passed the whole time the first defect was live,
+ * because not one of its seven negatives put a verify token in an ARGUMENT
+ * position. A word-boundary regex cannot express "the head of the segment",
+ * which is the property that actually distinguishes `npm test` from `ls tests`,
+ * so the predicate is now structural: split on shell separators, drop a
+ * segment whose failure the shell discards, and classify each remaining
+ * segment on its HEAD.
+ *
+ * THE LISTS ARE STILL DELIBERATELY NARROW.
+ * A positive list. The alternative — treating any `Bash` call as verification —
+ * was rejected because `ls` would then clear an unverified edit, which is the
+ * failure mode `verify-before-complete` names ("relying on partial
+ * verification"). The cost of narrowness is a MISSED detection when a project
+ * verifies by some command not listed here, and that is the safe direction for
+ * a gate that can refuse a turn: a false negative costs one unguarded turn, a
+ * false positive teaches the user to switch the gate off.
+ *
+ * AUDITED 2026-08-17, re-seeded 2026-09-30 from the union of both lists minus
+ * every row that only ever matched on an argument. The table of every command
+ * with its verdict is `turn_end_verify_allowlist.test.ts`; the two directions
+ * of the old disagreement are `verification_command_anchoring.test.ts`.
+ *
+ * Deliberate NON-additions, kept because Risk 2 of the originating roadmap is
+ * that every addition is a way to satisfy the gate without verifying anything:
+ *
+ *   · `npm run prepack` — a lifecycle hook whose content is per-project. Here
+ *     it validates; elsewhere it copies files.
+ *   · `task sync` / `task generate-tools` / `agent-config roadmap:progress` —
+ *     GENERATORS. They rewrite the tree; they check nothing.
+ *   · `agent-config gates --all` — enumerates gates, runs none.
+ *   · `rector` — a refactoring tool. Its dry run prints a diff; it asserts
+ *     nothing. It appears in `_VERIFICATION_RE`'s list and is dropped from the
+ *     union on the strength of the audited `false` row, which carries a reason
+ *     where the other list carried only a name.
+ *   · `./scripts-run src/scripts/rule_activation_census` — a census writes a
+ *     report; it asserts nothing. This is why the `scripts-run` rule keys on
+ *     the `check_` / `lint_` prefix rather than on the runner.
+ *
+ * `psalm` IS carried, unlike the pre-2026-09-30 note here which argued it out
+ * for want of a local user: it was in `_VERIFICATION_RE` all along, so the
+ * union rule admits it and dropping it would be a narrowing this change did not
+ * set out to make.
+ *
+ * WHAT THIS SELECTOR STILL CANNOT DO: it reads the command TEXT, so
+ * `vitest run` matches whether or not it passed. Deciding whether a run proved
+ * anything is `verification_evidence.ts`, which reads the exit code and the
+ * summary the command printed. This selector decides only what is WORTH
+ * recording and classifying.
+ */
+/** Binaries that verify when they are the head of a segment. */
+const VERIFY_BINARIES = new Set([
+    'vitest',
+    'jest',
+    'pytest',
+    'phpunit',
+    'pest',
+    'tsc',
+    'eslint',
+    'ruff',
+    'mypy',
+    'pyright',
+    'clippy',
+    'phpstan',
+    'psalm',
+    'ecs',
+]);
+/** Prefixes that delegate to the real command; dropped before classifying. */
+const DELEGATING_HEADS = new Set([
+    'npx',
+    'bunx',
+    'sudo',
+    'time',
+    'command',
+]);
+/** Path prefixes a binary is commonly reached through. */
+const PATH_PREFIXES = [
+    './',
+    'vendor/bin/',
+    '.venv/bin/',
+    'node_modules/.bin/',
+    'bin/',
+];
+/** A script or subcommand name that names a check rather than a build step. */
+const VERIFY_WORD = /(^|[-_:])(test|tests|check|checks|lint|typecheck|tsc|qa|preflight|smoke|validate)([-_:]|$)/i;
+/** `npm run build` verifies here; `task build` is not in the audited surface. */
+const NPM_SCRIPT_WORD = /(^|[-_:])(test|tests|check|checks|lint|typecheck|tsc|build)([-_:]|$)/i;
+/** Strip an unquoted trailing `#` comment. */
+function stripComment(command) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (ch === "'" && !inDouble)
+            inSingle = !inSingle;
+        else if (ch === '"' && !inSingle)
+            inDouble = !inDouble;
+        else if (ch === '#' && !inSingle && !inDouble && (i === 0 || /\s/.test(command[i - 1] ?? ''))) {
+            return command.slice(0, i);
+        }
+    }
+    return command;
+}
+/** Split into segments, remembering the separator that follows each. */
+function splitSegments(command) {
+    const raw = [];
+    let buf = '';
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        const two = command.slice(i, i + 2);
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            buf += ch;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            buf += ch;
+            continue;
+        }
+        if (!inSingle && !inDouble) {
+            if (two === '&&' || two === '||') {
+                raw.push({ text: buf, sep: two });
+                buf = '';
+                i += 1;
+                continue;
+            }
+            if (ch === ';' || ch === '|') {
+                raw.push({ text: buf, sep: ch });
+                buf = '';
+                continue;
+            }
+        }
+        buf += ch;
+    }
+    raw.push({ text: buf, sep: null });
+    return raw.map((entry, idx) => {
+        const next = raw[idx + 1];
+        const nextWords = next ? words(next.text) : [];
+        return {
+            words: words(entry.text),
+            nextSep: entry.sep,
+            nextHead: (nextWords[0] ?? null)?.toLowerCase() ?? null,
+        };
+    });
+}
+/** Tokenise a segment, dropping leading `VAR=value` assignments. */
+function words(text) {
+    const tokens = text.trim().split(/\s+/).filter((w) => w.length > 0);
+    let i = 0;
+    while (i < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i]))
+        i += 1;
+    return tokens.slice(i);
+}
+/** Strip a path prefix from a binary name. */
+function bareName(word) {
+    let w = word;
+    for (const prefix of PATH_PREFIXES) {
+        if (w.startsWith(prefix)) {
+            w = w.slice(prefix.length);
+            break;
+        }
+    }
+    const slash = w.lastIndexOf('/');
+    return (slash >= 0 ? w.slice(slash + 1) : w).toLowerCase();
+}
+/**
+ * Does the shell discard this segment's failure?
+ *
+ * `cmd || true`, `cmd || :` and `cmd ; true` all leave the caller with exit 0
+ * whatever `cmd` did, so a verification there proves nothing about the tree.
+ * Deliberately narrow: `cmd || exit 1` propagates the failure and still counts.
+ */
+function failureIsDiscarded(seg) {
+    if (seg.nextSep === '||')
+        return seg.nextHead === 'true' || seg.nextHead === ':';
+    if (seg.nextSep === ';')
+        return seg.nextHead === 'true' || seg.nextHead === ':';
+    return false;
+}
+/** Classify one segment on its head. */
+function segmentVerifies(rawWords) {
+    const w = rawWords.filter((x) => x.length > 0);
+    let idx = 0;
+    // Peel delegating prefixes: `npx vitest run`, `sudo make test`.
+    while (idx < w.length && DELEGATING_HEADS.has(bareName(w[idx])))
+        idx += 1;
+    if (idx >= w.length)
+        return false;
+    const head = bareName(w[idx]);
+    const rest = w.slice(idx + 1).map((x) => x.toLowerCase());
+    const arg1 = rest[0] ?? '';
+    if (VERIFY_BINARIES.has(head))
+        return true;
+    switch (head) {
+        case 'npm':
+        case 'pnpm':
+        case 'yarn':
+        case 'bun': {
+            // `pnpm dlx vitest` delegates; `npm run test:ts` names a script.
+            if (arg1 === 'dlx' || arg1 === 'exec')
+                return segmentVerifies(rest.slice(1));
+            const script = arg1 === 'run' ? (rest[1] ?? '') : arg1;
+            return NPM_SCRIPT_WORD.test(script);
+        }
+        case 'task':
+            return VERIFY_WORD.test(arg1) || /^ci([-_:]|$)/i.test(arg1);
+        case 'cargo':
+            return arg1 === 'test' || arg1 === 'check' || arg1 === 'clippy';
+        case 'go':
+            return arg1 === 'test' || arg1 === 'vet';
+        case 'make':
+            return VERIFY_WORD.test(arg1) || /^ci([-_:]|$)/i.test(arg1);
+        case 'composer':
+            return VERIFY_WORD.test(arg1) || arg1 === 'phpstan';
+        case 'php':
+            return arg1 === 'artisan' && (rest[1] ?? '') === 'test';
+        case 'artisan':
+            return arg1 === 'test';
+        case 'python':
+        case 'python3':
+            return arg1 === '-m' && VERIFY_BINARIES.has(rest[1] ?? '');
+        case 'node':
+        case 'deno':
+            // `node --test` is a runner selected by a FLAG, not by a
+            // subcommand, so head-anchoring alone would refuse it. Caught by
+            // `verification_evidence.test.ts` when this predicate narrowed:
+            // the old token-anywhere regex accepted it by accident and neither
+            // explicit list named it, so the union seeding missed it too.
+            return rest.some((a) => a === 'test' || a.startsWith('--test'));
+        case 'agent-config':
+            // NEITHER `ui:render` NOR `xmllint` verifies here, and the first
+            // half of that was true, then false, and is true again.
+            //
+            // Step 3.5 of `road-to-svg-with-a-witness` taught this predicate
+            // `ui:render --profile asset`, reasoning that it is the one
+            // subcommand which opens the delivered file in a real engine. Step
+            // 2.1(b) of `road-to-svg-review-followups` removed it again on
+            // review claim C2, which is narrower than the first argument and
+            // refutes it: the turn-end gate's TRANSCRIPT path matches a command
+            // and never sees an exit code, so a call that rendered nothing —
+            // the ordinary case on a machine with no Playwright, where the
+            // command also exited 0 until the same day — discharged the
+            // obligation from its text alone.
+            //
+            // What replaces it reads the RENDER instead of the call:
+            // `hooks/svg_obligation.ts` matches a manifest to the file's own
+            // digest, and accepts a renderer-absent manifest only together with
+            // a clean static witness on those same bytes. `xmllint --noout`
+            // stays out for its original reason (S6): a file can parse and
+            // still be the wrong picture.
+            return false;
+        case 'scripts-run': {
+            // `./scripts-run src/scripts/lint_x` verifies; `…/rule_activation_census`
+            // writes a report and asserts nothing, which is why this keys on the
+            // script's own prefix rather than on the runner.
+            const script = bareName(arg1);
+            return /^(check|lint|verify|validate)[-_]/.test(script);
+        }
+        default:
+            return false;
+    }
+}
+/**
+ * True when the command runs something that asserts the tree still holds.
+ *
+ * Classified per shell segment on the segment's HEAD, so a verification token
+ * appearing as an argument — `ls tests`, `git commit -m "fix ci"` — never
+ * counts, and a chained `task sync && task ci` counts on its second segment.
+ */
+export function isVerificationCommand(command) {
+    if (!command)
+        return false;
+    const segments = splitSegments(stripComment(command));
+    return segments.some((seg) => !failureIsDiscarded(seg) && segmentVerifies(seg.words));
+}
+/**
+ * The RECORDER's net — deliberately wider than the predicate above, and not a
+ * leftover of the two-regex era it replaces.
+ *
+ * The two answer different questions. `isVerificationCommand` answers *did
+ * this verify*, and a false positive there clears an unverified edit, so it is
+ * head-anchored and narrow. This one answers *is this worth writing down for
+ * `classifyRun` to judge*, and there the costly error is the opposite: a
+ * recorder that filtered `echo test` out would leave the turn-end gate unable
+ * to tell "the turn ran a non-verification command" from "the turn ran
+ * nothing at all", and `not_a_verification_command` is a verdict the gate
+ * needs to SEE rather than infer from silence.
+ *
+ * That is why unifying the two call sites into one predicate was tried and
+ * rejected on 2026-09-30: it is not two spellings of one idea, it is two
+ * questions with opposite error costs. What was wrong before was that each
+ * question had its own private regex in its own file and the two also
+ * disagreed about the FIRST question. Both now live here, and only this one
+ * matches on a token anywhere in the line.
+ */
+const _WIDE_CANDIDATE_RE = /\b(test|tests|vitest|jest|pytest|phpunit|pest|tsc|eslint|ruff|mypy|pyright|clippy|phpstan|typecheck|lint[-_:a-z]*|build|ci|preflight|smoke[-_:a-z]*|check[-_:a-z]*|validate[-_:a-z]*)\b|\b(task|npm|pnpm|yarn|composer|cargo|go|make|php artisan|bun)\s+(run\s+)?\S*(test|check|lint|build|ci|typecheck)/i;
+export function mightBeVerification(command) {
+    return _WIDE_CANDIDATE_RE.test(command);
+}
+/**
+ * `agent-config ui:render … --profile asset`, by shape.
+ *
+ * Moved here from `hooks/svg_obligation.ts` by finding 3 of this change's
+ * SECOND completion review: two detectors need it and one of them is in
+ * `_lib`, so a hook module was the wrong home. Re-exported there, so no
+ * caller moved.
+ */
+export function isAssetRenderCommand(command) {
+    return /\bui:render\b/.test(command) && /--profile[= ]\s*asset\b/.test(command);
+}
+/**
+ * Did this command ATTEMPT to verify something — as opposed to: did it produce
+ * a verdict this gate may read?
+ *
+ * The distinction is the whole point, and the first review round and the
+ * second each saw one half of it. Round one (claim C2) was right that
+ * `isVerificationCommand` must NOT learn the asset render: the transcript path
+ * never sees an exit code, so the command's TEXT would have discharged the SVG
+ * obligation on a machine where the render produced nothing. Round two
+ * (finding 3) was right that removing it left detector C — "did any
+ * verification command follow the last edit" — unable to see the one command
+ * this package PRESCRIBES for an `.svg`, so the prescribed turn was refused.
+ *
+ * Both hold because they are about different detectors. Detector C asks
+ * whether the author tried; it is satisfied by `eslint` and must be satisfied
+ * by a render too. The SVG obligation asks what the render FOUND, and still
+ * reads the manifest and the file's digest — an attempt that produced nothing
+ * discharges nothing there, with a far better reason than detector C's.
+ *
+ * So: one predicate per question, and `isVerificationCommand` is unchanged.
+ */
+export function isVerificationAttempt(command) {
+    return isVerificationCommand(command) || isAssetRenderCommand(command);
+}
+//# sourceMappingURL=verification_command.js.map