tickmarkr 2.2.1 → 2.4.0

package/dist/run/git.d.ts

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
 export declare const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export declare const SUITE_PARENT_ENV = "TICKMARKR_SUITE_PARENT";
 export declare const DEFAULT_FORK_CAP = "6";
 /**
  * OBS-618: how many PROCESSES one vitest fork can hold at its peak — the fork, a daemon it spawns,
@@ -89,6 +90,8 @@ export interface ShResult {
     stdout: string;
     stderr: string;
     timedOut?: boolean;
+    /** The shell exited, but descendants still held its process group and pipes past the grace. */
+    reapedGroup?: boolean;
     durationMs?: number;
     /** T7: the capacity THIS child ran under, stamped where its environment was built (see `shell`). */
     capacity?: RunCapacity;

package/dist/run/git.js

@@ -13,6 +13,7 @@ export { ROUTING_ENV_SEAMS };
 // Default to a modest cap through the environment so vitest honors it natively; never pass it
 // as argv (OBS-55) so child test oracles stay intact. The operator's own export wins.
 export const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export const SUITE_PARENT_ENV = "TICKMARKR_SUITE_PARENT";
 export const DEFAULT_FORK_CAP = "6";
 /**
  * The fork budget belongs to ONE run: how many gate suites can be in flight at once is exactly that
@@ -137,6 +138,9 @@ export const resetSpawnForTests = () => { spawnChild = undefined; };
 const RETRYABLE_SPAWN_CODE = "EAGAIN";
 export const SPAWN_ATTEMPT_LIMIT = 4;
 export const SPAWN_RETRY_BACKOFF_MS = 50;
+// RULING-P99-28: SHIP — every gate user can hit the inherited-pipe hang at this product seam.
+/** Give a normally-exited shell's descendants this long to close their inherited pipes themselves. */
+const SHELL_REAP_GRACE_MS = 2000;
 // stdin "ignore": same class as HARD-05 / SubprocessDriver — never leave an open pipe a child can block on
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 function shell(cmd, cwd, timeoutMs, login) {
@@ -150,6 +154,9 @@ function shell(cmd, cwd, timeoutMs, login) {
     // OBS-110: apply the run's own fork cap only when the operator has not already set one.
     if (!(FORK_CAP_ENV in env))
         env[FORK_CAP_ENV] = resolvedForkCap();
+    // OBS-854: descendants can leave the checkout (nested fixture suites do), so cwd alone cannot
+    // attribute them. Every daemon shell exports the daemon pid as their durable parentage marker.
+    env[SUITE_PARENT_ENV] = String(process.pid);
     // T7: the capacity every result of this shell carries, read HERE — off the environment the child
     // is about to receive, after the precedence above has settled. An operator export is already in
     // `env`, so what gets recorded is the operator's number, which is the case a release was re-taken
@@ -166,15 +173,25 @@ function shell(cmd, cwd, timeoutMs, login) {
         let stdout = "", stderr = "";
         const stdoutDecoder = new StringDecoder("utf8");
         const stderrDecoder = new StringDecoder("utf8");
-        let timedOut = false, done = false, started = false, outputSeen = false;
+        let timedOut = false, reapedGroup = false, done = false, started = false, outputSeen = false;
+        let reapTimer;
         const finish = (code, err) => {
             if (done)
                 return;
             done = true;
             clearTimeout(timer);
+            clearTimeout(reapTimer);
             stdout += stdoutDecoder.end();
             stderr += stderrDecoder.end();
-            resolve({ code, stdout, stderr: err ?? stderr, timedOut, durationMs: Date.now() - startedAt, capacity });
+            resolve({
+                code,
+                stdout,
+                stderr: err ?? stderr,
+                timedOut,
+                durationMs: Date.now() - startedAt,
+                capacity,
+                ...(reapedGroup ? { reapedGroup: true } : {}),
+            });
         };
         const timer = setTimeout(() => {
             timedOut = true;
@@ -211,9 +228,27 @@ function shell(cmd, cwd, timeoutMs, login) {
             finish(127, String(e));
         });
         p.on("close", (code) => finish(code ?? 1));
-        // "close" waits for stdio to drain; a surviving pipe-holder must not outlive the timeout
-        p.on("exit", (code) => { if (timedOut)
-            finish(code ?? 1); });
+        // "close" waits for stdio to drain. Once bash exits normally, give descendants a bounded grace
+        // to exit with it; a survivor still in bash's detached group is then reaped so its inherited pipe
+        // cannot hold this promise until the command ceiling. A real timeout wins first and is never
+        // reclassified as a grace reap.
+        p.on("exit", (code) => {
+            if (timedOut) {
+                finish(code ?? 1);
+                return;
+            }
+            reapTimer = setTimeout(() => {
+                if (done)
+                    return;
+                try {
+                    process.kill(-p.pid, "SIGKILL");
+                    reapedGroup = true;
+                }
+                catch {
+                    // The group closed between the shell's exit and the grace boundary; "close" owns finish.
+                }
+            }, SHELL_REAP_GRACE_MS);
+        });
     });
     return (async () => {
         const startedAt = Date.now();

package/dist/run/journal.d.ts

@@ -116,8 +116,21 @@ export declare function formatPriorFindingEvidence(evidence: PriorFindingEvidenc
 export declare function normalizeGateFailure(details: string): string;
 export declare const GATE_FINGERPRINT_CAP = 2;
 export declare function identicalGateFailures(events: JournalEvent[], taskId: string, gate: string, normalized: string): number;
-/** Repair attempts this engagement has already funded — journal-derived, so a resume inherits it. */
+/** What each funded repair's next battery actually reached. A repair spends its budget only
+ * when that battery reaches one of the gates it was funded to fix; an earlier red is evidence that
+ * this repair never got its funded turn, not a charge against the repair ladder. */
+export interface RepairReach {
+    repair: number;
+    funded: string[];
+    reached: string[];
+    diedAt?: string;
+    charged: boolean;
+}
+export declare function repairReachSinceApproval(events: JournalEvent[], taskId: string): RepairReach[];
+/** Repair slots actually spent this engagement — journal-derived, so a resume inherits it. */
 export declare function repairsSinceApproval(events: JournalEvent[], taskId: string): number;
+/** Recheck releases not yet enacted by a battery (or by a legacy worker launch). */
+export declare function pendingRechecks(events: JournalEvent[]): Set<string>;
 /**
  * Why the last attempt failed, one row per journaled cause, in the daemon's own `source: details`
  * shape. The daemon builds that brief in a loop-local variable, which dies with the process: a resumed
@@ -242,9 +255,9 @@ export declare const TelemetryRowSchema: z.ZodObject<{
     quotaFailover: z.ZodOptional<z.ZodLiteral<true>>;
     overrun: z.ZodOptional<z.ZodLiteral<true>>;
     retryMode: z.ZodOptional<z.ZodEnum<{
+        repair: "repair";
         resume: "resume";
         fresh: "fresh";
-        repair: "repair";
     }>>;
     signalQuality: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<0.75>, z.ZodLiteral<1>]>>;
     signalBasis: z.ZodOptional<z.ZodEnum<{

package/dist/run/journal.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 import { channelKey, shq, TokenUsageSchema } from "../adapters/types.js";
 import { stateDirName, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
 import { GATE_NAMES, TIERS } from "../graph/schema.js";
+import { channelRouteIdentity } from "../route/preference.js";
 import { buildProfile, classify } from "../route/profile.js";
 import { DecisionEventSchema, trackJournalRows, } from "./protocol.js";
 import { normalizeGateOutcome } from "./outcome.js";
@@ -72,8 +73,8 @@ export const REVIEW_UPHELD_RELEASE = "review-upheld";
 // OBS-203: the third decision a gate-fail park needs. Plain approve WAIVES the failed gate (and every
 // gate before it — daemon.ts remainingGates), which is wrong when the gate failed against a stale task
 // DECLARATION rather than a bad diff: amend the spec's files[], recompile, and the gate now passes
-// honestly. This release re-dispatches with the whole gate suite intact and no gate marked satisfied,
-// so the corrected declaration is the thing that earns the green. Budget semantics match attempt-cap
+// honestly. This release runs the whole gate suite over the parked commit before any worker and
+// marks no gate satisfied: green merges directly, red returns to the ladder. Budget semantics match attempt-cap
 // (fresh attempts, tried survives) because the park cost the task its remaining budget.
 export const RECHECK_RELEASE = "recheck";
 // OBS-738: one authority for every recovery surface. The ref is accepted only from the row that
@@ -547,18 +548,65 @@ export function identicalGateFailures(events, taskId, gate, normalized) {
     }
     return n;
 }
-/** Repair attempts this engagement has already funded — journal-derived, so a resume inherits it. */
-export function repairsSinceApproval(events, taskId) {
-    let n = 0;
+export function repairReachSinceApproval(events, taskId) {
+    const repairs = [];
     for (const e of events) {
         if (e.taskId !== taskId)
             continue;
-        if (e.event === "task-approved")
-            n = 0;
-        else if (e.event === "repair-attempt")
-            n++;
+        if (e.event === "task-approved") {
+            repairs.length = 0;
+        }
+        else if (e.event === "repair-attempt") {
+            const funded = Array.isArray(e.data.gates)
+                ? e.data.gates.filter((gate) => typeof gate === "string")
+                : [];
+            repairs.push({
+                repair: typeof e.data.repair === "number" ? e.data.repair : repairs.length + 1,
+                funded,
+                reached: [],
+                charged: false,
+                launched: false,
+                closed: false,
+            });
+        }
+        else {
+            const repair = repairs.at(-1);
+            if (!repair || repair.closed)
+                continue;
+            if (e.event === "worker-launch") {
+                if (repair.launched)
+                    repair.closed = true;
+                else
+                    repair.launched = true;
+            }
+            else if (repair.launched && e.event === "gate-result" && typeof e.data.gate === "string") {
+                if (!repair.reached.includes(e.data.gate))
+                    repair.reached.push(e.data.gate);
+                if (e.data.pass === false && repair.diedAt === undefined)
+                    repair.diedAt = e.data.gate;
+                if (repair.funded.includes(e.data.gate))
+                    repair.charged = true;
+            }
+        }
     }
-    return n;
+    return repairs.map(({ launched: _launched, closed: _closed, ...repair }) => repair);
+}
+/** Repair slots actually spent this engagement — journal-derived, so a resume inherits it. */
+export function repairsSinceApproval(events, taskId) {
+    return repairReachSinceApproval(events, taskId).filter((repair) => repair.charged).length;
+}
+/** Recheck releases not yet enacted by a battery (or by a legacy worker launch). */
+export function pendingRechecks(events) {
+    const pending = new Set();
+    for (const e of events) {
+        if (!e.taskId)
+            continue;
+        if (e.event === "task-approved" && e.data.release === RECHECK_RELEASE)
+            pending.add(e.taskId);
+        else if (e.event === "recheck-battery" || e.event === "worker-launch")
+            pending.delete(e.taskId);
+    }
+    return pending;
 }
 // Both retry decisions below govern exactly ONE dispatch: the next one. So both are read back from the
 // journal at the moment that dispatch is built, never carried in a process variable — a stop between
@@ -695,8 +743,21 @@ export function pendingRepairFindings(events, taskId) {
  * a channel it is no longer using, and a later unrelated failure is not parked under a stale reason.
  */
 export function activeRetryBan(events, taskId, channel) {
-    const e = decisionForNextDispatch(events, taskId, "gate-fingerprint-cap");
-    return e && e.data.channel === channel && typeof e.data.gate === "string" ? e.data.gate : undefined;
+    let pending;
+    for (const e of events) {
+        if (e.taskId !== taskId)
+            continue;
+        if (e.event === "gate-fingerprint-cap")
+            pending = e;
+        else if (e.event === DECISION_SPENT
+            || (e.event === "task-approved" && e.data.release === RECHECK_RELEASE))
+            pending = undefined;
+    }
+    return pending && typeof pending.data.channel === "string"
+        && channelRouteIdentity(pending.data.channel) === channelRouteIdentity(channel)
+        && typeof pending.data.gate === "string"
+        ? pending.data.gate
+        : undefined;
 }
 // Fail-closed shape for a dispatched assignment (journal.ts:75-90 posture): a malformed assignment in
 // one dispatch degrades that single task toward today's behavior — counts toward attempts, contributes

package/dist/run/supervision.d.ts

@@ -7,6 +7,12 @@ export declare const SUPERVISION_FUTURE_GRACE_MS = 1000;
 export declare const SUPERVISION_DEFAULT_THRESHOLD_PCT = 75;
 export declare const SUPERVISION_TIERS: readonly ["orchestrator", "orchestrator-context", "overseer", "overseer-context", "watch"];
 export type SupervisionTier = (typeof SUPERVISION_TIERS)[number];
+/**
+ * Resolve a one-shot supervision writer to the repository state it is claiming to supervise.
+ * The nearest state directory wins; reaching a git root without one is a refusal, not permission
+ * to create fresh state there or to wander into an enclosing repository. This function is read-only.
+ */
+export declare function resolveSupervisionRoot(cwd: string): string;
 export declare const SUPERVISION_SEAT_TIERS: readonly ["orchestrator", "orchestrator-context", "overseer", "overseer-context"];
 export type SeatTier = (typeof SUPERVISION_SEAT_TIERS)[number];
 /** Does this tier's record have to name the seat it speaks for? */

package/dist/run/supervision.js

@@ -1,6 +1,6 @@
 import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { stateDirName, tickmarkrDir } from "../graph/graph.js";
 // SUP-01: supervision liveness as FILE STATE, not as a report — lock.ts's proven shape, one file per
 // tier. A watcher beats its OWN file; every other seat derives that tier's state by stat()ing it. So
@@ -41,6 +41,34 @@ export const SUPERVISION_DEFAULT_THRESHOLD_PCT = 75;
 export const SUPERVISION_TIERS = [
     "orchestrator", "orchestrator-context", "overseer", "overseer-context", "watch",
 ];
+const pathKind = (path) => {
+    try {
+        return statSync(path).isDirectory() ? "directory" : "present";
+    }
+    catch {
+        return "absent";
+    }
+};
+/**
+ * Resolve a one-shot supervision writer to the repository state it is claiming to supervise.
+ * The nearest state directory wins; reaching a git root without one is a refusal, not permission
+ * to create fresh state there or to wander into an enclosing repository. This function is read-only.
+ */
+export function resolveSupervisionRoot(cwd) {
+    let current = resolve(cwd);
+    for (;;) {
+        if (pathKind(join(current, stateDirName(current))) === "directory")
+            return current;
+        if (pathKind(join(current, ".git")) !== "absent") {
+            throw new Error(`missing ${stateDirName(current)}/ state dir at repository root ${current}`);
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            throw new Error(`missing ${stateDirName(current)}/ state dir — no tickmarkr repository found from ${resolve(cwd)}`);
+        }
+        current = parent;
+    }
+}
 // The tiers whose records must NAME the seat behind them. A one-shot `tickmarkr beat` records a pid
 // that has already exited by the time anyone reads it, and an instant — nothing a reader can attribute
 // to a seat. Measured 2026-08-26: a consult seat of another tier ran the documented beat loop and the

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

@@ -68,6 +68,10 @@ export type FleetModelGroup = {
         detectedAt?: string;
         suggestion?: FleetModelSuggestion;
         evidence?: FleetModelEvidence;
+        classifyModel?: string;
+        variants?: string[];
+        foldedModels?: string[];
+        score?: number;
     }>;
 };
 export type FleetClassification = {

package/dist/tui/ink/fleet-app.js

@@ -96,7 +96,8 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
     };
     const groupRows = (group) => {
         const rows = group.rows.map((row) => {
-            const staged = ui.classifications.find((classification) => classification.adapter === group.adapter && classification.model === row.model);
+            const staged = ui.classifications.find((classification) => classification.adapter === group.adapter
+                && (classification.model === row.model || classification.model === row.classifyModel));
             return {
                 adapter: group.adapter,
                 model: row.model,
@@ -105,10 +106,14 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
                 suggestion: row.suggestion,
                 evidence: row.evidence,
                 channel: group.channel,
+                classifyModel: row.classifyModel,
+                variants: row.variants,
+                foldedModels: row.foldedModels,
+                score: row.score,
                 denied: ui.denyModels.has(`${group.adapter}:${row.model}`),
             };
         });
-        const known = new Set(rows.map((row) => row.model));
+        const known = new Set(rows.flatMap((row) => row.classifyModel ? [row.model, row.classifyModel] : [row.model]));
         for (const staged of ui.classifications) {
             if (staged.adapter === group.adapter && !known.has(staged.model)) {
                 rows.push({
@@ -125,10 +130,21 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
     const matches = (label, f) => f === "" || label.toLowerCase().includes(f.toLowerCase());
     // Operator directive 2026-08-13: retired shapes (dated snapshots, previews, non-worker SKUs,
     // legacy families) hide by DEFAULT. `a` reveals them; a CLASSIFIED row is never hidden.
-    const modelRows = (f = ui.filter) => scopedGroups().flatMap(groupRows).filter((row) => matches(`${row.adapter}/${row.model}`, f)
-        && (ui.showAll || row.tier !== undefined || retiredModelReason(row.model) === null));
-    const hiddenModelCount = (f = ui.filter) => scopedGroups().flatMap(groupRows).filter((row) => matches(`${row.adapter}/${row.model}`, f)).length
+    const modelRows = (f = ui.filter) => {
+        const rows = scopedGroups().flatMap(groupRows).filter((row) => matches(`${row.adapter}/${row.model} ${(row.foldedModels ?? []).join(" ")}`, f)
+            && (ui.showAll || row.tier !== undefined || retiredModelReason(row.model) === null));
+        const classified = rows.filter((row) => row.tier !== undefined);
+        const unclassified = rows.filter((row) => row.tier === undefined).sort((a, b) => Number(!!b.suggestion) - Number(!!a.suggestion)
+            || (b.detectedAt ?? "").localeCompare(a.detectedAt ?? "")
+            || (b.score ?? Number.NEGATIVE_INFINITY) - (a.score ?? Number.NEGATIVE_INFINITY)
+            || `${a.adapter}/${a.model}`.localeCompare(`${b.adapter}/${b.model}`));
+        return [...classified, ...unclassified];
+    };
+    const hiddenModelCount = (f = ui.filter) => scopedGroups().flatMap(groupRows)
+        .filter((row) => matches(`${row.adapter}/${row.model} ${(row.foldedModels ?? []).join(" ")}`, f)).length
         - modelRows(f).length;
+    const foldedModelCount = (f = ui.filter) => modelRows(f)
+        .reduce((count, row) => count + Math.max((row.foldedModels?.length ?? 1) - 1, 0), 0);
     /** rail counts mirror the list's retired-hide (never the text filter) so numbers agree on screen */
     const visibleCount = (scope) => {
         const groups = scope === -1 ? enabledGroups() : (modelGroups[scope] ? [modelGroups[scope]] : []);
@@ -232,14 +248,17 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
             return;
         // OBS-508: catalog evidence prefills the flow — the tier cursor lands on the suggested band and
         // (when the operator keeps that band) the provenance note arrives pre-typed. Free to override.
-        const suggestion = group.rows.find((row) => row.model === model)?.suggestion ?? null;
+        const source = group.rows.find((row) => row.model === model);
+        const suggestion = source?.suggestion ?? null;
+        const classifyModel = source?.classifyModel ?? model;
         const tierAt = suggestion ? Math.max(TIERS.indexOf(suggestion.tier), 0) : 0;
         const firstTouch = !group.rows.some((row) => row.tier !== undefined)
             && !ui.classifications.some((c) => c.adapter === adapter);
         const base = {
             kind: "classify",
             adapter,
-            model,
+            model: classifyModel,
+            ...(classifyModel !== model ? { displayModel: model } : {}),
             channelAt: 0,
             tierAt,
             note: "",
@@ -966,7 +985,7 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
                 const group = modelGroups[ui.adapterAt];
                 const suggested = rows
                     .filter((candidate) => candidate.adapter === group.adapter && !candidate.tier && candidate.suggestion !== undefined)
-                    .map((candidate) => ({ model: candidate.model, suggestion: candidate.suggestion }));
+                    .map((candidate) => ({ model: candidate.classifyModel ?? candidate.model, suggestion: candidate.suggestion }));
                 if (!suggested.length) {
                     ui.notice = "no catalog tier suggestions among the visible unclassified models — evidence comes from the cached catalogs (AA index / API pricing)";
                     bump();
@@ -1101,6 +1120,9 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
         const parts = [
             `${row.adapter}:${row.model}`,
             row.tier ?? "unclassified",
+            row.variants?.length ? `variants ${row.variants.join(", ")}` : "",
+            row.classifyModel ? `classify writes ${row.classifyModel}` : "",
+            row.foldedModels?.length ? `${row.foldedModels.length} gateway ids folded: ${row.foldedModels.join(", ")}` : "",
             row.evidence?.unauthed !== undefined ? `UNAUTHED — ${row.evidence.unauthed}` : "",
             row.evidence?.contextWindow !== undefined ? `${fmtCtx(row.evidence.contextWindow)} ctx` : "",
             row.evidence?.outputWindow !== undefined ? `${fmtCtx(row.evidence.outputWindow)} out` : "",
@@ -1120,7 +1142,8 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
         const nameW = bodyW - 4 - 11 - 6 - (showPrice ? 12 : 0) - (showProbe ? 7 : 0);
         // OBS-531: deep router ids (omp/prime-agent) clip tail-preserving — the LAST segment is the
         // distinguishing half; end-clipping rendered ten identical "prime-agent/anthropic/claude-…" rows.
-        const name = clipPathTail(`${row.adapter}/${row.model}`, nameW);
+        const folded = row.foldedModels?.length ?? 1;
+        const name = clipPathTail(`${row.adapter}/${row.model}${folded > 1 ? ` ×${folded}` : ""}`, nameW);
         const prefixLen = Math.min(name.length, row.adapter.length + 1);
         return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), row.denied
                     ? _jsx(Glyph, { kind: "off" })
@@ -1174,7 +1197,9 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
         if (overlay.kind === "classify") {
             const subject = overlay.bulk
                 ? `${overlay.adapter} · ${overlay.bulk.rows.length} suggested models`
-                : `${overlay.adapter}:${overlay.model}`;
+                : overlay.displayModel
+                    ? `${overlay.adapter}:${overlay.displayModel} · writes ${overlay.model}`
+                    : `${overlay.adapter}:${overlay.model}`;
             return (_jsxs(OverlayPanel, { title: `classify · ${subject}`, width: bodyW, children: [overlay.stage === "channel" && (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["first touch for ", overlay.adapter, " \u2014 how is this CLI billed?"] }), _jsx(Text, { children: " " }), CHANNELS.map((channel, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.channelAt === index }), _jsx(Text, { bold: overlay.channelAt === index, children: padCell(channel, 5) }), _jsx(Text, { dimColor: true, children: channel === "sub" ? "flat-rate subscription quota" : "metered API billing" })] }, channel)))] })), overlay.stage === "tier" && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: overlay.suggestion
                                     ? `catalog suggests ${overlay.suggestion.tier} — keep it and the provenance note arrives pre-typed`
                                     : "pick the capability band this model routes as" }), _jsx(Text, { children: " " }), TIERS.map((tier, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.tierAt === index }), overlay.suggestion?.tier === tier ? _jsx(Glyph, { kind: "on" }) : _jsx(Text, { children: " " }), _jsx(Text, { bold: overlay.tierAt === index, children: ` ${padCell(tier, 9)}` }), _jsx(Text, { dimColor: true, children: tier === "frontier" ? "strongest band — integrity shapes" : tier === "mid" ? "capable daily driver" : "fast + cheap" })] }, tier)))] })), overlay.stage === "note" && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "benchmark provenance (required) \u2014 where does this tier claim come from?" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: INK.brand, children: "> " }), _jsx(Text, { children: clip(overlay.note, bodyW - 6) || "" }), _jsx(Text, { color: INK.brand, children: "\u2588" })] })] }))] }));
