arcane-agents 0.1.0

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRuntimeActivityText = extractRuntimeActivityText;
+const openCodeCapturePaneLines = 420;
+const openCodeThinkingContinuationMaxLines = 3;
+function extractRuntimeActivityText(output, session) {
+    if (session.isClaude) {
+        return extractClaudeRuntimeActivityText(output);
+    }
+    if (session.isOpenCode) {
+        return extractOpenCodeRuntimeActivityText(output);
+    }
+    return undefined;
+}
+function extractClaudeRuntimeActivityText(output) {
+    const linesNewestFirst = recentLinesNewestFirst(output, 100);
+    for (const line of linesNewestFirst) {
+        const normalized = line.trim();
+        const bulletActivity = extractClaudeBulletActivityText(normalized);
+        if (bulletActivity) {
+            return truncateActivityText(bulletActivity, 72);
+        }
+    }
+    for (const line of linesNewestFirst) {
+        const normalized = line.trim();
+        if (/^✻\s+.+\bfor\s+\d+s\s*$/i.test(normalized)) {
+            return "Thinking";
+        }
+    }
+    return undefined;
+}
+function extractClaudeBulletActivityText(line) {
+    const bulletMatch = line.match(/^●\s+(.+)$/);
+    if (!bulletMatch?.[1]) {
+        return undefined;
+    }
+    let activityText = bulletMatch[1].replace(/\s+/g, " ").trim();
+    if (!activityText) {
+        return undefined;
+    }
+    if (/^Bash\(/i.test(activityText)) {
+        return undefined;
+    }
+    activityText = activityText.replace(/\s*\(ctrl\+o to expand\)\s*$/i, "").trim();
+    if (!activityText) {
+        return undefined;
+    }
+    const updateMatch = activityText.match(/^Update\((.+)\)$/i);
+    if (updateMatch?.[1]) {
+        return `Editing ${updateMatch[1].trim()}`;
+    }
+    return activityText;
+}
+function extractOpenCodeRuntimeActivityText(output) {
+    const latestThinkingText = extractLatestOpenCodeThinkingActivity(output);
+    if (latestThinkingText) {
+        return latestThinkingText;
+    }
+    const linesNewestFirst = recentLinesNewestFirst(output, openCodeCapturePaneLines);
+    let hasActiveSignal = false;
+    for (const line of linesNewestFirst) {
+        const normalized = normalizeOpenCodeRuntimeLine(line);
+        if (!normalized) {
+            continue;
+        }
+        const thinkingMatch = normalized.match(/\bThinking:\s+(.+)$/i);
+        if (thinkingMatch?.[1]) {
+            return `Thinking: ${truncateActivityText(thinkingMatch[1].trim(), 72)}`;
+        }
+        const patchedMatch = normalized.match(/^←\s+Patched\s+(.+)$/i);
+        if (patchedMatch?.[1]) {
+            return `Editing ${patchedMatch[1].trim()}`;
+        }
+        const commandMatch = normalized.match(/^\$\s+(.+)$/);
+        if (commandMatch?.[1]) {
+            return `Running ${summarizeCommand(commandMatch[1])}`;
+        }
+        const headerMatch = normalized.match(/^#\s+(.+)$/);
+        if (headerMatch?.[1]) {
+            return truncateActivityText(headerMatch[1], 52);
+        }
+        if (normalized.toLowerCase().includes("esc interrupt")) {
+            hasActiveSignal = true;
+        }
+    }
+    if (hasActiveSignal) {
+        return "Responding";
+    }
+    return undefined;
+}
+function extractLatestOpenCodeThinkingActivity(output) {
+    const normalizedLines = output
+        .split("\n")
+        .slice(-openCodeCapturePaneLines)
+        .map((line) => normalizeOpenCodeRuntimeLine(line));
+    for (let index = normalizedLines.length - 1; index >= 0; index -= 1) {
+        const line = normalizedLines[index];
+        if (!line) {
+            continue;
+        }
+        const thinkingMatch = line.match(/\bThinking:\s+(.+)$/i);
+        if (!thinkingMatch?.[1]) {
+            continue;
+        }
+        const fragments = [thinkingMatch[1].trim()];
+        for (let continuationIndex = index + 1, continuationCount = 0; continuationIndex < normalizedLines.length && continuationCount < openCodeThinkingContinuationMaxLines; continuationIndex += 1) {
+            const continuation = normalizedLines[continuationIndex];
+            if (!continuation || isOpenCodeRuntimeBoundaryLine(continuation)) {
+                break;
+            }
+            fragments.push(continuation);
+            continuationCount += 1;
+        }
+        const combined = fragments.join(" ").replace(/\s+/g, " ").trim();
+        if (!combined) {
+            return undefined;
+        }
+        return `Thinking: ${truncateActivityText(combined, 72)}`;
+    }
+    return undefined;
+}
+function isOpenCodeRuntimeBoundaryLine(line) {
+    const normalized = line.trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    if (normalized.includes("ctrl+t variants") || normalized.includes("ctrl+p commands") || normalized.includes("tab agents")) {
+        return true;
+    }
+    if (normalized.includes("esc interrupt")) {
+        return true;
+    }
+    if (/^thinking:\s+/i.test(line)) {
+        return true;
+    }
+    if (/^#\s+/.test(line)) {
+        return true;
+    }
+    if (/^\$\s+/.test(line)) {
+        return true;
+    }
+    if (/^←\s+patched\s+/i.test(line)) {
+        return true;
+    }
+    if (/^▣\s+/.test(line) || /^build\s+gpt/i.test(line)) {
+        return true;
+    }
+    return false;
+}
+function normalizeOpenCodeRuntimeLine(line) {
+    const normalized = line
+        .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "")
+        .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u0008\u000b-\u001a\u001c-\u001f\u007f]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized) {
+        return "";
+    }
+    const withoutFrame = normalized.replace(/^[│┃]\s*/, "").trim();
+    if (/^╹?▀+$/.test(withoutFrame)) {
+        return "";
+    }
+    return withoutFrame;
+}
+function recentLinesNewestFirst(output, limit) {
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-limit)
+        .reverse();
+}
+function summarizeCommand(command) {
+    const compact = command.replace(/\s+/g, " ").trim();
+    if (!compact) {
+        return "command";
+    }
+    return truncateActivityText(compact, 46);
+}
+function truncateActivityText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    if (maxLength <= 1) {
+        return text.slice(0, Math.max(0, maxLength));
+    }
+    return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractClaudeActiveTask = extractClaudeActiveTask;
+exports.hasClaudeLiveProgressSignal = hasClaudeLiveProgressSignal;
+exports.isGenericClaudeProgressLabel = isGenericClaudeProgressLabel;
+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();
+        if (task) {
+            if (isGenericClaudeProgressLabel(task)) {
+                continue;
+            }
+            return task;
+        }
+    }
+    return undefined;
+}
+function hasClaudeLiveProgressSignal(output) {
+    const lines = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-60);
+    for (const line of lines) {
+        const progressMatch = line.match(/^(?:\*|•|·|✶|✻|✢|✽)\s+(.+?)\s*$/);
+        if (!progressMatch?.[1]) {
+            continue;
+        }
+        const progressText = progressMatch[1].trim();
+        if (!progressText) {
+            continue;
+        }
+        if (!isGenericClaudeProgressLabel(progressText)) {
+            return true;
+        }
+        if (/\bfor\s+\d+[ms]\b/i.test(progressText) || /\((?:[^)]*(?:thinking|thought\s+for)[^)]*)\)/i.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isGenericClaudeProgressLabel(text) {
+    const normalized = text
+        .trim()
+        .replace(/[.…]+$/, "")
+        .toLowerCase();
+    return /^(?:whirring|thinking|saut[eé]ed|churned|baked|accomplishing|conversation compacted)\b/.test(normalized);
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOpenCodeSignals = detectOpenCodeSignals;
+exports.hasOpenCodePromptSignal = hasOpenCodePromptSignal;
+exports.hasOpenCodeActiveSignal = hasOpenCodeActiveSignal;
+exports.preferOpenCodeSpecificActivityText = preferOpenCodeSpecificActivityText;
+const openCodeSignalWindowLines = 64;
+const openCodePromptFreshLineWindow = 10;
+const openCodeActiveFreshLineWindow = 8;
+const openCodeActivePromptDriftLines = 2;
+function detectOpenCodeSignals(output) {
+    const lines = output
+        .split("\n")
+        .map((line) => line.trim().toLowerCase())
+        .filter((line) => line.length > 0)
+        .slice(-openCodeSignalWindowLines);
+    const newestIndex = lines.length - 1;
+    const latestVariantHintIndex = findLastMatchingIndex(lines, (line) => line.includes("ctrl+t variants"));
+    const latestCommandHintIndex = findLastMatchingIndex(lines, (line) => line.includes("ctrl+p commands"));
+    const latestPromptHintIndex = Math.max(latestVariantHintIndex, latestCommandHintIndex);
+    const hasPromptHints = latestVariantHintIndex >= 0 && latestCommandHintIndex >= 0;
+    const promptHintIsFresh = hasPromptHints &&
+        newestIndex >= 0 &&
+        newestIndex - latestPromptHintIndex <= openCodePromptFreshLineWindow;
+    const latestActiveSignalIndex = findLastMatchingIndex(lines, (line) => line.includes("esc interrupt"));
+    const activeSignalIsFresh = latestActiveSignalIndex >= 0 &&
+        newestIndex >= 0 &&
+        newestIndex - latestActiveSignalIndex <= openCodeActiveFreshLineWindow;
+    const activeSignalAlignedWithPrompt = latestPromptHintIndex < 0 || latestActiveSignalIndex >= latestPromptHintIndex - openCodeActivePromptDriftLines;
+    const prompt = promptHintIsFresh;
+    const active = activeSignalIsFresh && activeSignalAlignedWithPrompt;
+    return {
+        prompt,
+        active
+    };
+}
+function findLastMatchingIndex(lines, predicate) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (predicate(lines[index] ?? "")) {
+            return index;
+        }
+    }
+    return -1;
+}
+function hasOpenCodePromptSignal(output) {
+    return detectOpenCodeSignals(output).prompt;
+}
+function hasOpenCodeActiveSignal(output) {
+    return detectOpenCodeSignals(output).active;
+}
+function preferOpenCodeSpecificActivityText(previousActivityText, nextActivityText) {
+    if (!nextActivityText || nextActivityText.trim().toLowerCase() !== "responding") {
+        return nextActivityText;
+    }
+    if (!previousActivityText) {
+        return nextActivityText;
+    }
+    const previousThinkingMatch = previousActivityText.trim().match(/^Thinking:\s+(.+)$/i);
+    if (previousThinkingMatch?.[1]) {
+        return previousActivityText;
+    }
+    return nextActivityText;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capturePaneLineCount = capturePaneLineCount;
+exports.isLikelyClaudeSession = isLikelyClaudeSession;
+exports.isLikelyOpenCodeSession = isLikelyOpenCodeSession;
+const defaultCapturePaneLines = 35;
+const claudeCapturePaneLines = 60;
+const openCodeCapturePaneLines = 420;
+function capturePaneLineCount(worker, commandLower) {
+    if (isLikelyOpenCodeSession(worker, commandLower)) {
+        return openCodeCapturePaneLines;
+    }
+    if (isLikelyClaudeSession(worker, commandLower)) {
+        return claudeCapturePaneLines;
+    }
+    return defaultCapturePaneLines;
+}
+function isLikelyClaudeSession(worker, commandLower) {
+    if (worker.runtimeId.toLowerCase().includes("claude")) {
+        return true;
+    }
+    const runtimeBinary = worker.command[0]?.toLowerCase() ?? "";
+    if (runtimeBinary.includes("claude")) {
+        return true;
+    }
+    return commandLower.includes("claude");
+}
+function isLikelyOpenCodeSession(worker, commandLower) {
+    if (worker.runtimeId.toLowerCase().includes("opencode")) {
+        return true;
+    }
+    const runtimeBinary = worker.command[0]?.toLowerCase() ?? "";
+    if (runtimeBinary.includes("opencode")) {
+        return true;
+    }
+    return commandLower.includes("opencode");
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasActiveWorkActivityText = hasActiveWorkActivityText;
+exports.hasWaitingActivityText = hasWaitingActivityText;
+function hasActiveWorkActivityText(activityText) {
+    if (!activityText) {
+        return false;
+    }
+    const normalized = activityText.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /^(reading|editing|writing|running:?|searching|searched|subtask:|using|fetching|planning|responding|let me|fixing|working on)/.test(normalized);
+}
+function hasWaitingActivityText(activityText) {
+    if (!activityText) {
+        return false;
+    }
+    const normalized = activityText.trim().toLowerCase();
+    return normalized.includes("waiting for your answer") || normalized.includes("waiting for approval");
+}

package/dist/server/server/status/runtimeSignals.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRuntimeActivityText = exports.hasWaitingActivityText = exports.hasActiveWorkActivityText = exports.preferOpenCodeSpecificActivityText = exports.hasOpenCodeActiveSignal = exports.hasOpenCodePromptSignal = exports.detectOpenCodeSignals = exports.isGenericClaudeProgressLabel = exports.hasClaudeLiveProgressSignal = exports.extractClaudeActiveTask = exports.isLikelyOpenCodeSession = exports.isLikelyClaudeSession = exports.capturePaneLineCount = void 0;
+var sessionDetection_1 = require("./runtime/sessionDetection");
+Object.defineProperty(exports, "capturePaneLineCount", { enumerable: true, get: function () { return sessionDetection_1.capturePaneLineCount; } });
+Object.defineProperty(exports, "isLikelyClaudeSession", { enumerable: true, get: function () { return sessionDetection_1.isLikelyClaudeSession; } });
+Object.defineProperty(exports, "isLikelyOpenCodeSession", { enumerable: true, get: function () { return sessionDetection_1.isLikelyOpenCodeSession; } });
+var claudeSignals_1 = require("./runtime/claudeSignals");
+Object.defineProperty(exports, "extractClaudeActiveTask", { enumerable: true, get: function () { return claudeSignals_1.extractClaudeActiveTask; } });
+Object.defineProperty(exports, "hasClaudeLiveProgressSignal", { enumerable: true, get: function () { return claudeSignals_1.hasClaudeLiveProgressSignal; } });
+Object.defineProperty(exports, "isGenericClaudeProgressLabel", { enumerable: true, get: function () { return claudeSignals_1.isGenericClaudeProgressLabel; } });
+var openCodeSignals_1 = require("./runtime/openCodeSignals");
+Object.defineProperty(exports, "detectOpenCodeSignals", { enumerable: true, get: function () { return openCodeSignals_1.detectOpenCodeSignals; } });
+Object.defineProperty(exports, "hasOpenCodePromptSignal", { enumerable: true, get: function () { return openCodeSignals_1.hasOpenCodePromptSignal; } });
+Object.defineProperty(exports, "hasOpenCodeActiveSignal", { enumerable: true, get: function () { return openCodeSignals_1.hasOpenCodeActiveSignal; } });
+Object.defineProperty(exports, "preferOpenCodeSpecificActivityText", { enumerable: true, get: function () { return openCodeSignals_1.preferOpenCodeSpecificActivityText; } });
+var textSignals_1 = require("./runtime/textSignals");
+Object.defineProperty(exports, "hasActiveWorkActivityText", { enumerable: true, get: function () { return textSignals_1.hasActiveWorkActivityText; } });
+Object.defineProperty(exports, "hasWaitingActivityText", { enumerable: true, get: function () { return textSignals_1.hasWaitingActivityText; } });
+var activityTextExtractors_1 = require("./runtime/activityTextExtractors");
+Object.defineProperty(exports, "extractRuntimeActivityText", { enumerable: true, get: function () { return activityTextExtractors_1.extractRuntimeActivityText; } });

package/dist/server/server/status/statusEvaluator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateWorkerStatus = evaluateWorkerStatus;
+const signalContext_1 = require("./engine/signalContext");
+const stateMachine_1 = require("./engine/stateMachine");
+function evaluateWorkerStatus({ worker, currentCommand, output, observation, transcriptSnapshot }) {
+    const context = (0, signalContext_1.buildWorkerStatusSignalContext)({
+        worker,
+        currentCommand,
+        output,
+        observation,
+        transcriptSnapshot,
+        nowMs: Date.now()
+    });
+    return (0, stateMachine_1.deriveWorkerStatusDecision)(context);
+}

package/dist/server/server/status/statusHeuristics.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFallbackStatus = resolveFallbackStatus;
+exports.shouldKeepWorkingFromHeartbeat = shouldKeepWorkingFromHeartbeat;
+exports.shouldTreatAsSpawnGraceIdle = shouldTreatAsSpawnGraceIdle;
+exports.shouldPromoteIdleFromActiveClaudeTask = shouldPromoteIdleFromActiveClaudeTask;
+exports.shouldForceIdleOnOpenCodePrompt = shouldForceIdleOnOpenCodePrompt;
+exports.shouldDowngradeAttentionToWorking = shouldDowngradeAttentionToWorking;
+exports.shouldForceIdleOnStaleClaudeProgress = shouldForceIdleOnStaleClaudeProgress;
+const runtimeSignals_1 = require("./runtimeSignals");
+const shellCommands = new Set(["bash", "zsh", "fish", "sh", "nu", "pwsh"]);
+const nonShellIdleAfterMs = 10_000;
+const outputHeartbeatWorkingWindowMs = 12_000;
+const claudeStickyWorkingWindowMs = 10_000;
+const claudeActiveTextHoldWindowMs = 5 * 60_000;
+const claudeSpawnIdleGraceMs = 5_000;
+function resolveFallbackStatus(parsedStatus, currentCommand, observation, activity) {
+    if (parsedStatus !== "working") {
+        return parsedStatus;
+    }
+    const commandLower = currentCommand.toLowerCase();
+    if (shellCommands.has(commandLower)) {
+        return "idle";
+    }
+    const hasStrongActivitySignal = Boolean(activity.filePath) || (Boolean(activity.tool) && activity.tool !== "terminal");
+    if (!hasStrongActivitySignal && !commandLower.includes("claude")) {
+        return "idle";
+    }
+    const now = Date.now();
+    const quietForMs = now - Math.max(observation.lastCommandChangeAtMs, observation.lastOutputChangeAtMs);
+    if (quietForMs >= nonShellIdleAfterMs) {
+        return "idle";
+    }
+    return "working";
+}
+function shouldKeepWorkingFromHeartbeat(worker, currentCommand, observation, activity, activeClaudeTask, activityText, output) {
+    const now = Date.now();
+    const commandLower = currentCommand.toLowerCase();
+    const likelyClaudeSession = (0, runtimeSignals_1.isLikelyClaudeSession)(worker, commandLower);
+    const likelyOpenCodeSession = (0, runtimeSignals_1.isLikelyOpenCodeSession)(worker, commandLower);
+    const outputQuietForMs = now - observation.lastOutputChangeAtMs;
+    const hasClaudeProgressSignal = likelyClaudeSession && (0, runtimeSignals_1.hasClaudeLiveProgressSignal)(output);
+    if (likelyOpenCodeSession && (0, runtimeSignals_1.hasOpenCodePromptSignal)(output) && !(0, runtimeSignals_1.hasOpenCodeActiveSignal)(output)) {
+        return false;
+    }
+    if (likelyClaudeSession &&
+        (0, runtimeSignals_1.hasActiveWorkActivityText)(activityText) &&
+        !(0, runtimeSignals_1.hasWaitingActivityText)(activityText) &&
+        (Boolean(activeClaudeTask) || hasClaudeProgressSignal) &&
+        outputQuietForMs <= claudeActiveTextHoldWindowMs) {
+        return true;
+    }
+    const heartbeatWindowMs = likelyClaudeSession ? claudeStickyWorkingWindowMs : outputHeartbeatWorkingWindowMs;
+    if (outputQuietForMs > heartbeatWindowMs) {
+        return false;
+    }
+    if (likelyClaudeSession) {
+        return Boolean(activeClaudeTask || hasClaudeProgressSignal);
+    }
+    if (!shellCommands.has(commandLower)) {
+        return true;
+    }
+    if (activeClaudeTask) {
+        return true;
+    }
+    if (worker.status === "working") {
+        return true;
+    }
+    return Boolean(activity.filePath || activity.tool || activity.text);
+}
+function shouldTreatAsSpawnGraceIdle(worker, currentCommand, activity, activeClaudeTask) {
+    const createdAtMs = Date.parse(worker.createdAt);
+    if (!Number.isFinite(createdAtMs)) {
+        return false;
+    }
+    const ageMs = Date.now() - createdAtMs;
+    if (ageMs < 0 || ageMs > claudeSpawnIdleGraceMs) {
+        return false;
+    }
+    if (!(0, runtimeSignals_1.isLikelyClaudeSession)(worker, currentCommand.toLowerCase())) {
+        return false;
+    }
+    if (activeClaudeTask || activity.needsInput || activity.hasError) {
+        return false;
+    }
+    const hasStrongActivitySignal = Boolean(activity.filePath) || (Boolean(activity.tool) && activity.tool !== "terminal");
+    return !hasStrongActivitySignal;
+}
+function shouldPromoteIdleFromActiveClaudeTask(worker, currentCommand, observation, activeClaudeTask) {
+    if (!activeClaudeTask) {
+        return false;
+    }
+    if (!(0, runtimeSignals_1.isLikelyClaudeSession)(worker, currentCommand.toLowerCase())) {
+        return true;
+    }
+    const outputQuietForMs = Date.now() - observation.lastOutputChangeAtMs;
+    return outputQuietForMs <= claudeStickyWorkingWindowMs;
+}
+function shouldForceIdleOnOpenCodePrompt(worker, currentCommand, output, activity) {
+    if (!(0, runtimeSignals_1.isLikelyOpenCodeSession)(worker, currentCommand.toLowerCase())) {
+        return false;
+    }
+    if (!(0, runtimeSignals_1.hasOpenCodePromptSignal)(output)) {
+        return false;
+    }
+    if ((0, runtimeSignals_1.hasOpenCodeActiveSignal)(output)) {
+        return false;
+    }
+    if (activity.needsInput) {
+        return false;
+    }
+    return true;
+}
+function shouldDowngradeAttentionToWorking(worker, currentCommand, observation, activity, activeClaudeTask, activityText, output) {
+    const normalizedActivityText = (activityText ?? "").toLowerCase();
+    if (normalizedActivityText.includes("waiting for your answer") || normalizedActivityText.includes("waiting for approval")) {
+        return false;
+    }
+    const likelyClaudeSession = (0, runtimeSignals_1.isLikelyClaudeSession)(worker, currentCommand.toLowerCase());
+    const hasClaudeProgressSignal = likelyClaudeSession && (0, runtimeSignals_1.hasClaudeLiveProgressSignal)(output);
+    if (activity.needsInput && !hasClaudeProgressSignal) {
+        return false;
+    }
+    if (likelyClaudeSession && (Boolean(activeClaudeTask) || hasClaudeProgressSignal)) {
+        return true;
+    }
+    return shouldKeepWorkingFromHeartbeat(worker, currentCommand, observation, activity, activeClaudeTask, activityText, output);
+}
+function shouldForceIdleOnStaleClaudeProgress(worker, currentCommand, observation, activityText) {
+    if (!(0, runtimeSignals_1.isLikelyClaudeSession)(worker, currentCommand.toLowerCase())) {
+        return false;
+    }
+    if (!activityText) {
+        return false;
+    }
+    const normalized = activityText.trim();
+    if (!normalized) {
+        return false;
+    }
+    const looksLikeTransientProgress = (0, runtimeSignals_1.isGenericClaudeProgressLabel)(normalized) || /\bfor\s+\d+\s*[ms]\b/i.test(normalized);
+    if (!looksLikeTransientProgress) {
+        return false;
+    }
+    const outputQuietForMs = Date.now() - observation.lastOutputChangeAtMs;
+    return outputQuietForMs > claudeStickyWorkingWindowMs;
+}