tickmarkr 2.4.0 → 2.4.2

package/dist/adapters/catalog-remote.d.ts

@@ -11,6 +11,7 @@ export interface CatalogCache {
     modelsDev: unknown;
     artificialAnalysis?: unknown;
     liveBench?: unknown;
+    legFetchedAt?: Partial<Record<"modelsDev" | "artificialAnalysis" | "liveBench", string>>;
 }
 export interface CatalogReadResult {
     catalog: CatalogCache;
@@ -47,11 +48,21 @@ export interface RefreshCatalogOptions {
     timeoutMs?: number;
     now?: () => Date;
 }
+export type CatalogLegName = "models.dev" | "Artificial Analysis" | "LiveBench";
+export type CatalogLegStatus = "updated" | "failed" | "skipped";
+export interface CatalogLegResult {
+    leg: CatalogLegName;
+    status: CatalogLegStatus;
+    detail: string;
+    retry: string;
+}
 export interface RefreshCatalogResult {
     updated: boolean;
     catalog: CatalogReadResult;
     warning?: string;
+    legs: CatalogLegResult[];
 }
+export declare const formatCatalogRefreshLegs: (legs: readonly CatalogLegResult[]) => string;
 export declare const catalogCachePath: (repoRoot: string) => string;
 /**
  * Doctor's catalog seam: one synchronous local read with a vendored fail-open fallback.

package/dist/adapters/catalog-remote.js

@@ -60,9 +60,14 @@ const validModelsDevCatalog = (value) => {
     });
 };
 const staleAt = (fetchedAt, now) => {
-    const age = now.getTime() - Date.parse(fetchedAt);
+    const age = now.getTime() - Date.parse(fetchedAt ?? "");
     return !Number.isFinite(age) || age > CATALOG_CACHE_MAX_AGE_MS;
 };
+const legFetchedAt = (catalog, leg) => catalog.legFetchedAt?.[leg] ?? catalog.fetchedAt;
+const catalogStale = (catalog, now, source) => source === "vendored" || staleAt(legFetchedAt(catalog, "modelsDev"), now) || staleAt(legFetchedAt(catalog, "liveBench"), now)
+    || (catalog.artificialAnalysis !== undefined && catalog.legFetchedAt?.artificialAnalysis !== undefined
+        && staleAt(catalog.legFetchedAt.artificialAnalysis, now));
+export const formatCatalogRefreshLegs = (legs) => `catalog refresh: ${legs.map((leg) => `${leg.leg} ${leg.status} (${leg.detail}; ${leg.retry})`).join("; ")}`;
 export const catalogCachePath = (repoRoot) => join(repoRoot, ".tickmarkr", "catalog-cache.json");
 /**
  * Doctor's catalog seam: one synchronous local read with a vendored fail-open fallback.
@@ -74,14 +79,14 @@ export function readCachedCatalog(repoRoot, opts = {}) {
         const parsed = JSON.parse(readFileSync(catalogCachePath(repoRoot), "utf8"));
         if (!validCache(parsed))
             throw new Error("catalog cache schema is invalid");
-        return { catalog: parsed, source: "cache", stale: staleAt(parsed.fetchedAt, now) };
+        return { catalog: parsed, source: "cache", stale: catalogStale(parsed, now, "cache") };
     }
     catch (error) {
         const missing = error.code === "ENOENT";
         return {
             catalog: VENDORED_CATALOG,
             source: "vendored",
-            stale: staleAt(VENDORED_CATALOG.fetchedAt, now),
+            stale: true,
             ...(!missing ? { warning: error instanceof Error ? error.message : String(error) } : {}),
         };
     }
@@ -410,6 +415,13 @@ export async function refreshCatalogCommand(opts) {
     const fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
     const timeoutMs = opts.timeoutMs ?? CATALOG_REFRESH_TIMEOUT_MS;
     const warnings = [];
+    const legs = [];
+    const stamp = now().toISOString();
+    const legAt = {
+        modelsDev: legFetchedAt(current.catalog, "modelsDev"),
+        liveBench: legFetchedAt(current.catalog, "liveBench"),
+        ...(current.catalog.artificialAnalysis !== undefined ? { artificialAnalysis: legFetchedAt(current.catalog, "artificialAnalysis") } : {}),
+    };
     let modelsDev = current.catalog.modelsDev;
     let modelsDevUpdated = false;
     try {
@@ -417,46 +429,76 @@ export async function refreshCatalogCommand(opts) {
         if (!validModelsDevCatalog(modelsDev))
             throw new Error("models.dev catalog schema is invalid");
         modelsDevUpdated = true;
+        legAt.modelsDev = stamp;
+        legs.push({ leg: "models.dev", status: "updated", detail: "fetched", retry: "next retry after this leg is stale" });
     }
     catch (error) {
-        warnings.push(`models.dev refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        const detail = error instanceof Error ? error.message : String(error);
+        warnings.push(`models.dev refresh failed: ${detail}`);
+        legs.push({ leg: "models.dev", status: "failed", detail, retry: "retry next refresh because this leg kept its prior age" });
     }
     let artificialAnalysis = current.catalog.artificialAnalysis;
+    let artificialAnalysisUpdated = false;
     const apiKey = opts.artificialAnalysisKey ?? process.env.ARTIFICIAL_ANALYSIS_API_KEY?.trim();
     if (apiKey) {
         try {
             artificialAnalysis = await fetchArtificialAnalysis(fetcher, apiKey, timeoutMs);
+            artificialAnalysisUpdated = true;
+            legAt.artificialAnalysis = stamp;
+            legs.push({ leg: "Artificial Analysis", status: "updated", detail: "fetched", retry: "next retry after this leg is stale" });
         }
         catch (error) {
-            warnings.push(`Artificial Analysis refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+            const detail = error instanceof Error ? error.message : String(error);
+            warnings.push(`Artificial Analysis refresh failed: ${detail}`);
+            legs.push({ leg: "Artificial Analysis", status: "failed", detail, retry: "retry next refresh because this leg kept its prior age" });
         }
     }
+    else {
+        delete legAt.artificialAnalysis;
+        legs.push({ leg: "Artificial Analysis", status: "skipped", detail: "no API key", retry: "retry when ARTIFICIAL_ANALYSIS_API_KEY is set" });
+    }
     let liveBench = current.catalog.liveBench;
     let liveBenchUpdated = false;
     try {
         liveBench = await fetchLiveBench(fetcher, timeoutMs);
         liveBenchUpdated = true;
+        legAt.liveBench = stamp;
+        legs.push({ leg: "LiveBench", status: "updated", detail: `table ${LIVEBENCH_TABLE_DATE}`, retry: "next retry after this leg is stale" });
     }
     catch (error) {
-        warnings.push(`LiveBench refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        const detail = error instanceof Error ? error.message : String(error);
+        warnings.push(`LiveBench refresh failed: ${detail}`);
+        legs.push({ leg: "LiveBench", status: "failed", detail, retry: "retry next refresh because this leg kept its prior age" });
     }
-    // models.dev is the required cache spine. Still run every independent leg after it fails, but do
-    // not write a cache that would make the vendored fallback look fetched.
-    if (!modelsDevUpdated) {
-        return { updated: false, catalog: current, warning: warnings.join("; ") };
+    const updated = modelsDevUpdated || artificialAnalysisUpdated || liveBenchUpdated;
+    // models.dev is the cache spine: do not write a cache that would make the vendored fallback look
+    // fetched. Independent legs may only merge onto models.dev fetched now or already held in cache.
+    if (!updated || (!modelsDevUpdated && current.source !== "cache")) {
+        const reportedLegs = !modelsDevUpdated && current.source !== "cache"
+            ? legs.map((leg) => leg.status === "updated"
+                ? {
+                    ...leg,
+                    status: "failed",
+                    detail: "fetched but discarded — models.dev spine unavailable",
+                    retry: "retry next refresh",
+                }
+                : leg)
+            : legs;
+        return { updated: false, catalog: current, legs: reportedLegs, ...(warnings.length ? { warning: warnings.join("; ") } : {}) };
     }
     const catalog = {
         schemaVersion: 1,
-        // A failed keyless leg keeps the old age so doctor/fleet retry it rather than masking it for 7d.
-        fetchedAt: liveBenchUpdated ? now().toISOString() : current.catalog.fetchedAt,
+        fetchedAt: legAt.modelsDev ?? current.catalog.fetchedAt,
         modelsDev,
         ...(artificialAnalysis !== undefined ? { artificialAnalysis } : {}),
         ...(liveBench !== undefined ? { liveBench } : {}),
+        legFetchedAt: legAt,
     };
     writeCatalogCache(opts.repoRoot, catalog);
     return {
-        updated: true,
+        updated,
         catalog: readCachedCatalog(opts.repoRoot, { now }),
+        legs,
         ...(warnings.length ? { warning: warnings.join("; ") } : {}),
     };
 }

package/dist/adapters/claude-code.js

@@ -3,7 +3,7 @@ import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, declareInputBox, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+import { channelsFromConfig, declareInputBox, MODEL_ID_RE, promptFitsArgv, shq, TokenUsageSchema } from "./types.js";
 // SPEND-01/SPEND-11: claude writes a per-session JSONL to ~/.claude/projects/<slug>/ where slug is the
 // realpath'd cwd with every non-alphanumeric char replaced by "-" (verified 114/114 — 36-DIAGNOSIS.md).
 // The old `/`-only formula missed the "." in `.tickmarkr/worktrees/…` — ENOENT on every worktree dispatch.
@@ -239,7 +239,12 @@ export const claudeCode = {
     // live check ate the prompt), and --prompt-suggestions takes an OPTIONAL value — appended directly
     // before the prompt it would swallow it the same way. So the setting's value is always followed by
     // another flag, never by the prompt positional.
-    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --settings '{"promptSuggestionEnabled":false}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    // OBS-931: the same ONE-argv-string hazard as codex (OBS-930) — over promptArgvCeiling() the TUI
+    // launch would E2BIG on Linux, so it returns null → worker-mode-fallback → the headless form.
+    // resumeCommand keeps the shape: its contract returns a string (composer delivery is 2.4.3 work).
+    interactiveCommand: (promptFile, model) => promptFitsArgv(promptFile)
+        ? `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --settings '{"promptSuggestionEnabled":false}' --prompt-suggestions false --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`
+        : null,
     trustDialog: CLAUDE_TRUST_DIALOG,
     inputBox: CLAUDE_INPUT_BOX,
     // A resumed attempt lands in the same painted editor, so it carries the same ghost-text suppression

package/dist/adapters/codex.d.ts

@@ -4,6 +4,7 @@ export declare function readCodexModelsCache(path?: string): {
     fetchedAt?: string;
 };
 export declare const CODEX_TRUST_DIALOG: TrustDialog;
+export declare const CODEX_INPUT_BOX: import("./types.js").InputBox;
 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[];

package/dist/adapters/codex.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+import { channelsFromConfig, declareInputBox, MODEL_ID_RE, promptFitsArgv, shq, TokenUsageSchema } from "./types.js";
 // SPEND-07: codex writes per-session JSONL to ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl — date-partitioned,
 // NOT cwd-keyed. session_meta.payload.cwd is FILE-SCOPED (one codex exec per cwd). token_count events carry
 // per-turn DELTAS in payload.info.last_token_usage; we read POST-HOC (never the pane, never the trailer).
@@ -95,6 +95,56 @@ export const CODEX_TRUST_DIALOG = {
     fingerprint: "Do you trust the contents of this directory?",
     key: "Enter",
 };
+// OBS-930 / OBS-136: the codex TUI's composer, CAPTURED (codex 0.153.4, herdr pane read, 2026-09-05
+// 15:48Z — tests/fixtures/codex-input-box, provenance in its README), never guessed:
+//     (background row)
+//     › Ask Codex to do anything        ← U+203A, ASCII space, then the DIM placeholder (empty) or the draft
+//     (background row)
+//     gpt-5.6-luna medium · /private/tmp/tkr-obs930-smoke   ← footer: <model> <effort> · <cwd>
+// Two facts a fingerprint alone would get wrong: (1) a submitted turn is echoed into the transcript
+// with the SAME caret (`› You are a smoke test.`), and so is the trust dialog's cursor (`› 1. Yes,
+// continue`) — only the composer is followed by the footer row, so the footer is the anchor, exactly
+// as claude's editor is anchored by its rules; (2) an EMPTY composer paints its placeholder as text,
+// so "empty" is a closed allowlist of captured placeholders (0.153.4 above; 0.144.5's
+// `Run /review on my current changes` from tests/fixtures/codex-mcp-spinner). An unknown placeholder
+// reads as occupied and a submit onto it fails closed by name (OBS-140) — a fixture-capture chore,
+// never a drive-by widening. `match` is THE COMPOSER IS PAINTED (true while empty, true mid-turn);
+// `emptyMatch` is painted AND carrying nothing — the only positive evidence a submit registered.
+const CODEX_ANSI_SGR_RE = /\u001B\[[0-9;]*m/g;
+const CODEX_CARET_RE = /^› /;
+const CODEX_PLACEHOLDER_RE = /^› (?:Ask Codex to do anything|Run \/review on my current changes)$/;
+const CODEX_FOOTER_RE = /^\S+(?: \S+)? · \S/;
+// A wrapped or multi-line draft grows the composer downward before the footer.
+// ponytail: a fixed window, not a parser — raise it if a real capture ever shows a taller composer.
+const CODEX_MAX_COMPOSER_ROWS = 8;
+function matchesCodexComposer(paneText, empty) {
+    const lines = paneText.replace(CODEX_ANSI_SGR_RE, "").split("\n").map((l) => l.trim());
+    const caret = empty ? CODEX_PLACEHOLDER_RE : CODEX_CARET_RE;
+    return lines.some((line, i) => {
+        if (!caret.test(line))
+            return false;
+        for (let below = i + 1; below < lines.length && below <= i + CODEX_MAX_COMPOSER_ROWS; below++) {
+            if (CODEX_FOOTER_RE.test(lines[below]))
+                return true;
+            // only the composer's own rows may sit between the caret row and the footer: the background
+            // rows (blank in a text read) and a draft's continuation rows — never another caret row
+            if (lines[below] !== "" && CODEX_CARET_RE.test(lines[below]))
+                return false;
+        }
+        return false;
+    });
+}
+export const CODEX_INPUT_BOX = declareInputBox("codex", {
+    fingerprint: "› ",
+    match: (paneText) => matchesCodexComposer(paneText, false),
+    emptyMatch: (paneText) => matchesCodexComposer(paneText, true),
+    // As for claude (OBS-342): a fresh codex worker slot is a shell awaiting its launch line; every
+    // later delivery is a TUI turn awaiting this composer.
+    firstDeliveryIsLaunch: true,
+    // The 2026-09-05 capture painted the composer ~10 s after the trust answer with MCP suppressed;
+    // claude's bound, kept for the same cold-start reasons.
+    readinessTimeoutMs: 30_000,
+});
 // v1.22 T5 / OBS-16: codex keys trust on absolute path under [projects."<root>"] trust_level="trusted"
 // in ~/.codex/config.toml (CODEX_HOME relocates the dir). Worktrees inherit parent-project trust when
 // the REPO ROOT is trusted — seed the root once, cover every future worktree. Idempotent: a second
@@ -184,17 +234,26 @@ export const codex = {
     probeConcurrency: 1,
     probe: async () => probeVersion("codex"),
     channels: (cfg) => channelsFromConfig("codex", cfg),
-    // v1.65 T3: every flag the command builders below hardcode (incl. codexMcpSuppressionFlags' -c/
+    // v1.65 T3: every flag the command builder below hardcodes (incl. codexMcpSuppressionFlags' -c/
     // --disable and GITDIR_WRITABLE's -c) — all listed by top-level `codex --help`, verified 2026-07-22.
-    hardcodedFlags: { binary: "codex", flags: ["--sandbox", "--model", "-a", "-s", "-c", "--disable", "--dangerously-bypass-hook-trust"] },
+    hardcodedFlags: { binary: "codex", flags: ["--sandbox", "-a", "-s", "--model", "-c", "--disable", "--dangerously-bypass-hook-trust"] },
     // --sandbox workspace-write is the autonomous sandbox mode (codex v0.144.1+)
     // MCP suppression built per dispatch (config can change between runs) — see codexMcpSuppressionFlags.
     // CODEX_HOOK_TRUST (OBS-125) clears the per-worktree "Hooks need review" gate while keeping the sandbox.
-    headlessCommand: (promptFile, model) => `codex exec --sandbox workspace-write ${CODEX_HOOK_TRUST} ${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 ${CODEX_HOOK_TRUST} ${codexMcpSuppressionFlags()} ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    headlessCommand: (promptFile, model) => `codex exec --sandbox workspace-write ${CODEX_HOOK_TRUST} ${codexMcpSuppressionFlags()} ${GITDIR_WRITABLE} --model ${shq(model)} - < ${shq(promptFile)}`,
+    // OBS-930: the visible pane runs the REAL TUI. Codex's TUI takes its prompt only as the [PROMPT]
+    // positional (`codex --help`, 0.153.4 — no file/stdin form), so the launch inlines the file exactly
+    // as the claude adapter does: the prompt is the LAST positional and every flag value is followed by
+    // a flag, never by the prompt. The argv hazard that once forbade this (OBS-889: `countLiveSuites`
+    // matched a suite word 140 KB into a finished worker's argv) is closed on the counter side — the
+    // census reads a command's first four tokens only — and those four never carry a suite word here.
+    // Same sandbox, hook trust and MCP suppression as the headless form; `-a never` is the TUI's
+    // autonomous approval policy (exec has no approvals to configure).
+    // OBS-930 (Linux): the inlined prompt is ONE argv string and Linux caps one at 131072 bytes, so a
+    // prompt over promptArgvCeiling() returns null → worker-mode-fallback → the headless form (types.ts).
+    interactiveCommand: (promptFile, model) => promptFitsArgv(promptFile)
+        ? `codex -a never -s workspace-write ${CODEX_HOOK_TRUST} ${codexMcpSuppressionFlags()} ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`
+        : null,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },
@@ -203,6 +262,7 @@ export const codex = {
     // "Do you trust this directory?" (OBS-16). doctor-only side effect.
     trust: (repoRoot) => seedCodexTrust(repoRoot),
     trustDialog: CODEX_TRUST_DIALOG,
+    inputBox: CODEX_INPUT_BOX,
     // v1.5 MODEL-01: file read only (no `codex models` subcommand exists, verified 2026-07-10).
     // Already fails OPEN to [] internally — advisory detection, unlike gates' fail-closed.
     listModels: async () => readCodexModelsCache().models,

package/dist/adapters/qwen.js

@@ -58,7 +58,7 @@ function decodeQwenEvents(events) {
         }
     }
     const assistantText = text.join("\n");
-    const apiError = text.find((line) => line.startsWith("[API Error:"));
+    const apiError = assistantText.match(/\[API Error:[^\n]*/)?.[0];
     if (apiError)
         failed = true;
     if (!failed)
