tickmarkr 1.56.0 → 1.58.0

package/dist/adapters/codex.d.ts

@@ -5,4 +5,6 @@ export declare function readCodexModelsCache(path?: string): {
 };
 export declare function seedCodexTrust(repoRoot: string, configPath?: string): TrustVerdict;
 export declare function hasCodexTrustedProject(text: string, root: string): boolean;
+export declare function codexConfigMcpServerNames(configPath?: string): string[];
+export declare function codexMcpSuppressionFlags(configPath?: string): string;
 export declare const codex: WorkerAdapter;

package/dist/adapters/codex.js

@@ -123,6 +123,44 @@ export function hasCodexTrustedProject(text, root) {
     const re = new RegExp(String.raw `\[projects\.(?:"${esc}"|'${esc}')\][^\[]*?trust_level\s*=\s*"trusted"`, "s");
     return re.test(text);
 }
+// v1.57 T1 / OBS-82: first key segment after `mcp_servers.` — bare, "basic", or 'literal' TOML
+// keys; sub-tables ([mcp_servers.x.env]) dedupe to their server name. Fails OPEN to [] on a
+// missing/unreadable config (fresh install has none — base flags must still work).
+export function codexConfigMcpServerNames(configPath) {
+    const p = configPath ?? join(process.env.CODEX_HOME || join(homedir(), ".codex"), "config.toml");
+    let text;
+    try {
+        text = readFileSync(p, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const names = new Set();
+    for (const m of text.matchAll(/^[ \t]*\[mcp_servers\.(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))/gm)) {
+        names.add((m[1] ?? m[2] ?? m[3]));
+    }
+    return [...names];
+}
+// OBS-24 → OBS-82: -c 'mcp_servers={}' was codex's analog of claude's --strict-mcp-config, but
+// codex ≥0.144 MERGES the empty inline table with config instead of replacing it (live probe
+// 2026-07-18, codex-cli 0.144.5: `mcp list` identical with and without the override) — so a down
+// operator-global MCP server wedges startup indefinitely again (OBS-82: 45m spinner). No global
+// MCP kill switch exists (`codex features list` has nothing MCP-shaped), and plugin-bundled
+// servers (~/.codex/plugins/cache) never appear under [mcp_servers.*], so suppression is
+// two-pronged: --disable plugins kills plugin loading (incl. the OBS-82 sites-design-picker),
+// per-name enabled=false overrides kill every server named in $CODEX_HOME/config.toml. The empty
+// table stays for older codex (replace semantics there; harmless no-op under merge). The LIVE
+// test in real-adapters.test.ts runs this exact builder against the real `codex mcp list`
+// surface and asserts zero enabled servers — executable proof, not a comment claim. Scanned
+// names reach the shell line ONLY through shq — config values flow into shells.
+export function codexMcpSuppressionFlags(configPath) {
+    const flags = ["--disable plugins", `-c 'mcp_servers={}'`];
+    for (const name of codexConfigMcpServerNames(configPath)) {
+        const key = /^[A-Za-z0-9_-]+$/.test(name) ? name : JSON.stringify(name);
+        flags.push(`-c ${shq(`mcp_servers.${key}.enabled=false`)}`);
+    }
+    return flags.join(" ");
+}
 export const codex = {
     id: "codex",
     vendor: "openai",
@@ -132,14 +170,12 @@ export const codex = {
     probe: async () => probeVersion("codex"),
     channels: (cfg) => channelsFromConfig("codex", cfg),
     // --sandbox workspace-write is the autonomous sandbox mode (codex v0.144.1+)
-    // OBS-24: -c 'mcp_servers={}' is codex's analog of claude's --strict-mcp-config — operator-global
-    // MCP servers in ~/.codex/config.toml block startup indefinitely when one is down (live-measured
-    // 2026-07-15: probe wedged >120s with MCP, 30s clean), wedging probes and worktree workers alike.
-    headlessCommand: (promptFile, model) => `codex exec --sandbox workspace-write -c 'mcp_servers={}' ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    // MCP suppression built per dispatch (config can change between runs) — see codexMcpSuppressionFlags.
+    headlessCommand: (promptFile, model) => `codex exec --sandbox workspace-write ${codexMcpSuppressionFlags()} ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
     // TUI uses expanded -a never -s workspace-write (exec-only flags do not apply)
     // (--help 2026-07-09: valid approval policies are untrusted|on-request|never; the previously
     // used `on-failure` is invalid and made codex exit 2 pre-inference)
-    interactiveCommand: (promptFile, model) => `codex -a never -s workspace-write -c 'mcp_servers={}' ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    interactiveCommand: (promptFile, model) => `codex -a never -s workspace-write ${codexMcpSuppressionFlags()} ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },

package/dist/adapters/kimi.js

@@ -1,16 +1,33 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, MODEL_ID_RE, shq } from "./types.js";
-// KIMI-03: collectUsage is DELIBERATELY ABSENT — documented won't-implement, consistent with the
-// metering-honesty invariant (adapters/types.ts). Sessions live under ~/.kimi-code/sessions/ with
-// kimi export (ZIP) + session_index.jsonl; no harness-readable per-attempt token counter was found
-// in the session store (research F-6, 2026-07-17). Consequence: kimi channels report honestly
-// `unmetered` — same class as grok (grok.ts:11-39). Revisit if kimi ships usage in the
-// `-p --output-format stream-json` envelope or a counter in the session store.
+import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+// KIMI-03 → v1.58 T5: the "no harness-readable counter" block (research F-6, 2026-07-17) is
+// LIFTED for collectUsage — kimi 0.27.0 writes a wire journal per agent at
+// ~/.kimi-code/sessions/<wd>/session_<uuid>/agents/<agent>/wire.jsonl, and ~/.kimi-code/
+// workspaces.json maps each wd_* dir to its realpath'd workspace root. Field mapping pinned ONLY
+// after live verification of the real store (2026-07-18, 53 wire files / 178 usage rows, zero
+// tokens spent):
+//   - the canonical row is top-level `{"type":"usage.record","usage":{...},"usageScope":"turn",
+//     "time":<epoch ms>}` — 178/178 rows carried scope "turn" and the identical key set
+//     {inputOther, output, inputCacheRead, inputCacheCreation};
+//   - per-turn DELTA semantics verified arithmetically: each turn's inputCacheRead ≈ prior
+//     inputCacheRead + inputOther + output (the grown context re-read from cache — claude's
+//     per-message convention), and inputOther/output are non-monotonic per-turn counts, so
+//     SUMMING rows is the correct fold (never a cumulative 3A+2B+C trap);
+//   - the SAME usage object is echoed inside the step.end loop event
+//     (`type:"context.append_loop_event"`, event.usage) — folding anything but usage.record
+//     rows double-counts every turn, hence the exact type+scope pin below;
+//   - mapping: inputOther→input, output→output, inputCacheRead→cacheRead,
+//     inputCacheCreation→cacheWrite (creation observed live only as 0; mapped by name).
+// Absent or ambiguous usage resolves to UNMETERED, never an invented count: unknown usageScope,
+// non-numeric core fields, torn lines, or no post-cursor row all skip/return undefined — the
+// "?? 0" poisoning class stays banned. contextUsage remains absent (resumeUnknownContext below).
+const MAX_SESSION_FILES = 20;
+const MAX_SESSION_BYTES = 8_000_000;
 const CREDENTIALS_PATH = join(homedir(), ".kimi-code", "credentials", "kimi-code.json");
 // KIMI-01. Auth verdict from ~/.kimi-code/credentials/kimi-code.json ONLY — flat JSON, never a
 // network call. expires_at is epoch SECONDS (not ISO like grok). Non-empty refresh_token dominates
@@ -101,6 +118,102 @@ export const kimi = {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },
     parse: parseKimiResult,
+    collectUsage(cwd, sinceMs) {
+        try {
+            const real = realpathSync(cwd);
+            const home = join(homedir(), ".kimi-code");
+            const ws = JSON.parse(readFileSync(join(home, "workspaces.json"), "utf8"));
+            // a recreated workspace gets a new wd_* hash for the same root — fold every match
+            const wdDirs = Object.entries(ws.workspaces ?? {})
+                .filter(([, v]) => v && typeof v === "object" && v.root === real)
+                .map(([k]) => k);
+            // newest-first by mtime, bounded — mtime picks WHICH files to scan, never a record's cursor
+            const files = [];
+            for (const wd of wdDirs) {
+                const wdPath = join(home, "sessions", wd);
+                let sessions;
+                try {
+                    sessions = readdirSync(wdPath);
+                }
+                catch {
+                    continue;
+                }
+                for (const s of sessions) {
+                    if (!s.startsWith("session_"))
+                        continue;
+                    const agentsPath = join(wdPath, s, "agents");
+                    let agents;
+                    try {
+                        agents = readdirSync(agentsPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const a of agents) {
+                        const p = join(agentsPath, a, "wire.jsonl");
+                        try {
+                            files.push({ path: p, m: statSync(p).mtimeMs });
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            files.sort((a, b) => b.m - a.m);
+            let input = 0, output = 0, kept = false;
+            let cacheRead, cacheWrite;
+            for (const { path: fp } of files.slice(0, MAX_SESSION_FILES)) {
+                let text;
+                try {
+                    text = readFileSync(fp, "utf8").slice(0, MAX_SESSION_BYTES);
+                }
+                catch {
+                    continue;
+                }
+                for (const line of text.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    let recRaw;
+                    try {
+                        recRaw = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const rec = recRaw;
+                    // exact type+scope pin: the step.end loop event ECHOES the same usage (double-count),
+                    // and any scope other than the live-verified "turn" has unknown fold semantics — skip
+                    if (rec.type !== "usage.record" || rec.usageScope !== "turn")
+                        continue;
+                    if (typeof rec.time !== "number" || !Number.isFinite(rec.time) || rec.time < sinceMs)
+                        continue;
+                    const u = rec.usage;
+                    if (!u || typeof u !== "object")
+                        continue;
+                    const uu = u;
+                    // ambiguous row (core fields missing/non-numeric) resolves to unmetered, never 0
+                    if (typeof uu.inputOther !== "number" || typeof uu.output !== "number")
+                        continue;
+                    input += uu.inputOther;
+                    output += uu.output;
+                    if (typeof uu.inputCacheRead === "number")
+                        cacheRead = (cacheRead ?? 0) + uu.inputCacheRead;
+                    if (typeof uu.inputCacheCreation === "number")
+                        cacheWrite = (cacheWrite ?? 0) + uu.inputCacheCreation;
+                    kept = true;
+                }
+            }
+            if (!kept)
+                return undefined; // nothing matched ⇒ unmetered, never {input:0,…}
+            const out = { input, output, ...(cacheRead !== undefined ? { cacheRead } : {}), ...(cacheWrite !== undefined ? { cacheWrite } : {}) };
+            const p = TokenUsageSchema.safeParse(out);
+            return p.success ? p.data : undefined;
+        }
+        catch {
+            return undefined; // missing home/workspaces.json / any throw ⇒ fail open
+        }
+    },
     listModels: async () => {
         const r = spawnSync("kimi", ["provider", "list", "--json"], { encoding: "utf8", timeout: 15000 });
         return r.error || r.status !== 0 ? [] : parseKimiModels(r.stdout || "");

package/dist/route/router.js

@@ -67,6 +67,43 @@ function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
 }
+// v1.58 frontier spread (operator ruling .planning/rulings/2026-07-18-frontier-spread-credits.md):
+// every sub channel marginal-cost-ranks 0, so tier-equal frontier ties fell through all sort keys
+// to discovery order — the first sub channel (claude-code:fable) served every frontier auto pick,
+// and same-day quota exhaustion on that one channel interrupted two live pipeline agents. A
+// deterministic task-keyed rotation now spreads each residual frontier tie across its whole tie
+// group, so sol/k3-class channels serve frontier work as first-class candidates. Strictly the LAST
+// tiebreak: it permutes only maximal runs already tied on every key above it (prefer band,
+// marginal cost, tier — plus exploration bonus and learned score on the learned path), and only
+// runs of zero-marginal-cost frontier SUB channels outside any prefer entry. Pins return upstream,
+// denies filter upstream, prefer order is operator-explicit — none are touched.
+// ponytail: frontier runs only — the ruled scope (ruling §1); spreading mid/cheap ties too = drop
+// the tier guard. Rotation, not utilization: profile-driven spread would be inert exactly where
+// the concentration bites (cold profiles, plan-time static routing, learned:off).
+const spreadOffset = (task) => {
+    let h = 0;
+    for (const ch of `${task.id}\n${task.goal}`)
+        h = (h * 31 + ch.charCodeAt(0)) >>> 0;
+    return h;
+};
+function spreadFrontierTies(sorted, task, prefer, tied) {
+    const out = [...sorted];
+    const preferLen = prefer?.length ?? 0;
+    let i = 0;
+    while (i < out.length) {
+        let j = i + 1;
+        while (j < out.length && tied(out[i], out[j]))
+            j++;
+        const len = j - i;
+        if (len > 1 && out[i].tier === "frontier" && marginalCostRank(out[i]) === 0 && preferIndex(out[i], prefer) === preferLen) {
+            const run = out.slice(i, j);
+            const k = spreadOffset(task) % len;
+            out.splice(i, len, ...run.slice(k), ...run.slice(0, k));
+        }
+        i = j;
+    }
+    return out;
+}
 function withoutExcluded(channels, exclude) {
     if (!exclude?.size)
         return channels;
@@ -174,8 +211,9 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         for (const p of prefer ?? [])
             preflightPrefer(p);
     // key order is a contract: prefer > marginal cost > tier (cheapest sufficient) > learned score (v1.6 ROUTE-06)
-    // > discovery order (same-tier fairness, D2). The learned score is the LAST key — it decides only the
-    // discovery-order tail, never a pin/floor/prefer/cost/tier boundary (they all sort above it, ROUTE-08).
+    // > frontier spread (v1.58) > discovery order (same-tier fairness, D2). The learned score decides only the
+    // discovery-order tail, never a pin/floor/prefer/cost/tier boundary (they all sort above it, ROUTE-08);
+    // the spread rotates only what would otherwise fall to discovery order.
     const staticCmp = (a, b) => preferIndex(a, prefer) - preferIndex(b, prefer) || marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier];
     const eligibleRaw = channels.filter((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier]);
     if (!eligibleRaw.length) {
@@ -192,6 +230,11 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     let eligible;
     let deviation;
     let learnedChosen = "";
+    let spreadDecided = false;
+    // v1.58: the spread is applied identically on both sort paths (and to the deviation baseline), so
+    // an empty/cold profile stays byte-identical to the 3-arg call (ROUTE-07) and a deviation always
+    // means learned evidence moved the pick — never the spread mislabeled as learning.
+    const spreadStatic = (sorted) => spreadFrontierTies(sorted, task, prefer, (a, b) => staticCmp(a, b) === 0);
     if (profile) {
         // scores precomputed ONCE over the eligible set — never inside the comparator (Pitfall 1).
         // ponytail: no epsilon — two finite scores subtract to a finite number (Phase 12 totality); an
@@ -210,7 +253,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         const off = exploreOff(task, cfg, exploreCtx);
         const bonuses = new Map(eligibleRaw.map((c) => [channelKey(c), off ? 0 : explorationBonus(cellOf(profile, task.shape, channelKey(c), c.channel), cap)]));
         const bonusOf = (c) => bonuses.get(channelKey(c));
-        const staticWinner = [...eligibleRaw].sort(staticCmp)[0];
+        const staticWinner = spreadStatic([...eligibleRaw].sort(staticCmp))[0];
         // Phase 34 ROUTE-17: prefer becomes a BAND + group-rep keys so exploration fires ACROSS prefer
         // entries, while intra-entry order (cost > tier > bonus > score) and every cold path stay byte-identical.
         // Cold reduces to preferIndex || cost || tier ≡ staticCmp (proof P1); rep keys use the group HEAD so
@@ -232,7 +275,11 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }));
         const kOf = (c) => keyOf.get(channelKey(c));
         const firstDiff = (a, b) => kOf(a).findIndex((v, i) => v !== kOf(b)[i]);
-        eligible = [...eligibleRaw].sort((a, b) => { const i = firstDiff(a, b); return i === -1 ? 0 : kOf(a)[i] - kOf(b)[i]; });
+        const sortedByKey = [...eligibleRaw].sort((a, b) => { const i = firstDiff(a, b); return i === -1 ? 0 : kOf(a)[i] - kOf(b)[i]; });
+        // spread runs tied on the FULL learned key (bonus/score included) — a warm score or live probe
+        // bonus still decides its tie exactly as before; the spread rotates only the residual all-equal runs.
+        eligible = spreadFrontierTies(sortedByKey, task, prefer, (a, b) => firstDiff(a, b) === -1);
+        spreadDecided = channelKey(eligible[0]) !== channelKey(sortedByKey[0]);
         const w = eligible[0];
         const ru = channelKey(staticWinner) !== channelKey(w) ? staticWinner : eligible[1];
         // Phase 34 ROUTE-17: first-differing-key markers — probe when a rep or intra bonus key decided.
@@ -250,7 +297,9 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
     }
     else {
-        eligible = eligibleRaw.sort(staticCmp); // ROUTE-07/09: literally the v1.5 code path — dead code cannot deviate
+        const sortedStatic = eligibleRaw.sort(staticCmp); // ROUTE-07/09: the v1.5 key order, spread applied as the last key
+        eligible = spreadStatic(sortedStatic);
+        spreadDecided = channelKey(eligible[0]) !== channelKey(sortedStatic[0]);
     }
     const bound = qualityBound(quality, advisoryFloor, taskFloorRaw) ??
         (taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
@@ -261,8 +310,10 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     const preferVia = preferFromAuto(task.shape, preferCtx)
         ? `via prefer (auto-modernized ${preferCtx.autoPrefer.derivedAt.slice(0, 10)})`
         : "via prefer";
-    const chosenBy = learnedChosen || (prefer && preferIndex(eligible[0], prefer) < prefer.length
-        ? preferVia : "cheapest sufficient tier");
+    // a spread-decided winner is never inside a prefer band (the spread skips those runs), so the
+    // three arms below are mutually exclusive by construction
+    const chosenBy = learnedChosen || (spreadDecided ? "via frontier spread"
+        : prefer && preferIndex(eligible[0], prefer) < prefer.length ? preferVia : "cheapest sufficient tier");
     maybeSlaLint(lints, task, profile, slaMinutes, eligible[0]);
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }

package/dist/run/daemon.js

@@ -21,6 +21,7 @@ import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
 import { nextChannel, QUALITY_ENV, route } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
+import { normalizeStallSnapshot } from "./stall.js";
 const MODE_RANK = { "staff-led": 0, "risk-based": 1, "partner-led": 2 };
 // An override (flag/spec) re-resolves through loadConfigWithMode itself, via a synthesized repo overlay
 // carrying routing.mode — floors, explore, lints, and provenance all come from config.ts's preset
@@ -630,7 +631,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
                     // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    let lastOutput = output;
+                    // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
+                    // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
+                    // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                    let lastStallSnapshot = normalizeStallSnapshot(output);
                     let lastOutputAt = Date.now();
                     while (Date.now() - lastOutputAt < stallWindowMs) {
                         const sliceStart = Date.now();
@@ -649,9 +653,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                                 break;
                             }
                         }
-                        const currentOutput = await driver.read(slot, 1000);
-                        if (currentOutput !== lastOutput) {
-                            lastOutput = currentOutput;
+                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                        if (currentStallSnapshot !== lastStallSnapshot) {
+                            lastStallSnapshot = currentStallSnapshot;
                             lastOutputAt = Date.now();
                         }
                         // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
@@ -709,8 +713,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // T5: same brand header as the interactive path and the gate/consult dispatch scripts.
                     await driver.run(slot, `${bannerShell()}; ${inv.command}; ${exitMarkerCmd}`);
                     // OBS-54: headless workers have the same output-inactivity budget as visible panes.
+                    // OBS-82: same normalized-snapshot compare as the interactive site — spinner-only repaints
+                    // exhaust the budget here too; harvest below still reads the raw pane.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    let lastOutput = await driver.read(slot, 500);
+                    let lastStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
                     let lastOutputAt = Date.now();
                     finished = false;
                     while (Date.now() - lastOutputAt < stallWindowMs) {
@@ -720,9 +726,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                             finished = true;
                             break;
                         }
-                        const currentOutput = await driver.read(slot, 500);
-                        if (currentOutput !== lastOutput) {
-                            lastOutput = currentOutput;
+                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                        if (currentStallSnapshot !== lastStallSnapshot) {
+                            lastStallSnapshot = currentStallSnapshot;
                             lastOutputAt = Date.now();
                         }
                     }

package/dist/run/stall.d.ts

@@ -0,0 +1,4 @@
+/** Normalize one pane snapshot for the stall-inactivity compare (and ONLY that compare — trailer
+ * parsing, harvest, waitOutput, and paging read the raw text). Two snapshots that normalize equal
+ * are the same frame modulo spinner presentation; any other byte difference is worker activity. */
+export declare function normalizeStallSnapshot(text: string): string;

package/dist/run/stall.js

@@ -0,0 +1,24 @@
+// OBS-82: codex's MCP-startup spinner repaints a braille glyph + elapsed-time cell forever, so the
+// daemon's raw snapshot compare reads a wedged pane as active and the stall clock never fires.
+// This normalizer deletes ONLY presentation tokens from a closed allowlist — ANSI/VT escape
+// sequences, braille-range spinner glyphs, and elapsed-time tokens bound to time-unit suffixes.
+// Every other byte passes through identical: words, paths, server names, and progress counts
+// (a five-of-seven counter change IS activity) all remain change-sensitive. The asymmetry is the
+// design: an allowlist MISS degrades to today's recoverable no-reap behavior, while an over-broad
+// deletion would reap a healthy worker — a new failure class. Grow the allowlist only with
+// captured evidence (tests/fixtures/codex-mcp-spinner/).
+// CSI (with intermediates), OSC (BEL- or ST-terminated), DCS/SOS/PM/APC strings, single-char
+// escapes, and charset selection — the raw-pty forms; herdr pane reads are already rendered.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x9b[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[PX^_][^\x1b]*(?:\x1b\\)?|\x1b[()][0-9A-Za-z]|\x1b[0-~]/g;
+// Braille patterns U+2800–U+28FF — the codex spinner cell (captured fixture: ⠋⠙⠸⠴⠦⠇ …).
+const SPINNER_RE = /[⠀-⣿]/g;
+// A digit run (optionally decimal) bound directly to a time-unit suffix, standing alone as a
+// word: 9s, 41s, 3m, 1h, 800ms. Never bare digits — "(6/7)" and "5 of 7" stay change-sensitive.
+const ELAPSED_RE = /(?<![\w.])\d+(?:\.\d+)?(?:ms|[hms])(?!\w)/g;
+/** Normalize one pane snapshot for the stall-inactivity compare (and ONLY that compare — trailer
+ * parsing, harvest, waitOutput, and paging read the raw text). Two snapshots that normalize equal
+ * are the same frame modulo spinner presentation; any other byte difference is worker activity. */
+export function normalizeStallSnapshot(text) {
+    return text.replace(ANSI_RE, "").replace(SPINNER_RE, "").replace(ELAPSED_RE, "");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.56.0",
+  "version": "1.58.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",