tickmarkr 2.5.8 → 2.5.9

package/dist/adapters/qwen.js

@@ -21,7 +21,7 @@ function decodeQwenEvents(events) {
             continue;
         if ("type" in event && event.type === "assistant" && "message" in event) {
             const message = event.message;
-            if (message && typeof message === "object" && "content" in message && Array.isArray(message.content)) {
+            if (message && typeof message === "object" && (!("role" in message) || message.role === "assistant") && "content" in message && Array.isArray(message.content)) {
                 for (const content of message.content) {
                     if (!content || typeof content !== "object" || !(("type" in content) && content.type === "text"))
                         continue;
@@ -64,7 +64,7 @@ function decodeQwenEvents(events) {
                 failed = true;
         }
     }
-    const assistantText = text.join("\n");
+    const assistantText = text.join("");
     const apiError = assistantText.match(/\[API Error:[^\n]*/)?.[0];
     if (apiError)
         failed = true;
@@ -95,6 +95,33 @@ function eventArray(raw) {
     }
     return undefined;
 }
+// OBS-1085: a pane capture can begin inside an event's string. Do not repair that
+// event or scan its prose for trailers. A candidate must decode all the way to
+// the surviving array close: this prevents a nested object or an escaped tool
+// echo from masquerading as a top-level event. Keep terminal failures, but only
+// assistant events can contribute completion text. No partial tail is accepted.
+function eventSuffix(raw) {
+    // Shell prompts and stderr after the stream may contain `]`; use the event
+    // array's object-plus-close boundary, just as eventArray does.
+    const close = raw.lastIndexOf("}]");
+    if (close === -1)
+        return undefined;
+    const end = close + 1;
+    const boundaries = /,\s*(?=\{)/g;
+    for (const boundary of raw.matchAll(boundaries)) {
+        const start = boundary.index + boundary[0].length;
+        if (start >= end)
+            break;
+        try {
+            const events = JSON.parse(`[${raw.slice(start, end + 1)}`);
+            if (!Array.isArray(events) || !events.every((event) => event !== null && typeof event === "object" && "type" in event && typeof event.type === "string"))
+                continue;
+            return events;
+        }
+        catch { /* still inside the clipped event; try the next boundary */ }
+    }
+    return undefined;
+}
 // Decode qwen's JSON envelope before scanning only decoded assistant text for the worker trailer.
 export function parseQwenResult(raw, nonce) {
     const malformed = {
@@ -104,7 +131,7 @@ export function parseQwenResult(raw, nonce) {
         raw,
         cause: raw.trim() ? "malformed-verdict" : "empty-output",
     };
-    const parsed = eventArray(raw);
+    const parsed = eventArray(raw) ?? eventSuffix(raw);
     if (!parsed)
         return malformed;
     const decoded = decodeQwenEvents(parsed);

package/dist/cli/commands/approve.js

@@ -88,10 +88,16 @@ export function permittedDecisionVerbs(park) {
     }
     if (park.kind === "infra")
         return ["approve", "recheck"];
+    // OBS-1084: an authoring park whose newest gate row is a red tool gate is a runner report (a load
+    // flake in an unowned suite), so the battery re-runs on the preserved ref with no worker.
+    if (park.kind === "authoring" && isToolGate(park.failedGate))
+        return ["approve", "recheck"];
     if (park.kind === "diff-cap")
         return ["recheck"]; // OBS-1007: a cap trip is re-gated under a raised cap, never re-bought
     return ["approve"];
 }
+const TOOL_GATES = ["build", "test", "lint"];
+const isToolGate = (gate) => gate !== undefined && TOOL_GATES.includes(gate);
 /** The release marker this command appends for a verb on a park — the fact a read-back must match. */
 export function releaseForDecision(verb, park) {
     if (verb === "waive")
@@ -170,7 +176,8 @@ export async function approve(argv, cwd = process.cwd()) {
         const capPark = park?.kind === ATTEMPT_CAP_RELEASE;
         const gateFailPark = park?.kind === "gate-fail";
         const infraPark = park?.kind === "infra" || park?.kind === "diff-cap";
-        const failedGate = gateFailPark ? park?.failedGate : undefined;
+        const authoringRunnerPark = park?.kind === "authoring" && isToolGate(park.failedGate);
+        const failedGate = gateFailPark || authoringRunnerPark ? park?.failedGate : undefined;
         if ((park?.kind === "scope-request" && !decisions) || files !== undefined) {
             if (park?.kind !== "scope-request")
                 throw new Error("--files requires a scope-request park");
@@ -203,6 +210,7 @@ export async function approve(argv, cwd = process.cwd()) {
             }
             journal.append("task-approved", taskId, {
                 by, ...(reason ? { reason } : {}), via: "cli", release: "scope-request",
+                ...(reviewRoundCeiling === undefined ? {} : { reviewRoundCeiling }), // OBS-1083
                 amendment: { from, to: graphDefinitionHash(amended), beforeFiles: task.files, files: amendedFiles, parkLine: park.line, definition: taskDefinitionFingerprint(task) },
             });
             // Do not write graph.json from this process while the daemon owns it: its sweep materializes
@@ -231,14 +239,18 @@ export async function approve(argv, cwd = process.cwd()) {
             return disposition(cwd, runId, "fund-fixed-attempt", `upheld the reviewer for ${taskId} in ${runId} — by ${by}`, serialization.contended);
         }
         if (recheck) {
-            if ((!gateFailPark || !failedGate) && !infraPark) {
-                throw new Error(`--recheck applies to a gate-fail, infra or diff-cap park; ${taskId}'s newest park is ${String(lastHuman?.data.kind ?? "none")} with failed gate ${failedGate ?? "none"} — refusing`);
+            if ((!gateFailPark || !failedGate) && !infraPark && !authoringRunnerPark) {
+                throw new Error(`--recheck applies to a gate-fail, infra, diff-cap or red-tool-gate authoring park; ${taskId}'s newest park is ${String(lastHuman?.data.kind ?? "none")} with failed gate ${failedGate ?? "none"} — refusing`);
             }
             journal.append("task-approved", taskId, {
                 by,
                 ...(reason ? { reason } : {}),
                 via: "cli",
                 release: RECHECK_RELEASE,
+                // OBS-1084: failedGate names the runner report for every recheck. Authoring rechecks additionally
+                // carry gate so their durable release row identifies the red tool gate that made recheck admissible.
+                ...(failedGate ? { failedGate } : {}),
+                ...(authoringRunnerPark && failedGate ? { gate: failedGate } : {}),
                 ...(reviewRoundCeiling === undefined ? {} : { reviewRoundCeiling }),
             });
             return disposition(cwd, runId, "re-dispatch", `re-checking ${taskId} in ${runId} — by ${by}; ${failedGate ? `failed gate ${failedGate}` : `${park.kind} park`}; no gate marked satisfied`, serialization.contended);

package/dist/cli/commands/beat.d.ts

@@ -1 +1,3 @@
+import { type SupervisionTier } from "../../run/supervision.js";
 export declare function beat(argv: string[], cwd?: string): Promise<string>;
+export declare function standDownTier(repoRoot: string, tier: SupervisionTier, seat: string): string;

package/dist/cli/commands/beat.js

@@ -1,23 +1,13 @@
-import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { tickmarkrDir } from "../../graph/graph.js";
-import { SUPERVISION_BEAT_MS, SUPERVISION_DEFAULT_THRESHOLD_PCT, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, resolveSupervisionRoot, supervisionStandDownPath, } from "../../run/supervision.js";
-// SUP-04: the writer side of supervision, as a VERB. `beatSupervision` and `SUPERVISION_BEAT_MS` shipped
-// with exactly one in-repo caller — the daemon, on one tier — so `status` printed
-// `orchestrator ARMED / overseer ABSENT / watch ABSENT` while a real overseer worked the run: two thirds
-// of a supervision claim were constants dressed as measurements. A seat that supervises from a shell
-// (the overseer skill's watcher loop) has no way into a node module; a command does.
-//
-// ONE-SHOT AND ERROR-PROPAGATING, deliberately not `armSupervision`. That helper is the right shape for
-// a long-lived node process and the wrong shape here twice over. Its recurring interval would outlive
-// the invocation — in a long-lived dispatcher a later `--stand-down` would disarm only its own timer
-// while an earlier one kept writing, flipping DISARMED back to ARMED ten seconds later: the exact
-// fail-open this instrument exists to catch. And it swallows write failures by design (an unwritten
-// beat ages out, which is the truth for a watcher that must not be crashed by its own instrument) —
-// but a CLI that swallows them PRINTS a state nothing recorded, so `beat` says ARMED while `status`
-// reads UNREADABLE. Here the writes are unguarded: a failure leaves the process with a non-zero exit
-// and a message instead of a claim. The LOOP belongs to the caller, which is what makes the beat
-// evidence: stop calling it and the tier ages into STALE on its own.
+import { SUPERVISION_BEAT_MS, SUPERVISION_DEFAULT_THRESHOLD_PCT, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, newSupervisionArm, resolveSupervisionRoot, supervisionStandDownPath, } from "../../run/supervision.js";
+// One-shot ticks reuse a durable arm; only --new-arm (or --loop) acknowledges a stand-down.
+// The loop runs in this process, so its recorded pid belongs to the actual repeating writer.
+// Writes are unguarded and a refused ONE-SHOT tick THROWS: the shipped watcher gates on the exit
+// code with stdout discarded, so a refusal that exits 0 leaves a live watcher believing it is armed
+// while status reads DISARMED. Only the loop returns on stand-down — exiting is its designed end.
 const VALUE_OPTIONS = ["--seat", "--arm-id", "--pct", "--threshold-pct"];
 export async function beat(argv, cwd = process.cwd()) {
     const standDown = argv.includes("--stand-down");
@@ -28,11 +18,11 @@ export async function beat(argv, cwd = process.cwd()) {
     const named = argv.find((a, i) => !a.startsWith("--") && !VALUE_OPTIONS.includes(argv[i - 1] ?? ""));
     if (!isTier(named)) {
         throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> --seat <identity> ` +
-            `[--arm-id <identity> --pct <0..100> --threshold-pct <0..100>] [--stand-down] — ` +
+            `[--new-arm] [--loop] [--arm-id <identity> --pct <0..100> --threshold-pct <0..100>] [--stand-down] — ` +
             `got ${named ? `\`${named}\`` : "no tier"}`);
     }
     // SUP-05: NO SEAT, NO BEAT — and the refusal comes before any write, so a refused invocation leaves
-    // the tier exactly as it found it. This verb is one-shot: the exitedWriterPid it records has
+    // the tier exactly as it found it. In one-shot mode the exitedWriterPid it records has
     // already exited by the time anyone reads the record, so tier + writer + instant is a beat nobody can
     // attribute to a seat. Measured 2026-08-26: a consult seat ran the documented loop verbatim and the
     // board read that tier ARMED with no seat of that tier having armed anything, and a seatless ARMED
@@ -46,12 +36,21 @@ export async function beat(argv, cwd = process.cwd()) {
     const repoRoot = resolveSupervisionRoot(cwd);
     if (standDown)
         return standDownTier(repoRoot, named, seat);
-    // Clear a stand-down marker left by an earlier session BEFORE beating: a valid marker outranks every
-    // beat that does not strictly follow it, and two writes landing in the same millisecond do not. An
-    // uncleared marker would render DISARMED while this verb claimed ARMED, so the removal is unguarded
-    // too — `force` makes the ordinary "no marker" case a no-op, and anything else is a real failure.
-    rmSync(supervisionStandDownPath(repoRoot, named), { force: true, recursive: true });
-    beatSupervision(repoRoot, named, seat, pct === undefined ? undefined : { armId: armId ?? seat, pct, thresholdPct });
+    const loop = argv.includes("--loop");
+    const arm = argv.includes("--new-arm") || loop ? newSupervisionArm(repoRoot, named, armId) : undefined;
+    // Context arm ids retain their existing obligation semantics; they do not implicitly re-arm liveness.
+    const observation = pct === undefined ? undefined : { armId: armId ?? arm?.armId ?? seat, pct, thresholdPct };
+    do {
+        if (!beatSupervision(repoRoot, named, seat, observation, { arm, armId, loop })) {
+            const refusal = `${named} DISARMED — stood down; use --new-arm to resume beating`;
+            if (loop)
+                return refusal;
+            throw new Error(refusal);
+        }
+        if (!loop)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, SUPERVISION_BEAT_MS));
+    } while (loop);
     return `${named} ARMED as ${seat} — beat again every ${SUPERVISION_BEAT_MS / 1_000}s; the tier reads STALE ${SUPERVISION_STALE_MS / 1_000}s after the last beat`;
 }
 /** `--seat <identity>` or `--seat=<identity>`; blank and missing are the same answer — none. */
@@ -84,15 +83,15 @@ function percentageOf(argv, name) {
 // so the tier reads DISARMED rather than ageing out as a death. Published atomically — written aside,
 // renamed over — because a torn marker is rejected by the reader, and a rejected stand-down reports a
 // deliberate hand-off as a death.
-function standDownTier(repoRoot, tier, seat) {
+export function standDownTier(repoRoot, tier, seat) {
     tickmarkrDir(repoRoot); // the write path DOES create — markers land inside the gitignored state dir
     const p = supervisionStandDownPath(repoRoot, tier);
-    const tmp = `${p}.${process.pid}.tmp`;
+    const tmp = `${p}.${randomUUID()}.tmp`;
     mkdirSync(dirname(p), { recursive: true });
     // The marker names the seat for the same reason the beat does: "someone stood this tier down" is not
     // a hand-off anyone can act on, and on a seat tier the reader rejects an anonymous one outright.
     writeFileSync(tmp, JSON.stringify({
-        tier, seat, exitedWriterPid: process.pid, disarmedAt: new Date().toISOString(),
+        tier, seat, standDownId: randomUUID(), exitedWriterPid: process.pid, disarmedAt: new Date().toISOString(),
     }) + "\n");
     renameSync(tmp, p);
     return `${tier} DISARMED — ${seat} handed off; status reads it stood down, not dead`;

package/dist/cli/commands/compile.js

@@ -2,6 +2,8 @@ import { isAbsolute, join } from "node:path";
 import { parseArgs } from "node:util";
 import { collateralLints, sourceScopeFindings, sourceScopeLints, } from "../../compile/collateral.js";
 import { CompileError } from "../../compile/common.js";
+import { loadConfig } from "../../config/config.js";
+import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
 import { compileSource } from "../../compile/index.js";
 import { retiredLiteralErrors } from "../../compile/retired-literals.js";
 import { clearCompileRefusal, saveCompileRefusal, saveGraph, stateDirName } from "../../graph/graph.js";
@@ -82,6 +84,15 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
         if (uncovered.length > 0) {
             throw new CompileError(`${src} has uncovered declared pin obligations:\n${uncovered.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
         }
+        // v2.5.9 T11 (OBS-1086): a shape whose pool the config denies in full is unroutable for every task
+        // that uses it; plan already said so, compile now refuses the seal before any state write so a dry
+        // run reaches the same refusal. Pool only: a partial deny leaves live members, and pin/prefer
+        // collisions on the default map stay doctor's and resume's business. Scoped to the graph's shapes.
+        const deadPools = denyPreferCollisions(loadConfig(cwd), g.tasks.map((task) => task.shape))
+            .filter((collision) => collision.kind === "pool");
+        if (deadPools.length > 0) {
+            throw new CompileError(`${src} routes a task shape to a fully denied pool:\n${deadPools.map((collision) => `  - ${denyPreferCollisionLine(collision)}`).join("\n")}${diagnostics}`);
+        }
         // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
         // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
         // remain the source compiler's answer.

package/dist/cli/commands/fleet.js

@@ -5,7 +5,7 @@ import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, modelAuthE
 import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, fleetUnclassifiedModels } from "../../adapters/model-lints.js";
 import { CATALOG_REFRESH_TIMEOUT_MS, formatCatalogRefreshLegs, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, readClaudeAliasIdentity } from "../../adapters/claude-code.js";
-import { fleetEditableFromConfig, fleetEditableEquals, formatFleetPrint, globalConfigDir, loadConfigWithMode, overlayBytesLoadError, readOverlayFile, renderFleetOverlayWrite, repoOverlayPath, ROUTING_MODES, TIER_RANK, unifiedYamlDiff, } from "../../config/config.js";
+import { fleetEditableFromConfig, fleetEditableEquals, formatFleetPrint, globalConfigDir, DENY_SCOPES, initialDenyPropOf, loadConfigWithMode, overlayBytesLoadError, readOverlayFile, stagedDenyKeyOf, renderFleetOverlayWrite, repoOverlayPath, ROUTING_MODES, TIER_RANK, unifiedYamlDiff, } from "../../config/config.js";
 import { exclusionReason, projectFleetWhy, renderFleetWhy } from "../../config/fleet-why.js";
 import { SHAPES, TIERS } from "../../graph/schema.js";
 import { doctor } from "./doctor.js";
@@ -320,14 +320,12 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     ]));
     const channels = discoverChannels(cfg, adapters, health);
     const profile = loadRoutingProfile(cwd, cfg, { preview: true });
+    const stagedDenyOf = (editable) => Object.fromEntries(DENY_SCOPES.map((scope) => [stagedDenyKeyOf(scope), editable[scope.key] ?? []]));
     const stagedEditable = (map, deny) => ({
         ...structuredClone(initial),
-        denyAdapters: deny.adapters,
-        denyModels: deny.models,
+        ...Object.fromEntries(DENY_SCOPES.map((scope) => [scope.key, deny[stagedDenyKeyOf(scope)]])),
         // OBS-1046: the allow complement is staged beside the deny lists, never folded into them
         allowOut: deny.allowOut ?? initial.allowOut,
-        denyWorkersAdapters: deny.workersAdapters,
-        denyWorkersModels: deny.workersModels,
         map,
     });
     const candidateMemo = new Map();
@@ -573,39 +571,57 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         const floor = cfgPreview.routing.floors[shape];
         const collisions = denyPreferCollisions(cfgPreview, [shape]);
         const discovered = new Set(previewChannels.map((c) => `${c.adapter}:${c.model}`));
-        // discovery already dropped a channel whose model probe failed — it still gets its own row
-        const unauthedRows = [
-            ...unauthedClis.map((adapter) => `${adapter} — CLI unauthed — re-probe with tickmarkr doctor`),
-            ...unauthedModels.filter(({ key }) => !discovered.has(key))
-                .map(({ key, reason }) => `${key.replace(":", "/")} — unauthed (${reason}) — re-probe with tickmarkr doctor`),
-        ];
-        return [...unauthedRows, ...previewChannels.flatMap((c) => {
-                const key = `${c.adapter}:${c.model}`;
-                const reasons = exclusionCollector(c, cfgPreview.routing, "worker").map(exclusionReason);
-                if (health[c.adapter]?.authed === false)
-                    reasons.push(`${c.adapter} CLI unauthed — re-probe with tickmarkr doctor`);
-                else if (health[c.adapter]?.modelAuth?.[c.model]?.authed === false)
-                    reasons.push("unauthed — re-probe with tickmarkr doctor");
-                if (entry?.pin && key !== `${entry.pin.via}:${entry.pin.model}`) {
-                    reasons.push(`not routing.map.${shape}.pin (${entry.pin.via}:${entry.pin.model}) — not manageable here`);
-                }
-                if (entry?.pool && !entry.pool.channels.includes(key)) {
-                    reasons.push(`outside routing.map.${shape}.pool — not manageable here`);
-                }
-                if (floor && TIER_RANK[c.tier] < TIER_RANK[floor]) {
-                    reasons.push(`below routing.floors.${shape} (${floor}) — not manageable here`);
-                }
-                if (entry?.prefer?.some((p) => entryMatchesChannel(p, c))) {
-                    reasons.push(`task hint: routing.map.${shape}.prefer names it — not manageable here`);
-                }
-                for (const collision of collisions) {
-                    const named = collision.detail.split(" > ").some((p) => entryMatchesChannel(p, c));
-                    if (named || offered.size === 0)
-                        reasons.push(denyPreferCollisionLine(collision));
-                }
-                // labelled like the models view's row (adapter/model), so a ledger row never reads as a candidate
-                return reasons.length ? [`${c.adapter}/${c.model} — ${reasons.join("; ")}`] : [];
-            })];
+        // T2 review (D-225): discovery already dropped a channel whose model probe failed — it is
+        // rebuilt as a structured channel from its adapter's own declaration and walks the SAME
+        // reach + collector path as every other row, the auth reason appended LAST; never a bare string
+        const withIdentity = (adapter, declared) => {
+            const identity = health[adapter]?.modelAuth?.[declared.model]?.identity ?? health[adapter]?.modelIdentities?.[declared.model];
+            return identity ? { ...declared, identity } : declared;
+        };
+        const failedProbes = unauthedModels.filter(({ key }) => !discovered.has(key)).flatMap(({ key, adapter, reason }) => {
+            const declared = adapters.find((a) => a.id === adapter)?.channels(cfg).find((c) => `${c.adapter}:${c.model}` === key);
+            return declared ? [{ ...withIdentity(adapter, declared), authReason: `unauthed (${reason}) — re-probe with tickmarkr doctor` }] : [];
+        });
+        // T2 review round 6: an installed-but-unauthed CLI is dropped by discovery AND by the model
+        // probe list, so its configured channels are rebuilt from the adapter's own declaration too —
+        // each greys with its reach and covering entry, the CLI auth reason last; never one bare adapter line
+        const unauthedCliChannels = unauthedClis.flatMap((adapter) => (adapters.find((a) => a.id === adapter)?.channels(cfg) ?? [])
+            .map((declared) => ({ ...withIdentity(adapter, declared), authReason: `${adapter} CLI unauthed — re-probe with tickmarkr doctor` })));
+        // D-225: the ledger is the EXCLUDED half of a closed partition — a channel the picker offers
+        // never greys beside itself; its pin/pool/floor/prefer captions stay in excludedNote
+        const ledgerChannels = [...previewChannels.map((c) => ({ ...c, authReason: undefined })), ...failedProbes, ...unauthedCliChannels]
+            .filter((c) => !offered.has(`${c.adapter}:${c.model}`));
+        return ledgerChannels.flatMap((c) => {
+            const key = `${c.adapter}:${c.model}`;
+            const reasons = exclusionCollector(c, cfgPreview.routing, "worker").map(exclusionReason);
+            // OBS-1065: a greyed picker row carries its reach beside its reasons, like the models view
+            const allSeats = exclusionCollector(c, cfgPreview.routing, "judge");
+            const reach = allSeats.some((scope) => scope.by === "deny") ? "out all"
+                : allSeats.length ? "out allow" : reasons.length ? "out workers" : "in";
+            if (!c.authReason && health[c.adapter]?.modelAuth?.[c.model]?.authed === false)
+                reasons.push("unauthed — re-probe with tickmarkr doctor");
+            if (entry?.pin && key !== `${entry.pin.via}:${entry.pin.model}`) {
+                reasons.push(`not routing.map.${shape}.pin (${entry.pin.via}:${entry.pin.model}) — not manageable here`);
+            }
+            if (entry?.pool && !entry.pool.channels.includes(key)) {
+                reasons.push(`outside routing.map.${shape}.pool — not manageable here`);
+            }
+            if (floor && TIER_RANK[c.tier] < TIER_RANK[floor]) {
+                reasons.push(`below routing.floors.${shape} (${floor}) — not manageable here`);
+            }
+            if (entry?.prefer?.some((p) => entryMatchesChannel(p, c))) {
+                reasons.push(`task hint: routing.map.${shape}.prefer names it — not manageable here`);
+            }
+            for (const collision of collisions) {
+                const named = collision.detail.split(" > ").some((p) => entryMatchesChannel(p, c));
+                if (named || offered.size === 0)
+                    reasons.push(denyPreferCollisionLine(collision));
+            }
+            if (c.authReason)
+                reasons.push(c.authReason);
+            // labelled like the models view's row (adapter/model), so a ledger row never reads as a candidate
+            return reasons.length ? [`${c.adapter}/${c.model} — reach: ${reach} — ${reasons.join("; ")}`] : [];
+        });
     };
     const candidatesForShape = (shape, mode, map, deny) => {
         const preview = previewCfg(mode, map, deny);
@@ -616,6 +632,8 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
             id: `${candidate.assignment.adapter}:${candidate.assignment.model}`,
             label: candidateRow(candidate, cfg.pricing),
             pin: { via: candidate.assignment.adapter, model: candidate.assignment.model },
+            // OBS-1065: a picker lift reads eligibility from here, not the ledger strings
+            belowFloor: candidate.belowFloor,
         }));
         const offered = new Set(rows.map((row) => row.id));
         const notes = [excludedNoteFor(cfgPreview), ...shapeExclusionCaptions(shape, map, cfgPreview)].filter((note) => note !== undefined);
@@ -644,12 +662,10 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     let pendingWrite = null;
     const reviewOverlay = (state) => {
         const staged = structuredClone(initial);
-        staged.denyAdapters = state.denyAdapters;
-        staged.denyModels = state.denyModels;
+        // OBS-994/FL-1, OBS-1099 add.1: every schema-enumerated deny scope rides the same review/write funnel
+        for (const scope of DENY_SCOPES)
+            staged[scope.key] = state[scope.key];
         staged.allowOut = state.allowOut ?? initial.allowOut;
-        // OBS-994/FL-1: the workers-only deny scope rides the same review/write funnel as the flat one.
-        staged.denyWorkersAdapters = state.denyWorkersAdapters;
-        staged.denyWorkersModels = state.denyWorkersModels;
         staged.map = state.map;
         const today = new Date().toISOString().slice(0, 10);
         for (const classification of state.classifications) {
@@ -700,11 +716,8 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
         ageMs: doctorAgeMs(cwd),
         adapters,
         health,
-        initialDenyAdapters: editable.denyAdapters,
-        initialDenyModels: editable.denyModels,
+        ...Object.fromEntries(DENY_SCOPES.map((scope) => [initialDenyPropOf(scope), editable[scope.key] ?? []])),
         initialAllowOut: editable.allowOut,
-        initialDenyWorkersAdapters: editable.denyWorkersAdapters,
-        initialDenyWorkersModels: editable.denyWorkersModels,
         modelGroups,
         initialMode: rm.mode.mode,
         modeOptions: ROUTING_MODES.map((mode) => ({ id: mode, gloss: MODE_GLOSS[mode] })),
@@ -768,11 +781,6 @@ export async function assembleFleetEditor(cwd, adapters, io, opts) {
     return {
         props,
         commit,
-        renderWhy: () => renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map, {
-            adapters: editable.denyAdapters,
-            models: editable.denyModels,
-            workersAdapters: editable.denyWorkersAdapters ?? [],
-            workersModels: editable.denyWorkersModels ?? [],
-        })),
+        renderWhy: () => renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map, stagedDenyOf(editable))),
     };
 }

package/dist/cli/commands/verify.d.ts

@@ -1,4 +1,5 @@
 import { type Assignment, type BillingChannel } from "../../adapters/types.js";
+import { type GateEvidenceOptions } from "../../gates/baseline.js";
 import { type AcceptanceItem } from "../../graph/schema.js";
 export declare function parseCriteria(text: string): AcceptanceItem[];
 export declare const HUMAN_CHANNEL: BillingChannel;
@@ -10,7 +11,9 @@ export declare function verifyStateRoot(cwd: string): Promise<string>;
 export declare function baselineCachePath(cwd: string, baseSha: string, commands: Record<string, string>): string;
 export declare function excludeAuthorProvider(channels: BillingChannel[], author: BillingChannel): BillingChannel[];
 export declare const VERIFY_HELP = "usage: tickmarkr verify [--base <ref>] [--criteria <file> | --task <id>] [--json]\nThe final verdict and JSON result are written to stdout; progress and diagnostics are written to stderr.\nDo not merge stdout and stderr (for example with 2>&1): doing so corrupts the verdict stream.";
-export declare function verify(argv: string[], cwd?: string): Promise<{
+export declare function verify(argv: string[], cwd?: string, options?: {
+    evidence?: GateEvidenceOptions;
+}): Promise<{
     out: string;
     code: number;
 }>;

package/dist/cli/commands/verify.js

@@ -130,7 +130,7 @@ async function warnWideTaskRange(cwd, stateRoot, taskId, mergeBase) {
 export const VERIFY_HELP = `usage: tickmarkr verify [--base <ref>] [--criteria <file> | --task <id>] [--json]
 The final verdict and JSON result are written to stdout; progress and diagnostics are written to stderr.
 Do not merge stdout and stderr (for example with 2>&1): doing so corrupts the verdict stream.`;
-export async function verify(argv, cwd = process.cwd()) {
+export async function verify(argv, cwd = process.cwd(), options = {}) {
     if (argv.some((arg) => arg === "--help" || arg === "-h"))
         return { out: VERIFY_HELP, code: 0 };
     const { values } = parseArgs({
@@ -328,6 +328,7 @@ export async function verify(argv, cwd = process.cwd()) {
             worktree: cwd, baseRef: mergeBase,
             result: { ok: true, summary: "standalone verify — no worker claims to trust", deviations: [], raw: "" },
             author, commands, baseline, channels, ...(judgeChannels ? { judgeChannels } : {}), adapters, cfg,
+            evidence: options.evidence,
             verificationScope: "standalone", artifactDir, stateDir: join(stateRoot, ".tickmarkr"),
             onGate: (e) => {
                 if (e.phase === "start")
@@ -345,17 +346,27 @@ export async function verify(argv, cwd = process.cwd()) {
             return match ? [{ classification: match[1], note: match[2], reviewer: result.meta?.reviewer }] : [];
         }));
         const artifactPath = join(artifactDir, "verify-results.json");
-        writeFileSync(artifactPath, JSON.stringify({ base: baseTip, head, mergeBase, green, gateRows: results, reviewFindings }, null, 2) + "\n");
-        console.error(`verify: artifacts written to ${artifactPath}`);
+        const artifactBytes = Buffer.from(JSON.stringify({ base: baseTip, head, mergeBase, green, gateRows: results, reviewFindings }, null, 2) + "\n");
+        let artifactSha256 = null;
+        let artifactAvailability = "capture-failed";
+        try {
+            writeFileSync(artifactPath, artifactBytes, { flag: "wx" });
+            artifactSha256 = createHash("sha256").update(artifactBytes).digest("hex");
+            artifactAvailability = "available";
+            console.error(`verify: artifacts written to ${artifactPath}`);
+        }
+        catch {
+            console.error(`verify: evidence capture failed for ${artifactPath}`);
+        }
         const review = reviewRows.at(-1);
         if (recordJournal && review) {
             recordJournal.append("review-leg2", values.task ?? "VERIFY", {
-                base: baseTip, head, mergeBase, author: channelKey(author), artifactPath,
+                base: baseTip, head, mergeBase, author: channelKey(author), artifactPath, artifactSha256, artifactAvailability,
                 ...review,
             });
         }
         if (values.json) {
-            return { out: JSON.stringify({ base: baseTip, head, mergeBase, green, artifactPath, results }, null, 2), code: green ? 0 : 2 };
+            return { out: JSON.stringify({ base: baseTip, head, mergeBase, green, artifactPath, artifactSha256, artifactAvailability, results }, null, 2), code: green ? 0 : 2 };
         }
         const lines = results.map((r) => `${r.pass ? "PASS" : "FAIL"} ${r.gate}\n${r.details.split("\n").map((l) => `  ${l}`).join("\n")}`);
         const verdict = green

package/dist/cli/help.d.ts

@@ -176,6 +176,8 @@ export declare const COMMAND_HELP: {
         description: string;
         options: {
             "--seat <identity>": string;
+            "--new-arm": string;
+            "--loop": string;
             "--arm-id <identity>": string;
             "--pct <0..100>": string;
             "--threshold-pct <0..100>": string;

package/dist/cli/help.js

@@ -140,14 +140,16 @@ export const COMMAND_HELP = {
     },
     beat: {
         usage: "beat <orchestrator|orchestrator-context|overseer|overseer-context|watch> --seat <identity> [options]",
-        description: "Write one supervision beat. The supervising seat's watcher loop repeats it; stopped beats become STALE.",
+        description: "Write one supervision beat using the recorded arm. Stood-down arms stay DISARMED until explicitly re-armed; stopped beats become STALE.",
         options: {
             "--seat <identity>": "Required: identify the supervising pane or agent.",
-            "--arm-id <identity>": "Identify this supervision arm.",
+            "--new-arm": "Create a new durable arm, allowing beats to resume after stand-down; the hand-off step for a seat taking over a stood-down tier (combine with --arm-id and --pct on a context tier).",
+            "--loop": "Create a new durable arm and beat in this process every 10 seconds; exit within one interval after stand-down.",
+            "--arm-id <identity>": "Name a newly created arm; with --pct, identify the context observation arm. Never refuses a tick.",
             "--pct <0..100>": "Report current context consumption percentage.",
             "--threshold-pct <0..100>": "Set the context warning threshold (default 75).",
-            "--stand-down": "Record an explicit handoff and stand down this tier.",
-        }, examples: ["beat overseer --seat supervisor", "beat overseer --seat supervisor --stand-down"],
+            "--stand-down": "Record an explicit handoff and stand down this tier. A later one-shot tick on the old arm exits non-zero; context observations still raise and discharge the clear duty.",
+        }, examples: ["beat overseer --seat supervisor", "beat overseer --seat supervisor --loop", "beat overseer --seat supervisor --stand-down", "beat overseer --seat supervisor --new-arm"],
     },
     version: {
         usage: "version [--dist]", description: "Print the installed package version. Top-level aliases: --version and -v.",

package/dist/config/config.d.ts

@@ -62,6 +62,46 @@ export declare const TierEntrySchema: z.ZodObject<{
     windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, z.core.$strip>;
 export type TierEntry = z.infer<typeof TierEntrySchema>;
+export declare const DenyBlockSchema: z.ZodObject<{
+    adapters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    workers: z.ZodOptional<z.ZodObject<{
+        adapters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DenyKeysOf<T, P extends string> = {
+    [K in keyof T & string]: NonNullable<T[K]> extends string[] ? `${P}${Capitalize<K>}` : DenyKeysOf<NonNullable<T[K]>, `${P}${Capitalize<K>}`>;
+}[keyof T & string];
+export type DenyScopeKey = DenyKeysOf<z.infer<typeof DenyBlockSchema>, "deny">;
+export type DenyScope = {
+    /** the FleetEditable field: deny + the path segments capitalized (denyWorkersModels) */
+    key: DenyScopeKey;
+    /** the overlay path: ["routing", "deny", ...segments] */
+    path: string[];
+    /** the dotted config path the exclusion collector reports (routing.deny.workers.models) */
+    dotted: string;
+};
+export declare function denyScopesOf(schema: z.ZodObject<z.ZodRawShape>, segments?: string[]): Array<{
+    key: string;
+    path: string[];
+    dotted: string;
+}>;
+export declare const DENY_SCOPES: readonly DenyScope[];
+/** the staged-set key the fleet browser uses for a scope: its key minus the `deny` prefix (denyWorkersAdapters → workersAdapters) */
+export type StagedDenyKey = DenyScopeKey extends `deny${infer Rest}` ? Uncapitalize<Rest> : never;
+export declare const stagedDenyKeyOf: (scope: DenyScope) => StagedDenyKey;
+/** the FleetApp prop that seeds one scope's staged set (initialDenyWorkersAdapters). Lives here, not in
+ * fleet-app.tsx, so the fleet command needs no runtime import of the Ink module (the print path must
+ * never load Ink, and chalk reads FORCE_COLOR at import time). */
+export type InitialDenyProps = {
+    [K in DenyScopeKey as `initial${Capitalize<K>}`]?: string[];
+};
+export declare const initialDenyPropOf: (scope: DenyScope) => keyof InitialDenyProps;
+/** the authored list at one deny scope of a routing block, undefined when the scope is absent */
+export declare function denyEntriesAt(routing: TickmarkrConfig["routing"], scope: DenyScope): string[] | undefined;
+/** a routing.deny block built from per-scope lists (absent or empty lists are left out) */
+export declare function denyBlockFrom(lists: Partial<Record<DenyScopeKey, string[]>>): NonNullable<TickmarkrConfig["routing"]["deny"]>;
 export declare const ModelPricingSchema: z.ZodObject<{
     inPerMtok: z.ZodNumber;
     outPerMtok: z.ZodNumber;
@@ -371,11 +411,9 @@ export type FleetTierAssignment = {
     tier: Tier;
     provenance?: string;
 };
-export type FleetEditable = {
+export type FleetEditable = Partial<Record<DenyScopeKey, string[]>> & {
     denyAdapters: string[];
     denyModels: string[];
-    denyWorkersAdapters?: string[];
-    denyWorkersModels?: string[];
     allowOut?: string[];
     tiers: Record<string, Record<string, FleetTierAssignment | null>>;
     map: Record<string, MapEntry>;