tickmarkr 2.7.0 → 2.7.1

package/dist/adapters/prompt.js

@@ -129,7 +129,7 @@ export function parseWorkerResult(raw, nonce) {
     return fail(cause === "malformed-verdict" ? UNPARSEABLE_TRAILER_SUMMARY : NO_TRAILER_SUMMARY, cause);
 }
 // Signatures anchor distinctive CLI-error phrasing — never bare fragments or bare status-code
-// numbers (the QUOTA_RE Pitfall-3 lesson): these run only over no-trailer output, but a stalled
+// numbers (the quota classifier's Pitfall-3 lesson): these run only over no-trailer output, but a stalled
 // worker's harvested pane can still contain ordinary work text. E1: the recorded refresh failure
 // ("access token could not be refreshed") is auth-required — classified, never re-probed or relaunched.
 const AUTH_RE = /not logged in|please (?:log ?in|sign in)|please run [^\n]{0,30}log ?in|authentication[ _](?:required|failed|error)|invalid (?:api key|credentials)|api key (?:is )?(?:not set|missing|invalid|required)|credentials? (?:have )?expired|401 unauthorized|access token could not be refreshed/i;

package/dist/adapters/registry.js

@@ -11,7 +11,7 @@ import { FakeAdapter } from "./fake.js";
 import { parseWorkerResult } from "./prompt.js";
 import { sealHerdrEnv } from "../drivers/subprocess.js";
 import { catalogEntries, isNativeCliDrive, projectCliEntries, SHIPPED_CLI_CATALOG, } from "./catalog.js";
-import { channelKey, channelsFromConfig, modelAuthed, MODEL_ID_RE, MODEL_PROBE_ERRORS, QUOTA_RE, shq, } from "./types.js";
+import { channelKey, channelsFromConfig, modelAuthed, MODEL_ID_RE, MODEL_PROBE_ERRORS, QUOTA_PHRASE_RE, shq, STATUS_LABEL, } from "./types.js";
 // Compatibility projection for callers/tests that only need shipped advisory names. The literal
 // list is gone: both advisory and routable catalog views derive from SHIPPED_CLI_CATALOG. Native
 // definitions (claudeCode, codex, cursorAgent, opencode, pi, grok, kimi) are owned by catalog.ts;
@@ -389,7 +389,23 @@ const MODEL_PROBE_TIMEOUT_MS = 60000;
 // probe of any adapter that prints a comma-grouped token count. Lookarounds reject a group that is part of a
 // larger number (26,485 · 1.400 · 400.5) while keeping real bare codes (401 · "error 429" · "403 Forbidden."
 // — trailing sentence punctuation still matches, only a following DIGIT means "decimal, not status code").
-const AUTH_FAILURE_RE = /\b(?<![\d.,])4\d\d\b(?![.,]\d)|\bauth(?:entication|orization)?\s+(?:error|failed|failure|denied)|unauthori[sz]ed|forbidden|access denied|credit(?:s)?\s+(?:exhausted|error|denied)/i;
+// Queue row 20 (D-1148 (1)): a bare number is never a status code. qwen's healthy probe telemetry
+// `"totalGenerationDurationMs":438` read as an auth failure and dropped a working channel, so a 4xx counts only
+// where the output labels it as a status — `HTTP 401`, `HTTP/1.1 403`, `status 401`, `status code 401`,
+// `"statusCode":401`, `"httpStatus":401`, `httpStatusCode: 403`, `errorCode: 401`, `code: 403`, `Error: 401`. A
+// label matches only as a WHOLE token — no letter of any script, combining mark, digit or underscore before it:
+// `unicode`, `barcode`, `standardError`, `zipCode`, `foo_code`, `éstatus` are not labels; punctuation such as `“` or
+// `—` is no letter — so compound labels are enumerated (the `u` flag is what lets `\p{…}` name every script). The
+// label only NARROWS the base's bare-4xx match (both `\b`s and the no-decimal/grouping tail stay), so nothing the
+// base read as authed fails here; the base's digit-before guard is implied by the `\b` after a label. The word
+// branches are unchanged.
+// The labelled 4xx needs the `u` flag (\p{…} in STATUS_LABEL). The auth-word branches keep the base's bytes and its
+// "i" flag: under "iu" case folding maps ſ (U+017F) → s and K (U+212A) → k, so `unauthoriſed` would read as a failure
+// the base never read (D-1582).
+const LABELLED_4XX_RE = new RegExp(String.raw `${STATUS_LABEL}\b4\d\d\b(?![.,]\d)`, "iu");
+const AUTH_WORDS_RE = /\bauth(?:entication|orization)?\s+(?:error|failed|failure|denied)|unauthori[sz]ed|forbidden|access denied|credit(?:s)?\s+(?:exhausted|error|denied)/i;
+// The probe's quota reading is the shared QUOTA_PHRASE_RE (types.ts, queue row 106): a labelled 429 is a labelled 4xx
+// above, and an unlabelled `429 Too Many Requests` keeps failing on its phrase.
 const PROBE_REASON_CAP = 240;
 // v1.55 T3: the tail must open at a word boundary — a mid-word slice ("odel 'grok-…'") reads as
 // corruption in operator-facing diagnostics. Input is already space-normalized, so " " is the only
@@ -421,7 +437,7 @@ function probeFailure(code, stdout, stderr, timedOut, timeoutMs = MODEL_PROBE_TI
     const output = `${stderr}\n${stdout}`.trim().replace(/\s+/g, " ");
     // OBS-72: TAIL, not head — the error lands at the END of CLI output; a head slice stores only the
     // startup banner and hid the real "Not inside a trusted directory" failure for a day.
-    return code !== 0 || QUOTA_RE.test(output) || AUTH_FAILURE_RE.test(output)
+    return code !== 0 || QUOTA_PHRASE_RE.test(output) || LABELLED_4XX_RE.test(output) || AUTH_WORDS_RE.test(output)
         ? reasonTail(output) || `probe exited ${code}`
         : undefined;
 }

package/dist/adapters/types.d.ts

@@ -237,5 +237,16 @@ export declare const PROMPT_ARGV_CEILING_DEFAULT = 900000;
 export declare function promptArgvCeiling(platform?: string): number;
 export declare function promptFitsArgv(promptFile: string, platform?: string): boolean;
 export declare const CAPACITY_RE: RegExp;
