tickmarkr 2.5.5 → 2.5.6

package/dist/run/lease.js

@@ -1,5 +1,9 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { closeSync, constants, fstatSync, linkSync, mkdirSync, openSync, readFileSync, readdirSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, resolve } from "node:path";
 // The process census and command admission deliberately use the same command-head classifier.
 export function isRunnerCommand(command) {
     // Inspect executable positions only: inference prompts and shell script bodies may name runners.
@@ -17,9 +21,11 @@ export function isRunnerCommand(command) {
     const flags = "(?:\\s+(?:--?[\\w-]+(?:=[^\\s]+)?|--))*";
     const manager = `${binary}(?:npm|pnpm|yarn|bun)${flags}`;
     const jsRunner = `${binary}(?:vitest(?:\\.mjs)?|jest|mocha)(?:\\s|$)`;
-    // Test scripts may be scoped (test:unit); runner binaries may be launched through a manager.
-    // Keep each match anchored to that executable position so prompt/argument mentions stay out.
-    return new RegExp(`^${manager}\\s+(?:run${flags}\\s+)?test[\\w:.-]*(?:\\s|$)`, "i").test(head)
+    // Test scripts may be scoped (test:unit, test.integration); runner binaries may be launched
+    // through a manager. Keep each match anchored to that executable position so prompt/argument
+    // mentions stay out. OBS-1045: the scope is `test` followed by a `:` or `.` separator — the npm
+    // scoping convention — so a differently named script such as `test-lint` is never leased.
+    return new RegExp(`^${manager}\\s+(?:run${flags}\\s+)?test(?:[:.][\\w.-]+)?(?:\\s|$)`, "i").test(head)
         || new RegExp(`^${manager}\\s+(?:(?:exec|x|dlx)${flags}\\s+)?${jsRunner}`, "i").test(head)
         || new RegExp(`^${binary}npx${flags}\\s+${jsRunner}`, "i").test(head)
         || /^(?:\S*\/)?(?:go|make|cargo)\s+test(?:\s|$)/i.test(head)
@@ -85,3 +91,220 @@ export class CommandLeases {
         }
     }
 }
