arcane-agents 1.2.0 → 1.2.3

package/dist/server/server/status/engine/stateMachine/decision.test.js

@@ -50,15 +50,21 @@ function createContext(overrides = {}) {
         },
         runtimeActivityText: undefined,
         activeClaudeTask: undefined,
+        activeRuntimeProcess: undefined,
+        hasClaudePromptSignal: false,
         hasClaudeProgressSignal: false,
         hasOpenCodePromptSignal: false,
         hasOpenCodeActiveSignal: false,
+        hasCodexPromptSignal: false,
+        hasCodexActiveSignal: false,
         isClaudeSession: false,
         isOpenCodeSession: false,
+        isCodexSession: false,
         outputQuietForMs: 1_000,
         commandQuietForMs: 5_000,
         workerAgeMs: 30_000,
         interactiveCommands: new Set(),
+        runtimeFreshnessWindowMs: undefined,
         ...overrides
     };
 }
@@ -150,4 +156,62 @@ function createContext(overrides = {}) {
         (0, vitest_1.expect)(decision.status).toBe("idle");
         (0, vitest_1.expect)(decision.reasons.some((r) => r.code === "opencode-spawn-grace-idle")).toBe(true);
     });
+    (0, vitest_1.it)("returns attention for Codex approval prompts", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            worker: {
+                ...createWorker(),
+                runtimeId: "codex",
+                runtimeLabel: "Codex",
+                command: ["codex"]
+            },
+            currentCommand: "bash",
+            commandLower: "bash",
+            runtimeActivityText: "Waiting for approval",
+            hasCodexPromptSignal: true,
+            hasCodexActiveSignal: false,
+            isCodexSession: true
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("attention");
+        (0, vitest_1.expect)(decision.activityText).toBe("Waiting for approval");
+        (0, vitest_1.expect)(decision.reasons[0]?.code).toBe("codex-approval-prompt");
+    });
+    (0, vitest_1.it)("returns working when a wrapped agent runtime process is active", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            currentCommand: "bash",
+            commandLower: "bash",
+            activeRuntimeProcess: {
+                pid: 42,
+                runtime: "codex",
+                command: "codex",
+                args: "codex exec"
+            },
+            isCodexSession: true,
+            outputQuietForMs: 45_000
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("working");
+        (0, vitest_1.expect)(decision.reasons.some((reason) => reason.code === "agent-runtime-child-process")).toBe(true);
+    });
+    (0, vitest_1.it)("returns idle when the Claude prompt is visible under a shell wrapper", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            worker: {
+                ...createWorker(),
+                runtimeId: "claude",
+                runtimeLabel: "Claude",
+                command: ["claude"]
+            },
+            currentCommand: "bash",
+            commandLower: "bash",
+            isClaudeSession: true,
+            hasClaudePromptSignal: true,
+            activeRuntimeProcess: {
+                pid: 42,
+                runtime: "claude",
+                command: "claude",
+                args: "claude"
+            },
+            outputQuietForMs: 45_000
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("idle");
+        (0, vitest_1.expect)(decision.reasons[0]?.code).toBe("shell-command-idle");
+    });
 });

package/dist/server/server/status/engine/stateMachine/helpers.js