@@ -1220,6 +1245,15 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
         const selectedSeat = ui.judgeSeat ?? judgeKeepRow;
         return (_jsxs(OverlayPanel, { title: "pick \u00B7 judge", width: bodyW, children: [_jsx(Text, { dimColor: true, children: "one seat judges acceptance criteria \u2014 failover stays runtime (GATE-09)" }), _jsx(SearchRow, { filter: ui.filter, active: true }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((label, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: start + index === overlay.at }), label === selectedSeat ? _jsx(Glyph, { kind: "on" }) : _jsx(Text, { children: " " }), _jsx(Text, { bold: start + index === overlay.at, children: ` ${clip(label, bodyW - 10)}` })] }, label))), below > 0 && _jsx(ElisionMark, { count: below, side: "below" })] }));
     })();
+    const modelVisibilityLine = () => {
+        const hidden = hiddenModelCount();
+        const folded = foldedModelCount();
+        return [
+            ...(folded ? [`${folded} same-model gateway id${folded === 1 ? "" : "s"} folded`] : []),
+            ...(hidden ? [`${hidden} retired/preview/non-worker hidden — a shows all`] : []),
+            ...(ui.showAll ? ["showing retired models — a hides them again"] : []),
+        ].join(" · ");
+    };
     const listNode = (() => {
         if (overlayNode)
             return overlayNode;
@@ -1230,7 +1264,7 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
                 ? "All models"
                 : modelGroups[ui.adapterAt]?.adapter ?? "";
             const scopeDenied = ui.adapterAt !== -1 && ui.deny.has(modelGroups[ui.adapterAt]?.adapter ?? "");
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: scopeLabel }), _jsx(Text, { dimColor: true, children: `  ${rows.length}` })] }), _jsx(SearchRow, { filter: ui.filter, active: ui.searching, hint: "/ to search" }), scopeDenied && _jsx(Text, { color: INK.warn, children: `${modelGroups[ui.adapterAt]?.adapter} is out of the fleet — Space on its rail row adds it back` }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((row, index) => renderModelRow(row, ui.focus === "list" && start + index === ui.listAt)), below > 0 && _jsx(ElisionMark, { count: below, side: "below", hint: "/ to search" }), rows.length === 0 && !scopeDenied && _jsx(Text, { dimColor: true, children: "  no models match" })] }));
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: scopeLabel }), _jsx(Text, { dimColor: true, children: `  ${rows.length}` })] }), _jsx(SearchRow, { filter: ui.filter, active: ui.searching, hint: "/ to search" }), modelVisibilityLine() && _jsx(Text, { dimColor: true, children: `  ${modelVisibilityLine()}` }), scopeDenied && _jsx(Text, { color: INK.warn, children: `${modelGroups[ui.adapterAt]?.adapter} is out of the fleet — Space on its rail row adds it back` }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((row, index) => renderModelRow(row, ui.focus === "list" && start + index === ui.listAt)), below > 0 && _jsx(ElisionMark, { count: below, side: "below", hint: "/ to search" }), rows.length === 0 && !scopeDenied && _jsx(Text, { dimColor: true, children: "  no models match" })] }));
         }
         if (ui.view === "shapes") {
             const rows = shapeList();
@@ -1266,11 +1300,6 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
                         : "unclassified — Space/Enter classifies; unclassified models are never routed");
                 }
             }