-export declare const QUOTA_RE: RegExp;
+export declare const QUOTA_PHRASE_RE: RegExp;
+export declare const STATUS_LABEL: string;
+export declare const LABELLED_429_RE: RegExp;
+export type QuotaSignal = RegExpExecArray & {
+    readonly source: string;
+};
+/**
+ * The LEFTMOST quota signal in `text` — a phrase or a labelled 429 — with the source of the regex that matched (the
+ * quota-banner record names it, so a false positive stays legible from the record alone), or null. A phrase and a
+ * label never start at the same index (phrase initials r q u o i t, label initials h e s c); a tie would go to the phrase.
+ */
+export declare function quotaSignal(text: string): QuotaSignal | null;
 export declare const MODEL_ID_RE: RegExp;

package/dist/adapters/types.js

@@ -302,7 +302,7 @@ export function promptFitsArgv(promptFile, platform = process.platform) {
 // on ordinary billing/wallet task output the harness edits (research Pitfall 3, 2026-07-10).
 // OBS-1161: transient provider capacity ("Selected model is at capacity") is NOT quota — the seat
 // comes back within minutes, so it takes bounded same-seat backoff before a same-floor failover and
-// never permanent demotion. Kept apart from QUOTA_RE so permanent quota policy stays untouched, and
+// never permanent demotion. Kept apart from quotaSignal so permanent quota policy stays untouched, and
 // anchored on the full phrase (the Pitfall-3 lesson: a bare "capacity" fires on ordinary work text).
 // A banner is the CLI speaking, so the phrase must OPEN its row — after at most an error glyph
 // (codex paints "■ Selected model is at capacity. …") or an "error:" label. Anything else in front —
@@ -310,7 +310,25 @@ export function promptFitsArgv(promptFile, platform = process.platform) {
 // ponytail: row-start grammar, not per-adapter fixtures — the ceiling is a worker whose own output
 // opens a row with the bare phrase inside the banner tail; widen the glyph set only from a captured frame.
 export const CAPACITY_RE = /^[ \t■⚠✗✘×!]*(?:(?:stream )?error:[ \t]*)?(?:(?:selected |the )?model is (?:currently |temporarily )?at capacity|(?:provider|service|server) is (?:currently )?at capacity)/im;
-export const QUOTA_RE = /rate.?limit|quota|usage limit|out of credits|insufficient credit|insufficient balance or no resource|\b429\b/i;
+// Queue row 106 (D-1597): a bare 429 is never a quota signal. Every bare 429 in the captured corpus was a line number
+// or a count — `429:` in a diff listing failed a pinned codex worker over 41 985 bytes before EOF (OBS-926) — and the
+// one real 429 banner also carries a phrase and a labelled status. Quota is a PHRASE, or a 429 the output LABELS.
+export const QUOTA_PHRASE_RE = /rate.?limit|quota|usage limit|out of credits|insufficient credit|insufficient balance or no resource|too many requests/i;
+// A whole-token status label (row 20, D-1581): no letter of any script, combining mark, digit or underscore before it;
+// compound labels enumerated. Its \p{} classes need the "u" flag, kept on the regexes that use it — under "iu" case
+// folding maps ſ → s and K → k, so it never reaches the phrases above (D-1582). Shared with the model probe.
+export const STATUS_LABEL = String.raw `(?<![\p{L}\p{M}\p{N}_])(?:http[_-]?status(?:[_-]?code)?|error[_-]?code|HTTP(?:\/\d(?:\.\d)?)?|status(?:[\s_-]*code)?|code|error)["']?\s*[:=]?\s*["']?`;
+export const LABELLED_429_RE = new RegExp(String.raw `${STATUS_LABEL}\b429\b(?![.,]\d)`, "iu");
+/**
+ * The LEFTMOST quota signal in `text` — a phrase or a labelled 429 — with the source of the regex that matched (the
+ * quota-banner record names it, so a false positive stays legible from the record alone), or null. A phrase and a
+ * label never start at the same index (phrase initials r q u o i t, label initials h e s c); a tie would go to the phrase.
+ */
+export function quotaSignal(text) {
+    const phrase = QUOTA_PHRASE_RE.exec(text), label = LABELLED_429_RE.exec(text);
+    const [match, re] = phrase && (!label || phrase.index <= label.index) ? [phrase, QUOTA_PHRASE_RE] : label ? [label, LABELLED_429_RE] : [null, null];
+    return match && re ? Object.assign(match, { source: re.source }) : null;
+}
 // v1.5 MODEL-01: charset gate for detected model ids (research Pitfall 4, verified 2026-07-10).
 // Ids come from CLI stdout / another program's JSON (models_cache.json) and are echoed into
 // operator-facing lint text and persisted to doctor.json — defense-in-depth for MODEL-05 (config

package/dist/compile/gsd.js

@@ -307,14 +307,15 @@ export function compileGsd(src, root) {
     // snapshot; classifyContextPath remains the single authority for missing, untracked, and glob refs.
     const gitDir = dirname(files[0]);
     const top = spawnSync("git", ["-C", gitDir, "rev-parse", "--show-toplevel"], { encoding: "utf8", maxBuffer: 1 << 28 });
-    const tree = spawnSync("git", ["-C", gitDir, "ls-tree", "--full-tree", "-r", "--name-only", "HEAD"], { encoding: "utf8", maxBuffer: 1 << 28 });
+    // -z (queue row 71): without it a non-ASCII path is C-quoted and a tracked ref reads as untracked
+    const tree = spawnSync("git", ["-C", gitDir, "ls-tree", "--full-tree", "-r", "--name-only", "-z", "HEAD"], { encoding: "utf8", maxBuffer: 1 << 28 });
     const repoRoot = typeof top.stdout === "string" ? top.stdout.trim() : "";
     // `root` is the repository whose worktrees will consume these refs. A source nested inside some
     // unrelated repository (as with vendored fixtures) must not be judged against that outer tree.
     const authoritative = root === undefined
         || (top.status === 0 && repoRoot !== "" && realpathSync(root) === realpathSync(repoRoot));
     if (top.status === 0 && tree.status === 0 && repoRoot && typeof tree.stdout === "string" && authoritative) {
-        const tracked = new Set(tree.stdout.split("\n").filter(Boolean));
+        const tracked = new Set(tree.stdout.split("\0").filter(Boolean));
         const unreachable = [];
         for (const [i, t] of tasks.entries()) {
             for (const entry of compiled[i].refs) {

package/dist/compile/native.js

@@ -23,11 +23,12 @@ function trackedAtHead(dir) {
     // --full-tree is load-bearing: without it `ls-tree` scopes to the CWD's subtree and prints paths
     // relative to it, so a spec in specs/ would see only specs/-relative names and misjudge every
     // path outside it. Caught only by a fixture whose spec is NOT at the repo root.
-    const r = git("ls-tree", "--full-tree", "-r", "--name-only", "HEAD");
+    // -z (queue row 71): without it a non-ASCII path is C-quoted and a tracked file reads as untracked
+    const r = git("ls-tree", "--full-tree", "-r", "--name-only", "-z", "HEAD");
     // not a repo, or no commits yet — fail open, so non-repo fixtures and fresh inits stay silent
     if (top.status !== 0 || r.status !== 0 || typeof r.stdout !== "string")
         return undefined;
-    return { root: top.stdout.trim(), tracked: new Set(r.stdout.split("\n").filter(Boolean)) };
+    return { root: top.stdout.trim(), tracked: new Set(r.stdout.split("\0").filter(Boolean)) };
 }
 const GLOB_CHARS = /[*?{[]/;
 /**

package/dist/drivers/herdr.d.ts

@@ -1,5 +1,5 @@
 import { type JournalEvent } from "../run/journal.js";
-import { type ExecutorDriver, type FocusTarget, type FocusResult, type NotifyOpts, type PanesToCloseOpts, type Slot, type SlotOpts } from "./types.js";
+import { type ExecutorDriver, type FocusTarget, type TransportState, type FocusResult, type NotifyOpts, type PanesToCloseOpts, type Slot, type SlotOpts } from "./types.js";
 export declare const TRAILER_SAFE_FLOOR_COLS = 108;
 export declare const TRAILER_WIDTH_MARGIN = 2;
 export declare const DELIVERY_ATTEMPTS = 3;
@@ -134,6 +134,7 @@ export declare class HerdrDriver implements ExecutorDriver {
     waitAgentStatus(slot: Slot, status: string, timeoutMs: number): Promise<boolean>;
     status(slot: Slot): Promise<string>;
     private statusByName;
+    transportState(_slot: Slot): Promise<TransportState>;
     read(slot: Slot, lines: number): Promise<string>;
     sendKey(slot: Slot, key: string): Promise<void>;
     notify(msg: string, opts?: NotifyOpts): Promise<void>;

package/dist/drivers/herdr.js

@@ -1142,6 +1142,11 @@ export class HerdrDriver {
             return "unknown";
         }
     }
+    // Queue row 108: a pane's transport closes when the pane is gone, which the dead-worker park already requires
+    // (an empty read), so the answer is closed — parity with the park before row 108, never a new hold.
+    async transportState(_slot) {
+        return { closed: true };
+    }
     async read(slot, lines) {
         const pane = await this.paneId(slot);
         const r = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${lines}`, slot.cwd);

package/dist/drivers/orca.d.ts

@@ -1,7 +1,7 @@
 import { type ShResult } from "../run/git.js";
 import { type JournalEvent } from "../run/journal.js";
 import { type WatchBoardOwner } from "../run/supervision.js";
-import { type ExecutorDriver, type FocusTarget, type FocusResult, type NotifyOpts, type Slot, type SlotOpts } from "./types.js";
+import { type ExecutorDriver, type FocusTarget, type TransportState, type FocusResult, type NotifyOpts, type Slot, type SlotOpts } from "./types.js";
 /** The response families the ONE shared envelope parser serves. There is no second JSON seam. */
 export declare const ORCA_RESPONSE_FAMILIES: readonly ["status", "create", "list", "read", "send", "wait", "show", "close", "worktree-current", "worktree-set", "hooks-status", "split"];
 export type OrcaFamily = (typeof ORCA_RESPONSE_FAMILIES)[number];
@@ -325,6 +325,7 @@ export declare class OrcaDriver implements ExecutorDriver {
     readScreen(slot: Slot): Promise<string>;
     /** A single UNPAGED tail read — exactly what the caller asked for and nothing more. Markers split
      *  across cursor pages are not reassembled here; that is waitOutput's job. */
+    transportState(_slot: Slot): Promise<TransportState>;
     read(slot: Slot, lines: number): Promise<string>;
     /**
      * Bounded cursor-paged sweep into the slot's accumulated buffer. The first read of a slot carries

package/dist/drivers/orca.js

@@ -1545,6 +1545,11 @@ export class OrcaDriver {
     }
     /** A single UNPAGED tail read — exactly what the caller asked for and nothing more. Markers split
      *  across cursor pages are not reassembled here; that is waitOutput's job. */
+    // Queue row 108: a pane's transport closes when the pane is gone, which the dead-worker park already requires
+    // (an empty read), so the answer is closed — parity with the park before row 108, never a new hold.
+    async transportState(_slot) {
+        return { closed: true };
+    }
     async read(slot, lines) {
         if (!Number.isInteger(lines) || lines <= 0)
             throw new OrcaError("read", `invalid line limit ${lines}`, "");

package/dist/drivers/subprocess.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutorDriver, NotifyOpts, Slot } from "./types.js";
+import type { ExecutorDriver, NotifyOpts, Slot, TransportState } from "./types.js";
 export declare const MAX_BUF: number;
 export declare const HERDR_CONTROL_VARS: readonly ["HERDR_ENV", "HERDR_SOCKET_PATH", "ORCA_TERMINAL_HANDLE", "ORCA_PANE_KEY", "ORCA_TAB_ID"];
 /**
@@ -22,6 +22,7 @@ export declare class SubprocessDriver implements ExecutorDriver {
     }): Promise<boolean>;
     waitAgentStatus(slot: Slot, status: string, timeoutMs: number): Promise<boolean>;
     status(_slot: Slot): Promise<string>;
+    transportState(slot: Slot): Promise<TransportState>;
     read(slot: Slot, lines: number): Promise<string>;
     focus(): Promise<import("./types.js").FocusResult>;
     notify(msg: string, _opts?: NotifyOpts): Promise<void>;

package/dist/drivers/subprocess.js

@@ -75,6 +75,16 @@ export class SubprocessDriver {
         p.stderr.on("data", (d) => (s.buf = (s.buf + d).slice(-MAX_BUF)));
         p.on("close", () => (s.exited = true));
         p.on("error", (e) => { s.buf = (s.buf + `\n[tickmarkr subprocess error] ${e}\n`).slice(-MAX_BUF); s.exited = true; });
+        // Queue row 108 (D-1622): THIS run's transport state. The slot's `exited` outlives an invocation (a reused slot) and
+        // an 'error' sets it before stdio closes, so it is not the fact. This object is fresh per run and written only by
+        // THIS process's listeners: a previous worker's late close lands on its own state, never on the current one. Only
+        // stdio 'close' closes it — or a spawn that never started (no pid), which has nothing to drain.
+        const invocation = { closed: false, exitCode: null, signal: null };
+        s.invocation = invocation;
+        p.on("exit", (code, signal) => { invocation.exitCode = code; invocation.signal = signal; });
+        p.on("close", () => { invocation.closed = true; });
+        p.on("error", () => { if (p.pid === undefined)
+            invocation.closed = true; });
     }
     async waitOutput(slot, pattern, timeoutMs, opts) {
         const s = this.state(slot);
@@ -103,6 +113,11 @@ export class SubprocessDriver {
     async status(_slot) {
         return "unknown"; // no screen to scrape; never reports blocked
     }
+    async transportState(slot) {
+        const s = this.state(slot);
+        const run = s.invocation;
+        return { closed: run?.closed ?? false, bytes: Buffer.byteLength(s.buf), exitCode: run?.exitCode ?? null, signal: run?.signal ?? null };
+    }
     async read(slot, lines) {
         return this.state(slot).buf.split("\n").slice(-lines).join("\n");
     }

package/dist/drivers/types.d.ts

@@ -83,6 +83,13 @@ export interface SlotPlacement {
     surface?: string;
     hostPlatform?: string;
 }
+/** Queue row 108: a worker transport's own account of its output stream (ExecutorDriver.transportState). */
+export interface TransportState {
+    closed: boolean;
+    bytes?: number;
+    exitCode?: number | null;
+    signal?: string | null;
+}
 export interface ExecutorDriver {
     id: string;
     interactive: boolean;
@@ -101,6 +108,7 @@ export interface ExecutorDriver {
     waitAgentStatus(slot: Slot, status: string, timeoutMs: number): Promise<boolean>;
     status(slot: Slot): Promise<string>;
     read(slot: Slot, lines: number): Promise<string>;
+    transportState?(slot: Slot): Promise<TransportState>;
     sendKey?(slot: Slot, key: string): Promise<void>;
     nudge?(slot: Slot, message: string): Promise<boolean>;
     notify(msg: string, opts?: NotifyOpts): Promise<void>;

package/dist/gates/acceptance.d.ts

@@ -55,6 +55,7 @@ export type AcceptanceCorpusAuditResult = {
     };
 };
 export declare function auditAcceptanceCorpus(corpusRoot: string, listedTests: readonly VitestListedTest[]): AcceptanceCorpusAuditResult[];
+export declare function changedLinesByFile(diff: string): Map<string, Set<number>>;
 /** OBS-1151: one criterion of a parsed judge verdict, as the contradiction check compares it. */
 export interface JudgedCriterion {
     id: string;

package/dist/gates/acceptance.js

@@ -10,6 +10,7 @@ import { checkTaskDiffCaps, fetchTaskDiff, isProtectedEvidence, setAsideReceiptP
 import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, SeatLaunchError, verdictNonceLine } from "./llm.js";
 import { classifyVerdictCause } from "./verdict-cause.js";
 import { reviewableLogicDiff } from "./artifact-manifest.js";
+import { diffSidePath } from "./git-paths.js";
 import { classifyFailureOutput } from "./baseline.js";
 // Fable F4: acceptance judge shares review's 900s timeout — 300s default killed frontier judges on cap-sized diffs.
 const JUDGE_TIMEOUT_MS = 900_000;
@@ -248,8 +249,9 @@ function oracleExecutionFailure(label, code, stdout, stderr) {
 // holds: a citation outside every hunk, or to an untouched file, still fails (matching the documented
 // "outside every changed hunk → rejected" contract in acceptance.test.ts).
 // ponytail: assumes git's default a/ b/ prefixes (fetchTaskDiff uses plain `git diff`); revisit if a
-// caller passes a --no-prefix diff.
-function changedLinesByFile(diff) {
+// caller passes a --no-prefix diff. Queue row 71b: a +++ side is decoded by the shared git-paths reader (git's
+// C-quoting and the tab that ends a space-holding name), so a non-ASCII file's lines are citable by its real name.
+export function changedLinesByFile(diff) {
     const byFile = new Map();
     let path = null;
     let newLine = 0;
@@ -263,8 +265,7 @@ function changedLinesByFile(diff) {
         if (!inHunk && raw.startsWith("--- "))
             continue;
         if (!inHunk && raw.startsWith("+++ ")) {
-            const p = raw.slice(4).trim();
-            path = p === "/dev/null" ? null : p.replace(/^[ab]\//, "");
+            path = diffSidePath(raw.slice(4));
             continue;
         }
         const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(raw);

package/dist/gates/artifact-manifest.js

@@ -3,6 +3,7 @@
  * path receives capture accounting only when its manifest row names a
  * registered producer and repeats that producer's current provenance exactly.
  */
+import { diffSidePath, gitHeaderPaths, unquoteGitPath } from "./git-paths.js";
 const GOLDEN_PROVENANCE = {
     source: "src/tui/cockpit/capture.ts",
     entrypoint: "regenerateGoldenFrames",
@@ -201,9 +202,7 @@ function deletedPath(section) {
         return null;
     const oldPath = /^--- (.+)$/m.exec(section)?.[1]
         ?? /^Binary files (.+) and \/dev\/null differ$/m.exec(section)?.[1];
-    if (!oldPath || oldPath === "/dev/null")
-        return null;
-    return unquoteGitPath(oldPath).replace(/^a\//, "");
+    return oldPath ? diffSidePath(oldPath) : null;
 }
 /**
  * Whole-file source deletions retain their operation fact instead of spending
@@ -220,26 +219,6 @@ export function reviewableLogicDiff(diff) {
         return `deleted file: ${path}\n`;
     }).join("");
 }
-function unquoteGitPath(raw) {
-    const value = raw.trim();
-    if (!value.startsWith('"') || !value.endsWith('"'))
-        return value;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value.slice(1, -1);
-    }
-}
-function diffSidePath(raw) {
-    const value = unquoteGitPath(raw);
-    if (value === "/dev/null")
-        return null;
-    return value.replace(/^[ab]\//, "");
-}
-function gitHeaderTokens(raw) {
-    return raw.match(/"(?:\\.|[^"\\])*"|\S+/g) ?? [];
-}
 function parseContentSection(section) {
     const lines = section.split("\n");
     const minus = lines.findIndex((line) => line.startsWith("--- "));
@@ -267,12 +246,7 @@ function sectionPaths(section, parsed) {
         return [...new Set([renamedFrom, renamedTo].filter((path) => path !== undefined).map(unquoteGitPath))];
     }
     const header = /^diff --git (.+)$/m.exec(section)?.[1];
-    if (!header)
-        return [];
-    const tokens = gitHeaderTokens(header);
-    if (tokens.length !== 2)
-        return [];
-    return [...new Set(tokens.map(diffSidePath).filter((path) => path !== null))];
+    return header ? gitHeaderPaths(header) : [];
 }
 function hunkPayload(body, sign) {
     return body

package/dist/gates/git-paths.d.ts

@@ -0,0 +1,18 @@
+/** A path exactly as git printed it, quoted or not, decoded to the name on disk. Unquoted input is returned as is. */
+export declare function unquoteGitPath(raw: string): string;
+/**
+ * One side of a `--- ` / `+++ ` line, after its four-character marker: null for /dev/null, else the path without its
+ * a/ or b/ prefix. git ends a side holding a space with ONE tab (quoted or not, measured on git 2.54) — exactly that tab
+ * is dropped, never trimmed, so a name that begins or ends with a space survives.
+ */
+export declare function diffSidePath(raw: string): string | null;
+/**
+ * The paths a `diff --git <a> <b>` header names, for a section with no ---/+++ or rename lines (a mode-only change, a
+ * binary or an empty file). git writes such a header for ONE path, twice: `a/<X> b/<X>`. Each grammar only splits the
+ * header into its two sides, and both answer through the same samePath rule (D-1608), so they cannot disagree: an
+ * unquoted header splits where git apply's git_header_name does — the ` ` before `b/` at the midpoint, whitespace kept, so
+ * a name that ends in (or is) a space survives (D-1604); a quoted one must be two complete quoted strings joined by
+ * exactly one space, matched end to end, each unquoted with its prefix kept (D-1607). Anything else is unresolvable: []
+ * (the artifact manifest then keeps the section as logic, rendered and charged — over-charged, never hidden).
+ */
+export declare function gitHeaderPaths(header: string): string[];

package/dist/gates/git-paths.js

@@ -0,0 +1,69 @@
+/**
+ * Queue row 71b: git's path quoting, decoded once for every patch-text parser (acceptance's citable changed lines,
+ * the artifact manifest's section paths). git C-quotes a path holding a byte >= 0x80 (unless core.quotePath=false),
+ * a control character, a double quote or a backslash — `"docs/caf\303\251.md"` — with the escapes \a \b \t \n \v \f
+ * \r \" \\ and \ooo octal BYTES, so a non-ASCII name arrives as its UTF-8 bytes. JSON.parse is not this grammar: it
+ * has no octal escapes and returned `caf\303\251` with literal backslashes.
+ */
+const ESCAPES = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, "\\": 92 };
+/** A path exactly as git printed it, quoted or not, decoded to the name on disk. Unquoted input is returned as is. */
+export function unquoteGitPath(raw) {
+    if (raw.length < 2 || !raw.startsWith('"') || !raw.endsWith('"'))
+        return raw;
+    const chars = Array.from(raw.slice(1, -1)); // code points, so a non-ASCII character is pushed whole
+    const bytes = [];
+    for (let i = 0; i < chars.length; i++) {
+        const ch = chars[i];
+        if (ch !== "\\") {
+            bytes.push(...Buffer.from(ch, "utf8"));
+            continue;
+        }
+        const octal = /^[0-7]{1,3}/.exec(chars.slice(i + 1, i + 4).join(""))?.[0];
+        if (octal) {
+            bytes.push(parseInt(octal, 8) & 0xff);
+            i += octal.length;
+            continue;
+        }
+        const escape = chars[i + 1];
+        if (escape !== undefined && escape in ESCAPES) {
+            bytes.push(ESCAPES[escape]);
+            i++;
+            continue;
+        }
+        bytes.push(92); // a backslash git never writes alone: kept literally
+    }
+    return Buffer.from(bytes).toString("utf8");
+}
+/**
+ * One side of a `--- ` / `+++ ` line, after its four-character marker: null for /dev/null, else the path without its
+ * a/ or b/ prefix. git ends a side holding a space with ONE tab (quoted or not, measured on git 2.54) — exactly that tab
+ * is dropped, never trimmed, so a name that begins or ends with a space survives.
+ */
+export function diffSidePath(raw) {
+    const value = unquoteGitPath(raw.endsWith("\t") ? raw.slice(0, -1) : raw);
+    if (value === "/dev/null")
+        return null;
+    return value.replace(/^[ab]\//, "");
+}
+/** The one path a header side pair names — `a/<X>` and `b/<X>`, the same non-empty X — or none (D-1608: one rule). */
+function samePath(left, right) {
+    return left.startsWith("a/") && right.startsWith("b/") && left.length > 2 && left.slice(2) === right.slice(2) ? [left.slice(2)] : [];
+}
+/**
+ * The paths a `diff --git <a> <b>` header names, for a section with no ---/+++ or rename lines (a mode-only change, a
+ * binary or an empty file). git writes such a header for ONE path, twice: `a/<X> b/<X>`. Each grammar only splits the
+ * header into its two sides, and both answer through the same samePath rule (D-1608), so they cannot disagree: an
+ * unquoted header splits where git apply's git_header_name does — the ` ` before `b/` at the midpoint, whitespace kept, so
+ * a name that ends in (or is) a space survives (D-1604); a quoted one must be two complete quoted strings joined by
+ * exactly one space, matched end to end, each unquoted with its prefix kept (D-1607). Anything else is unresolvable: []
+ * (the artifact manifest then keeps the section as logic, rendered and charged — over-charged, never hidden).
+ */
+export function gitHeaderPaths(header) {
+    if (!header.includes('"')) {
+        const half = (header.length - 5) / 2;
+        return Number.isInteger(half) && half > 0 && header[2 + half] === " "
+            ? samePath(header.slice(0, 2 + half), header.slice(3 + half)) : [];
+    }
+    const quoted = /^("(?:\\.|[^"\\])*") ("(?:\\.|[^"\\])*")$/.exec(header);
+    return quoted ? samePath(unquoteGitPath(quoted[1]), unquoteGitPath(quoted[2])) : [];
+}

package/dist/gates/scope.js

@@ -32,7 +32,9 @@ export async function scopeGate(worktree, integrationTip, files, result, allowDe
     if (!files.length)
         return { gate: "scope", pass: true, details: "no file scope declared — unrestricted" };
     const baseRef = await scopeDiffBase(worktree, integrationTip);
-    const changed = (await shGitOk(`git diff --name-only '${baseRef}..HEAD'`, worktree)).trim().split("\n").filter(Boolean);
+    // Queue row 71: without -z git C-quotes a non-ASCII path (`"docs/caf\303\251.md"`), which no files[] entry can ever
+    // match; -z prints every path verbatim, NUL-terminated (no trim: a name may begin or end with a space).
+    const changed = (await shGitOk(`git diff --name-only -z '${baseRef}..HEAD'`, worktree)).split("\0").filter(Boolean);
     const inScope = filesGlob(files); // the ONE files[] matcher — src/graph/files-glob.ts (Q120s)
     const offenders = changed.filter((f) => !inScope(f));
     if (!offenders.length)

package/dist/run/daemon.d.ts

@@ -18,7 +18,7 @@ export interface DispatchObservation {
     outcome: "accepted" | "not-accepted";
     authoritative: true;
 }
-export declare function heldWorkerTransport(driver: ExecutorDriver, slot: Slot, dispatchId: string, held: (data: Record<string, unknown>) => void, sleep?: (ms: number) => Promise<void>): Pick<ExecutorDriver, "run" | "read" | "status" | "waitOutput" | "waitAgentStatus">;
+export declare function heldWorkerTransport(driver: ExecutorDriver, slot: Slot, dispatchId: string, held: (data: Record<string, unknown>) => void, sleep?: (ms: number) => Promise<void>): Pick<ExecutorDriver, "run" | "read" | "status" | "waitOutput" | "waitAgentStatus" | "transportState">;
 export declare function setAttemptHardTimeoutMsForTests(ms: number): void;
 export declare function resetAttemptHardTimeoutMsForTests(): void;
 export { harvestCpuFlatWindowMs, resetHarvestCpuFlatMsForTests, setHarvestCpuFlatMsForTests, workerTreeCpuMs, } from "./stall.js";

package/dist/run/daemon.js

@@ -13,7 +13,7 @@ import { batchedProcessProbes, runnerPids } from "./suite-census.js";
 import { stringify } from "yaml";
 import { BOOTSTRAP_FAILURE_RE, classifyDeadChannel, classifyTransientCapacity, trailerPattern, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, getAdapter, probeAll, readDoctor, rolePools } from "../adapters/registry.js";
-import { SettledTrailerTracker, addUsage, CAPACITY_RE, channelKey, matchesInputBox, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
+import { SettledTrailerTracker, addUsage, CAPACITY_RE, channelKey, matchesInputBox, matchesTrustDialog, quotaSignal } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { collateralHits } from "../compile/collateral.js";
 import { ExecutionPolicySchema, DEFAULT_DIFF_CAP, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
@@ -103,6 +103,8 @@ export function heldWorkerTransport(driver, slot, dispatchId, held, sleep = (ms)
         status: (s) => probe("status", () => driver.status(s)),
         waitOutput: (s, p, ms, o) => probe("waitOutput", () => driver.waitOutput(s, p, ms, o)),
         waitAgentStatus: (s, st, ms) => probe("waitAgentStatus", () => driver.waitAgentStatus(s, st, ms)),
+        // row 108: forwarded only when the driver answers; absent stays absent, so the park reads it as unknown
+        ...(driver.transportState ? { transportState: (s) => probe("transportState", () => driver.transportState(s)) } : {}),
         run: async (s, command) => {
             const observer = driver;
             // A second delivery needs a receipt for THIS mutation, not an empty or idle terminal.
@@ -683,7 +685,7 @@ export function resetNudgeTimingForTests() {
     workerNudgeGraceMs = WORKER_NUDGE_GRACE_MS;
 }
 // T1 (OBS-263): in-loop quota-banner classification — the banner IS output, so the empty-output
-// rules can never catch it and the post-loop QUOTA_RE check only runs after the full window. Two
+// rules can never catch it and the post-loop quota check only runs after the full window. Two
 // consecutive matching slices plus this much monotonic-tracker silence classify (a worker whose
 // diff merely quotes "rate limit" keeps working undisturbed).
 const QUOTA_BANNER_SILENT_MS = 3 * 60_000;
@@ -5361,6 +5363,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     let rowSaturationHeld = false; // journaled once per attempt when the kill stands down
                                     let cpuHeld = false; // likewise for the CPU leg's stand-down (OBS-548)
                                     let paneReadHeld = false;
+                                    let transportHeldNoted = false; // row 108: an open transport is journaled once per attempt
                                     let paneStatusHeld = false;
                                     const hardDeadline = attemptStart + (attemptHardTimeoutMs ?? stallWindowMs * 4);
                                     await armCpuLeg(true);
@@ -5512,7 +5515,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         // and concludes the attempt the same way — only its post-loop outcome differs (bounded
                                         // requeue on this seat, then same-floor failover, never demotion). Quota wins a tie.
                                         const bannerRows = stallSnapshotBannerRows(paneText);
-                                        const quotaBanner = QUOTA_RE.exec(bannerRows);
+                                        const quotaBanner = quotaSignal(bannerRows);
                                         const bannerMatch = quotaBanner ?? CAPACITY_RE.exec(bannerRows);
                                         if (bannerMatch)
                                             quotaStreak++;
@@ -5533,7 +5536,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             // no `output =` here: the post-loop no-trailer tail re-reads the pane anyway, so an
                                             // assignment would only split the classification read from the verdict read.
                                             quotaBannerKilled = true;
-                                            journal.append("quota-banner", t.id, { slot: slot.name, attempt, silentMs: sliceNow - lastProgressAt, matched: quotaBanner[0], excerpt: quotaBanner.input, regex: QUOTA_RE.source });
+                                            journal.append("quota-banner", t.id, { slot: slot.name, attempt, silentMs: sliceNow - lastProgressAt, matched: quotaBanner[0], excerpt: quotaBanner.input, regex: quotaBanner.source });
                                             break;
                                         }
                                         // T1 (OBS-262): the `paged` latch is deleted — status is sampled EVERY slice (and
@@ -5675,10 +5678,42 @@ export async function runDaemon(repoRoot, opts = {}) {
                                         const confirmedProcessTree = worktreeDelta === "unchanged"
                                             ? await observeWorkerProcessTree(dispatchScript, wt)
                                             : "unmeasurable";
+                                        // Queue row 108 (D-1619): the transport's own CLOSED fact. A subprocess 'exit' precedes its stdio 'close', so a
+                                        // just-finished worker can look gone — no pane bytes, no process, an unchanged worktree — with its trailer still
+                                        // in flight. Not closed, or a driver with no answer, never parks: the rolling timeout continues, as for every
+                                        // other unproven leg. Pane drivers answer closed (their closure is the pane gone, already required above).
+                                        // ORDER MATTERS: the closed fact is read FIRST, then the pane once more. Closed means every byte is already in
+                                        // the read surface, so an empty read AFTER it proves the worker wrote nothing; the earlier empty reads may
+                                        // predate the close and are not that proof (the stale-empty race this row's own test caught).
+                                        const transport = confirmedProcessTree === "empty" ? await workerTransport.transportState?.(slot) : undefined;
+                                        let drainedEmpty = false;
+                                        if (transport?.closed === true) {
+                                            try {
+                                                const drained = await workerTransport.read(slot, PANE_READ_ROWS);
+                                                drainedEmpty = drained.trim().length === 0;
+                                                if (!drainedEmpty) {
+                                                    everHadOutput = true;
+                                                    if (stallProgress.observe({ paneText: drained, contextTokens }))
+                                                        lastProgressAt = Date.now();
+                                                }
+                                            }
+                                            catch (error) {
+                                                if (error instanceof HeldProbeExhausted)
+                                                    throw error;
+                                            }
+                                        }
                                         const deathCertain = paneAbsent
                                             && processTree === "empty"
                                             && confirmedProcessTree === "empty"
-                                            && worktreeDelta === "unchanged";
+                                            && worktreeDelta === "unchanged"
+                                            && transport?.closed === true
+                                            && drainedEmpty;
+                                        if (confirmedProcessTree === "empty" && transport?.closed !== true && !transportHeldNoted) {
+                                            transportHeldNoted = true;
+                                            noteWorkerLiveness("worker-dead-held", {
+                                                slot: slot.name, attempt, reason: transport ? "transport-open" : "transport-unknown", ...(transport ? { transport } : {}),
+                                            });
+                                        }
                                         if (deathCertain) {
                                             const preservation = await preserveDeadWorker(wt, taskBase);
                                             if (!preservation.ref) {
@@ -5692,7 +5727,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                                             deadWorkerPark = { ref, reason };
                                             journal.append("worktree-preserved", t.id, { ref, ...producerFields(producerNow()) });
                                             noteWorkerLiveness("worker-dead-held", {
-                                                slot: slot.name, attempt, reason: "unambiguous-worker-death", ref,
+                                                // row 108 legibility: the transport's closed state, byte count and exit code/signal (a kill shows its signal)
+                                                slot: slot.name, attempt, reason: "unambiguous-worker-death", ref, transport,
                                             });
                                             break;
                                         }
@@ -6256,7 +6292,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // this repository's own fixture prose. The matched bytes and their stream offset ride the
                         // row so a false positive is legible from the record alone.
                         const quotaMatch = (interactive ? !workerFinished : exitCode !== 0)
-                            ? QUOTA_RE.exec(stallSnapshotBannerRows(output))
+                            ? quotaSignal(stallSnapshotBannerRows(output))
                             : null;
                         // OBS-1161: transient capacity reads the SAME tail under the same guards — a live idle banner
                         // and a no-trailer capacity exit classify identically — through the parse-boundary rule that a

package/dist/run/git-trust.d.ts

@@ -74,6 +74,24 @@ export interface DetachedAddCapability {
 export interface TrustedStoreCapability {
     store: string;
 }
+/**
+ * Whether, before the child spawns, the git its PATH resolves honours GIT_REFERENCE_BACKEND (git >= 2.54): a fresh
+ * probe repository whose own refs lack PROBE_REF, pinned to a fresh store that holds it as a symbolic ref. A git that
+ * ignores the pin reads the probe repository's own refs. Nothing is cached: each attempt probes again.
+ * Queue row 21: only a git that RAN TO COMPLETION and answered something else has shown it ignores the pin. A spawn
+ * error (EAGAIN, EMFILE, ENOENT), a timeout or a kill is no answer at all — "unknown", never "git < 2.54".
+ */
+export type RefStorePinProbe = {
+    pin: "honoured" | "ignored";
+} | {
+    pin: "unknown";
+    cause: string;
+};
+/** A probe git that threw: "ignored" only when it ran to completion and exited non-zero (a numeric exit status, no
+ * signal, no error code); anything else never gave an answer that was read — a timeout, a kill, a spawn failure, or
+ * ENOBUFS (status 0 with its output over the buffer cap) — and the cause is named for the refusal (queue row 21's
+ * closed table, D-1563). */
+export declare function refStorePinProbeFailure(error: unknown): RefStorePinProbe;
 /**
  * v2.6.8 T2 (P3): the same uncached check, returning the child of tickmarkr's OWN git in a linked checkout — `env`
  * (the caller's) with GIT_DIR, GIT_COMMON_DIR and GIT_WORK_TREE set to the canonical gitdir, trusted common directory
@@ -83,7 +101,8 @@ export interface TrustedStoreCapability {
  * descendant) is followed for neither config, hooks, info/, objects nor refs: HEAD, branches, status and diffs read
  * the real repository and every ref write lands in the trusted store, whatever an inherited GIT_CONFIG_* or ref backend
  * says; a commondir REMOVED after it cannot move the main checkout's branch. Before such a child spawns, the git it
- * would run must prove it honours that pin (refStorePinHonoured); one that cannot (git < 2.54) runs without it, below.
+ * would run must prove it honours that pin (refStorePinProbe); one that cannot (git < 2.54) runs without it, below, and
+ * one whose probe never answers twice is refused (queue row 21).
  * Nothing here reads the command, and no caller leaves any pin. `recheck` (after the child exits) fails closed on ANY change to commondir since the check: the result
  * of that child is never returned. An ordinary checkout or a non-repository gets no pin.
  * NAMED RESIDUAL: git still reads $GIT_DIR/config.worktree when the trusted common config already enables

package/dist/run/git-trust.js

@@ -235,12 +235,21 @@ function assertFilesRefStore(common) {
 /** A detached auto gc or maintenance would outlive its child and read refs through a view already released. */
 const NO_BACKGROUND_GIT = "'gc.auto=0' 'maintenance.auto=false'";
 const PROBE_REF = "refs/tickmarkr/ref-pin-probe", PROBE_TARGET = "refs/tickmarkr/ref-pin-honoured";
-/**
- * Whether, before the child spawns, the git its PATH resolves honours GIT_REFERENCE_BACKEND (git >= 2.54): a fresh
- * probe repository whose own refs lack PROBE_REF, pinned to a fresh store that holds it as a symbolic ref. A git that
- * ignores the pin reads the probe repository's own refs. Nothing is cached: each attempt probes again.
- */
-function refStorePinHonoured(env) {
+/** A probe git that threw: "ignored" only when it ran to completion and exited non-zero (a numeric exit status, no
+ * signal, no error code); anything else never gave an answer that was read — a timeout, a kill, a spawn failure, or
+ * ENOBUFS (status 0 with its output over the buffer cap) — and the cause is named for the refusal (queue row 21's
+ * closed table, D-1563). */
+export function refStorePinProbeFailure(error) {
+    const ran = error;
+    if (typeof ran?.status === "number" && !ran.signal && !ran.code)
+        return { pin: "ignored" };
+    // Queue row 107: the code names the cause before the signal — Node kills an overflowing child with SIGTERM and sets
+    // ENOBUFS, and "killed by SIGTERM" would hide why; a self-inflicted kill carries no code, so it still reads "killed by".
+    const cause = ran?.code === "ETIMEDOUT" ? "timed out after 15 s" : ran?.code ? `failed with ${ran.code}`
+        : ran?.signal ? `killed by ${ran.signal}` : "failed with an unknown error";
+    return { pin: "unknown", cause };
+}
+function refStorePinProbe(env) {
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-ref-pin-"));
     try {
         const repo = join(dir, "repo"), store = join(dir, "store");
@@ -252,12 +261,14 @@ function refStorePinHonoured(env) {
         const probe = { ...env, GIT_DIR: repo, GIT_REFERENCE_BACKEND: `files://${store}` };
         for (const k of ["GIT_COMMON_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES"])
             delete probe[k];
-        let read = "";
+        let read;
         try {
             read = execFileSync("git", ["symbolic-ref", PROBE_REF], { cwd: dir, env: probe, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15_000 }).trim();
         }
-        catch { /* refused below */ }
-        return read === PROBE_TARGET;
+        catch (error) {
+            return refStorePinProbeFailure(error);
+        }
+        return { pin: read === PROBE_TARGET ? "honoured" : "ignored" };
     }
     finally {
         rmSync(dir, { recursive: true, force: true });
@@ -280,7 +291,8 @@ function warnRefStorePinUnavailable() {
  * descendant) is followed for neither config, hooks, info/, objects nor refs: HEAD, branches, status and diffs read
  * the real repository and every ref write lands in the trusted store, whatever an inherited GIT_CONFIG_* or ref backend
  * says; a commondir REMOVED after it cannot move the main checkout's branch. Before such a child spawns, the git it
- * would run must prove it honours that pin (refStorePinHonoured); one that cannot (git < 2.54) runs without it, below.
+ * would run must prove it honours that pin (refStorePinProbe); one that cannot (git < 2.54) runs without it, below, and
+ * one whose probe never answers twice is refused (queue row 21).
  * Nothing here reads the command, and no caller leaves any pin. `recheck` (after the child exits) fails closed on ANY change to commondir since the check: the result
  * of that child is never returned. An ordinary checkout or a non-repository gets no pin.
  * NAMED RESIDUAL: git still reads $GIT_DIR/config.worktree when the trusted common config already enables
@@ -309,7 +321,16 @@ export function ownGitPin(cwd, env, capability = {}) {
     // linked checkout on most installed gits, and a hostile git binary ignores every pin anyway; so it runs with the
     // path pins and the post-exit recheck (the 2.6.7 guard). NAMED RESIDUAL there: refs still resolve through the
     // commondir file, so a rewrite between check and exit can reach the hostile store before the recheck refuses.
-    if (!refStorePinHonoured(child)) {
+    // Queue row 21: a probe that never answered is asked once more; a second non-answer refuses, because dropping to
+    // the weaker guard on a spawn error or timeout under load would silently weaken own git and blame the git version.
+    let pin = refStorePinProbe(child);
+    if (pin.pin === "unknown")
+        pin = refStorePinProbe(child);
+    if (pin.pin === "unknown") {
+        // infra, not a verdict: the ref-store pin probe never answered — name the probe and its cause
+        throw new GitTrustRefusal(common, `could not tell whether this git honours the ref-store pin: the probe (git symbolic-ref ${PROBE_REF}) did not complete twice (${pin.cause}), so tickmarkr's own git does not run here without it`);
+    }
+    if (pin.pin === "ignored") {
         delete child.GIT_REFERENCE_BACKEND;
         warnRefStorePinUnavailable();
         return { env: child, store: common, release: () => { }, unview: (text) => text, recheck };

package/dist/run/stall.js

@@ -559,7 +559,7 @@ export function stallSnapshotTail(text, rows = QUOTA_BANNER_TAIL_ROWS) {
 }
 // T1 review (chrome-blind-matcher class, OBS-152/155): the tail of a RENDERED TUI frame is not
 // "what the pane printed last" — its bottom rows are fixed composer/welcome chrome. Codex pins
-// "• You have 3 usage limit resets available." there, so a raw-tail QUOTA_RE match fires on every
+// "• You have 3 usage limit resets available." there, so a raw-tail quota match fires on every
 // frame of a wedged pane (verified against all 8 frames of tests/fixtures/codex-mcp-spinner) and
 // would fail a live worker over mid-work. Filter the KNOWN chrome instead of everything on screen
 // at some anchor: a novelty baseline cannot distinguish "chrome that was already there" from "a

package/package.json

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