+const LEASE_FILE = "tickmarkr-runner.lease";
+export async function repositoryLeasePath(cwd) {
+    const commonDir = await new Promise((ok, fail) => execFile("git", ["rev-parse", "--git-common-dir"], { cwd, encoding: "utf8" }, (error, stdout) => error ? fail(error) : ok(stdout.trim())));
+    return join(resolve(cwd, commonDir), LEASE_FILE);
+}
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+};
+const isCode = (error, code) => error.code === code;
+/** OBS-1057: dev+ino alone is not an identity across unlink/recreate — Linux hands the freed inode
+ * number straight to the next file, so a stale observation of a dead or corrupt reservation matched
+ * the fresh reservation that replaced it and reclaimDead removed the live winner (public CI, ubuntu).
+ * The bytes are the generation: a fragment never hashes like a complete record, and two complete
+ * records differ by token. Size and mtime are not enough (a same-length reservation written within
+ * the filesystem's timestamp resolution — Leg-2 review of the first cut). */
+export const inodeIdentity = (st, bytes) => `${st.dev}-${st.ino}-${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}`;
+/** The identity a reclaimer would observe at a path right now, or undefined when nothing is there. */
+export const observeIdentity = (path) => readOccupant(path)?.identity;
+const readOccupant = (path) => {
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const st = fstatSync(fd);
+        const bytes = readFileSync(fd, "utf8");
+        const identity = inodeIdentity(st, bytes);
+        try {
+            const holder = JSON.parse(bytes);
+            if (typeof holder.pid === "number" && typeof holder.cwd === "string" && typeof holder.token === "string")
+                return { holder, identity };
+        }
+        catch { /* incomplete/foreign bytes are reclaimable under the mutation lock */ }
+        return { holder: undefined, identity };
+    }
+    catch (error) {
+        if (isCode(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+};
+export const readHolder = (path) => readOccupant(path)?.holder;
+/** Crash-recoverable serialization for lease-path mutations. The highest atomic owner-generation
+ * symlink is authoritative. A process killed in the critical section leaves its pid behind, so one
+ * contender can exclusively publish the next generation and finish the interrupted operation. */
+const mutationLock = (path) => `${path}.lock`;
+const lockGeneration = (entry) => {
+    const match = /^owner\.(\d+)$/.exec(entry);
+    return match ? Number(match[1]) : undefined;
+};
+const mutationHolder = (lock) => {
+    let names;
+    try {
+        names = readdirSync(lock);
+    }
+    catch (error) {
+        if (isCode(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+    const current = names.flatMap((entry) => {
+        const gen = lockGeneration(entry);
+        return gen === undefined ? [] : [{ entry, gen }];
+    }).sort((a, b) => b.gen - a.gen)[0];
+    if (!current)
+        return undefined;
+    try {
+        const target = readlinkSync(join(lock, current.entry));
+        const pid = Number(/^([1-9]\d*):/.exec(target)?.[1]);
+        return Number.isInteger(pid) && pid > 0 ? { ...current, target, pid } : { ...current, target };
+    }
+    catch {
+        return current;
+    }
+};
+const releaseMutationLock = (lock, entry, target, inherited) => {
+    const holder = mutationHolder(lock);
+    if (holder?.entry !== entry || holder.target !== target)
+        return;
+    // Remove our marker last. A successor published after that point is never in this snapshot.
+    for (const name of [...inherited, entry]) {
+        try {
+            unlinkSync(join(lock, name));
+        }
+        catch (error) {
+            if (!isCode(error, "ENOENT"))
+                return;
+        }
+    }
+    try {
+        rmdirSync(lock);
+    }
+    catch { /* ENOTEMPTY: a successor owns the directory */ }
+};
+const withMutationLock = async (path, pollMs, signal, run) => {
+    const lock = mutationLock(path);
+    const target = `${process.pid}:${randomUUID()}`;
+    let entry = "";
+    let inherited = [];
+    for (;;) {
+        signal?.throwIfAborted();
+        try {
+            mkdirSync(lock);
+        }
+        catch (error) {
+            if (!isCode(error, "EEXIST"))
+                throw error;
+        }
+        const holder = mutationHolder(lock);
+        if (holder?.pid !== undefined && alive(holder.pid)) {
+            await new Promise((wake) => setTimeout(wake, pollMs));
+            continue;
+        }
+        entry = `owner.${(holder?.gen ?? -1) + 1}`;
+        try {
+            symlinkSync(target, join(lock, entry));
+            inherited = readdirSync(lock).filter((name) => name !== entry && lockGeneration(name) !== undefined);
+            break;
+        }
+        catch (error) {
+            if (!isCode(error, "EEXIST") && !isCode(error, "ENOENT"))
+                throw error;
+        }
+    }
+    try {
+        return await run();
+    }
+    finally {
+        releaseMutationLock(lock, entry, target, inherited);
+    }
+};
+/** Publish `mine` at `path` atomically: the record is written whole to a private file and linked
+ * into place — `link` is exclusive (EEXIST when the path is taken) and a reader never sees a partial
+ * record, so a process killed at any point of its acquisition leaves either nothing or a complete
+ * record naming a pid a waiter can check. Returns false when the path is taken. */
+export function tryReserve(path, mine) {
+    const draft = `${path}.${mine.token}.draft`;
+    writeFileSync(draft, JSON.stringify(mine) + "\n");
+    try {
+        linkSync(draft, path);
+        return true;
+    }
+    catch (error) {
+        if (isCode(error, "EEXIST"))
+            return false;
+        throw error;
+    }
+    finally {
+        rmSync(draft, { force: true });
+    }
+}
+/** Link the inspected dead inode to its stable tombstone, then remove the canonical name. This runs
+ * only under the mutation lock. EEXIST means an earlier reclaimer died after link: recovery finishes
+ * only if both names still bind that exact inode, never a replacement holder. */
+const reclaimDeadLocked = (path, identity) => {
+    const tombstone = `${path}.dead-${identity}`;
+    try {
+        linkSync(path, tombstone);
+    }
+    catch (error) {
+        if (!isCode(error, "EEXIST") && !isCode(error, "ENOENT"))
+            throw error;
+    }
+    const dead = readOccupant(tombstone);
+    const current = readOccupant(path);
+    if (dead?.identity !== identity || current?.identity !== identity)
+        return false;
+    unlinkSync(path);
+    return true;
+};
+/** Exposed for recovery regressions; the standalone verify uses the combined critical section. */
+export const reclaimDead = async (path, identity, pollMs = 10) => withMutationLock(path, pollMs, undefined, () => reclaimDeadLocked(path, identity));
+const inspectAndReserve = (path, mine) => {
+    let occupant = readOccupant(path);
+    if (occupant && (!occupant.holder || !alive(occupant.holder.pid))) {
+        reclaimDeadLocked(path, occupant.identity);
+        occupant = readOccupant(path);
+    }
+    if (!occupant && tryReserve(path, mine))
+        return { acquired: true };
+    return { acquired: false, holder: occupant?.holder };
+};
+export async function withRepositoryLease(cwd, run, opts = {}) {
+    const path = await repositoryLeasePath(cwd);
+    const pollMs = opts.pollMs ?? 1_000;
+    const mine = { pid: process.pid, cwd, at: Date.now(), token: randomUUID() };
+    let waitingOn;
+    for (;;) {
+        opts.signal?.throwIfAborted();
+        const attempt = await withMutationLock(path, pollMs, opts.signal, () => inspectAndReserve(path, mine));
+        if (attempt.acquired)
+            break;
+        if (attempt.holder && attempt.holder.pid !== waitingOn) {
+            waitingOn = attempt.holder.pid;
+            opts.onWait?.(attempt.holder);
+        }
+        await new Promise((wake) => setTimeout(wake, pollMs));
+    }
+    try {
+        return await run();
+    }
+    finally {
+        // Release is serialized with reclamation/acquisition and removes only this generation.
+        await withMutationLock(path, pollMs, undefined, () => {
+            if (readHolder(path)?.token === mine.token)
+                unlinkSync(path);
+        });
+    }
+}

package/dist/run/recovery.d.ts

@@ -0,0 +1,8 @@
+import type { GateResult } from "../gates/types.js";
+import type { JournalEvent } from "./journal.js";
+export type FailureDisposition = "infrastructure" | "behavioral" | "unknown";
+export type VerificationRetryCause = "infrastructure" | "host-starved";
+/** Structured verifier evidence wins; neither an exit code nor prose proves infrastructure. */
+export declare function failureDisposition(result: Pick<GateResult, "pass" | "meta">): FailureDisposition;
+/** Reserve before re-execution. Interrupted reservations and new subjects never refill the task cap. */
+export declare function reserveInfrastructureRetry(events: readonly JournalEvent[], taskId: string, subject: string, append: (event: string, taskId: string, data: Record<string, unknown>) => void, cause?: VerificationRetryCause): boolean;

package/dist/run/recovery.js

@@ -0,0 +1,25 @@
+/** Structured verifier evidence wins; neither an exit code nor prose proves infrastructure. */
+export function failureDisposition(result) {
+    if (result.pass)
+        return "unknown";
+    if (result.meta?.classification === "regression")
+        return "behavioral";
+    if (result.meta?.infra === true && result.meta?.classification === "infra")
+        return "infrastructure";
+    return "unknown";
+}
+/** Reserve before re-execution. Interrupted reservations and new subjects never refill the task cap. */
+export function reserveInfrastructureRetry(events, taskId, subject, append, cause = "infrastructure") {
+    const used = events.filter((e) => e.taskId === taskId && e.event === "infra-retry-reserved");
+    const malformed = used.some((e) => typeof e.data.subject !== "string" || !e.data.subject
+        || (e.data.cause !== "infrastructure" && e.data.cause !== "host-starved"));
+    const reason = !subject ? "unknown-subject" : malformed ? "invalid-accounting"
+        : used.some((e) => e.data.subject === subject) ? "subject-allowance-exhausted"
+            : used.length >= 2 ? "task-allowance-exhausted" : undefined;
+    if (reason) {
+        append("infra-retry-denied", taskId, { subject, cause, reason, consumed: used.length });
+        return false;
+    }
+    append("infra-retry-reserved", taskId, { subject, cause, consumed: used.length + 1 });
+    return true;
+}

package/dist/run/repair-selection.d.ts

@@ -0,0 +1,12 @@
+import type { JournalEvent } from "./journal.js";
+export interface RepairSelectionDecision {
+    selectTests: boolean;
+    requiredFiles: string[];
+    reason: "no-test-failure" | "known-failing-files" | "legacy-test-failure" | "unattributed-test-failure" | "full-suite-failure";
+}
+type SelectionEvent = Pick<JournalEvent, "event" | "taskId" | "data">;
+/** Diagnostic selection only: neither a narrow pass nor this decision can authorize integration.
+ * Distrust and known failing files survive later green results, approvals and resume. A historical
+ * ambiguous failure is never reinterpreted using a newly enabled policy. */
+export declare function repairSelectionDecision(events: readonly SelectionEvent[], taskId: string, enabled: boolean): RepairSelectionDecision;
+export {};

package/dist/run/repair-selection.js

@@ -0,0 +1,56 @@
+/** These are literal repository-relative identities. Existence and selection support are checked
+ * against the current worktree by the gate; this journal fold cannot establish either. */
+function fileIdentities(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.some((file) => typeof file !== "string" || !file || /[\\\x00-\x1f\x7f]/.test(file)
+        || /^[A-Za-z]:/.test(file) || file.split("/").some((part) => !part || part === "." || part === ".."))) {
+        return undefined;
+    }
+    return [...new Set(value)].sort();
+}
+/** Diagnostic selection only: neither a narrow pass nor this decision can authorize integration.
+ * Distrust and known failing files survive later green results, approvals and resume. A historical
+ * ambiguous failure is never reinterpreted using a newly enabled policy. */
+export function repairSelectionDecision(events, taskId, enabled) {
+    const required = new Set();
+    let distrust;
+    for (const event of events) {
+        if (event.taskId !== taskId || event.event !== "gate-result"
+            || event.data.gate !== "test" || event.data.pass !== false)
+            continue;
+        const data = event.data;
+        if (!enabled) {
+            distrust ??= "legacy-test-failure";
+            continue;
+        }
+        // Only the recorded closed disposition can exempt infrastructure. Contradictory structured
+        // failure evidence cannot turn a behavioral failure into a harmless infrastructure event.
+        if (data.disposition === "infrastructure" && data.classification !== "regression"
+            && (data.failingFiles === undefined || (Array.isArray(data.failingFiles) && data.failingFiles.length === 0)))
+            continue;
+        if (data.disposition !== "behavioral" || typeof data.commit !== "string"
+            || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(data.commit)) {
+            distrust ??= "unattributed-test-failure";
+            continue;
+        }
+        // A replacement full-suite failure follows a passing screen in the current pipeline. No
+        // ordinary full-suite failure establishes that a selector safely covers the failed behavior.
+        if (data.fullSuite === true) {
+            distrust ??= "full-suite-failure";
+            continue;
+        }
+        const selected = fileIdentities(data.selectedTests);
+        const failing = fileIdentities(data.failingFiles);
+        if (!selected || !failing || failing.some((file) => !selected.includes(file))
+            || (data.fullSuite !== undefined && data.fullSuite !== false)) {
+            distrust ??= "unattributed-test-failure";
+            continue;
+        }
+        for (const file of failing)
+            required.add(file);
+    }
+    return {
+        selectTests: distrust === undefined,
+        requiredFiles: [...required].sort(),
+        reason: distrust ?? (required.size ? "known-failing-files" : "no-test-failure"),
+    };
+}

package/dist/run/stall.d.ts

@@ -10,6 +10,10 @@ export declare function harvestCpuFlatWindowMs(resolutionMs: number): number;
 /** Test seam — pin the quantization-aware flat window without changing production policy. */
 export declare function setHarvestCpuFlatMsForTests(ms: number): void;
 export declare function resetHarvestCpuFlatMsForTests(): void;
+/** The dispatch shell records its foreground group in an attempt-unique artifact. */
+export declare function readOwnedProcessGroup(path: string): number | undefined;
+/** Never infer ownership from a task name or scan another attempt's marker when reaping. */
+export declare function reapOwnedProcessGroup(group: number | undefined, cwd: string): Promise<number[] | null>;
 export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
     ms: number;
     resolutionMs: number;
@@ -17,6 +21,7 @@ export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
 export declare class WorkerTreeCpuAccountant {
     private marker;
     private cwd;
+    private group?;
     private active;
     private loop;
     private live;
@@ -24,7 +29,7 @@ export declare class WorkerTreeCpuAccountant {
     private gaps;
     private consecutiveGaps;
     private latest;
-    constructor(marker: string, cwd: string);
+    constructor(marker: string, cwd: string, group?: (() => number | undefined) | undefined);
     private sample;
     start(): Promise<void>;
     read(): {

package/dist/run/stall.js

@@ -52,6 +52,51 @@ function parsePsCpu(raw) {
         + Math.round(Number(m[4]) * 1000);
     return { ms, frac: m[4].includes(".") };
 }
+/** The dispatch shell records its foreground group in an attempt-unique artifact. */
+export function readOwnedProcessGroup(path) {
+    try {
+        const raw = readFileSync(path, "utf8").trim();
+        const group = /^\d+$/.test(raw) ? Number(raw) : 0;
+        return Number.isSafeInteger(group) && group > 1 ? group : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Never infer ownership from a task name or scan another attempt's marker when reaping. */
+export async function reapOwnedProcessGroup(group, cwd) {
+    if (group === undefined)
+        return null;
+    const own = await shGit(`ps -o pgid= -p ${process.pid}`, cwd, 5_000);
+    // An in-process driver fixture (or a non-isolating host) can share the daemon's
+    // group. It is not an owned worker group: let the driver's close retire that slot.
+    if (own.code !== 0 || !/^\d+$/.test(own.stdout.trim()) || Number(own.stdout.trim()) === group)
+        return null;
+    try {
+        process.kill(-group, "SIGKILL");
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+    let survivors = [];
+    // SIGKILL delivery and process retirement are asynchronous. Bound the confirmation
+    // grace, retaining names if a process is still present after it.
+    for (let probe = 0; probe < 5; probe++) {
+        const snapshot = await shGit("ps -Awwo pid=,pgid=,stat=", cwd, 5_000);
+        if (snapshot.code !== 0)
+            return null;
+        survivors = snapshot.stdout.split("\n").flatMap((line) => {
+            const row = /^\s*(\d+)\s+(\d+)\s+(\S+)/.exec(line);
+            return row && Number(row[2]) === group && !row[3].startsWith("Z") ? [Number(row[1])] : [];
+        });
+        if (survivors.length === 0)
+            break;
+        if (probe < 4)
+            await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return survivors;
+}
 let linuxClockTickMs;
 function linuxProcessCpuMs(pid, cwd) {
     if (!existsSync("/proc/self/stat"))
@@ -81,7 +126,7 @@ function linuxProcessCpuMs(pid, cwd) {
 // Every non-seeded worker process descends from its attempt-unique dispatch script. One ps snapshot
 // finds that root and its descendants. An empty tree is measurable zero; a failed or unparseable
 // snapshot is undefined because missing evidence can never prove inactivity.
-async function workerTreeCpuSnapshot(marker, cwd) {
+async function workerTreeCpuSnapshot(marker, cwd, group) {
     const snapshot = await shGit("ps -Awwo pid=,ppid=,time=,command=", cwd, 15_000);
     if (snapshot.code !== 0)
         return undefined;
@@ -97,6 +142,16 @@ async function workerTreeCpuSnapshot(marker, cwd) {
     if (rows.length === 0)
         return undefined;
     const tree = new Set(rows.filter((p) => p.cmd.includes(marker)).map((p) => p.pid));
+    if (group !== undefined) {
+        const groups = await shGit("ps -Awwo pid=,pgid=", cwd, 15_000);
+        if (groups.code !== 0)
+            return undefined;
+        for (const line of groups.stdout.split("\n")) {
+            const row = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+            if (row && Number(row[2]) === group)
+                tree.add(row[1]);
+        }
+    }
     // ps output is not topologically ordered; relax the parent -> child closure until stable.
     for (let grew = true; grew;) {
         grew = false;
@@ -141,6 +196,7 @@ export async function workerTreeCpuMs(marker, cwd) {
 export class WorkerTreeCpuAccountant {
     marker;
     cwd;
+    group;
     active = false;
     loop;
     live = new Map();
@@ -148,12 +204,13 @@ export class WorkerTreeCpuAccountant {
     gaps = 0;
     consecutiveGaps = 0;
     latest;
-    constructor(marker, cwd) {
+    constructor(marker, cwd, group) {
         this.marker = marker;
         this.cwd = cwd;
+        this.group = group;
     }
     async sample() {
-        const snapshot = await workerTreeCpuSnapshot(this.marker, this.cwd);
+        const snapshot = await workerTreeCpuSnapshot(this.marker, this.cwd, this.group?.());
         if (snapshot === undefined) {
             this.gaps++;
             this.live.clear();

package/dist/tui/ink/fleet-app.d.ts

@@ -5,6 +5,8 @@ export type FleetSteeringKey = "review" | "consult";
 export type FleetEditorState = {
     denyAdapters: string[];
     denyModels: string[];
+    /** OBS-1046: the staged routing.allow complement, distinct from the authored deny lists above */
+    allowOut?: string[];
     denyWorkersAdapters: string[];
     denyWorkersModels: string[];
     classifications: FleetClassification[];
@@ -67,6 +69,8 @@ export type FleetStagedDeny = {
     models: string[];
     workersAdapters: string[];
     workersModels: string[];
+    /** OBS-1046: the staged routing.allow complement; absent ⇒ the session's initial one */
+    allowOut?: string[];
 };
 export type FleetModelGroup = {
     adapter: string;
@@ -119,11 +123,13 @@ export type FleetStagedRouting = {
     ok: false;
     error: string;
 };
-export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, initialDenyWorkersAdapters, initialDenyWorkersModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, }: {
+export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, initialAllowOut, initialDenyWorkersAdapters, initialDenyWorkersModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, viewRows, frameColumns, frameRows, }: {
     ageMs: number | null;
     agents: AgentCli[];
     initialDenyAdapters: string[];
     initialDenyModels: string[];
+    /** OBS-1046: adapter ids and adapter:model keys routing.allow leaves out of the fleet */
+    initialAllowOut?: string[];
     initialDenyWorkersAdapters?: string[];
     initialDenyWorkersModels?: string[];
     modelGroups: FleetModelGroup[];
@@ -157,12 +163,14 @@ export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDe
     /** terminal height — set only on a real TTY so the footer sticks to the bottom */
     frameRows?: number;
 }): import("react").JSX.Element;
-export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, initialDenyWorkersAdapters, initialDenyWorkersModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, initialInput, input, output, debug, }: {
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, initialAllowOut, initialDenyWorkersAdapters, initialDenyWorkersModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, stagedRouting, entry, initialJudge, judgeSeats, initialInput, input, output, debug, }: {
     ageMs: number | null;
     adapters: WorkerAdapter[];
     health: Record<string, AuthHealth>;
     initialDenyAdapters: string[];
     initialDenyModels: string[];
+    /** OBS-1046: adapter ids and adapter:model keys routing.allow leaves out of the fleet */
+    initialAllowOut?: string[];
     initialDenyWorkersAdapters?: string[];
     initialDenyWorkersModels?: string[];
     modelGroups: FleetModelGroup[];