-            const hidden = hiddenModelCount();
-            if (hidden > 0 && lines.length < 2)
-                lines.push(`${hidden} retired/preview/non-worker hidden — a shows all`);
-            if (ui.showAll && lines.length < 2)
-                lines.push("showing retired models — a hides them again");
             return lines;
         }
         if (ui.view === "shapes") {

package/dist/tui/ink/init-app.js

@@ -5,13 +5,13 @@ import { ToggleMark } from "./components.js";
 import { clip, INK, inkInput, inkOutput, KeyBar, padCell, Pointer } from "./frame.js";
 const DRIVERS = ["auto", "herdr", "subprocess", "orca"];
 // One line per driver, shown for the value currently selected: four environments no longer fit on
-// a single description row at 80 columns (the shipped three already clipped), and orca is an
-// EXPLICIT choice — `auto` still means herdr-else-subprocess and never reaches for it.
+// a single description row at 80 columns (the shipped three already clipped). Auto identifies its
+// innermost host from environment markers only; outside an Orca terminal, Orca is named explicitly.
 const DRIVER_DESC = {
-    auto: "auto: herdr when HERDR_ENV=1, else subprocess — never orca",
+    auto: "auto: herdr when HERDR_ENV=1, else orca inside an Orca terminal, else subprocess",
     herdr: "herdr: every worker runs in a visible pane you can watch and unblock",
     subprocess: "subprocess: headless child processes — no cockpit, same fail-closed gates",
-    orca: "orca: visible terminals in the Orca app — an explicit choice, never auto's",
+    orca: "orca: visible terminals in the Orca app — picked by auto inside one; name it elsewhere",
 };
 const VISIBILITY = ["pane", "headless"];
 // Three fields, one toggle, one action — a descriptor array, deliberately not a forms framework.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -57,5 +57,63 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^3.0.0"
+  },
+  "tickmarkrExport": {
+    "publicPaths": {
+      "exact": [
+        ".gitignore",
+        ".oxlintrc.json",
+        "CHANGELOG.md",
+        "CODE_OF_CONDUCT.md",
+        "CONTRIBUTING.md",
+        "FLEET.md",
+        "LICENSE",
+        "README.md",
+        "RELEASING.md",
+        "SECURITY.md",
+        "package-lock.json",
+        "package.json",
+        "tickmarkr.spec.md",
+        "tsconfig.json",
+        "vitest.config.ts",
+        ".github/pull_request_template.md",
+        "scripts/assert-test-file-count.sh",
+        "scripts/emit-schema.ts",
+        "scripts/probe-rig.mjs",
+        "specs/export-selftest.spec.md"
+      ],
+      "prefixes": [
+        ".github/ISSUE_TEMPLATE/",
+        ".github/workflows/",
+        "assets/",
+        "docs/codebase/",
+        "fixtures/",
+        "schema/",
+        "skills/tickmarkr-auto/",
+        "skills/tickmarkr-loop/",
+        "skills/tickmarkr-overseer/",
+        "src/",
+        "tests/"
+      ]
+    },
+    "excludedPaths": [
+      ".planning",
+      "specs",
+      ".tickmarkr",
+      ".overseer",
+      ".claude",
+      "docs",
+      "ASSESSMENT-*.md",
+      ".gitignore",
+      "scripts/measure-trailer-width.mjs",
+      "scripts/scan-scope-corpus.mjs",
+      "scripts/repro-obs96.mjs",
+      "CLAUDE.md",
+      "scripts/export-public.sh",
+      "scripts/verify-export.sh",
+      "tests/scripts/verify-export.test.ts",
+      ".github/workflows/ci.yml",
+      "**/*.local.*"
+    ]
   }
 }