@@ -22,7 +22,7 @@ function recentNormalizedLines(output, limit) {
         .map((line) => line.toLowerCase());
 }
 function isAgentRuntime(context) {
-    return context.isOpenCodeSession || context.isClaudeSession;
+    return context.isOpenCodeSession || context.isClaudeSession || context.isCodexSession;
 }
 function shouldSuppressShellHistorySignals(context) {
     if (!isShellCommand(context.commandLower) && !isInteractiveCommand(context)) {
@@ -53,12 +53,18 @@ function looksLikeActiveRuntimeText(activityText) {
     return normalized.startsWith("thinking");
 }
 function statusFreshnessWindowMs(context) {
+    if (context.runtimeFreshnessWindowMs !== undefined) {
+        return context.runtimeFreshnessWindowMs;
+    }
     if (context.isClaudeSession) {
         return constants_1.claudeWorkingFreshWindowMs;
     }
     if (context.isOpenCodeSession) {
         return constants_1.openCodeWorkingFreshWindowMs;
     }
+    if (context.isCodexSession) {
+        return constants_1.codexWorkingFreshWindowMs;
+    }
     return constants_1.genericWorkingFreshWindowMs;
 }
 function isShellCommand(commandLower) {

package/dist/server/server/status/engine/stateMachine/helpers.test.js

@@ -50,15 +50,21 @@ function createContext(overrides = {}) {
         },
         runtimeActivityText: undefined,
         activeClaudeTask: undefined,
+        activeRuntimeProcess: undefined,
+        hasClaudePromptSignal: false,
         hasClaudeProgressSignal: false,
         hasOpenCodePromptSignal: false,
         hasOpenCodeActiveSignal: false,
+        hasCodexPromptSignal: false,
+        hasCodexActiveSignal: false,
         isClaudeSession: false,
         isOpenCodeSession: false,
+        isCodexSession: false,
         outputQuietForMs: 200,
         commandQuietForMs: 300,
         workerAgeMs: 10_000,
         interactiveCommands: new Set(),
+        runtimeFreshnessWindowMs: undefined,
         ...overrides
     };
 }
@@ -88,7 +94,10 @@ function createContext(overrides = {}) {
     (0, vitest_1.it)("returns freshness windows by runtime session", () => {
         (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext({ isClaudeSession: true }))).toBe(10_000);
         (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext({ isOpenCodeSession: true }))).toBe(12_000);
-        (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext())).toBe(12_000);
+        (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext({ isCodexSession: true }))).toBe(10_000);
+        (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext())).toBe(20_000);
+        (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext({ runtimeFreshnessWindowMs: 45_000 }))).toBe(45_000);
+        (0, vitest_1.expect)((0, helpers_1.statusFreshnessWindowMs)(createContext({ isClaudeSession: true, runtimeFreshnessWindowMs: 30_000 }))).toBe(30_000);
     });
     (0, vitest_1.it)("handles helper utility behavior", () => {
         const values = [];

package/dist/server/server/status/engine/stateMachine/idleBlockers.js

@@ -54,6 +54,19 @@ function detectIdleBlocker(context, evidence) {
             }
         };
     }
