tickmarkr 1.89.0 → 1.90.0

package/dist/compile/native.js

@@ -1,8 +1,9 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { basename, dirname } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { filesGlob } from "../graph/files-glob.js";
 import picomatch from "picomatch";
-import { GATE_NAMES, GRAPH_ROUTING_MODES, ORACLES, SHAPES, TIERS, validateGraph } from "../graph/schema.js";
+import { GATE_NAMES, GRAPH_ROUTING_MODES, ORACLES, renderAcceptanceItem, SHAPES, TIERS, validateGraph, } from "../graph/schema.js";
 import { CompileError, inferShape, sha256 } from "./common.js";
 // OBS-170/OBS-184: `context:` is a promise to the worker, and nothing ever checked it could be kept.
 // Workers run in `git worktree add <baseRef>` (run/git.ts:169-176), which materialises the base
@@ -71,6 +72,202 @@ const FIELDS = new Set(["goal", "shape", "deps", "files", "context", "complexity
 function invalid(task, field, detail) {
     throw new CompileError(`Task ${task} field "${field}" ${detail}`);
 }
+export const AUTHORING_LINT_CODES = [
+    "criterion-scope",
+    "dependency-closure",
+    "dependency-coupling",
+    "proxy-metric",
+    "external-referent",
+    "closed-enumeration",
+    "one-behavior",
+    "concern-bundle",
+    "seam-exists",
+];
+// The authoring frame's observable oracle is the branch-tip test corpus, never the mutable index or
+// an author's untracked checkout. Load it once per repository: one bounded git read replaces a grep
+// subprocess per token and preserves the base-only native compile's zero-Git property (the index is
+// requested only when a criterion actually carries a rendered observable or a test basename).
+const headTestCache = new Map();
+function repositoryRoot(file) {
+    let current = resolve(dirname(file));
+    for (;;) {
+        if (existsSync(join(current, ".git")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function testsAtHead(root) {
+    const cached = headTestCache.get(root);
+    if (cached)
+        return cached;
+    const grep = spawnSync("git", ["-C", root, "grep", "-I", "-n", "-e", "", "HEAD", "--", "tests/*.test.ts", "tests/**/*.test.ts"], { encoding: "utf8", maxBuffer: 1 << 25 });
+    if (grep.status !== 0 || typeof grep.stdout !== "string") {
+        headTestCache.set(root, []);
+        return [];
+    }
+    const bodies = new Map();
+    for (const line of grep.stdout.split("\n")) {
+        const match = line.match(/^HEAD:(tests\/.*\.test\.ts):\d+:(.*)$/);
+        if (!match)
+            continue;
+        const lines = bodies.get(match[1]) ?? [];
+        lines.push(match[2]);
+        bodies.set(match[1], lines);
+    }
+    const tests = [...bodies].map(([path, lines]) => ({ path, text: lines.join("\n") }));
+    headTestCache.set(root, tests);
+    return tests;
+}
+function criterionTexts(task) {
+    return task.acceptance.map(renderAcceptanceItem);
+}
+function fixtureId(file) {
+    return basename(file).replace(/(?:\.spec)?\.md$/, "");
+}
+function strictNegativeCount(text) {
+    return (text.match(/\b(?:never|neither|cannot)\b|\bno\s+[a-z][a-z-]*(?:\s+[a-z][a-z-]*){0,3}\s+(?:may|can|supplies|becomes)\b/gi) ?? []).length;
+}
+function namedCriterionPaths(text, tests) {
+    const paths = new Set();
+    for (const match of text.matchAll(/(?:^|[\s("'`])((?:src|tests|fixtures|scripts)\/[A-Za-z0-9_@{}*?.,/+-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|txt))/g)) {
+        paths.add(match[1]);
+    }
+    for (const match of text.matchAll(/\b([A-Za-z0-9_.-]+\.test\.ts)\b/g)) {
+        for (const test of tests)
+            if (basename(test.path) === match[1])
+                paths.add(test.path);
+    }
+    return [...paths];
+}
+function renderedObservables(text) {
+    const exact = new Set();
+    const denominators = new Set();
+    for (const match of text.matchAll(/`([^`\n]{2,120})`/g)) {
+        const token = match[1].trim();
+        // Plain vocabulary in backticks is documentation, not a concrete rendered value. Digit-bearing,
+        // path/punctuation-shaped, snake/camel-case tokens are the branch-tip grep substrate from C1.
+        if (/\d|[_./:%-]|[a-z][A-Z]/.test(token))
+            exact.add(token);
+    }
+    for (const match of text.matchAll(/\b(\d+)\s*(?:\/|of)\s*(\d+)\b/gi)) {
+        exact.add(`${match[1]}/${match[2]}`);
+        denominators.add(match[2]);
+    }
+    return { exact: [...exact], denominators: [...denominators] };
+}
+function criterionScopeFinding(task, text, criterion, id, tests) {
+    if (task.files.length === 0)
+        return undefined; // empty files[] is deliberately unrestricted
+    const inScope = filesGlob(task.files.map((entry) => entry.replace(/^\.\//, ""))); // Q120s shared matcher
+    const named = namedCriterionPaths(text, tests);
+    const { exact, denominators } = renderedObservables(text);
+    const asserting = tests.filter((test) => exact.some((token) => test.text.includes(token))
+        || denominators.some((denominator) => new RegExp(`(?:^|\\D)\\d+/${denominator}(?:\\D|$)`).test(test.text))).map((test) => test.path);
+    const missing = [...new Set([...named, ...asserting])].filter((path) => !inScope(path));
+    if (missing.length === 0)
+        return undefined;
+    return {
+        code: "criterion-scope",
+        fixtureId: id,
+        taskId: task.id,
+        criterion,
+        detail: `criterion names asserting file${missing.length === 1 ? "" : "s"} outside expanded files[]: ${missing.join(", ")}`,
+    };
+}
+function exportedIdentifier(root, files, identifier) {
+    const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const declaration = new RegExp(`\\bexport\\s+(?:(?:declare|default|async)\\s+)*(?:function|class|const|let|var|interface|type)\\s+${escaped}\\b|\\bexport\\s*\\{[^}]*\\b${escaped}\\b`);
+    return files.some((file) => {
+        if (/[*?{[]/.test(file))
+            return false;
+        try {
+            return declaration.test(readFileSync(join(root, file), "utf8"));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Frame-v2 authoring checks over the compiled native task shape. Criterion-scope is blocking at the
+ * compile boundary; the remaining checks are review findings, emitted by compileNative below.
+ */
+export function authoringLintFindings(tasks, file) {
+    const id = fixtureId(file);
+    const root = repositoryRoot(file);
+    let indexedTests;
+    const testIndex = () => indexedTests ??= root ? testsAtHead(root) : [];
+    const findings = [];
+    for (const task of tasks) {
+        const criteria = criterionTexts(task);
+        for (const [index, text] of criteria.entries()) {
+            const needsTestIndex = /`[^`\n]{2,120}`|\b\d+\s*(?:\/|of)\s*\d+\b|\b[A-Za-z0-9_.-]+\.test\.ts\b/.test(text);
+            const scope = criterionScopeFinding(task, text, index + 1, id, needsTestIndex ? testIndex() : []);
+            if (scope)
+                findings.push(scope);
+            if (/line[- ]count|physical line|not greater than (?:the|\d)|no larger than|at most \d+ (?:lines|bytes)/i.test(text)) {
+                findings.push({ code: "proxy-metric", fixtureId: id, taskId: task.id, criterion: index + 1, detail: "criterion uses a proxy size metric; state the structural intent instead" });
+            }
+            if (/\bthe (?:audit|ruling|sweep|standby|decision|analysis|handoff)\b|\bper the\b|\bat \.planning\//i.test(text)) {
+                findings.push({ code: "external-referent", fixtureId: id, taskId: task.id, criterion: index + 1, detail: "criterion depends on an external governance referent; inline the deciding fact" });
+            }
+            const separators = text.match(/\band\b|\bwhile\b|\bthen\b|\bplus\b|\bwith\b|,|—/gi) ?? [];
+            if (separators.length >= 4) {
+                findings.push({ code: "one-behavior", fixtureId: id, taskId: task.id, criterion: index + 1, detail: `${separators.length} independently-failable separators; split unless one leg alone reds this title` });
+            }
+        }
+        const prose = [task.goal, ...criteria].join("\n");
+        const dependencyText = prose
+            .replace(/`[^`]*`/g, "")
+            .split("\n")
+            .filter((line) => !/\b(?:accepts?|rejects?)\b/i.test(line))
+            .join("\n");
+        const referenced = [...new Set(dependencyText.match(/\bT\d+\b/g) ?? [])]
+            .filter((dep) => dep !== task.id && !task.deps.includes(dep));
+        if (referenced.length > 0) {
+            findings.push({ code: "dependency-closure", fixtureId: id, taskId: task.id, detail: `references ${referenced.join(", ")} outside deps[]` });
+        }
+        if (/\bwhose independent [^.\n]{0,80}(?:classification|result|decision|output|evidence)\b|\b(?:from|through|provided by|owned by) (?:a |the )?(?:successor|downstream|later|sibling)\b/i.test(dependencyText)) {
+            findings.push({ code: "dependency-coupling", fixtureId: id, taskId: task.id, detail: "de-numbered cross-task coupling needs a dependency or a declared consumes contract" });
+        }
+        const negatives = strictNegativeCount(prose);
+        if (negatives >= 2 && !/enumerat|closed (?:input )?list|closed \w* table|STANDBY/i.test(prose)) {
+            findings.push({ code: "closed-enumeration", fixtureId: id, taskId: task.id, detail: `${negatives} strict prohibitions have no closed enumeration pointer` });
+        }
+        const concerns = [...new Set(task.goal.match(/\bQ\d+\b/g) ?? [])];
+        if (concerns.length > 1) {
+            findings.push({ code: "concern-bundle", fixtureId: id, taskId: task.id, detail: `goal bundles ${concerns.join(", ")}` });
+        }
+        if (root && negatives > 0) {
+            const monoliths = task.files.filter((entry) => {
+                if (!entry.startsWith("src/") || /[*?{[]/.test(entry))
+                    return false;
+                try {
+                    return readFileSync(join(root, entry), "utf8").split("\n").length > 1500;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (monoliths.length > 0) {
+                const identifiers = [...prose.matchAll(/`([A-Za-z_$][A-Za-z0-9_$]*)`/g)].map((match) => match[1]);
+                const seamExists = identifiers.some((identifier) => exportedIdentifier(root, task.files, identifier));
+                const firstCreatesSeam = /\b(?:add|create|extract|introduce|ship)\b[^.\n]{0,100}\b(?:injectable|seam|clock|snapshot|evidence)\b/i.test(criteria[0] ?? "");
+                if (!seamExists && !firstCreatesSeam) {
+                    findings.push({ code: "seam-exists", fixtureId: id, taskId: task.id, detail: `law-shaped task touches ${monoliths.join(", ")} but names no exported seam and does not create one first` });
+                }
+            }
+        }
+    }
+    return findings;
+}
+function renderAuthoringFinding(finding) {
+    const criterion = finding.criterion === undefined ? "" : ` criterion ${finding.criterion}`;
+    return `tickmarkr: authoring-lint[${finding.code}] fixture ${finding.fixtureId} task ${finding.taskId}${criterion}: ${finding.detail}`;
+}
 export function compileNative(file) {
     if (!existsSync(file))
         throw new CompileError(`no such native spec file: ${file}`);
@@ -328,7 +525,7 @@ export function compileNative(file) {
         return [probe, ...variants];
     };
     const canHostTest = (entry) => {
-        const self = picomatch(entry, { dot: true });
+        const self = filesGlob(entry); // Q120s shared matcher — paren dirs stay literal in the self-probe
         return expandBraces(entry)
             .flatMap((branch) => PROBE_TOKENS.map((token) => branch.replace(/\*+/g, token)))
             .flatMap(qmarkVariants)
@@ -400,6 +597,15 @@ export function compileNative(file) {
         },
         tasks,
     });
+    const authoringFindings = authoringLintFindings(result.tasks, file);
+    for (const finding of authoringFindings.filter(({ code }) => code !== "criterion-scope")) {
+        console.warn(renderAuthoringFinding(finding));
+    }
+    const scopeErrors = authoringFindings.filter(({ code }) => code === "criterion-scope");
+    if (scopeErrors.length > 0) {
+        throw new CompileError(`${file} violates the criterion-scope authoring lint (${scopeErrors.length} error${scopeErrors.length === 1 ? "" : "s"}):\n`
+            + scopeErrors.map((finding) => `  - ${renderAuthoringFinding(finding)}`).join("\n"));
+    }
     // v1.19 read-old/write-new: a plain-string acceptance item compiles as a judge oracle. This is the
     // one-time nudge toward typed oracles (command/test/judge); PRD/Spec Kit/GSD stay silent (untouched).
     if (plainCount > 0) {

package/dist/config/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import picomatch from "picomatch";
+import { filesGlob } from "../graph/files-glob.js";
 import { Document, parse } from "yaml";
 import { z } from "zod";
 import { CITED_MODEL_WINDOWS } from "../adapters/model-windows.js";
@@ -223,7 +223,7 @@ export function criticalPathHits(files, criticalPaths = []) {
             const critical = normPath(rawCritical);
             if (!critical)
                 continue;
-            if (f === critical || picomatch(critical, { dot: true })(f) || picomatch(f, { dot: true })(critical)
+            if (f === critical || filesGlob(critical)(f) || filesGlob(f)(critical) // Q120s shared matcher
                 || (GLOB_META_RE.test(f) && GLOB_META_RE.test(critical) && globsMayIntersect(f, critical))) {
                 hits.add(f);
             }

package/dist/gates/baseline.d.ts

@@ -1,12 +1,18 @@
 import type { TickmarkrConfig } from "../config/config.js";
 import type { AcceptanceItem } from "../graph/schema.js";
+import { type ShResult } from "../run/git.js";
 import type { GateResult } from "./types.js";
+export interface BaselineCommand {
+    exitCode: number;
+    fingerprints: string[];
+    missingCommand?: boolean;
+    /** What this command actually took at capture, on a pristine tree. Absent in pre-v1.90 baselines. */
+    durationMs?: number;
+    /** The ceiling that measurement implies, persisted so every later battery uses the same number. */
+    ceilingMs?: number;
+}
 export interface Baseline {
-    commands: Record<string, {
-        exitCode: number;
-        fingerprints: string[];
-        missingCommand?: boolean;
-    }>;
+    commands: Record<string, BaselineCommand>;
     warnings?: BaselineWarning[];
 }
 export interface BaselineWarning {
@@ -22,7 +28,35 @@ export type FailureClassification = "regression" | "infra";
 export declare function classifyFailureOutput(output: string): FailureClassification | undefined;
 export declare const UNRECOGNIZED_FAILURE = "<unrecognized failure output>";
 export declare function fingerprint(output: string): string[];
+/**
+ * Q121s: the battery's forgiveness math, exported so tip-verify applies the IDENTICAL rule.
+ * Returns the failure fingerprints of `raw` that are NOT in the baseline entry (fresh), and
+ * whether the output carried no recognizable failure shape at all.
+ */
+export declare function freshFailures(entry: BaselineCommand | undefined, raw: string): {
+    failing: string[];
+    unreadable: boolean;
+};
 export declare function detectGateCommands(repoRoot: string, cfg: TickmarkrConfig): Record<string, string>;
+/**
+ * The ceiling a battery runs under: whichever is larger of the shipped constant and the slack applied
+ * to what this command actually measured. A pre-v1.90 baseline (no measurement) gets exactly the
+ * shipped constant, so nothing regresses on an existing on-disk baseline.json — the same read-old
+ * compat rule the fingerprint renormalizer follows.
+ */
+export declare const effectiveCeilingMs: (entry?: Pick<BaselineCommand, "durationMs" | "ceilingMs">) => number;
+/**
+ * The ONLY producer of a `ceiling-kill` gate result. It is gated on `timedOut`, which git.ts sets in
+ * exactly one place — inside the timer callback that issues the SIGKILL — so a process that exited on
+ * its own can never reach this text however it exited: a slow red suite, an unreadable runner, exit
+ * 137 from a kill somebody ELSE sent. Returning `undefined` rather than a result keeps that structural:
+ * every caller must go on to the ordinary verdict path, it cannot fall through into this one.
+ *
+ * A kill is not a verdict. The battery was still running when the machine took it away, so its exit
+ * code is evidence about the ceiling and nothing about the work — which is why this reports `infra`
+ * and never enters baseline forgiveness (there is no runner output to forgive).
+ */
+export declare function ceilingKillResult(gate: string, r: ShResult, ceilingMs: number): GateResult | undefined;
 export declare function captureBaseline(cwd: string, commands: Record<string, string>): Promise<Baseline>;
 export interface VacuousOracleWarning {
     kind: "vacuous-oracle";

package/dist/gates/baseline.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { sh } from "../run/git.js";
+import { DEFAULT_SHELL_TIMEOUT_MS, sh } from "../run/git.js";
 // incident #2 (run-20260709-104447): a vitest ✓ PASS line with "error" in the test NAME, wrapped in ANSI
 // codes that varied between baseline and worktree runs, was reported as a "new failure". Strip ANSI first;
 // a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
@@ -111,6 +111,18 @@ const unrecognizedEvidence = (raw) => raw
 // stored baselines may predate ANSI/pass-marker hardening — renormalize at compare time so existing
 // on-disk baseline.json files stay comparable without recapture (compat invariant, CLAUDE.md)
 const renormalize = (fp) => normalizeLine(fp.replace(ANSI_RE, ""));
+/**
+ * Q121s: the battery's forgiveness math, exported so tip-verify applies the IDENTICAL rule.
+ * Returns the failure fingerprints of `raw` that are NOT in the baseline entry (fresh), and
+ * whether the output carried no recognizable failure shape at all.
+ */
+export function freshFailures(entry, raw) {
+    const known = new Set((entry?.fingerprints ?? []).map(renormalize));
+    // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
+    const current = fingerprint(raw);
+    const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
+    return { failing: fresh.filter((f) => f !== UNRECOGNIZED_FAILURE), unreadable: current.includes(UNRECOGNIZED_FAILURE) };
+}
 export function detectGateCommands(repoRoot, cfg) {
     const out = {};
     const pkgPath = join(repoRoot, "package.json");
@@ -145,17 +157,59 @@ function missingConfiguredCommand(cmd, result) {
     const output = `${result.stdout}\n${result.stderr}`;
     return new RegExp(`(?:^|[:\\s])${reEscape(token)}:\\s+(?:command not found|No such file or directory)`, "i").test(output);
 }
+/**
+ * How much longer than the baseline a battery may legitimately take. Gate batteries run inside a
+ * worktree beside up to `concurrency` siblings, so the same suite is genuinely slower than its
+ * pristine-tree capture — 3× is the headroom, not a performance budget.
+ */
+const CEILING_SLACK = 3;
+/**
+ * The ceiling a battery runs under: whichever is larger of the shipped constant and the slack applied
+ * to what this command actually measured. A pre-v1.90 baseline (no measurement) gets exactly the
+ * shipped constant, so nothing regresses on an existing on-disk baseline.json — the same read-old
+ * compat rule the fingerprint renormalizer follows.
+ */
+export const effectiveCeilingMs = (entry) => entry?.ceilingMs ?? Math.max(DEFAULT_SHELL_TIMEOUT_MS, CEILING_SLACK * (entry?.durationMs ?? 0));
+/**
+ * The ONLY producer of a `ceiling-kill` gate result. It is gated on `timedOut`, which git.ts sets in
+ * exactly one place — inside the timer callback that issues the SIGKILL — so a process that exited on
+ * its own can never reach this text however it exited: a slow red suite, an unreadable runner, exit
+ * 137 from a kill somebody ELSE sent. Returning `undefined` rather than a result keeps that structural:
+ * every caller must go on to the ordinary verdict path, it cannot fall through into this one.
+ *
+ * A kill is not a verdict. The battery was still running when the machine took it away, so its exit
+ * code is evidence about the ceiling and nothing about the work — which is why this reports `infra`
+ * and never enters baseline forgiveness (there is no runner output to forgive).
+ */
+export function ceilingKillResult(gate, r, ceilingMs) {
+    if (r.timedOut !== true)
+        return undefined;
+    // no measurement only when a caller synthesized the result; a real kill fires AT the ceiling
+    const durationMs = r.durationMs ?? ceilingMs;
+    return {
+        gate,
+        pass: false,
+        details: `ceiling-kill: SIGKILLed after ${durationMs}ms at the configured ${ceilingMs}ms ceiling — `
+            + `the battery never returned a verdict, so this gate verified nothing (exit ${r.code} is the kill, not a test result)`,
+        meta: { classification: "infra", infra: true, kind: "ceiling-kill", durationMs, ceilingMs },
+    };
+}
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
     for (const [name, cmd] of Object.entries(commands)) {
         const r = await sh(cmd, cwd);
         // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
+        // ponytail: a capture that was itself killed records the ceiling as its "measurement", which
+        // scales the next ceiling up — the right direction for a suite that never finished once.
+        const durationMs = r.durationMs ?? 0;
         base.commands[name] = {
             exitCode: r.code,
             // a command that exits 0 has no failures to fingerprint — recording any would be a lie the
             // compare step then has to forgive
             fingerprints: r.code === 0 ? [] : fingerprint((r.stdout + "\n" + r.stderr).split(cwd).join("")),
             missingCommand: missingConfiguredCommand(cmd, r),
+            durationMs,
+            ceilingMs: effectiveCeilingMs({ durationMs }),
         };
     }
     const names = Object.keys(commands);
@@ -223,7 +277,17 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
             results.push({ gate: name, pass: true, details: `no ${name} command detected — skipped`, meta: { skipped: true } });
             continue;
         }
-        const r = await sh(cmd, cwd);
+        const ceilingMs = effectiveCeilingMs(baseline.commands[name]);
+        const r = await sh(cmd, cwd, ceilingMs);
+        // Q24: the kill is read BEFORE the exit code is interpreted at all. A SIGKILLed battery has
+        // whatever partial output it had flushed — typically no failure shape — so every path below
+        // would otherwise turn a timeout into a claim about the work: "no recognizable failure lines"
+        // when the baseline was green, or a forgiven pre-existing red when it was not. Neither is true.
+        const killed = ceilingKillResult(name, r, ceilingMs);
+        if (killed) {
+            results.push(killed);
+            continue;
+        }
         if (r.code === 0) {
             results.push({ gate: name, pass: true, details: "exit 0" });
             continue;
@@ -244,10 +308,6 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
             });
             continue;
         }
-        const known = new Set((baseline.commands[name]?.fingerprints ?? []).map(renormalize));
-        // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
-        const current = fingerprint(raw);
-        const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
         // OBS-278: only a failure SHAPE is a verdict — everything fingerprint() keeps is one, except the
         // unrecognized-output marker, which is evidence for the operator and never grounds to reject.
         // ponytail: ceiling — a runner whose failure output holds no shape above and whose baseline is
@@ -255,8 +315,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         // below rather than reading as a verified green. Raise the ceiling by teaching isFailureShaped
         // that runner's position rule (leading verdict + identifier, or identifier + separator + trailing
         // verdict); loosening back to vocabulary re-opens OBS-278.
-        const unreadable = current.includes(UNRECOGNIZED_FAILURE);
-        const failing = fresh.filter((f) => f !== UNRECOGNIZED_FAILURE);
+        const { failing, unreadable } = freshFailures(baseline.commands[name], raw);
         if (!failing.length && (baseline.commands[name]?.exitCode ?? 1) === 0) {
             const closed = `command was green at baseline but now exits ${r.code} with no recognizable failure lines — failing closed`;
             const evidence = unrecognizedEvidence(raw);

package/dist/gates/scope.js

@@ -1,4 +1,4 @@
-import picomatch from "picomatch";
+import { filesGlob } from "../graph/files-glob.js";
 import { shGitOk } from "../run/git.js";
 // OBS-61: the live integration tip can advance between attempts (sibling merge) while a resumed
 // worktree stays parented on the old base — merge-base(tip, HEAD) pins the diff to the worktree's
@@ -11,7 +11,7 @@ export async function scopeDiffBase(worktree, integrationTip) {
 }
 /** Pure offender split — corpus-replay oracle exercises this exact decision logic. */
 export function dispositionOffenders(offenders, allowDeviations) {
-    const allowedMatch = allowDeviations.length ? picomatch(allowDeviations, { dot: true }) : () => false;
+    const allowedMatch = allowDeviations.length ? filesGlob(allowDeviations) : () => false;
     const allowed = [];
     const hard = [];
     for (const f of offenders) {
@@ -27,7 +27,7 @@ export async function scopeGate(worktree, integrationTip, files, result, allowDe
         return { gate: "scope", pass: true, details: "no file scope declared — unrestricted" };
     const baseRef = await scopeDiffBase(worktree, integrationTip);
     const changed = (await shGitOk(`git diff --name-only '${baseRef}..HEAD'`, worktree)).trim().split("\n").filter(Boolean);
-    const inScope = picomatch(files, { dot: true }); // byte-identical options to assertWriteScope in src/compile/common.ts
+    const inScope = filesGlob(files); // the ONE files[] matcher — src/graph/files-glob.ts (Q120s)
     const offenders = changed.filter((f) => !inScope(f));
     if (!offenders.length)
         return { gate: "scope", pass: true, details: `all ${changed.length} changed files in scope` };

package/dist/graph/files-glob.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The ONE matcher for files[] / scope.allowDeviations semantics (Q120s, TRIAL T-OBS-4).
+ *
+ * Parens in a files[] entry are LITERAL path characters. Expo Router and Next.js name
+ * group directories `(app)`, `(marketing)` — but picomatch compiles a bare `(app)` to a
+ * regex CAPTURE GROUP matching `app`, so a pattern naming such a path can never match it
+ * (SentioQ run-1: T3 burned 3 dispatches on a scope red unwinnable by construction).
+ * Brackets need no help: this picomatch already compiles `[id]` to the alternation
+ * `(?:\[id\]|[id])`, literal-or-class.
+ *
+ * The price is extglobs (`@(a|b)` etc.) become literal text in files[] entries — they
+ * have no recorded use in any spec, and a scope allowlist wants boring, predictable
+ * matching over regex power. Every consumer of files[]-shaped patterns MUST match
+ * through this module; a second picomatch call with hand-rolled options is how the
+ * gate and the compiler drift apart.
+ */
+export declare const literalParens: (pattern: string) => string;
+export declare function filesGlob(patterns: string | string[]): (path: string) => boolean;

package/dist/graph/files-glob.js

@@ -0,0 +1,22 @@
+import picomatch from "picomatch";
+/**
+ * The ONE matcher for files[] / scope.allowDeviations semantics (Q120s, TRIAL T-OBS-4).
+ *
+ * Parens in a files[] entry are LITERAL path characters. Expo Router and Next.js name
+ * group directories `(app)`, `(marketing)` — but picomatch compiles a bare `(app)` to a
+ * regex CAPTURE GROUP matching `app`, so a pattern naming such a path can never match it
+ * (SentioQ run-1: T3 burned 3 dispatches on a scope red unwinnable by construction).
+ * Brackets need no help: this picomatch already compiles `[id]` to the alternation
+ * `(?:\[id\]|[id])`, literal-or-class.
+ *
+ * The price is extglobs (`@(a|b)` etc.) become literal text in files[] entries — they
+ * have no recorded use in any spec, and a scope allowlist wants boring, predictable
+ * matching over regex power. Every consumer of files[]-shaped patterns MUST match
+ * through this module; a second picomatch call with hand-rolled options is how the
+ * gate and the compiler drift apart.
+ */
+export const literalParens = (pattern) => pattern.replace(/\\?[()]/g, (m) => (m.length === 2 ? m : `\\${m}`));
+export function filesGlob(patterns) {
+    const list = (Array.isArray(patterns) ? patterns : [patterns]).map(literalParens);
+    return picomatch(list, { dot: true });
+}

package/dist/run/daemon.d.ts

@@ -1,6 +1,7 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type ExecutorDriver } from "../drivers/types.js";
+import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export interface RunOptions {
@@ -131,6 +132,7 @@ export declare function commandsHash(commands: Record<string, string>): string;
  */
 export declare function verifyIntegrationTipCached(intWt: string, commands: Record<string, string>, journal: Journal, opts?: {
     lastMergedTask?: string;
+    baseline?: Baseline;
 }): Promise<boolean>;
 export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
     ms: number;

package/dist/run/daemon.js

@@ -414,7 +414,7 @@ function lastVerifyCycle(events) {
         if (e.event === "tip-verify-start") {
             const { tip, cmdHash } = e.data;
             cur = typeof tip === "string" && typeof cmdHash === "string"
-                ? { tip, cmdHash, gates: new Set(), failed: false }
+                ? { tip, cmdHash, gates: new Set(), failed: false, forgiven: false }
                 : undefined;
             afterRunEnd = false;
             continue;
@@ -432,13 +432,19 @@ function lastVerifyCycle(events) {
             continue;
         }
         if (!cur || afterRunEnd || cur.tip !== tip || cur.cmdHash !== cmdHash) {
-            cur = { tip, cmdHash, gates: new Set(), failed: false };
+            cur = { tip, cmdHash, gates: new Set(), failed: false, forgiven: false };
         }
         afterRunEnd = false;
         if (e.event === "tip-verify-failed")
             cur.failed = true;
-        else
+        else {
             cur.gates.add(gate);
+            // Q121s review M1: a forgiven green depends on the baseline that forgave it. Baselines are not
+            // part of the cache key, so a forgiven cycle is NEVER cache-eligible — an unchanged tip whose
+            // baseline later vanishes or changes must re-run the full verify, not inherit the green.
+            if (e.data.forgiven === true)
+                cur.forgiven = true;
+        }
     }
     return cur;
 }
@@ -459,7 +465,7 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
     const porcelain = await shGit("git status --porcelain", intWt);
     const clean = porcelain.code === 0 && porcelain.stdout.trim() === "";
     const last = lastVerifyCycle(journal.read());
-    const cached = last !== undefined && !last.failed && last.tip === tip && last.cmdHash === cmdHash
+    const cached = last !== undefined && !last.failed && !last.forgiven && last.tip === tip && last.cmdHash === cmdHash
         && Object.keys(commands).every((g) => last.gates.has(g));
     // A pair can be verified red and then green without either SHA or command hash changing (for
     // example, an external service or ignored fixture recovers). Delimit attempts explicitly so that
@@ -477,9 +483,10 @@ export async function verifyIntegrationTipCached(intWt, commands, journal, opts
         return false;
     }
     let tipFailed = false;
-    for (const r of await verifyIntegrationTip(intWt, commands, journal.dir)) {
+    for (const r of await verifyIntegrationTip(intWt, commands, journal.dir, opts.baseline)) {
         if (r.pass) {
-            journal.append("tip-verify", undefined, { gate: r.gate, cmd: r.cmd, pass: true, exitCode: r.exitCode, details: r.details, tip, cmdHash });
+            // Q121s: a forgiven pass journals its fingerprints — honest about what was carried, never a silent green.
+            journal.append("tip-verify", undefined, { gate: r.gate, cmd: r.cmd, pass: true, exitCode: r.exitCode, details: r.details, ...(r.forgiven ? { forgiven: true, fingerprints: r.fingerprints } : {}), tip, cmdHash });
         }
         else {
             journal.append("tip-verify-failed", undefined, {
@@ -3095,7 +3102,7 @@ export async function runDaemon(repoRoot, opts = {}) {
             // OBS-34: post-merge integration-tip verify — strict exit codes, no baseline forgiveness.
             const lastMergedTask = [...journal.read()].reverse().find((e) => e.event === "merge" && e.taskId)?.taskId;
             if (summary.done.length > 0 && Object.keys(commands).length > 0) {
-                const tipFailed = await verifyIntegrationTipCached(intWt, commands, journal, { lastMergedTask });
+                const tipFailed = await verifyIntegrationTipCached(intWt, commands, journal, { lastMergedTask, baseline });
                 summary.tipVerify = tipFailed ? "failed" : "passed";
                 if (tipFailed && lastMergedTask)
                     summary.lastMergedTask = lastMergedTask;

package/dist/run/git.d.ts

@@ -14,11 +14,14 @@ export declare const deriveForkCap: (concurrency: number, cores?: number) => num
 export declare const runWithForkBudget: <T>(concurrency: number, fn: () => Promise<T>) => Promise<T>;
 /** The cap owned by the run on this async context; the standalone default outside one. */
 export declare const resolvedForkCap: () => string;
+/** The shipped shell ceiling: the fallback every caller gets when nothing measured a better one. */
+export declare const DEFAULT_SHELL_TIMEOUT_MS = 600000;
 export interface ShResult {
     code: number;
     stdout: string;
     stderr: string;
     timedOut?: boolean;
+    durationMs?: number;
 }
 export declare function sh(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;
 export declare function shGit(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;

package/dist/run/git.js

@@ -43,6 +43,8 @@ export const deriveForkCap = (concurrency, cores = availableParallelism()) => Ma
 export const runWithForkBudget = (concurrency, fn) => forkBudget.run(String(deriveForkCap(concurrency)), fn);
 /** The cap owned by the run on this async context; the standalone default outside one. */
 export const resolvedForkCap = () => forkBudget.getStore() ?? DEFAULT_FORK_CAP;
+/** The shipped shell ceiling: the fallback every caller gets when nothing measured a better one. */
+export const DEFAULT_SHELL_TIMEOUT_MS = 600000;
 // stdin "ignore": same class as HARD-05 / SubprocessDriver — never leave an open pipe a child can block on
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 function shell(cmd, cwd, timeoutMs, login) {
@@ -57,6 +59,7 @@ function shell(cmd, cwd, timeoutMs, login) {
     if (!(FORK_CAP_ENV in env))
         env[FORK_CAP_ENV] = resolvedForkCap();
     return new Promise((resolve) => {
+        const startedAt = Date.now();
         // detached: bash gets its own process group so a timeout can kill the whole tree —
         // SIGKILLing bash alone orphans grandchildren (codex/pi) that hold the stdio pipes
         // open, so "close" never fires and the promise wedges forever (v1.33.1 init hang).
@@ -68,7 +71,7 @@ function shell(cmd, cwd, timeoutMs, login) {
                 return;
             done = true;
             clearTimeout(timer);
-            resolve({ code, stdout, stderr: err ?? stderr, timedOut });
+            resolve({ code, stdout, stderr: err ?? stderr, timedOut, durationMs: Date.now() - startedAt });
         };
         const timer = setTimeout(() => {
             timedOut = true;
@@ -88,11 +91,11 @@ function shell(cmd, cwd, timeoutMs, login) {
             finish(code ?? 1); });
     });
 }
-export function sh(cmd, cwd, timeoutMs = 600000) {
+export function sh(cmd, cwd, timeoutMs = DEFAULT_SHELL_TIMEOUT_MS) {
     return shell(cmd, cwd, timeoutMs, true);
 }
 // Git plumbing never needs an operator profile; skip login-shell startup and its side effects.
-export function shGit(cmd, cwd, timeoutMs = 600000) {
+export function shGit(cmd, cwd, timeoutMs = DEFAULT_SHELL_TIMEOUT_MS) {
     return shell(cmd, cwd, timeoutMs, false);
 }
 export async function shOk(cmd, cwd) {