tickmarkr 2.4.1 → 2.4.2

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
@@ -186,14 +236,24 @@ export const codex = {
     channels: (cfg) => channelsFromConfig("codex", cfg),
     // 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", "-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)} - < ${shq(promptFile)}`,
-    // OBS-889: Codex's TUI has no file/stdin prompt form. Returning null makes the daemon journal
-    // worker-mode-fallback before it runs the argv-safe headless command in the visible pane.
-    interactiveCommand: () => null,
+    // 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) };
     },
@@ -202,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/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/package.json

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