tickmarkr 2.5.4 → 2.5.6

package/dist/cli/commands/run.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, probeAll, readDoctor } from "../../adapters/registry.js";
 import { ROUTING_MODES } from "../../config/config.js";
-import { parseDriverOverride, pickDriver } from "../../drivers/index.js";
+import { classifyHost, parseDriverOverride, pickDriver, preflightHostDriver } from "../../drivers/index.js";
 import { loadGraph, onDiskSpecHash, readCompileRefusal } from "../../graph/graph.js";
 import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
 import { isRunLockLive } from "../../run/lock.js";
@@ -106,6 +106,7 @@ export const RAIL_ROWS = {
     "gate-fingerprint-cap": { label: "repeat capped", tone: "attention" },
     // a scope red every collateral prediction already named: the daemon parks the task WITHOUT
     // charging an attempt, which is the most consequential unchargeable decision it makes
+    "scope-request": { label: "scope requested", tone: "attention" },
     "scope-authoring": { label: "authoring defect", tone: "attention" },
     "session-reset": { label: "session reset", tone: "attention" },
     "worker-mode-fallback": { label: "dispatch mode", tone: "attention" },
@@ -131,6 +132,9 @@ export const RAIL_ROWS = {
     "phase-start": { label: "gate start", tone: "active" },
     "gate-result": { label: "gate", tone: "pass" },
     "baseline-wait": { label: "baseline wait", tone: "active" },
+    "suite-wait": { label: "suite wait", tone: "active" },
+    "suite-wait-ceiling": { label: "suite wait ceiling", tone: "attention" },
+    "worker-reaped-before-harvest": { label: "worker reaped", tone: "attention" },
     "suite-budget": { label: "suite budget", tone: "attention" },
     "gate-replayed": { label: "gate replayed", tone: "attention" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
@@ -320,6 +324,7 @@ const RAIL_PROJECTION = {
         ? `to ${d.chosen}${typeof d.static === "string" ? ` over ${d.static}` : ""}`
         : undefined,
     // both rehash hashes: the ladder reaches `from` (null on an unbound journal) and never `to`
+    "scope-request": (d) => Array.isArray(d.paths) ? `files[]: ${d.paths.join(", ")}` : undefined,
     "graph-rehash": (d) => (typeof d.to === "string" ? `to ${d.to.slice(0, 12)}` : undefined),
     "repair-dispatch": (d) => typeof d.diffBytes === "number" ? `diff ${d.diffBytes}B${d.capped === true ? ", capped" : ""}` : undefined,
     "tip-moved": (d) => typeof d.gatedCommit === "string" && typeof d.branchTip === "string"
@@ -328,6 +333,8 @@ const RAIL_PROJECTION = {
     "trust-auto-answer": (d) => typeof d.adapter === "string" ? `${d.adapter}${typeof d.phase === "string" ? ` ${d.phase}` : ""}` : undefined,
     // SB-1: the census the ceiling released beside, and the budget the round ran under versus the one it
     // would have had on an empty census — none of `{count, occupancyCap, conservativeCap}` is on the ladder
+    "suite-wait": (d) => typeof d.count === "number" ? `waiting for ${d.count} command(s)` : undefined,
+    "suite-wait-ceiling": (d) => typeof d.count === "number" ? `${d.count} still live after ${d.waitedMs}ms` : undefined,
     "suite-budget": (d) => typeof d.count === "number" && typeof d.conservativeCap === "number" && typeof d.occupancyCap === "number"
         ? `beside ${d.count}, cap ${d.conservativeCap} not ${d.occupancyCap}`
         : undefined,
@@ -503,6 +510,8 @@ export async function run(argv, cwd = process.cwd()) {
                 throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
         }
         await assertRefsWritable(cwd, "run");
+        const host = classifyHost();
+        preflightHostDriver(cfg, driverOverride, host);
         // The run id is minted HERE rather than inside the daemon, because the narration sink has to know
         // which run it is narrating before the first event arrives (the daemon's `narrate` callback is
         // handed an event and nothing else, and `run-start` carries no run id). `runDaemon` uses the id
@@ -512,7 +521,7 @@ export async function run(argv, cwd = process.cwd()) {
         const s = await runDaemon(cwd, {
             runId,
             concurrency: values.concurrency ? Number(values.concurrency) : undefined,
-            driver: bindNarration(pickDriver(cfg, driverOverride), narrate),
+            driver: bindNarration(pickDriver(cfg, driverOverride, host), narrate),
             mode: flagMode,
             supersedes: values.supersedes,
             narrate,

package/dist/cli/commands/verify.js

@@ -6,13 +6,15 @@ import { parseArgs } from "node:util";
 import { allAdapters, probeAll, readDoctor, rolePools } from "../../adapters/registry.js";
 import { channelKey } from "../../adapters/types.js";
 import { loadConfig } from "../../config/config.js";
-import { captureBaseline, detectGateCommands } from "../../gates/baseline.js";
+import { captureBaseline, detectGateCommands, staleFileCountCommands } from "../../gates/baseline.js";
 import { modelProvider } from "../../gates/review.js";
 import { runGates } from "../../gates/run-gates.js";
 import { getTask, loadGraph } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
+import { executionSignal } from "../../run/execution-budget.js";
 import { linkNodeModules, removeWorktree, shGit, shGitOk } from "../../run/git.js";
 import { Journal } from "../../run/journal.js";
+import { withRepositoryLease } from "../../run/lease.js";
 /**
  * tickmarkr verify — the gate battery as a standalone command (OPERATING-MODEL-2026-08-11 item 3).
  *
@@ -249,95 +251,114 @@ export async function verify(argv, cwd = process.cwd()) {
     // ponytail: tmpdir means the baseline cache dies on reboot/cleanup — worst case is one re-capture.
     const stateDir = verifyStateDir(cwd);
     mkdirSync(stateDir, { recursive: true });
-    let baseline;
-    const cachePath = baselineCachePath(cwd, mergeBase, commands);
-    const verdictlessMarker = `${cachePath}.verdictless`;
-    mkdirSync(dirname(cachePath), { recursive: true });
-    if (values.baseline) {
-        baseline = JSON.parse(readFileSync(values.baseline, "utf8"));
-    }
-    else {
-        let cached;
-        if (existsSync(cachePath)) {
-            cached = JSON.parse(readFileSync(cachePath, "utf8"));
-            const missing = verdictlessCommands(cached, commands);
-            if (missing.length) {
-                console.error(`verify: cached baseline recorded no verdict for ${missing.join(", ")}; it was not reusable and will be recaptured`);
-                rmSync(cachePath, { force: true });
-                cached = undefined;
-            }
-        }
-        if (cached) {
-            console.error(`verify: reusing cached baseline for ${mergeBase.slice(0, 12)} (${cachePath})`);
-            baseline = cached;
+    const recordJournal = values.record ? Journal.open(stateRoot, values.record) : undefined;
+    // OBS-1042: one runner root per repository across every linked worktree — the capture and the
+    // battery below run under a reservation keyed on the common git dir, and a waiter says who holds it.
+    return withRepositoryLease(cwd, () => leasedVerify(), {
+        signal: executionSignal(),
+        onWait: (holder) => {
+            console.error(`verify: waiting for the repository's runner lease held by pid ${holder.pid} in ${holder.cwd}`);
+            recordJournal?.append("suite-wait", values.task ?? "VERIFY", { holderPid: holder.pid, holderCwd: holder.cwd });
+        },
+    });
+    async function leasedVerify() {
+        let baseline;
+        const cachePath = baselineCachePath(cwd, mergeBase, commands);
+        const verdictlessMarker = `${cachePath}.verdictless`;
+        mkdirSync(dirname(cachePath), { recursive: true });
+        if (values.baseline) {
+            baseline = JSON.parse(readFileSync(values.baseline, "utf8"));
         }
         else {
-            if (existsSync(verdictlessMarker)) {
-                console.error(`verify: prior baseline recorded no verdict and was not cached; recapturing merge-base ${mergeBase.slice(0, 12)}`);
-            }
-            else {
-                console.error(`verify: capturing baseline at merge-base ${mergeBase.slice(0, 12)} (cached by base, lockfile and command hashes at ${cachePath})`);
-            }
-            const baseDir = join(stateDir, `base-${mergeBase.slice(0, 12)}`);
-            await shGit(`git worktree remove --force '${baseDir}'`, cwd); // stale leftover from an interrupted run
-            await shGitOk(`git worktree add --detach '${baseDir}' '${mergeBase}'`, cwd);
-            try {
-                linkNodeModules(cwd, baseDir, { force: true });
-                baseline = await captureBaseline(baseDir, commands);
-                const missing = verdictlessCommands(baseline, commands);
+            let cached;
+            if (existsSync(cachePath)) {
+                cached = JSON.parse(readFileSync(cachePath, "utf8"));
+                const missing = verdictlessCommands(cached, commands);
                 if (missing.length) {
-                    writeFileSync(verdictlessMarker, JSON.stringify({ base: mergeBase, commands: missing }) + "\n");
+                    console.error(`verify: cached baseline recorded no verdict for ${missing.join(", ")}; it was not reusable and will be recaptured`);
                     rmSync(cachePath, { force: true });
+                    cached = undefined;
                 }
-                else {
-                    writeFileSync(cachePath, JSON.stringify(baseline, null, 2));
-                    rmSync(verdictlessMarker, { force: true });
+                // OBS-1044: a cached vitest count that is a stdout sum may be inflated by nested runner echo;
+                // applying it would manufacture a deficit. Only a manifest-derived count is a floor.
+                const stale = cached ? staleFileCountCommands(cached, commands, cwd) : [];
+                if (stale.length) {
+                    console.error(`verify: cached baseline's file count for ${stale.join(", ")} is not manifest-derived; it will be recaptured`);
+                    rmSync(cachePath, { force: true });
+                    cached = undefined;
                 }
             }
-            finally {
-                await removeWorktree(cwd, baseDir);
+            if (cached) {
+                console.error(`verify: reusing cached baseline for ${mergeBase.slice(0, 12)} (${cachePath})`);
+                baseline = cached;
+            }
+            else {
+                if (existsSync(verdictlessMarker)) {
+                    console.error(`verify: prior baseline recorded no verdict and was not cached; recapturing merge-base ${mergeBase.slice(0, 12)}`);
+                }
+                else {
+                    console.error(`verify: capturing baseline at merge-base ${mergeBase.slice(0, 12)} (cached by base, lockfile and command hashes at ${cachePath})`);
+                }
+                const baseDir = join(stateDir, `base-${mergeBase.slice(0, 12)}`);
+                await shGit(`git worktree remove --force '${baseDir}'`, cwd); // stale leftover from an interrupted run
+                await shGitOk(`git worktree add --detach '${baseDir}' '${mergeBase}'`, cwd);
+                try {
+                    linkNodeModules(cwd, baseDir, { force: true });
+                    baseline = await captureBaseline(baseDir, commands);
+                    const missing = verdictlessCommands(baseline, commands);
+                    if (missing.length) {
+                        writeFileSync(verdictlessMarker, JSON.stringify({ base: mergeBase, commands: missing }) + "\n");
+                        rmSync(cachePath, { force: true });
+                    }
+                    else {
+                        writeFileSync(cachePath, JSON.stringify(baseline, null, 2));
+                        rmSync(verdictlessMarker, { force: true });
+                    }
+                }
+                finally {
+                    await removeWorktree(cwd, baseDir);
+                }
             }
         }
-    }
-    const recordJournal = values.record ? Journal.open(stateRoot, values.record) : undefined;
-    const artifactDir = join(stateDir, new Date().toISOString().replace(/[:.]/g, "-"));
-    mkdirSync(artifactDir, { recursive: true });
-    const { results } = await runGates(task, {
-        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,
-        pipeline: "v185", artifactDir,
-        onGate: (e) => {
-            if (e.phase === "start")
-                console.error(`verify: → ${e.gate} (${e.index}/${e.total})`);
-            else if (e.phase === "note")
-                console.error(`verify: note ${e.gate} ${e.name} ${JSON.stringify(e.payload)}`);
-            else
-                console.error(`verify: ${e.result.pass ? "✓" : "✗"} ${e.result.gate} — ${e.result.details.split("\n")[0] ?? ""}`);
-        },
-    });
-    const green = results.length > 0 && results.every((r) => r.pass || r.meta?.skipped === true);
-    const reviewRows = results.filter((result) => result.gate === "review");
-    const reviewFindings = reviewRows.flatMap((result) => result.details.split("\n").flatMap((line) => {
-        const match = /^- \[([^\]]+)\] (.*)$/.exec(line);
-        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 review = reviewRows.at(-1);
-    if (recordJournal && review) {
-        recordJournal.append("review-leg2", values.task ?? "VERIFY", {
-            base: baseTip, head, mergeBase, author: channelKey(author), artifactPath,
-            ...review,
+        const artifactDir = join(stateDir, new Date().toISOString().replace(/[:.]/g, "-"));
+        mkdirSync(artifactDir, { recursive: true });
+        const { results } = await runGates(task, {
+            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,
+            verificationScope: "standalone", artifactDir, stateDir: join(stateRoot, ".tickmarkr"),
+            onGate: (e) => {
+                if (e.phase === "start")
+                    console.error(`verify: → ${e.gate} (${e.index}/${e.total})`);
+                else if (e.phase === "note")
+                    console.error(`verify: note ${e.gate} ${e.name} ${JSON.stringify(e.payload)}`);
+                else
+                    console.error(`verify: ${e.result.pass ? "✓" : "✗"} ${e.result.gate} — ${e.result.details.split("\n")[0] ?? ""}`);
+            },
         });
+        const green = results.length > 0 && results.every((r) => r.pass || r.meta?.skipped === true);
+        const reviewRows = results.filter((result) => result.gate === "review");
+        const reviewFindings = reviewRows.flatMap((result) => result.details.split("\n").flatMap((line) => {
+            const match = /^- \[([^\]]+)\] (.*)$/.exec(line);
+            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 review = reviewRows.at(-1);
+        if (recordJournal && review) {
+            recordJournal.append("review-leg2", values.task ?? "VERIFY", {
+                base: baseTip, head, mergeBase, author: channelKey(author), artifactPath,
+                ...review,
+            });
+        }
+        if (values.json) {
+            return { out: JSON.stringify({ base: baseTip, head, mergeBase, green, artifactPath, 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
+            ? `verify GREEN — ${results.length} gate(s) passed on ${mergeBase.slice(0, 12)}..${head.slice(0, 12)} (merge is a human decision; artifacts: ${artifactPath})`
+            : `verify RED — first failure decides; artifacts: ${artifactPath}`;
+        return { out: [...lines, "", verdict].join("\n"), code: green ? 0 : 2 };
     }
-    if (values.json) {
-        return { out: JSON.stringify({ base: baseTip, head, mergeBase, green, artifactPath, 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
-        ? `verify GREEN — ${results.length} gate(s) passed on ${mergeBase.slice(0, 12)}..${head.slice(0, 12)} (merge is a human decision; artifacts: ${artifactPath})`
-        : `verify RED — first failure decides; artifacts: ${artifactPath}`;
-    return { out: [...lines, "", verdict].join("\n"), code: green ? 0 : 2 };
 }

package/dist/cli/help.d.ts

@@ -15,6 +15,7 @@ export declare const COMMAND_HELP: {
             "--docs": string;
             "--fresh": string;
             "--yes": string;
+            "--remove": string;
         };
         examples: string[];
     };
@@ -160,6 +161,7 @@ export declare const COMMAND_HELP: {
         usage: string;
         description: string;
         options: {
+            "--files <glob,\u2026>": string;
             "--by <name>": string;
             "--reason <text>": string;
             "--waive": string;

package/dist/cli/help.js

@@ -10,7 +10,8 @@ export const COMMAND_HELP = {
             "--docs": "Include agent guidance documents with --agent.",
             "--fresh": "Force fresh adapter probes instead of reusing recent health.",
             "--yes": "Skip the interactive setup wizard and use defaults.",
-        }, examples: ["init --yes", "init --agent --force --docs"],
+            "--remove": "Reverse init without scaffolding: delete state, skills, docs block, unedited spec, and prune worktrees.",
+        }, examples: ["init --yes", "init --agent --force --docs", "init --remove"],
     },
     doctor: {
         usage: "doctor [options]", description: "Probe configured adapters and models and print diagnostics. Default probing may make model calls and refresh a stale catalog.",
@@ -128,6 +129,7 @@ export const COMMAND_HELP = {
     approve: {
         usage: "approve <run-id> <task-id> [options]", description: "Append a validated park decision. A running owner may enact it; a closed run requires a separate resume. Decisions cannot be undone.",
         options: {
+            "--files <glob,…>": "Extend files[] for a scope-request park with comma-separated repository-relative globs; required for scope approval.",
             "--by <name>": "Name the actor (default: current OS user).",
             "--reason <text>": "Record the decision reason.",
             "--waive": "Waive only the identified failed gate.",

package/dist/config/config.d.ts

@@ -132,7 +132,17 @@ export declare function effectiveReviewPolicy(files: ReadonlyArray<string>, revi
  * under-flagged one skips the only gate that exists for it.
  */
 export declare function criticalPathHits(files: ReadonlyArray<string>, criticalPaths?: ReadonlyArray<string>): string[];
+export declare const ExecutionPolicySchema: z.ZodObject<{
+    boundedInfrastructure: z.ZodDefault<z.ZodBoolean>;
+    repairSelection: z.ZodDefault<z.ZodBoolean>;
+    taskExecutionLimitMs: z.ZodNumber;
+}, z.core.$strict>;
 export declare const TickmarkrConfigSchema: z.ZodObject<{
+    executionPolicy: z.ZodOptional<z.ZodObject<{
+        boundedInfrastructure: z.ZodDefault<z.ZodBoolean>;
+        repairSelection: z.ZodDefault<z.ZodBoolean>;
+        taskExecutionLimitMs: z.ZodNumber;
+    }, z.core.$strict>>;
     concurrency: z.ZodNumber;
     driver: z.ZodEnum<{
         auto: "auto";
@@ -364,24 +374,31 @@ export type FleetTierAssignment = {
 export type FleetEditable = {
     denyAdapters: string[];
     denyModels: string[];
+    denyWorkersAdapters?: string[];
+    denyWorkersModels?: string[];
+    allowOut?: string[];
     tiers: Record<string, Record<string, FleetTierAssignment | null>>;
     map: Record<string, MapEntry>;
     floors: Record<string, Tier>;
 };
 export declare function repoOverlayPath(repoRoot: string): string;
 export declare function readOverlayFile(path: string): Record<string, unknown>;
+/** A discovered fleet universe row: the served models of one adapter and, per model, the resolved
+ * identity doctor recorded for a floating alias (LEG2-T3 round 2 finding 3). */
+export type FleetUniverseRow = {
+    adapter: string;
+    models: string[];
+    identities?: Record<string, string>;
+};
+/** Does a deny/allow entry name this universe channel? Grammar A1 (adapter id, bare model id,
+ * adapter:model) plus the recorded identity (bare or adapter:identity) — the collector's authority. */
+export declare function universeEntryMatches(row: FleetUniverseRow, model: string, entry: string): boolean;
 /** Grammar A1 membership test: does any discovered universe row cover this deny/allow entry
  * (adapter id, bare model id, or adapter:model)? Uncovered entries name channels the probe
  * did not serve this session (failed auth, rate limit, retired sku) — they are NOT editable
  * membership state and must survive a membership write verbatim, never be re-derived away. */
-export declare function universeCovers(universe: {
-    adapter: string;
-    models: string[];
-}[], entry: string): boolean;
-export declare function fleetEditableFromConfig(cfg: TickmarkrConfig, universe?: {
-    adapter: string;
-    models: string[];
-}[]): FleetEditable;
+export declare function universeCovers(universe: FleetUniverseRow[], entry: string): boolean;
+export declare function fleetEditableFromConfig(cfg: TickmarkrConfig, universe?: FleetUniverseRow[]): FleetEditable;
 /** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
 export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
     globalDir?: string;

package/dist/config/config.js

@@ -264,7 +264,14 @@ const ShapeGateParticipationSchema = z
         });
     }
 });
+export const ExecutionPolicySchema = z.object({
+    boundedInfrastructure: z.boolean().default(false),
+    repairSelection: z.boolean().default(false),
+    taskExecutionLimitMs: z.number().int().positive(),
+}).strict();
 export const TickmarkrConfigSchema = z.object({
+    // Opt-in recovery experiment. The original run snapshot owns this across resumes.
+    executionPolicy: ExecutionPolicySchema.optional(),
     concurrency: z.number().int().positive(),
     driver: z.enum(["auto", "herdr", "subprocess", "orca"]),
     integrationBranchPrefix: z
@@ -887,6 +894,14 @@ export function readOverlayFile(path) {
         throw new ConfigError(`invalid overlay at ${path}`);
     return raw;
 }
+/** Does a deny/allow entry name this universe channel? Grammar A1 (adapter id, bare model id,
+ * adapter:model) plus the recorded identity (bare or adapter:identity) — the collector's authority. */
+export function universeEntryMatches(row, model, entry) {
+    if (entry === row.adapter || entry === model || entry === `${row.adapter}:${model}`)
+        return true;
+    const identity = row.identities?.[model];
+    return identity !== undefined && (entry === identity || entry === `${row.adapter}:${identity}`);
+}
 /** Grammar A1 membership test: does any discovered universe row cover this deny/allow entry
  * (adapter id, bare model id, or adapter:model)? Uncovered entries name channels the probe
  * did not serve this session (failed auth, rate limit, retired sku) — they are NOT editable
@@ -894,10 +909,13 @@ export function readOverlayFile(path) {
 export function universeCovers(universe, entry) {
     return universe.some((row) => entry === row.adapter || row.models.some((m) => entry === m || entry === `${row.adapter}:${m}`));
 }
-// v1.92 fleet membership: with a discovered `universe` (classified models only) the deny sets become
-// the EFFECTIVE out-of-fleet complement — anything routing.allow does not admit (fail-closed) UNION
-// routing.deny adapters/models scopes (never workers). Absent universe ⇒ deny arrays verbatim, so
-// non-UI callers stay byte-identical.
+// v1.92 fleet membership: with a discovered `universe` (classified models only) the routing.allow
+// complement (fail-closed) rides as `allowOut` — adapter ids and adapter:model keys — BESIDE the
+// authored routing.deny adapters/models entries, which ride VERBATIM in their own lists (never
+// workers). LEG2-T3 round 2 finding 2: authored entries are never collapsed into a membership key;
+// OBS-1046: nor is an allow exclusion folded into a deny list — the two reasons stay distinct so
+// one Space press clears one; finding 3: allow admission honours recorded identity.
+// Absent universe ⇒ deny arrays verbatim and no allowOut, so non-UI callers stay byte-identical.
 export function fleetEditableFromConfig(cfg, universe) {
     const tiers = {};
     for (const [adapter, entry] of Object.entries(cfg.tiers)) {
@@ -906,46 +924,36 @@ export function fleetEditableFromConfig(cfg, universe) {
             tiers[adapter][model] = { tier };
         }
     }
-    let denyAdapters = [...(cfg.routing.deny?.adapters ?? [])].sort();
-    let denyModels = [...(cfg.routing.deny?.models ?? [])].sort();
+    const denyAdapters = [...(cfg.routing.deny?.adapters ?? [])].sort();
+    const denyModels = [...(cfg.routing.deny?.models ?? [])].sort();
+    let allowOut;
     if (universe !== undefined) {
-        const { allow, deny } = cfg.routing;
-        // Grammar A1 (disallowedBy precedent): entries match adapter id, bare model id, or adapter:model.
-        // Inlined rather than imported — route/preference.ts imports this module.
-        const denyEntries = [...(deny?.adapters ?? []), ...(deny?.models ?? [])];
+        const { allow } = cfg.routing;
         const allowEntries = allow ? [...(allow.adapters ?? []), ...(allow.models ?? [])] : null;
-        const outOfFleet = (adapter, model) => {
-            const matches = (e) => e === adapter || e === model || e === `${adapter}:${model}`;
-            if (denyEntries.some(matches))
-                return true;
-            return allowEntries !== null && !allowEntries.some(matches);
-        };
+        const notAdmitted = (row, model) => allowEntries !== null && !allowEntries.some((entry) => universeEntryMatches(row, model, entry));
         const adaptersOut = [];
         const modelsOut = [];
         for (const row of universe) {
-            const out = row.models.filter((m) => outOfFleet(row.adapter, m));
-            if (row.models.length ? out.length === row.models.length : outOfFleet(row.adapter, "")) {
+            const out = row.models.filter((m) => notAdmitted(row, m));
+            if (row.models.length ? out.length === row.models.length : notAdmitted(row, "")) {
                 adaptersOut.push(row.adapter);
             }
             else {
                 modelsOut.push(...out.map((m) => `${row.adapter}:${m}`));
             }
         }
-        // OBS-517: deny entries the probe universe does not cover (failed/rate-limited probes drop the
-        // channel from discoverChannels) are preserved VERBATIM — deriving membership purely from the
-        // universe silently un-denied them on the next write (fail-open on the operator's own ban list).
-        denyAdapters = [...new Set([
-                ...adaptersOut,
-                ...(deny?.adapters ?? []).filter((e) => !universeCovers(universe, e)),
-            ])].sort();
-        denyModels = [...new Set([
-                ...modelsOut,
-                ...(deny?.models ?? []).filter((e) => !universeCovers(universe, e)),
-            ])].sort();
+        // OBS-517: authored deny entries — covered by the probe universe or not — ride verbatim (above),
+        // so a transient probe failure can never un-deny one on the next write (fail-open on the ban list).
+        allowOut = [...new Set([...adaptersOut, ...modelsOut])].sort();
     }
     return {
         denyAdapters,
         denyModels,
+        ...(allowOut !== undefined ? { allowOut } : {}),
+        // OBS-994: workers-only deny is never folded into the all-seats complement above — it is
+        // returned verbatim beside the flat scopes so the fleet browser can show and toggle it.
+        denyWorkersAdapters: [...(cfg.routing.deny?.workers?.adapters ?? [])].sort(),
+        denyWorkersModels: [...(cfg.routing.deny?.workers?.models ?? [])].sort(),
         tiers,
         map: structuredClone(cfg.routing.map),
         floors: { ...cfg.routing.floors },
@@ -988,6 +996,10 @@ export function formatFleetPrint(repoRoot, opts = {}) {
         annotate(["routing", "deny", "adapters"]);
     if (effective.routing.deny?.models !== undefined)
         annotate(["routing", "deny", "models"]);
+    if (effective.routing.deny?.workers?.adapters !== undefined)
+        annotate(["routing", "deny", "workers", "adapters"]);
+    if (effective.routing.deny?.workers?.models !== undefined)
+        annotate(["routing", "deny", "workers", "models"]);
     for (const shape of Object.keys(effective.routing.map))
         annotate(["routing", "map", shape]);
     annotate(["routing", "floors"]);

package/dist/config/fleet-overlay.d.ts

@@ -1,4 +1,4 @@
-import { type FleetEditable, type RoutingMode } from "./config.js";
+import { type FleetEditable, type FleetUniverseRow, type RoutingMode } from "./config.js";
 /** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
 export declare const FLEET_OVERLAY_KEYS: readonly ["routing", "tiers"];
 export type FleetOverlayWrite = {
@@ -19,10 +19,7 @@ export type FleetOverlayWrite = {
             consult?: string[];
         };
     };
-    universe?: {
-        adapter: string;
-        models: string[];
-    }[];
+    universe?: FleetUniverseRow[];
 };
 export type FleetFirstTouch = {
     vendor: string;
@@ -33,10 +30,7 @@ export declare function fleetFirstTouchProvenance(note: string, firstTouch: Flee
  * keys, ordering, scalar style, and comments; fresh provenance is written directly on its tier node. */
 export declare function renderFleetOverlayWrite(priorBytes: string, write: FleetOverlayWrite): string;
 /** Build the repo overlay fragment fleet would write for edits since session start. */
-export declare function fleetRepoOverlayFromDelta(initial: FleetEditable, edited: FleetEditable, existingRepo?: Record<string, unknown>, firstTouches?: Readonly<Record<string, FleetFirstTouch>>, universe?: {
-    adapter: string;
-    models: string[];
-}[]): Record<string, unknown>;
+export declare function fleetRepoOverlayFromDelta(initial: FleetEditable, edited: FleetEditable, existingRepo?: Record<string, unknown>, firstTouches?: Readonly<Record<string, FleetFirstTouch>>, universe?: FleetUniverseRow[]): Record<string, unknown>;
 export declare function repoOverlayYaml(overlay: Record<string, unknown>): string;
 export declare function serializeFleetOverlay(overlay: Record<string, unknown>): string;
 export declare function unifiedYamlDiff(before: string, after: string, label?: string): string;