+    if (context.isCodexSession &&
+        context.workerAgeMs <= constants_1.codexSpawnGraceMs &&
+        !context.hasCodexActiveSignal &&
+        !context.activeRuntimeProcess &&
+        !evidence.parsedStrongSignal) {
+        return {
+            reason: {
+                code: "codex-spawn-grace-idle",
+                message: "During early Codex spawn grace window without active signals.",
+                detail: `${Math.round(context.workerAgeMs)}ms since worker creation`
+            }
+        };
+    }
     const activeWindowMs = (0, helpers_1.statusFreshnessWindowMs)(context);
     if (context.outputQuietForMs > activeWindowMs && context.transcriptSnapshot?.status !== "working") {
         return {

package/dist/server/server/status/engine/stateMachine/workingEvidence.js

@@ -37,6 +37,19 @@ function collectWorkingEvidence(context, hasRecoverableParserError) {
         activityTextCandidates.push(context.runtimeActivityText ?? "Responding");
         activityToolCandidates.push("terminal");
     }
+    if (context.hasCodexActiveSignal) {
+        strongReasons.push({ code: "codex-active-signal", message: "Codex active execution signal detected." });
+        activityTextCandidates.push(context.runtimeActivityText ?? "Responding");
+        activityToolCandidates.push("terminal");
+    }
+    if (context.activeRuntimeProcess && !(context.activeRuntimeProcess.runtime === "claude" && context.hasClaudePromptSignal)) {
+        strongReasons.push({
+            code: "agent-runtime-child-process",
+            message: `${labelRuntime(context.activeRuntimeProcess.runtime)} is still running under the pane shell.`
+        });
+        activityTextCandidates.push(context.runtimeActivityText ?? `${labelRuntime(context.activeRuntimeProcess.runtime)} running`);
+        activityToolCandidates.push("terminal");
+    }
     if ((0, helpers_1.looksLikeActiveRuntimeText)(context.runtimeActivityText)) {
         strongReasons.push({ code: "runtime-activity-text", message: "Runtime activity text indicates active work." });
         (0, helpers_1.pushMaybe)(activityTextCandidates, context.runtimeActivityText);
@@ -80,6 +93,21 @@ function collectWorkingEvidence(context, hasRecoverableParserError) {
         activityToolCandidates.push(context.parsed.activity.tool);
         (0, helpers_1.pushMaybe)(activityPathCandidates, context.parsed.activity.filePath);
     }
+    if (context.worker.status === "working" &&
+        !(0, helpers_1.isShellCommand)(context.commandLower) &&
+        !(0, helpers_1.isInteractiveCommand)(context) &&
+        context.outputQuietForMs <= (0, helpers_1.statusFreshnessWindowMs)(context) &&
+        strongReasons.length === 0 &&
+        weakReasons.length === 0) {
+        weakReasons.push({
+            code: "output-still-fresh",
+            message: "Output is still within the freshness window; maintaining working status.",
+            detail: `${Math.round(context.outputQuietForMs)}ms quiet (window: ${(0, helpers_1.statusFreshnessWindowMs)(context)}ms)`
+        });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.runtimeActivityText ?? context.worker.activityText);
+        activityToolCandidates.push(context.worker.activityTool ?? "terminal");
+        (0, helpers_1.pushMaybe)(activityPathCandidates, context.worker.activityPath);
+    }
     return {
         strongReasons,
         weakReasons,
@@ -98,3 +126,13 @@ function shouldKeepStickyWorking(context, evidence) {
     }
     return (0, helpers_1.hasAnyWorkingEvidence)(evidence);
 }
+function labelRuntime(runtime) {
+    switch (runtime) {
+        case "claude":
+            return "Claude";
+        case "opencode":
+            return "OpenCode";
+        case "codex":
+            return "Codex";
+    }
+}

package/dist/server/server/status/runtime/activityTextExtractors.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractRuntimeActivityText = extractRuntimeActivityText;
+const codexSignals_1 = require("./codexSignals");
 const openCodeCapturePaneLines = 420;
 const openCodeThinkingContinuationMaxLines = 3;
+const codexCapturePaneLines = 240;
 function extractRuntimeActivityText(output, session) {
     if (session.isClaude) {
         return extractClaudeRuntimeActivityText(output);
@@ -10,6 +12,9 @@ function extractRuntimeActivityText(output, session) {
     if (session.isOpenCode) {
         return extractOpenCodeRuntimeActivityText(output);
     }
+    if (session.isCodex) {
+        return extractCodexRuntimeActivityText(output);
+    }
     return undefined;
 }
 function extractClaudeRuntimeActivityText(output) {
@@ -163,6 +168,41 @@ function normalizeOpenCodeRuntimeLine(line) {
     }
     return withoutFrame;
 }
+function extractCodexRuntimeActivityText(output) {
+    const signals = (0, codexSignals_1.detectCodexSignals)(output);
+    const linesNewestFirst = output
+        .split("\n")
+        .slice(-codexCapturePaneLines)
+        .map((line) => (0, codexSignals_1.normalizeCodexRuntimeLine)(line))
+        .filter((line) => line.length > 0)
+        .reverse();
+    for (const line of linesNewestFirst) {
+        const statusText = (0, codexSignals_1.extractCodexStatusText)(line);
+        if (!statusText) {
+            continue;
+        }
+        const normalizedStatus = statusText.toLowerCase();
+        if (normalizedStatus.includes("waiting on approval") || normalizedStatus.includes("approval requested")) {
+            return "Waiting for approval";
+        }
+        if (normalizedStatus.includes("waiting on user input") ||
+            normalizedStatus.includes("question requested") ||
+            normalizedStatus.includes("user input requested")) {
+            return "Waiting for input";
+        }
+        if (normalizedStatus === "finished" || normalizedStatus.includes("agent turn complete")) {
+            return undefined;
+        }
+        return truncateActivityText(statusText, 72);
+    }
+    if (signals.prompt) {
+        return "Waiting for approval";
+    }
+    if (signals.active) {
+        return "Responding";
+    }
+    return undefined;
+}
 function recentLinesNewestFirst(output, limit) {
     return output
         .split("\n")

package/dist/server/server/status/runtime/claudeSignals.js

@@ -2,55 +2,136 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractClaudeActiveTask = extractClaudeActiveTask;
 exports.hasClaudeLiveProgressSignal = hasClaudeLiveProgressSignal;
+exports.hasClaudePromptSignal = hasClaudePromptSignal;
+exports.detectClaudeSignals = detectClaudeSignals;
 exports.isGenericClaudeProgressLabel = isGenericClaudeProgressLabel;
+const claudeSignalWindowLines = 120;
+const claudePromptFreshLineWindow = 8;
+const claudeActiveFreshLineWindow = 12;
+const escapeChar = String.fromCharCode(0x1b);
+const bellChar = String.fromCharCode(0x07);
 function extractClaudeActiveTask(output) {
-    const linesNewestFirst = output
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .slice(-120)
-        .reverse();
-    for (const line of linesNewestFirst) {
-        const parentheticalMatch = line.match(/^(?:\*|•|·|✶|✻|✢|✽)\s+(.+?)\s+\((?:[^)]*(?:thinking|thought\s+for)[^)]*)\)\s*$/i);
-        const plainProgressMatch = line.match(/^(?:\*|•|·|✶|✻|✢|✽)\s+(.+?)\s*$/);
-        const task = parentheticalMatch?.[1]?.trim() ?? plainProgressMatch?.[1]?.trim();
+    const lines = recentClaudeLines(output);
+    const latestPromptIndex = findLastMatchingIndex(lines, isClaudePromptLine);
+    const lowerBound = latestPromptIndex >= 0 ? latestPromptIndex : 0;
+    for (let index = lines.length - 1; index >= lowerBound; index -= 1) {
+        const task = extractClaudeTaskText(lines[index] ?? "");
         if (task) {
-            if (isGenericClaudeProgressLabel(task)) {
-                continue;
-            }
             return task;
         }
     }
     return undefined;
 }
 function hasClaudeLiveProgressSignal(output) {
-    const lines = output
+    return detectClaudeSignals(output).active;
+}
+function hasClaudePromptSignal(output) {
+    return detectClaudeSignals(output).prompt;
+}
+function detectClaudeSignals(output) {
+    const lines = recentClaudeLines(output);
+    const newestIndex = lines.length - 1;
+    const latestPromptIndex = findLastMatchingIndex(lines, isClaudePromptLine);
+    const latestProgressIndex = findLastMatchingIndex(lines, isClaudeProgressLine);
+    return {
+        prompt: latestPromptIndex >= 0 &&
+            newestIndex >= 0 &&
+            newestIndex - latestPromptIndex <= claudePromptFreshLineWindow,
+        active: latestProgressIndex >= 0 &&
+            newestIndex >= 0 &&
+            newestIndex - latestProgressIndex <= claudeActiveFreshLineWindow &&
+            (latestPromptIndex < 0 || latestProgressIndex >= latestPromptIndex)
+    };
+}
+function isGenericClaudeProgressLabel(text) {
+    const normalized = text
+        .trim()
+        .replace(/[.…]+$/, "")
+        .toLowerCase();
+    return /^(?:whirring|thinking|saut[eé]ed|churned|baked|accomplishing|conversation compacted)\b/.test(normalized);
+}
+function extractClaudeTaskText(line) {
+    const task = extractClaudeBulletText(line);
+    if (!task || isGenericClaudeProgressLabel(task)) {
+        return undefined;
+    }
+    return task;
+}
+function isClaudeProgressLine(line) {
+    const progressText = extractClaudeBulletText(line);
+    if (!progressText) {
+        return false;
+    }
+    if (!isGenericClaudeProgressLabel(progressText)) {
+        return true;
+    }
+    return /\bfor\s+\d+[ms]\b/i.test(progressText) || /\((?:[^)]*(?:thinking|thought\s+for)[^)]*)\)/i.test(line);
+}
+function extractClaudeBulletText(line) {
+    const parentheticalMatch = line.match(/^(?:\*|•|·|✶|✻|✢|✽)\s+(.+?)\s+\((?:[^)]*(?:thinking|thought\s+for)[^)]*)\)\s*$/i);
+    const plainProgressMatch = line.match(/^(?:\*|•|·|✶|✻|✢|✽)\s+(.+?)\s*$/);
+    return parentheticalMatch?.[1]?.trim() ?? plainProgressMatch?.[1]?.trim();
+}
+function isClaudePromptLine(line) {
+    return /^\u276f$/u.test(line) || /^--\s*insert\s*--.*\bbypass permissions\b/i.test(line) || /\bbypass permissions\b/i.test(line);
+}
+function recentClaudeLines(output) {
+    return output
         .split("\n")
-        .map((line) => line.trim())
+        .map((line) => normalizeClaudeRuntimeLine(line))
         .filter((line) => line.length > 0)
-        .slice(-60);
-    for (const line of lines) {
-        const progressMatch = line.match(/^(?:\*|•|·|✶|✻|✢|✽)\s+(.+?)\s*$/);
-        if (!progressMatch?.[1]) {
+        .slice(-claudeSignalWindowLines);
+}
+function normalizeClaudeRuntimeLine(line) {
+    return stripTerminalControlSequences(line)
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function stripTerminalControlSequences(line) {
+    let normalized = "";
+    for (let index = 0; index < line.length; index += 1) {
+        const current = line[index] ?? "";
+        const next = line[index + 1] ?? "";
+        if (current === escapeChar && next === "]") {
+            index += 2;
+            while (index < line.length) {
+                const cursor = line[index] ?? "";
+                const following = line[index + 1] ?? "";
+                if (cursor === bellChar) {
+                    break;
+                }
+                if (cursor === escapeChar && following === "\\") {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
             continue;
         }
-        const progressText = progressMatch[1].trim();
-        if (!progressText) {
+        if (current === escapeChar && next === "[") {
+            index += 2;
+            while (index < line.length) {
+                const code = line.charCodeAt(index);
+                if (code >= 0x40 && code <= 0x7e) {
+                    break;
+                }
+                index += 1;
+            }
             continue;
         }
-        if (!isGenericClaudeProgressLabel(progressText)) {
-            return true;
-        }
-        if (/\bfor\s+\d+[ms]\b/i.test(progressText) || /\((?:[^)]*(?:thinking|thought\s+for)[^)]*)\)/i.test(line)) {
-            return true;
+        const code = current.charCodeAt(0);
+        if ((code >= 0x00 && code <= 0x08) || (code >= 0x0b && code <= 0x1a) || (code >= 0x1c && code <= 0x1f) || code === 0x7f) {
+            continue;
         }
+        normalized += current;
     }
-    return false;
+    return normalized;
 }
-function isGenericClaudeProgressLabel(text) {
-    const normalized = text
-        .trim()
-        .replace(/[.…]+$/, "")
-        .toLowerCase();
-    return /^(?:whirring|thinking|saut[eé]ed|churned|baked|accomplishing|conversation compacted)\b/.test(normalized);
+function findLastMatchingIndex(lines, predicate) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (predicate(lines[index] ?? "")) {
+            return index;
+        }
+    }
+    return -1;
 }

package/dist/server/server/status/runtime/claudeSignals.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const claudeSignals_1 = require("./claudeSignals");
+(0, vitest_1.describe)("claudeSignals", () => {
+    (0, vitest_1.it)("stops treating progress lines as active once the Claude prompt returns", () => {
+        const output = [
+            "• Reviewing the final patch",
+            "✻ Churned for 1m 42s",
+            "",
+            "❯",
+            "  -- INSERT -- ⏵⏵ bypass permissions on (shift+tab to cycle)"
+        ].join("\n");
+        (0, vitest_1.expect)((0, claudeSignals_1.hasClaudePromptSignal)(output)).toBe(true);
+        (0, vitest_1.expect)((0, claudeSignals_1.hasClaudeLiveProgressSignal)(output)).toBe(false);
+        (0, vitest_1.expect)((0, claudeSignals_1.extractClaudeActiveTask)(output)).toBeUndefined();
+    });
+    (0, vitest_1.it)("keeps reporting live progress when Claude is still actively working", () => {
+        const output = ["✻ Churned for 12s", "", "Thinking through the next change"].join("\n");
+        (0, vitest_1.expect)((0, claudeSignals_1.hasClaudePromptSignal)(output)).toBe(false);
+        (0, vitest_1.expect)((0, claudeSignals_1.hasClaudeLiveProgressSignal)(output)).toBe(true);
+    });
+});

package/dist/server/server/status/runtime/codexSignals.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCodexSignals = detectCodexSignals;
+exports.hasCodexPromptSignal = hasCodexPromptSignal;
+exports.hasCodexActiveSignal = hasCodexActiveSignal;
+exports.extractCodexStatusText = extractCodexStatusText;
+exports.normalizeCodexRuntimeLine = normalizeCodexRuntimeLine;
+const codexSignalWindowLines = 240;
+const codexPromptFreshLineWindow = 24;
+const codexActiveFreshLineWindow = 12;
+const escapeChar = String.fromCharCode(0x1b);
+const bellChar = String.fromCharCode(0x07);
+const codexPromptMatchers = [
+    /needs your approval\./i,
+    /^would you like to run the following command\?/i,
+    /^would you like to make the following edits\?/i,
+    /^do you want to approve network access to /i,
+    /^permission rule:/i,
+    /^yes, just this once$/i,
+    /^yes, and don't ask again/i,
+    /^yes, and allow these permissions for this session$/i,
+    /^yes, and allow this host /i,
+    /^yes, provide the requested info$/i,
+    /^no, but continue without it$/i,
+    /^no, continue without running it$/i,
+    /^no, and tell codex what to do differently$/i,
+    /^cancel this request$/i
+];
+const codexPromptStatusMatchers = [
+    /\bwaiting on approval\b/i,
+    /\bwaiting on user input\b/i,
+    /\bapproval[-\s]requested\b/i,
+    /\buser[-\s]input[-\s]requested\b/i,
+    /\bquestion requested\b/i
+];
+const codexActiveMatchers = [/\besc to interrupt\b/i];
+function detectCodexSignals(output) {
+    const lines = output
+        .split("\n")
+        .slice(-codexSignalWindowLines)
+        .map((line) => normalizeCodexRuntimeLine(line))
+        .filter((line) => line.length > 0);
+    const newestIndex = lines.length - 1;
+    const latestPromptIndex = findLastMatchingIndex(lines, (line) => isCodexPromptLine(line) || hasCodexPromptStatus(line));
+    const latestActiveIndex = findLastMatchingIndex(lines, (line) => codexActiveMatchers.some((matcher) => matcher.test(line)));
+    return {
+        prompt: latestPromptIndex >= 0 &&
+            newestIndex >= 0 &&
+            newestIndex - latestPromptIndex <= codexPromptFreshLineWindow,
+        active: latestActiveIndex >= 0 &&
+            newestIndex >= 0 &&
+            newestIndex - latestActiveIndex <= codexActiveFreshLineWindow
+    };
+}
+function hasCodexPromptSignal(output) {
+    return detectCodexSignals(output).prompt;
+}
+function hasCodexActiveSignal(output) {
+    return detectCodexSignals(output).active;
+}
+function extractCodexStatusText(line) {
+    const match = normalizeCodexRuntimeLine(line).match(/^status:\s+(.+)$/i);
+    return match?.[1]?.trim() || undefined;
+}
+function normalizeCodexRuntimeLine(line) {
+    const normalized = stripTerminalControlSequences(line)
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized) {
+        return "";
+    }
+    const withoutFrame = normalized.replace(/^[│┃╹▀▣⬝■•·]+/, "").trim();
+    if (!withoutFrame || /^╹?▀+$/.test(withoutFrame)) {
+        return "";
+    }
+    return withoutFrame;
+}
+function stripTerminalControlSequences(line) {
+    let normalized = "";
+    for (let index = 0; index < line.length; index += 1) {
+        const current = line[index] ?? "";
+        const next = line[index + 1] ?? "";
+        if (current === escapeChar && next === "]") {
+            index += 2;
+            while (index < line.length) {
+                const cursor = line[index] ?? "";
+                const following = line[index + 1] ?? "";
+                if (cursor === bellChar) {
+                    break;
+                }
+                if (cursor === escapeChar && following === "\\") {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            continue;
+        }
+        if (current === escapeChar && next === "[") {
+            index += 2;
+            while (index < line.length) {
+                const code = line.charCodeAt(index);
+                if (code >= 0x40 && code <= 0x7e) {
+                    break;
+                }
+                index += 1;
+            }
+            continue;
+        }
+        const code = current.charCodeAt(0);
+        if ((code >= 0x00 && code <= 0x08) || (code >= 0x0b && code <= 0x1a) || (code >= 0x1c && code <= 0x1f) || code === 0x7f) {
+            continue;
+        }
+        normalized += current;
+    }
+    return normalized;
+}
+function hasCodexPromptStatus(line) {
+    const statusText = extractCodexStatusText(line);
+    return statusText ? codexPromptStatusMatchers.some((matcher) => matcher.test(statusText)) : false;
+}
+function isCodexPromptLine(line) {
+    return codexPromptMatchers.some((matcher) => matcher.test(line));
+}
+function findLastMatchingIndex(lines, predicate) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (predicate(lines[index] ?? "")) {
+            return index;
+        }
+    }
+    return -1;
+}

package/dist/server/server/status/runtime/codexSignals.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const activityTextExtractors_1 = require("./activityTextExtractors");
+const codexSignals_1 = require("./codexSignals");
+(0, vitest_1.describe)("detectCodexSignals", () => {
+    (0, vitest_1.it)("detects approval prompts from Codex terminal output", () => {
+        const output = `
+      Would you like to run the following command?
+      Permission rule: Yes, just this once
+      Yes, and don't ask again for this command in this session
+      No, continue without running it
+    `;
+        (0, vitest_1.expect)((0, codexSignals_1.detectCodexSignals)(output)).toEqual({
+            prompt: true,
+            active: false
+        });
+    });
+    (0, vitest_1.it)("detects active Codex turns from interrupt hints", () => {
+        const output = `
+      Searching repository
+      esc to interrupt
+    `;
+        (0, vitest_1.expect)((0, codexSignals_1.detectCodexSignals)(output)).toEqual({
+            prompt: false,
+            active: true
+        });
+    });
+});
+(0, vitest_1.describe)("extractRuntimeActivityText", () => {
+    (0, vitest_1.it)("maps Codex approval status lines to waiting text", () => {
+        const output = "Status: Waiting on approval";
+        (0, vitest_1.expect)((0, activityTextExtractors_1.extractRuntimeActivityText)(output, {
+            isClaude: false,
+            isOpenCode: false,
+            isCodex: true
+        })).toBe("Waiting for approval");
+    });
+    (0, vitest_1.it)("maps Codex interrupt hints to responding text", () => {
+        const output = "Scanning files\nesc to interrupt";
+        (0, vitest_1.expect)((0, activityTextExtractors_1.extractRuntimeActivityText)(output, {
+            isClaude: false,
+            isOpenCode: false,
+            isCodex: true
+        })).toBe("Responding");
+    });
+});