@roamcode.ai/server 1.0.0

package/dist/providers/claude-metadata-service.js

@@ -0,0 +1,352 @@
+import { execFile as nodeExecFile, spawn as nodeSpawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+import { ProviderError } from "./types.js";
+const SAFE_VALUE = /^[A-Za-z0-9][A-Za-z0-9._:/\u005b\u005d-]*$/;
+const MAX_MODELS = 64;
+const MAX_EFFORTS = 32;
+const MAX_TOKEN = 128;
+const MAX_STREAM_OBJECTS = 256;
+const CLAUDE_BASELINE_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+const DEFAULT_TTL_MS = 5 * 60_000;
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+const CLAUDE_METADATA_ARGS = [
+    "--print",
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--no-session-persistence",
+    "--permission-mode",
+    "plan",
+];
+function metadataUnavailable() {
+    const error = new Error("Claude model metadata is unavailable");
+    error.name = "ClaudeMetadataError";
+    return error;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeToken(value) {
+    return typeof value === "string" && value.length <= MAX_TOKEN && SAFE_VALUE.test(value);
+}
+function normalizeCatalog(envelope) {
+    if (!isRecord(envelope) || !isRecord(envelope.response) || !isRecord(envelope.response.response)) {
+        throw metadataUnavailable();
+    }
+    const models = envelope.response.response.models;
+    if (!Array.isArray(models) || models.length === 0 || models.length > MAX_MODELS) {
+        throw metadataUnavailable();
+    }
+    const seenModels = new Set();
+    return models.map((candidate) => {
+        if (!isRecord(candidate) || !isSafeToken(candidate.value) || seenModels.has(candidate.value)) {
+            throw metadataUnavailable();
+        }
+        seenModels.add(candidate.value);
+        if (typeof candidate.displayName !== "string" ||
+            candidate.displayName.length === 0 ||
+            candidate.displayName.length > 512 ||
+            (candidate.description !== undefined &&
+                (typeof candidate.description !== "string" || candidate.description.length > 4_096)) ||
+            !Array.isArray(candidate.supportedEffortLevels) ||
+            candidate.supportedEffortLevels.length > MAX_EFFORTS ||
+            typeof candidate.isDefault !== "boolean") {
+            throw metadataUnavailable();
+        }
+        const seenEfforts = new Set();
+        const supportedEffortLevels = candidate.supportedEffortLevels.map((effort) => {
+            if (!isSafeToken(effort) || seenEfforts.has(effort))
+                throw metadataUnavailable();
+            seenEfforts.add(effort);
+            return effort;
+        });
+        return {
+            value: candidate.value,
+            displayName: candidate.displayName,
+            ...(candidate.description !== undefined ? { description: candidate.description } : {}),
+            supportedEffortLevels,
+            isDefault: candidate.isDefault,
+        };
+    });
+}
+const MODEL_LIST_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+const MODEL_DISPLAY_NAMES = {
+    sonnet: "Sonnet",
+    opus: "Opus",
+    haiku: "Haiku",
+    fable: "Fable",
+    best: "Best available",
+    opusplan: "Opus Plan",
+};
+/** Parse Claude's stable human-facing `/model` result, e.g.
+ * `Available: sonnet, opus, fable[1m], default, or a full model ID.` The provider-default option already
+ * exists as the picker's empty value, so the literal `default` alias is intentionally omitted here. */
+function normalizeModelList(result) {
+    const text = typeof result === "string" ? result : isRecord(result) && typeof result.result === "string" ? result.result : "";
+    const available = /Available:\s*(.*?)\s*,?\s*or a full model ID\b/is.exec(text)?.[1];
+    if (!available)
+        throw metadataUnavailable();
+    const values = available
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0 && value !== "default");
+    if (values.length === 0 || values.length > MAX_MODELS)
+        throw metadataUnavailable();
+    const seen = new Set();
+    return values.map((value) => {
+        if (!isSafeToken(value) || seen.has(value))
+            throw metadataUnavailable();
+        seen.add(value);
+        const context = /\[1m\]$/i.test(value);
+        const base = value.replace(/\[1m\]$/i, "");
+        const displayName = `${MODEL_DISPLAY_NAMES[base] ?? base}${context ? " · 1M context" : ""}`;
+        return {
+            value,
+            displayName,
+            supportedEffortLevels: [...MODEL_LIST_EFFORTS],
+            isDefault: false,
+        };
+    });
+}
+function cloneCatalog(models) {
+    return models.map((model) => ({ ...model, supportedEffortLevels: [...model.supportedEffortLevels] }));
+}
+export class ClaudeMetadataService {
+    runner;
+    now;
+    ttlMs;
+    cache;
+    inFlight;
+    disposed = false;
+    constructor(runner, options = {}) {
+        this.runner = runner;
+        this.now = options.now ?? (() => Date.now());
+        this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    }
+    async getModels(force = false) {
+        if (!force && this.cache && this.now() - this.cache.at < this.ttlMs) {
+            return cloneCatalog(this.cache.models);
+        }
+        if (this.inFlight)
+            return cloneCatalog(await this.inFlight);
+        const request = this.loadModels();
+        this.inFlight = request;
+        try {
+            const models = await request;
+            this.cache = { at: this.now(), models: cloneCatalog(models) };
+            return cloneCatalog(models);
+        }
+        finally {
+            if (this.inFlight === request)
+                this.inFlight = undefined;
+        }
+    }
+    async validateModelSelection(model, effort) {
+        const models = await this.getModels();
+        const selected = models.find((candidate) => candidate.value === model);
+        if (!selected) {
+            if (effort === undefined || CLAUDE_BASELINE_EFFORTS.has(effort))
+                return;
+            throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Invalid Claude custom model effort selection");
+        }
+        if (effort === undefined || selected.supportedEffortLevels.includes(effort))
+            return;
+        throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Invalid Claude model and effort selection");
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        return this.runner.dispose?.();
+    }
+    async loadModels() {
+        try {
+            return normalizeCatalog(await this.runner.run());
+        }
+        catch {
+            if (!this.runner.runModelList)
+                throw metadataUnavailable();
+            try {
+                return normalizeModelList(await this.runner.runModelList());
+            }
+            catch {
+                throw metadataUnavailable();
+            }
+        }
+    }
+}
+export function createClaudeMetadataRunner(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+    const spawnProcess = options.spawnProcess ?? nodeSpawn;
+    const activeRuns = new Set();
+    let disposed = false;
+    return {
+        runModelList() {
+            if (disposed)
+                return Promise.reject(metadataUnavailable());
+            if (options.modelListRun)
+                return options.modelListRun();
+            const env = { ...options.env };
+            delete env.ANTHROPIC_API_KEY;
+            return new Promise((resolve, reject) => {
+                nodeExecFile(options.claudeBin, ["-p", "/model", "--output-format", "json", "--dangerously-skip-permissions"], {
+                    cwd: options.cwd,
+                    env,
+                    timeout: timeoutMs,
+                    maxBuffer: maxOutputBytes,
+                    windowsHide: true,
+                }, (error, stdout) => {
+                    if (error) {
+                        reject(metadataUnavailable());
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(stdout);
+                        if (typeof parsed.result !== "string")
+                            throw metadataUnavailable();
+                        resolve(parsed.result);
+                    }
+                    catch {
+                        reject(metadataUnavailable());
+                    }
+                });
+            });
+        },
+        run() {
+            if (disposed)
+                return Promise.reject(metadataUnavailable());
+            return new Promise((resolve, reject) => {
+                const env = { ...options.env };
+                delete env.ANTHROPIC_API_KEY;
+                let child;
+                try {
+                    child = spawnProcess(options.claudeBin, CLAUDE_METADATA_ARGS, {
+                        cwd: options.cwd,
+                        env,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                }
+                catch {
+                    reject(metadataUnavailable());
+                    return;
+                }
+                const requestId = `roamcode-models-${randomUUID()}`;
+                const decoder = new StringDecoder("utf8");
+                let stdoutBuffer = "";
+                let outputBytes = 0;
+                let streamObjects = 0;
+                let settled = false;
+                let timer = undefined;
+                const cleanup = () => {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    child.stdout.off("data", onStdout);
+                    child.stderr.off("data", onStderr);
+                    child.stdin.off("error", onStdinError);
+                    child.off("error", onError);
+                    child.off("exit", onExit);
+                    activeRuns.delete(cancel);
+                    try {
+                        child.kill();
+                    }
+                    catch {
+                        // Cleanup is best-effort and must not replace the original settlement.
+                    }
+                };
+                const settle = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    if (value === undefined)
+                        reject(metadataUnavailable());
+                    else
+                        resolve(value);
+                };
+                const addBytes = (chunk) => {
+                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+                    outputBytes += buffer.byteLength;
+                    if (outputBytes > maxOutputBytes) {
+                        settle();
+                        return undefined;
+                    }
+                    return buffer;
+                };
+                const onStdout = (chunk) => {
+                    const buffer = addBytes(chunk);
+                    if (!buffer || settled)
+                        return;
+                    stdoutBuffer += decoder.write(buffer);
+                    while (!settled) {
+                        const newline = stdoutBuffer.indexOf("\n");
+                        if (newline < 0)
+                            return;
+                        const line = stdoutBuffer.slice(0, newline).trim();
+                        stdoutBuffer = stdoutBuffer.slice(newline + 1);
+                        if (line.length === 0)
+                            continue;
+                        streamObjects += 1;
+                        if (streamObjects > MAX_STREAM_OBJECTS) {
+                            settle();
+                            return;
+                        }
+                        let message;
+                        try {
+                            message = JSON.parse(line);
+                        }
+                        catch {
+                            settle();
+                            return;
+                        }
+                        if (isRecord(message) &&
+                            message.type === "control_response" &&
+                            isRecord(message.response) &&
+                            message.response.request_id === requestId) {
+                            settle(message);
+                        }
+                    }
+                };
+                const onStderr = (chunk) => {
+                    addBytes(chunk);
+                };
+                const onStdinError = () => settle();
+                const onError = () => settle();
+                const onExit = () => settle();
+                const cancel = () => settle();
+                child.stdout.on("data", onStdout);
+                child.stderr.on("data", onStderr);
+                child.stdin.on("error", onStdinError);
+                child.on("error", onError);
+                child.on("exit", onExit);
+                activeRuns.add(cancel);
+                timer = setTimeout(cancel, timeoutMs);
+                const request = {
+                    type: "control_request",
+                    request_id: requestId,
+                    request: {
+                        subtype: "initialize",
+                        hooks: { PreToolUse: [{ matcher: "", hookCallbackIds: ["roamcode-metadata"] }] },
+                    },
+                };
+                try {
+                    child.stdin.end(`${JSON.stringify(request)}\n`);
+                }
+                catch {
+                    settle();
+                }
+            });
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            for (const cancel of [...activeRuns])
+                cancel();
+        },
+    };
+}

package/dist/providers/claude-provider.d.ts

@@ -0,0 +1,11 @@
+import { type AttachSpawnOptions } from "../config.js";
+import { type AgentProvider } from "./types.js";
+import type { ProviderAvailability } from "./types.js";
+export interface CreateClaudeProviderOptions {
+    claudeBin: string;
+    env?: NodeJS.ProcessEnv;
+    attach?: AttachSpawnOptions;
+    getAttach?: () => AttachSpawnOptions | undefined;
+    probe?: () => Promise<ProviderAvailability>;
+}
+export declare function createClaudeProvider(options: CreateClaudeProviderOptions): AgentProvider;

package/dist/providers/claude-provider.js

@@ -0,0 +1,166 @@
+import { buildHooksSettingsDocument, buildMcpConfigDocument, hookAuthFileContent, hookAuthPathFor, hooksSettingsPathFor, mcpConfigPathFor, } from "../config.js";
+import { classifyPaneStatus } from "../pane-status.js";
+import { cleanupProviderArtifacts, writeProviderArtifact0600 } from "./provider-artifacts.js";
+import { ProviderError } from "./types.js";
+const OWNED_VALUE_FLAGS = new Map([
+    ["--resume", "optional"],
+    ["--session-id", "one"],
+    ["--model", "one"],
+    ["--effort", "one"],
+    ["--permission-mode", "one"],
+    ["--add-dir", "variadic"],
+    ["--mcp-config", "variadic"],
+    ["--settings", "one"],
+]);
+const OWNED_BOOLEAN_FLAGS = ["--continue", "--dangerously-skip-permissions"];
+function invalidLegacyArg(message) {
+    return new ProviderError("INVALID_PROVIDER_OPTIONS", `Invalid provider options: ${message}`);
+}
+function requireLegacyValue(args, index, flag) {
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("-"))
+        throw invalidLegacyArg(`${flag} requires a value`);
+    return index + 1;
+}
+function sanitizeLegacyArgs(legacyArgs) {
+    const preserved = [];
+    for (let index = 0; index < legacyArgs.length; index += 1) {
+        const arg = legacyArgs[index];
+        if (arg === "--") {
+            preserved.push(...legacyArgs.slice(index));
+            break;
+        }
+        if (arg === "-c")
+            continue;
+        if (arg.startsWith("-c")) {
+            throw invalidLegacyArg("-c has an ambiguous attached value");
+        }
+        if (arg === "-r") {
+            const value = legacyArgs[index + 1];
+            if (value !== undefined && !value.startsWith("-"))
+                index += 1;
+            continue;
+        }
+        if (arg.startsWith("-r")) {
+            if (arg === "-r=" || arg.length === 2)
+                throw invalidLegacyArg("-r has an ambiguous empty value");
+            continue;
+        }
+        let handled = false;
+        for (const flag of OWNED_BOOLEAN_FLAGS) {
+            if (arg === flag) {
+                handled = true;
+                break;
+            }
+            if (arg.startsWith(`${flag}=`)) {
+                if (arg.length === flag.length + 1)
+                    throw invalidLegacyArg(`${flag} has an ambiguous empty value`);
+                handled = true;
+                break;
+            }
+        }
+        if (handled)
+            continue;
+        for (const [flag, arity] of OWNED_VALUE_FLAGS) {
+            if (arg.startsWith(`${flag}=`)) {
+                if (arg.length === flag.length + 1) {
+                    const detail = arity === "optional" ? "has an ambiguous empty value" : "requires a value";
+                    throw invalidLegacyArg(`${flag} ${detail}`);
+                }
+                handled = true;
+                break;
+            }
+            if (arg !== flag)
+                continue;
+            handled = true;
+            if (arity === "optional") {
+                const value = legacyArgs[index + 1];
+                if (value !== undefined && !value.startsWith("-"))
+                    index += 1;
+            }
+            else {
+                index = requireLegacyValue(legacyArgs, index, flag);
+                if (arity === "variadic") {
+                    while (legacyArgs[index + 1] !== undefined && !legacyArgs[index + 1].startsWith("-"))
+                        index += 1;
+                }
+            }
+            break;
+        }
+        if (!handled)
+            preserved.push(arg);
+    }
+    return preserved;
+}
+function insertBeforeSeparator(args, ownedArgs) {
+    const separatorIndex = args.indexOf("--");
+    args.splice(separatorIndex === -1 ? args.length : separatorIndex, 0, ...ownedArgs);
+}
+function claudeArgs(options) {
+    const args = [];
+    if (options.model)
+        args.push("--model", options.model);
+    if (options.effort)
+        args.push("--effort", options.effort);
+    if (options.dangerouslySkip)
+        args.push("--dangerously-skip-permissions");
+    else if (options.permissionMode)
+        args.push("--permission-mode", options.permissionMode);
+    for (const dir of options.addDirs ?? [])
+        args.push("--add-dir", dir);
+    // Legacy arguments exist only for rollback-readable Claude rows. Provider-owned model, safety, session,
+    // and attachment flags are rebuilt from typed options so historical argv cannot override adapter policy.
+    args.push(...sanitizeLegacyArgs(options.legacyArgs ?? []));
+    return args;
+}
+export function createClaudeProvider(options) {
+    return {
+        id: "claude",
+        displayName: "Claude Code",
+        resumeIdentity: "optional",
+        probe: options.probe ?? (() => Promise.resolve({ terminalAvailable: true, metadataAvailable: true })),
+        buildProcess: async (context) => {
+            if (context.options.provider !== "claude") {
+                throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Claude provider received non-Claude options");
+            }
+            const args = claudeArgs(context.options);
+            const ownedPaths = [];
+            const attach = context.attach ?? options.getAttach?.() ?? options.attach;
+            if (attach) {
+                try {
+                    const mcpPath = mcpConfigPathFor(attach.dataDir, context.roamSessionId);
+                    if (writeProviderArtifact0600(mcpPath, JSON.stringify(buildMcpConfigDocument(context.roamSessionId, attach)), context, ownedPaths)) {
+                        insertBeforeSeparator(args, ["--mcp-config", mcpPath]);
+                    }
+                    const authPath = hookAuthPathFor(attach.dataDir, context.roamSessionId);
+                    const settingsPath = hooksSettingsPathFor(attach.dataDir, context.roamSessionId);
+                    if (writeProviderArtifact0600(authPath, hookAuthFileContent(attach.token), context, ownedPaths)) {
+                        if (writeProviderArtifact0600(settingsPath, JSON.stringify(buildHooksSettingsDocument(context.roamSessionId, attach, authPath)), context, ownedPaths)) {
+                            insertBeforeSeparator(args, ["--settings", settingsPath]);
+                        }
+                        else {
+                            cleanupProviderArtifacts([authPath]);
+                        }
+                    }
+                }
+                catch (error) {
+                    cleanupProviderArtifacts(ownedPaths);
+                    throw error;
+                }
+            }
+            if (context.intent === "resume")
+                insertBeforeSeparator(args, ["--continue"]);
+            const env = { ...(options.env ?? process.env) };
+            delete env.ANTHROPIC_API_KEY;
+            return {
+                executable: options.claudeBin,
+                args,
+                env,
+                cleanupPaths: ownedPaths,
+            };
+        },
+        runtimeSignals: () => [],
+        classifyPane: classifyPaneStatus,
+        cleanup: cleanupProviderArtifacts,
+    };
+}

package/dist/providers/codex-activity.d.ts

@@ -0,0 +1,21 @@
+import { type PaneStatus } from "../pane-status.js";
+import type { ProviderRuntimeMetadata, ProviderRuntimeSignal, ProviderRuntimeSignalParser } from "./types.js";
+export declare const CODEX_OSC_MAX_CARRY: number;
+export declare const CODEX_CLASSIFIER_TESTED_UP_TO = "0.144";
+export interface CodexOscParser extends ProviderRuntimeSignalParser {
+    readonly bufferedLength: number;
+}
+export declare function createCodexOscParser(): CodexOscParser;
+export declare function parseCodexOscNotifications(input: string): ProviderRuntimeSignal[];
+export declare function classifyCodexPane(pane: string): PaneStatus;
+/**
+ * Read Codex's LIVE model + reasoning level from the pinned bottom status row. Unlike launch options, this
+ * changes immediately when the user switches reasoning inside the TUI. Only the final non-empty row is
+ * considered, so conversation text that happens to mention a model/effort pair cannot rewrite metadata.
+ *
+ * Supported real Codex layouts:
+ *   gpt-5.6-sol xhigh · ~/Developer/remote-coder
+ *   gpt-5.6 · high · 91% left
+ */
+export declare function parseCodexRuntimeMetadata(pane: string): ProviderRuntimeMetadata | undefined;
+export declare function codexClassifierVersionWarning(codexVersion: string | undefined): string | undefined;

package/dist/providers/codex-activity.js

@@ -0,0 +1,122 @@
+import { isNewerMajorMinor } from "../pane-status.js";
+export const CODEX_OSC_MAX_CARRY = 8 * 1024;
+export const CODEX_CLASSIFIER_TESTED_UP_TO = "0.144";
+const OSC_START = "\u001b]";
+const OSC_9_START = "\u001b]9;";
+const ST = "\u001b\\";
+function signalForPayload(payload) {
+    if (payload.startsWith("Approval requested: ") ||
+        payload.startsWith("Codex wants to edit ") ||
+        payload.startsWith("Approval requested by ") ||
+        payload.startsWith("Plan mode prompt: ")) {
+        return { type: "blocked" };
+    }
+    return payload.length > 0 ? { type: "idle" } : undefined;
+}
+function terminatorAt(input, from) {
+    const bel = input.indexOf("\u0007", from);
+    const st = input.indexOf(ST, from);
+    if (bel === -1 && st === -1)
+        return undefined;
+    if (bel !== -1 && (st === -1 || bel < st))
+        return { index: bel, width: 1 };
+    return { index: st, width: 2 };
+}
+export function createCodexOscParser() {
+    let carry = "";
+    return {
+        get bufferedLength() {
+            return carry.length;
+        },
+        push(chunk) {
+            const input = carry + chunk;
+            carry = "";
+            const signals = [];
+            let cursor = 0;
+            while (cursor < input.length) {
+                const start = input.indexOf("\u001b", cursor);
+                if (start === -1)
+                    break;
+                if (start === input.length - 1) {
+                    carry = "\u001b";
+                    break;
+                }
+                if (!input.startsWith(OSC_START, start)) {
+                    cursor = start + 1;
+                    continue;
+                }
+                if (input.length < start + OSC_9_START.length) {
+                    carry = input.slice(start);
+                    break;
+                }
+                if (!input.startsWith(OSC_9_START, start)) {
+                    cursor = start + OSC_START.length;
+                    continue;
+                }
+                const payloadStart = start + OSC_9_START.length;
+                const terminator = terminatorAt(input, payloadStart);
+                if (!terminator) {
+                    const pending = input.slice(start);
+                    carry = pending.length <= CODEX_OSC_MAX_CARRY ? pending : "";
+                    break;
+                }
+                const frameLength = terminator.index + terminator.width - start;
+                if (frameLength <= CODEX_OSC_MAX_CARRY) {
+                    const signal = signalForPayload(input.slice(payloadStart, terminator.index));
+                    if (signal)
+                        signals.push(signal);
+                }
+                cursor = terminator.index + terminator.width;
+            }
+            return signals;
+        },
+    };
+}
+export function parseCodexOscNotifications(input) {
+    return createCodexOscParser().push(input);
+}
+export function classifyCodexPane(pane) {
+    const tail = pane.split("\n").slice(-24).join("\n");
+    if (/\bWould you like to run the following command\b/i.test(tail))
+        return "blocked";
+    if (/\bDo you want to allow\b/i.test(tail))
+        return "blocked";
+    if (/\bPress enter to confirm or esc to cancel\b/i.test(tail))
+        return "blocked";
+    if (/\besc to interrupt\b/i.test(tail))
+        return "working";
+    if (/[•●]\s*(?:Working|Thinking|Running)\s*\(\s*\d+\s*[ms]\b/i.test(tail))
+        return "working";
+    return "idle";
+}
+const RUNTIME_TOKEN = "[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}";
+const EFFORT_TOKEN = "[A-Za-z0-9][A-Za-z0-9._-]{0,127}";
+/**
+ * Read Codex's LIVE model + reasoning level from the pinned bottom status row. Unlike launch options, this
+ * changes immediately when the user switches reasoning inside the TUI. Only the final non-empty row is
+ * considered, so conversation text that happens to mention a model/effort pair cannot rewrite metadata.
+ *
+ * Supported real Codex layouts:
+ *   gpt-5.6-sol xhigh · ~/Developer/remote-coder
+ *   gpt-5.6 · high · 91% left
+ */
+export function parseCodexRuntimeMetadata(pane) {
+    const line = pane
+        .split(/\r?\n/)
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .at(-1);
+    if (!line)
+        return undefined;
+    const current = new RegExp(`^(${RUNTIME_TOKEN})\\s+(${EFFORT_TOKEN})\\s+·\\s+(?:~/|/).+$`).exec(line);
+    if (current)
+        return { model: current[1], effort: current[2] };
+    const legacy = new RegExp(`^(${RUNTIME_TOKEN})\\s+·\\s+(${EFFORT_TOKEN})\\s+·\\s+.+$`).exec(line);
+    return legacy ? { model: legacy[1], effort: legacy[2] } : undefined;
+}
+export function codexClassifierVersionWarning(codexVersion) {
+    if (!codexVersion || !isNewerMajorMinor(codexVersion, CODEX_CLASSIFIER_TESTED_UP_TO))
+        return undefined;
+    return (`Codex pane-status markers were verified against Codex <=${CODEX_CLASSIFIER_TESTED_UP_TO}; ` +
+        `current is ${codexVersion} — verify rail statuses after this upgrade`);
+}