tickmarkr 1.44.0 → 1.46.0

package/dist/adapters/fake.js

@@ -37,7 +37,7 @@ export class FakeAdapter {
         let isJudge = false;
         try {
             prompt = readFileSync(promptFile, "utf8");
-            isJudge = /TICKMARKR-JUDGE/.test(prompt);
+            isJudge = /TICKMARKR-(?:JUDGE|SCOPE)/.test(prompt);
         }
         catch {
             // unreadable promptFile: can't detect role; serve static values (legacy headless-call behavior)
@@ -61,7 +61,7 @@ export class FakeAdapter {
             writeFileSync(p, JSON.stringify(val ?? {}, null, 1));
             return p;
         };
-        return `bash -c 'grep -q TICKMARKR-JUDGE ${shq(promptFile)} && cat ${shq(serve("judge"))}; grep -q TICKMARKR-REVIEW ${shq(promptFile)} && cat ${shq(serve("review"))}; grep -q TICKMARKR-CONSULT ${shq(promptFile)} && cat ${shq(serve("consult"))}; true'`;
+        return `bash -c 'grep -Eq "TICKMARKR-(JUDGE|SCOPE)" ${shq(promptFile)} && cat ${shq(serve("judge"))}; grep -q TICKMARKR-REVIEW ${shq(promptFile)} && cat ${shq(serve("review"))}; grep -q TICKMARKR-CONSULT ${shq(promptFile)} && cat ${shq(serve("consult"))}; true'`;
     }
     resumeCommand(_sessionId, promptFile, model) {
         return this.interactiveCommand(promptFile, model) ?? this.headlessCommand(promptFile, model);

package/dist/adapters/registry.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { overlayPreferShapes, TIER_RANK } from "../config/config.js";
@@ -178,7 +178,13 @@ async function mapLimit(items, limit, fn) {
 }
 const doctorPath = (repoRoot) => join(repoRoot, stateDirName(repoRoot), "doctor.json");
 function readDoctorFile(repoRoot) {
-    return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+    try {
+        return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+    }
+    catch {
+        // A torn cache is disposable: callers already re-probe when this returns null.
+        return null;
+    }
 }
 export function writeDoctor(repoRoot, health) {
     tickmarkrDir(repoRoot);
@@ -187,7 +193,10 @@ export function writeDoctor(repoRoot, health) {
     delete payload[pendingAutoPreferKey];
     if (pending)
         payload.autoPrefer = pending;
-    writeFileSync(doctorPath(repoRoot), JSON.stringify(payload, null, 2) + "\n");
+    const path = doctorPath(repoRoot);
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(payload, null, 2) + "\n");
+    renameSync(tmp, path);
 }
 export function readDoctor(repoRoot) {
     const raw = readDoctorFile(repoRoot);

package/dist/brand.js

@@ -1,3 +1,4 @@
+import { shq } from "./adapters/types.js";
 // TTY-only pixel-tick logo (assets/mark.svg is the image twin — same block geometry).
 // Never printed to pipes — the non-TTY stdout surface is byte-pinned by tests and consumed by machines.
 const B = "\x1b[1m", R = "\x1b[0m";
@@ -26,5 +27,5 @@ export function paneDispatchScript(body) {
 }
 /** OBS-50: one short herdr pane-run line; bootstrap lives in the script file beside the prompt. */
 export function paneDispatchCommand(scriptPath) {
-    return `bash ${JSON.stringify(scriptPath)}`;
+    return `bash ${shq(scriptPath)}`;
 }

package/dist/cli/commands/approve.js

@@ -6,10 +6,10 @@ import { ATTEMPT_CAP_RELEASE, Journal } from "../../run/journal.js";
 // append-only journal. Writing it into tickmarkr's compiled graph artifact would be silently erased by
 // the next recompile (which re-emits humanGate:true from the plan frontmatter) — Phase 42 D-02.
 //
-// v1.24 OBS-18: when the park was attempt-cap (not a humanGate pre-dispatch park), the event also
-// carries `release: "attempt-cap"`. replayResumeState zeros the attempt budget on that marker so
-// resume dispatches instead of re-parking in the same tick; tried-list is preserved. humanGate
-// parks (attempts 0, reason starts with "humanGate:") stamp no release — byte-identical to GATE-08.
+// v1.24 OBS-18: when the park kind is attempt-cap (not a humanGate pre-dispatch park), the event
+// also carries `release: "attempt-cap"`. replayResumeState zeros the attempt budget on that marker so
+// resume dispatches instead of re-parking in the same tick; tried-list is preserved. Unknown kinds
+// receive no release and remain fail-closed to a human rather than being inferred from prose.
 //
 // Fail-closed (D-05): unknown runId, unknown taskId, a not-parked task, and a double-approve are all
 // LOUD refusals that name the reason and append NO event — never a silent no-op. A handler throw
@@ -30,10 +30,9 @@ export async function approve(argv, cwd = process.cwd()) {
         throw new Error(`task ${taskId} is ${status}, not a parked human gate — refusing (a silent no-op would be worse)`);
     }
     // OBS-18: only the most recent task-human for this task decides whether this approval grants a
-    // fresh attempt budget. Match the daemon's park reason literally (`attempt cap (N) reached`).
+    // fresh attempt budget. The closed daemon-issued kind, never a human prose string, controls release.
     const lastHuman = journal.read().filter((e) => e.event === "task-human" && e.taskId === taskId).at(-1);
-    const capPark = typeof lastHuman?.data.reason === "string"
-        && /attempt cap \(\d+\) reached/.test(lastHuman.data.reason);
+    const capPark = lastHuman?.data.kind === ATTEMPT_CAP_RELEASE;
     journal.append("task-approved", taskId, {
         by,
         ...(reason ? { reason } : {}),

package/dist/cli/commands/compile.js

@@ -2,7 +2,7 @@ import { isAbsolute, join } from "node:path";
 import { parseArgs } from "node:util";
 import { compileSource } from "../../compile/index.js";
 import { saveGraph, stateDirName } from "../../graph/graph.js";
-import { isRunLockLive } from "../../run/lock.js";
+import { acquireRunLock, releaseRunLock } from "../../run/lock.js";
 export async function compile(argv, cwd = process.cwd()) {
     const { values, positionals } = parseArgs({
         args: argv,
@@ -14,11 +14,15 @@ export async function compile(argv, cwd = process.cwd()) {
         throw new Error("usage: tickmarkr compile <spec-dir-or-md> [--type speckit|prd|gsd|native]");
     // resolve against the target repo, not the process cwd (the CLI test passes a tmp repo)
     const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd);
-    // HARD-01: a compile clobbering a running daemon's graph.json is the same last-write-wins race
-    // as a second daemon. Read-only check — compile never acquires/holds (it's instantaneous).
+    // HARD-01 / Sol #3: hold the same link(2) run lock as the daemon around saveGraph so compile
+    // cannot swap graph.json under an active run between the daemon's read and act.
     const stateDir = stateDirName(cwd);
-    if (isRunLockLive(cwd))
-        throw new Error(`${stateDir}/graph.lock is held by another tickmarkr run, or is a stale/garbage lock — refusing to overwrite graph.json. If no run is active, run \`tickmarkr unlock\`.`);
-    saveGraph(cwd, g);
+    acquireRunLock(cwd, "compile");
+    try {
+        saveGraph(cwd, g);
+    }
+    finally {
+        releaseRunLock(cwd);
+    }
     return `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
 }

package/dist/cli/commands/init.js

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
@@ -7,7 +7,59 @@ import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
 import { BANNER } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
+import { Journal } from "../../run/journal.js";
 import { doctor } from "./doctor.js";
+const SCAFFOLD_SPEC = "tickmarkr.spec.md";
+// Operator-approved (2026-07-17) environments footer — three rows; no npm install for herdr
+// (npm package "herdr" is a reserved 0.0.0 placeholder as of that date).
+const ENVIRONMENTS_FOOTER = [
+    "environments:",
+    "  herdr — the full cockpit — every worker, judge, and consult is a visible pane you can watch and unblock · https://herdr.dev",
+    "  claude code — tickmarkr init --agent installs the /tkr skills + AGENTS.md so Claude Code (or any agent CLI) drives the loop natively",
+    "  anywhere — no herdr? same fail-closed gates, headless subprocess driver",
+].join("\n");
+/** Latest journal without a run-end event, if any. */
+function activeRunId(cwd) {
+    const runId = Journal.latestRunId(cwd, { withJournal: true });
+    if (!runId)
+        return null;
+    try {
+        const events = Journal.open(cwd, runId).read();
+        if (events.some((e) => e.event === "run-end"))
+            return null;
+        return runId;
+    }
+    catch {
+        return null;
+    }
+}
+/** Relative paths of specs/*.spec.md already in the repo. */
+function existingSpecs(cwd) {
+    const dir = join(cwd, "specs");
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.endsWith(".spec.md"))
+            .sort()
+            .map((f) => `specs/${f}`);
+    }
+    catch {
+        return [];
+    }
+}
+/** Context-aware next-steps line (operator-approved 2026-07-17). */
+function nextSteps(cwd, scaffoldedSpec) {
+    const runId = activeRunId(cwd);
+    if (runId)
+        return `run ${runId} active — tickmarkr status`;
+    const specs = existingSpecs(cwd);
+    if (specs.length > 0) {
+        const listed = specs.length <= 3 ? specs.join(", ") : `${specs.slice(0, 3).join(", ")}, …`;
+        return `next: existing specs under specs/ (${listed}) — tickmarkr compile <spec> && tickmarkr plan && tickmarkr run`;
+    }
+    return `next: edit ${scaffoldedSpec}, then tickmarkr compile ${scaffoldedSpec} && tickmarkr plan && tickmarkr run`;
+}
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto"];
 const DOCS_BEGIN = "<!-- tickmarkr:agent-docs begin -->";
@@ -173,7 +225,7 @@ export async function init(argv, cwd = process.cwd()) {
     const repoConfigExists = existsSync(repoConfigPath);
     if (repoConfigExists)
         notes.push(`kept existing ${repoConfigPath}`);
-    const specPath = join(cwd, "tickmarkr.spec.md");
+    const specPath = join(cwd, SCAFFOLD_SPEC);
     if (existsSync(specPath)) {
         notes.push(`kept existing ${specPath}`);
     }
@@ -210,7 +262,7 @@ export async function init(argv, cwd = process.cwd()) {
     }
     if (values.agent)
         await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
-    const body = `${notes.join("\n")}\n${doc}\nnext: edit tickmarkr.spec.md, then tickmarkr compile tickmarkr.spec.md && tickmarkr plan && tickmarkr run`;
+    const body = `${notes.join("\n")}\n${doc}\n${nextSteps(cwd, SCAFFOLD_SPEC)}\n${ENVIRONMENTS_FOOTER}`;
     if (visual() && !bannerEmitted)
         return BANNER + body;
     return body;

package/dist/cli/commands/profile.js

@@ -1,13 +1,21 @@
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "../../config/config.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
-import { learnedScore, MIN_SAMPLES, cellsOf } from "../../route/profile.js";
-import { Journal, loadRoutingProfile, readProfileCursor, RUNS_WINDOW } from "../../run/journal.js";
-// tickmarkr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
-// Read-only class like plan/status/report: no run lock. `reset` writes ONE cursor scalar, nothing else.
+import { cellOf, cellSummary, explorationBonus, EXPLORE_CAP, learnedScore, learnedScoreTerms, MIN_SAMPLES, PRIOR_K, REF_MS, cellsOf, } from "../../route/profile.js";
+import { Journal, loadRoutingProfile, parseRunId, readProfileCursor, readProfileDiscounts, appendProfileDiscount, profileDiscountsPath, RUNS_WINDOW, } from "../../run/journal.js";
+// tickmarkr profile — inspect (show), forget (reset), and discount poisoned evidence (v1.46 T5).
+// Read-only class like plan/status/report except discount append. `reset` writes ONE cursor scalar.
 export async function profile(argv, cwd = process.cwd()) {
-    return argv[0] === "reset" ? reset(cwd) : show(cwd);
+    if (argv[0] === "reset")
+        return reset(cwd);
+    if (argv[0] === "discount")
+        return discount(argv.slice(1), cwd);
+    if (argv[0] === "discounts")
+        return listDiscounts(cwd);
+    if (argv[0] === "--explain" || argv.includes("--explain"))
+        return explain(argv, cwd);
+    return show(cwd);
 }
 // Non-destructive reset (T-13-06): a one-line runId cutoff at .tickmarkr/profile-since. NEVER deletes,
 // truncates, or rotates any telemetry — the profile is derived (PROF-01), so there is nothing to delete;
@@ -26,6 +34,119 @@ function reset(cwd) {
         `  to un-reset: delete ${stateDir}/profile-since.`,
     ].join("\n");
 }
+function parseDiscountArgs(argv) {
+    let runId;
+    let taskId;
+    let weight;
+    let reason;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--weight" && argv[i + 1]) {
+            const w = argv[++i];
+            if (w !== "0" && w !== "0.5")
+                throw new Error(`profile discount --weight must be 0 or 0.5 (got ${w})`);
+            weight = w === "0" ? 0 : 0.5;
+        }
+        else if (argv[i] === "--reason" && argv[i + 1]) {
+            reason = argv[++i];
+        }
+        else if (!argv[i].startsWith("--") && runId === undefined) {
+            runId = parseRunId(argv[i]);
+        }
+        else if (!argv[i].startsWith("--") && taskId === undefined) {
+            taskId = argv[i];
+        }
+    }
+    if (!runId)
+        throw new Error("profile discount requires <runId>");
+    if (weight === undefined)
+        throw new Error("profile discount requires --weight 0|0.5");
+    if (!reason?.trim())
+        throw new Error("profile discount requires --reason (a discount is an evidence claim)");
+    return { runId, taskId, weight, reason: reason.trim() };
+}
+function discount(argv, cwd) {
+    const mark = parseDiscountArgs(argv);
+    appendProfileDiscount(cwd, mark);
+    const stateDir = stateDirName(cwd);
+    const scope = mark.taskId ? `${mark.runId} task ${mark.taskId}` : mark.runId;
+    return [
+        `profile discount — marked ${scope} at weight ${mark.weight}.`,
+        `  reason: ${mark.reason}`,
+        `  wrote ${stateDir}/profile-discounts (append-only).`,
+        `  list: tickmarkr profile discounts`,
+    ].join("\n");
+}
+function listDiscounts(cwd) {
+    const marks = readProfileDiscounts(cwd);
+    const path = profileDiscountsPath(cwd);
+    if (!marks.length) {
+        return existsDiscountsFile(cwd)
+            ? `profile discounts — ${path}\n  (no valid marks)`
+            : `profile discounts — no ${stateDirName(cwd)}/profile-discounts file yet.`;
+    }
+    const lines = marks.map((m) => {
+        const scope = m.taskId ? `${m.runId} ${m.taskId}` : m.runId;
+        return `  ${scope.padEnd(28)} weight=${m.weight}  # ${m.reason}`;
+    });
+    return [`profile discounts — ${path}`, ...lines].join("\n");
+}
+function existsDiscountsFile(cwd) {
+    try {
+        readFileSync(profileDiscountsPath(cwd));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const fmtSigned = (n) => (n >= 0 ? `+${n.toFixed(3)}` : n.toFixed(3));
+function explain(argv, cwd) {
+    const rest = argv[0] === "--explain" ? argv.slice(1) : argv.filter((a) => a !== "--explain");
+    const shape = rest[0];
+    const chKey = rest[1];
+    const channel = rest[2] ?? "sub";
+    if (!shape || !chKey)
+        throw new Error("profile --explain requires <shape> <channel>");
+    const cfg = loadConfig(cwd);
+    const p = loadRoutingProfile(cwd, cfg, { preview: true });
+    const tuning = { availWeight: cfg.routing.learnedTuning?.availWeight };
+    const cell = cellOf(p, shape, chKey, channel);
+    const terms = learnedScoreTerms(p, shape, chKey, channel, tuning);
+    const score = learnedScore(p, shape, chKey, channel, tuning);
+    const header = `${shape} × ${chKey} (${channel})`;
+    if (!cell) {
+        return [
+            header,
+            `  quality   ${fmtSigned(terms.quality)}   (no cell — neutral)`,
+            `  perf      ${fmtSigned(terms.perf)}`,
+            `  avail     ${fmtSigned(terms.avail)}`,
+            `  overrun   ${fmtSigned(terms.overrun)}`,
+            `  score     ${fmtSigned(score)}`,
+        ].join("\n");
+    }
+    const s = cellSummary(cell);
+    const disc = s.discounted > 0 ? `, ${s.discounted} rows discounted` : "";
+    const qualityDetail = s.cold
+        ? `n_eff ${s.nEff} < ${MIN_SAMPLES} (cold)`
+        : `q̂=(qSum ${cell.qSum} + ${PRIOR_K})/(n ${cell.n} + ${2 * PRIOR_K}) − 0.5  n_raw ${s.nRaw}${disc}`;
+    const perfDetail = cell.doneMedianMs === undefined || s.cold
+        ? `cold`
+        : `median ${Math.round(cell.doneMedianMs / 60_000)}m vs ref ${REF_MS / 60_000}m  done=${cell.doneCount}`;
+    const availDetail = `quotaHits ${cell.quotaHits} / dispatches ${cell.dispatches}`;
+    const overrunDetail = `overruns ${cell.overruns ?? 0} / dispatches ${cell.dispatches}`;
+    const explore = cell.dispatches >= EXPLORE_CAP
+        ? `spent  dispatches ${cell.dispatches} ≥ cap ${EXPLORE_CAP}`
+        : `remaining ${s.exploreRemaining}  bonus ${explorationBonus(cell).toFixed(3)}`;
+    return [
+        header,
+        `  quality   ${fmtSigned(terms.quality)}   ${qualityDetail}`,
+        `  perf      ${fmtSigned(terms.perf)}   ${perfDetail}`,
+        `  avail     ${fmtSigned(terms.avail)}   ${availDetail}`,
+        `  overrun   ${fmtSigned(terms.overrun)}   ${overrunDetail}`,
+        `  score     ${fmtSigned(score)}   (deciding only below prefer/cost/tier — ROUTE-08)`,
+        `  explore   ${explore}`,
+    ].join("\n");
+}
 // Inspection surface: preview:true bypasses the routing.learned:off short-circuit so `show` renders the
 // profile even under the default off — same trust ramp as `tickmarkr plan`. The routing path stays inert.
 function show(cwd) {
@@ -51,7 +172,8 @@ function show(cwd) {
         // VIS-04/ROUTE-15 — preview must match routing's tuning, never the bare module default.
         const score = learnedScore(p, shape, chKey, channel, { availWeight: cfg.routing.learnedTuning?.availWeight }).toFixed(3);
         const cold = cell.n < MIN_SAMPLES ? `  cold (n<${MIN_SAMPLES})` : "";
-        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${cold}`;
+        const disc = (cell.discounted ?? 0) > 0 ? `  disc=${cell.discounted}` : "";
+        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${disc}${cold}`;
     });
     return [...header, "", "  shape      channel                      class obs   quality  median    dispatch  score", ...rows].join("\n");
 }

package/dist/cli/commands/resume.js

@@ -8,7 +8,11 @@ export async function resume(argv, cwd = process.cwd()) {
     const runId = argv[0];
     if (!runId)
         throw new Error("usage: tickmarkr resume <run-id>");
-    const s = await runDaemon(cwd, { runId, resume: true, driver: pickDriver(loadConfig(cwd)), narrate: (event) => console.log(formatJournalNarration(event)) });
+    // T3: --graph-changed is the operator's audited release of the engagement-identity guard (Sol #2 /
+    // Fable F2) — the daemon refuses a mismatched/unbound journal unless this is set, then journals a
+    // graph-rehash event naming both hashes. Strip the flag before runId resolution so a bare id still wins.
+    const graphChanged = argv.includes("--graph-changed");
+    const s = await runDaemon(cwd, { runId, resume: true, graphChanged, driver: pickDriver(loadConfig(cwd)), narrate: (event) => console.log(formatJournalNarration(event)) });
     const out = `resumed ${s.runId} — ${formatSummary(s)}`;
     return { out, code: summaryGreen(s) ? 0 : 2 };
 }

package/dist/cli/commands/status.js

@@ -1,7 +1,7 @@
 import { BANNER } from "../../brand.js";
-import { blockedTasks, loadGraph, pendingTasks } from "../../graph/graph.js";
+import { blockedTasks, graphDefinitionHash, loadGraph, pendingTasks } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
-import { Journal, journalComparable } from "../../run/journal.js";
+import { Journal, engagementComparable } from "../../run/journal.js";
 // ponytail: fixed 2s refresh; promote to config.visibility.* only when an operator asks.
 const REFRESH_MS = 2000;
 const NOT_COMPARABLE_NOTICE = "graph recompiled since this run — task states not comparable; run `tickmarkr run` to execute";
@@ -127,8 +127,10 @@ const renderFrame = (cwd) => {
     if (runId) {
         const j = Journal.open(cwd, runId);
         events = j.read();
-        // OBS-52: refuse journal join when the run's recorded graphHash ≠ loaded graph — bare task-id replay lied after recompile.
-        comparable = journalComparable(events, g.spec.hash);
+        // T3 (Sol #2 / Fable F2): the SAME comparator resume uses (engagementComparable) — one decision,
+        // two consumers. graphDefinitionHash (compiled task definitions only) survives status/evidence
+        // mutation but changes when a task definition changes, so a recompiled graph is detected here too.
+        comparable = engagementComparable(events, graphDefinitionHash(g)).comparable;
         if (comparable) {
             replayed = j.replayStatuses();
             for (const e of events) {

package/dist/compile/collateral.js

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { extname, join, relative } from "node:path";
+import picomatch from "picomatch";
 // Advisory plan-time scan only (OBS-12/13/14/21). NEVER expands files[], fails compile, or
 // feeds the scope gate — a warning the author acts on. Plain-text (no AST), capped + sorted.
 /** Max test files walked under tests/ (sorted walk; rest ignored). */
@@ -99,7 +100,8 @@ export function collateralLints(tasks, repoRoot) {
     };
     const lines = [];
     for (const t of tasks) {
-        const scoped = new Set(t.files.map((f) => f.replace(/^\.\//, "")));
+        // OBS-22: scopeGate accepts picomatch globs; advisory collateral warnings must agree.
+        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
         const srcFiles = t.files.map((f) => f.replace(/^\.\//, "")).filter(isSrcPath);
         if (!srcFiles.length)
             continue;
@@ -107,7 +109,7 @@ export function collateralLints(tasks, repoRoot) {
         const needles = [...new Set(srcFiles.flatMap(needlesFor))];
         const hits = [];
         for (const tf of testFiles) {
-            if (scoped.has(tf))
+            if (scoped(tf))
                 continue;
             const text = read(tf);
             if (text === null)

package/dist/drivers/herdr.d.ts

@@ -28,6 +28,7 @@ export declare class HerdrDriver implements ExecutorDriver {
     private glyphFor;
     private joinGroup;
     run(slot: Slot, cmd: string): Promise<void>;
+    private waitOk;
     waitOutput(slot: Slot, pattern: string, timeoutMs: number, opts?: {
         regex?: boolean;
     }): Promise<boolean>;

package/dist/drivers/herdr.js

@@ -275,15 +275,25 @@ export class HerdrDriver {
         if (r.code !== 0)
             throw new Error(`herdr pane run failed: ${r.stderr || r.stdout}`);
     }
+    waitOk(code, stdout) {
+        if (code !== 0 || !stdout.trim())
+            return code === 0; // herdr's successful waits may be silent
+        try {
+            return !Object.hasOwn(JSON.parse(stdout), "error");
+        }
+        catch {
+            return false; // a non-empty herdr wait response must be a parseable envelope
+        }
+    }
     async waitOutput(slot, pattern, timeoutMs, opts) {
         const pane = await this.paneId(slot);
         const r = await this.herdr(`wait output ${shq(pane)} --match ${shq(pattern)}${opts?.regex ? " --regex" : ""} --timeout ${Math.floor(timeoutMs)}`, slot.cwd, timeoutMs + 15_000);
-        return r.code === 0 && !r.stdout.includes('"error"'); // dead pane: exit 0 + error json (herdr bite)
+        return this.waitOk(r.code, r.stdout); // dead pane: exit 0 + top-level error envelope (herdr bite)
     }
     async waitAgentStatus(slot, status, timeoutMs) {
         const pane = await this.paneId(slot);
         const r = await this.herdr(`wait agent-status ${shq(pane)} --status ${shq(status)} --timeout ${Math.floor(timeoutMs)}`, slot.cwd, timeoutMs + 15_000);
-        return r.code === 0 && !r.stdout.includes('"error"');
+        return this.waitOk(r.code, r.stdout);
     }
     async status(slot) {
         return this.statusByName(slot.name);

package/dist/gates/acceptance.d.ts

@@ -10,6 +10,8 @@ export interface JudgeVerdict {
         reason: string;
     }>;
 }
+export declare function judgeCriterionId(index: number): string;
+export declare function testFiltered(testCmd: string, name: string): string;
 export interface AcceptanceGateOpts {
     testCmd?: string;
     diffCap?: number;