@@ -134,8 +134,8 @@ export const qwen = {
     probeCwd: "neutral",
     probe: async () => probeQwen(),
     channels: (cfg) => channelsFromConfig("qwen", cfg),
-    hardcodedFlags: { binary: "qwen", flags: ["--approval-mode", "-m", "-o", "-p"] },
-    headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
+    hardcodedFlags: { binary: "qwen", flags: ["--safe-mode", "--approval-mode", "-m", "-o", "-p"] },
+    headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --safe-mode --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
     // OBS-905: qwen has NO interactive form. The `-i "$(cat prompt)"` TUI launch put the whole prompt in
     // argv (the OBS-889 leak-and-census shape) and produced a rendered transcript the JSON decoder above
     // can never read — under the herdr driver every qwen task read "unparseable" and merged only by harvest.

package/dist/adapters/registry.js

@@ -399,6 +399,17 @@ function reasonTail(output) {
     const sp = tail.indexOf(" ");
     return sp === -1 ? tail : tail.slice(sp + 1);
 }
+function parsedStartupFailureReason(adapter, output) {
+    try {
+        const parsed = adapter.parse(output, "tickmarkr-model-probe");
+        const cause = parsed.cause;
+        if (!parsed.ok && cause === "startup-failure" && parsed.summary.trim()) {
+            return reasonTail(parsed.summary.trim().replace(/\s+/g, " "));
+        }
+    }
+    catch { /* adapter parse is advisory for probe diagnostics */ }
+    return undefined;
+}
 function probeFailure(code, stdout, stderr, timedOut, timeoutMs = MODEL_PROBE_TIMEOUT_MS) {
     // SIGKILL-timeout is not exit-1: report the budget, never the masked kill code (v1.27 T1).
     if (timedOut)
@@ -456,7 +467,8 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
                         if (r.timedOut && !retry && priorModelAuth?.[model]?.reason?.includes("timed out") === true) {
                             return { verdict: v(false, `probe timed out (repeat — retry skipped) (${MODEL_PROBE_TIMEOUT_MS}ms)`), timedOut: true };
                         }
-                        const reason = probeFailure(r.code, r.stdout, r.stderr, r.timedOut, MODEL_PROBE_TIMEOUT_MS);
+                        const output = `${r.stderr}\n${r.stdout}`.trim();
+                        const reason = parsedStartupFailureReason(a, output) ?? probeFailure(r.code, r.stdout, r.stderr, r.timedOut, MODEL_PROBE_TIMEOUT_MS);
                         if (!reason)
                             return { verdict: v(true), timedOut: false };
                         if (!retry)

package/dist/adapters/types.d.ts

@@ -185,5 +185,9 @@ export declare function channelKey(c: {
     model: string;
 }): string;
 export declare function shq(s: string): string;
+export declare const PROMPT_ARGV_CEILING_LINUX = 120000;
+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 QUOTA_RE: RegExp;
 export declare const MODEL_ID_RE: RegExp;

package/dist/adapters/types.js

@@ -1,3 +1,4 @@
+import { statSync } from "node:fs";
 import { z } from "zod";
 // SPEND-01/06: normalized token counts — the measurable fact. NO cost field, ever: CLIs report
 // cost:0 on sub plans and notional list prices on others (LIVE-CHECK finding 3); money is Phase 18's
@@ -232,6 +233,38 @@ export function channelKey(c) {
 export function shq(s) {
     return `'${s.replaceAll("'", `'\\''`)}'`;
 }
+// OBS-930 (Linux) / OBS-931: a TUI launch inlines the prompt file as ONE argv string — "$(cat prompt)"
+// as the last positional. Linux caps a single argv string at MAX_ARG_STRLEN = PAGE_SIZE × 32 =
+// 131072 bytes (E2BIG: CI run 33979013874, ubuntu, `codex: Argument list too long` on a 140 KB
+// prompt); darwin enforces only the 1 MB total ARG_MAX, which is why the macOS export proof passed.
+// A real worker prompt is 60–150 KB (OBS-889 measured 149,417 bytes), so on a Linux host the launch
+// fails in production, not only in the test. Ceilings are named BY PLATFORM — never a probe of the
+// running kernel at dispatch time:
+//   linux  120_000 — the cap is per STRING and every flag is its own argv entry, so only the prompt
+//                    counts against it; "$(cat …)" strips nothing but trailing newlines, so the
+//                    file's byte size IS the string's. 131072 − 120000 leaves ~11 KB of headroom.
+//   others 900_000 — under the 1 MB total that darwin/BSD enforce across argv + envp.
+// Over the ceiling the adapter returns null: the daemon journals worker-mode-fallback
+// {reason:"adapter"} and runs the headless form in the visible pane — the pre-OBS-930 behaviour,
+// now only for oversized prompts. An unreadable file is "not proven oversized" and keeps the TUI
+// rendering: the daemon writes the prompt before it builds the launch, a missing file fails the
+// same way in either form, and docs-truth renders the command against a placeholder path.
+// OBS-931 (2.4.3): the real fix is prompt delivery through the composer for large prompts.
+export const PROMPT_ARGV_CEILING_LINUX = 120_000;
+export const PROMPT_ARGV_CEILING_DEFAULT = 900_000;
+export function promptArgvCeiling(platform = process.platform) {
+    return platform === "linux" ? PROMPT_ARGV_CEILING_LINUX : PROMPT_ARGV_CEILING_DEFAULT;
+}
+export function promptFitsArgv(promptFile, platform = process.platform) {
+    let bytes;
+    try {
+        bytes = statSync(promptFile).size;
+    }
+    catch {
+        return true;
+    }
+    return bytes <= promptArgvCeiling(platform);
+}
 // Quota exhaustion is detected from CLI errors, never predicted (spec §4).
 // ZAI coding-plan exhaustion text: "Insufficient balance or no resource package. Please recharge."
 // Anchor the distinctive full phrase, not the two-word "insufficient balance" fragment — that fires

package/dist/cli/commands/compile.d.ts

@@ -1 +1,4 @@
+import { type SourceScopeFinding } from "../../compile/collateral.js";
+import { compileSource } from "../../compile/index.js";
+export declare function nativeSourceScopeErrors(graph: ReturnType<typeof compileSource>, findings: readonly SourceScopeFinding[]): string[];
 export declare function compile(argv: string[], cwd?: string, harnessFrom?: string | undefined): Promise<string>;

package/dist/cli/commands/compile.js

@@ -1,25 +1,21 @@
 import { isAbsolute, join } from "node:path";
 import { parseArgs } from "node:util";
-import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
+import { collateralLints, sourceScopeFindings, sourceScopeLints, } from "../../compile/collateral.js";
 import { CompileError } from "../../compile/common.js";
 import { compileSource } from "../../compile/index.js";
-import { saveGraph, stateDirName } from "../../graph/graph.js";
+import { clearCompileRefusal, saveCompileRefusal, saveGraph, stateDirName } from "../../graph/graph.js";
 import { formatPriorFindingEvidence, readPriorRunEvidence } from "../../run/journal.js";
 import { shGit } from "../../run/git.js";
 import { acquireRunLock, releaseRunLock } from "../../run/lock.js";
 import { harnessLine, resolveHarness } from "../harness.js";
-function nativeSourceScopeErrors(graph, lints) {
+export function nativeSourceScopeErrors(graph, findings) {
     const byId = new Map(graph.tasks.map((task) => [task.id, task]));
     const errors = [];
-    for (const lint of lints) {
-        const match = lint.match(/^(\S+): criteria implicate out-of-scope source not in files\[\]: (.*)$/);
-        if (!match)
-            continue;
-        const task = byId.get(match[1]);
+    for (const finding of findings) {
+        const task = byId.get(finding.taskId);
         if (!task)
             continue;
-        const paths = match[2].replace(/ \(capped\)$/, "").split(", ").filter(Boolean);
-        for (const path of paths) {
+        for (const path of finding.paths) {
             if (task.goal.includes(`scope-waiver: ${path}`))
                 continue;
             errors.push(`${task.id}: ${path} requires scope-waiver: ${path} in the task goal`);
@@ -60,43 +56,78 @@ export async function compile(argv, cwd = process.cwd(), harnessFrom = process.a
     const src = positionals[0];
     if (!src)
         throw new Error("usage: tickmarkr compile <spec-dir-or-md> [--type speckit|prd|gsd|native] [--dry-run] [--strict]");
-    // resolve against the target repo, not the process cwd (the CLI test passes a tmp repo)
-    // Both modes reach the same pure compiler; --dry-run only removes the lock/write side effect below.
-    const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd, // repo root: gsd stores context[0] repo-relative so workers resolve it inside their worktree
-    (plan) => plan, { strict: values.strict });
-    const scopeLints = [...collateralLints(g.tasks, cwd), ...sourceScopeLints(g.tasks, cwd)];
-    const diagnostics = scopeLints.length
-        ? `\nscope lints:\n${scopeLints.map((lint) => `  ! ${lint}`).join("\n")}`
-        : "";
-    const unwaived = g.spec.source === "native" ? nativeSourceScopeErrors(g, scopeLints) : [];
-    if (unwaived.length > 0) {
-        throw new CompileError(`${src} has unwaived native source-scope authoring errors:\n${unwaived.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
-    }
-    // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
-    // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
-    // remain the source compiler's answer.
-    const prior = readPriorRunEvidence(cwd, g.tasks);
-    const mergedPending = await mergedPendingDiagnostics(cwd, new Set(g.tasks.filter((task) => task.status === "pending").map((task) => task.id)), prior.merges);
-    const stateDir = stateDirName(cwd);
-    if (!values["dry-run"]) {
-        // HARD-01 / Sol #3: hold the same link(2) run lock as the daemon around saveGraph so compile
-        // cannot swap graph.json under an active run between the daemon's read and act.
-        acquireRunLock(cwd, "compile");
-        try {
-            saveGraph(cwd, g);
+    const sourcePath = isAbsolute(src) ? src : join(cwd, src);
+    let stateWriteStarted = false;
+    try {
+        // Resolve against the target repo, not the process cwd (the CLI test passes a tmp repo).
+        // Both modes reach the same pure compiler; --dry-run removes every state write below.
+        const g = compileSource(sourcePath, values.type, cwd, // repo root: gsd stores context[0] repo-relative so workers resolve it inside their worktree
+        (plan) => plan, { strict: values.strict });
+        const sourceFindings = sourceScopeFindings(g.tasks, cwd);
+        const scopeLints = [
+            ...collateralLints(g.tasks, cwd),
+            ...sourceScopeLints(g.tasks, cwd, sourceFindings),
+        ];
+        const diagnostics = scopeLints.length
+            ? `\nscope lints:\n${scopeLints.map((lint) => `  ! ${lint}`).join("\n")}`
+            : "";
+        const unwaived = g.spec.source === "native" ? nativeSourceScopeErrors(g, sourceFindings) : [];
+        if (unwaived.length > 0) {
+            throw new CompileError(`${src} has unwaived native source-scope authoring errors:\n${unwaived.map((line) => `  - ${line}`).join("\n")}${diagnostics}`);
         }
-        finally {
-            releaseRunLock(cwd);
+        // One bounded read supplies both cross-run surfaces: unresolved findings below and merge facts for
+        // the ancestry check. Neither fact mutates the compiled graph; status and every readiness predicate
+        // remain the source compiler's answer.
+        const prior = readPriorRunEvidence(cwd, g.tasks);
+        const mergedPending = await mergedPendingDiagnostics(cwd, new Set(g.tasks.filter((task) => task.status === "pending").map((task) => task.id)), prior.merges);
+        const stateDir = stateDirName(cwd);
+        if (!values["dry-run"]) {
+            // HARD-01 / Sol #3: hold the same link(2) run lock as the daemon around both truth records so
+            // compile cannot swap graph.json under an active run between the daemon's read and act.
+            stateWriteStarted = true;
+            acquireRunLock(cwd, "compile");
+            try {
+                saveGraph(cwd, g);
+                clearCompileRefusal(cwd);
+            }
+            finally {
+                releaseRunLock(cwd);
+            }
+        }
+        const summary = values["dry-run"]
+            ? `validated ${src} (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)}) — dry run; no graph written`
+            : `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
+        const priorFindings = prior.findings.length
+            ? `\nprior-run evidence:\n${prior.findings.map((finding) => `  ${formatPriorFindingEvidence(finding)}`).join("\n")}`
+            : "";
+        const mergeHistory = mergedPending.length
+            ? `\nmerge history:\n${mergedPending.map((line) => `  ${line}`).join("\n")}`
+            : "";
+        return `${harnessLine(resolveHarness(harnessFrom))}\n${summary}${diagnostics}${priorFindings}${mergeHistory}`;
+    }
+    catch (error) {
+        // A dry run is a pure validation query. A real authoring refusal records the negative result
+        // without replacing the last good graph; run treats this sibling as newer truth than that graph.
+        // State-write failures are excluded: a live daemon's lock refusal is not a verdict on the spec.
+        if (!values["dry-run"] && !stateWriteStarted) {
+            try {
+                acquireRunLock(cwd, "compile-refusal");
+                try {
+                    saveCompileRefusal(cwd, {
+                        refusedAt: new Date().toISOString(),
+                        source: sourcePath,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                finally {
+                    releaseRunLock(cwd);
+                }
+            }
+            catch {
+                // The refusal record is best-effort when a live run owns the state boundary. That lock
+                // verdict must never replace the compile error that tells the operator what to repair.
+            }
         }
+        throw error;
     }
-    const summary = values["dry-run"]
-        ? `validated ${src} (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)}) — dry run; no graph written`
-        : `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
-    const priorFindings = prior.findings.length
-        ? `\nprior-run evidence:\n${prior.findings.map((finding) => `  ${formatPriorFindingEvidence(finding)}`).join("\n")}`
-        : "";
-    const mergeHistory = mergedPending.length
-        ? `\nmerge history:\n${mergedPending.map((line) => `  ${line}`).join("\n")}`
-        : "";
-    return `${harnessLine(resolveHarness(harnessFrom))}\n${summary}${diagnostics}${priorFindings}${mergeHistory}`;
 }