arcane-agents 0.1.0

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const decision_1 = require("./decision");
+function createWorker(status = "idle") {
+    return {
+        id: "worker-1",
+        name: "worker-1",
+        displayName: "Worker 1",
+        projectId: "project-1",
+        projectPath: "/tmp/project-1",
+        runtimeId: "opencode",
+        runtimeLabel: "OpenCode",
+        command: ["opencode"],
+        status,
+        activityText: undefined,
+        activityTool: undefined,
+        activityPath: undefined,
+        avatarType: "ranger",
+        movementMode: "hold",
+        position: { x: 120, y: 180 },
+        tmuxRef: { session: "arcane-agents", window: "worker-1", pane: "%1" },
+        createdAt: "2026-03-04T00:00:00.000Z",
+        updatedAt: "2026-03-04T00:00:00.000Z"
+    };
+}
+function createContext(overrides = {}) {
+    return {
+        worker: createWorker(),
+        nowMs: 1_000_000,
+        currentCommand: "opencode",
+        commandLower: "opencode",
+        output: "",
+        observation: {
+            lastCommand: "opencode",
+            lastCommandChangeAtMs: 999_000,
+            lastOutputSignature: "sig",
+            lastOutputChangeAtMs: 999_500
+        },
+        transcriptSnapshot: undefined,
+        parsed: {
+            status: "idle",
+            activity: {
+                text: undefined,
+                tool: undefined,
+                filePath: undefined,
+                needsInput: false,
+                hasError: false
+            }
+        },
+        runtimeActivityText: undefined,
+        activeClaudeTask: undefined,
+        hasClaudeProgressSignal: false,
+        hasOpenCodePromptSignal: false,
+        hasOpenCodeActiveSignal: false,
+        isClaudeSession: false,
+        isOpenCodeSession: false,
+        outputQuietForMs: 1_000,
+        commandQuietForMs: 5_000,
+        workerAgeMs: 30_000,
+        ...overrides
+    };
+}
+(0, vitest_1.describe)("deriveWorkerStatusDecision", () => {
+    (0, vitest_1.it)("returns attention when transcript reports attention", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            transcriptSnapshot: {
+                status: "attention",
+                activityText: "Waiting for confirmation",
+                activityTool: "terminal"
+            }
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("attention");
+        (0, vitest_1.expect)(decision.activityText).toBe("Waiting for confirmation");
+        (0, vitest_1.expect)(decision.reasons[0]?.code).toBe("transcript-attention");
+    });
+    (0, vitest_1.it)("returns attention when parsed output requires user input", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            parsed: {
+                status: "attention",
+                activity: {
+                    text: "Allow this action?",
+                    tool: "terminal",
+                    filePath: undefined,
+                    needsInput: true,
+                    hasError: false
+                }
+            }
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("attention");
+        (0, vitest_1.expect)(decision.activityText).toBe("Allow this action?");
+        (0, vitest_1.expect)(decision.reasons[0]?.code).toBe("parser-input-prompt");
+    });
+    (0, vitest_1.it)("returns error for fatal parser signal on non-agent runtime", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            currentCommand: "python",
+            commandLower: "python",
+            output: "Traceback (most recent call last):\nBoom",
+            parsed: {
+                status: "error",
+                activity: {
+                    text: "Error",
+                    tool: "terminal",
+                    filePath: undefined,
+                    needsInput: false,
+                    hasError: true
+                }
+            },
+            outputQuietForMs: 400
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("error");
+        (0, vitest_1.expect)(decision.reasons.some((reason) => reason.code === "parser-error-signal")).toBe(true);
+    });
+    (0, vitest_1.it)("returns working when strong transcript evidence is present", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            transcriptSnapshot: {
+                status: "working",
+                activityText: "Reading src/app.ts",
+                activityTool: "read",
+                activityPath: "src/app.ts"
+            },
+            outputQuietForMs: 40_000
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("working");
+        (0, vitest_1.expect)(decision.activityText).toBe("Reading src/app.ts");
+        (0, vitest_1.expect)(decision.reasons.some((reason) => reason.code === "transcript-working")).toBe(true);
+    });
+    (0, vitest_1.it)("returns idle for prompt-dominant OpenCode sessions", () => {
+        const decision = (0, decision_1.deriveWorkerStatusDecision)(createContext({
+            isOpenCodeSession: true,
+            hasOpenCodePromptSignal: true,
+            hasOpenCodeActiveSignal: false
+        }));
+        (0, vitest_1.expect)(decision.status).toBe("idle");
+        (0, vitest_1.expect)(decision.activityText).toBeUndefined();
+        (0, vitest_1.expect)(decision.activityTool).toBeUndefined();
+        (0, vitest_1.expect)(decision.reasons[0]?.code).toBe("opencode-prompt-idle");
+    });
+});

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recentNormalizedLines = recentNormalizedLines;
+exports.isAgentRuntime = isAgentRuntime;
+exports.shouldSuppressShellHistorySignals = shouldSuppressShellHistorySignals;
+exports.hasLikelyInteractiveShellPrompt = hasLikelyInteractiveShellPrompt;
+exports.normalizePromptLine = normalizePromptLine;
+exports.looksLikeActiveRuntimeText = looksLikeActiveRuntimeText;
+exports.statusFreshnessWindowMs = statusFreshnessWindowMs;
+exports.isShellCommand = isShellCommand;
+exports.pushMaybe = pushMaybe;
+exports.firstDefined = firstDefined;
+exports.hasAnyWorkingEvidence = hasAnyWorkingEvidence;
+const runtimeSignals_1 = require("../../runtimeSignals");
+const types_1 = require("../types");
+const constants_1 = require("./constants");
+function recentNormalizedLines(output, limit) {
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-limit)
+        .map((line) => line.toLowerCase());
+}
+function isAgentRuntime(context) {
+    return context.isOpenCodeSession || context.isClaudeSession;
+}
+function shouldSuppressShellHistorySignals(context) {
+    if (!isShellCommand(context.commandLower)) {
+        return false;
+    }
+    if (isAgentRuntime(context)) {
+        return false;
+    }
+    return hasLikelyInteractiveShellPrompt(context.output);
+}
+function hasLikelyInteractiveShellPrompt(output) {
+    const lines = output
+        .split("\n")
+        .map((line) => normalizePromptLine(line))
+        .filter((line) => line.length > 0)
+        .slice(-6)
+        .reverse();
+    for (const line of lines) {
+        if (constants_1.shellPromptTailMatchers.some((matcher) => matcher.test(line))) {
+            return true;
+        }
+        return false;
+    }
+    return false;
+}
+function normalizePromptLine(line) {
+    return line.replace(/^[\s│┃╹▀▣⬝■]+/, "").trim();
+}
+function looksLikeActiveRuntimeText(activityText) {
+    if (!activityText) {
+        return false;
+    }
+    if ((0, runtimeSignals_1.hasWaitingActivityText)(activityText)) {
+        return false;
+    }
+    const normalized = activityText.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    if ((0, runtimeSignals_1.hasActiveWorkActivityText)(activityText)) {
+        return true;
+    }
+    return normalized.startsWith("thinking");
+}
+function statusFreshnessWindowMs(context) {
+    if (context.isClaudeSession) {
+        return constants_1.claudeWorkingFreshWindowMs;
+    }
+    if (context.isOpenCodeSession) {
+        return constants_1.openCodeWorkingFreshWindowMs;
+    }
+    return constants_1.genericWorkingFreshWindowMs;
+}
+function isShellCommand(commandLower) {
+    return types_1.shellCommands.has(commandLower);
+}
+function pushMaybe(values, value) {
+    if (!value) {
+        return;
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        return;
+    }
+    values.push(normalized);
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function hasAnyWorkingEvidence(evidence) {
+    return evidence.strongReasons.length > 0 || evidence.weakReasons.length > 0;
+}

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const helpers_1 = require("./helpers");
+function createWorker(status = "idle") {
+    return {
+        id: "worker-1",
+        name: "worker-1",
+        displayName: "Worker 1",
+        projectId: "project-1",
+        projectPath: "/tmp/project-1",
+        runtimeId: "shell",
+        runtimeLabel: "Shell",
+        command: ["bash"],
+        status,
+        activityText: undefined,
+        activityTool: undefined,
+        activityPath: undefined,
+        avatarType: "wizard",
+        movementMode: "hold",
+        position: { x: 100, y: 100 },
+        tmuxRef: { session: "arcane-agents", window: "w1", pane: "%1" },
+        createdAt: "2026-03-04T00:00:00.000Z",
+        updatedAt: "2026-03-04T00:00:00.000Z"
+    };
+}
+function createContext(overrides = {}) {
+    return {
+        worker: createWorker(),
+        nowMs: 1_000_000,
+        currentCommand: "bash",
+        commandLower: "bash",
+        output: "user@host:~$",
+        observation: {
+            lastCommand: "bash",
+            lastCommandChangeAtMs: 999_500,
+            lastOutputSignature: "sig",
+            lastOutputChangeAtMs: 999_800
+        },
+        transcriptSnapshot: undefined,
+        parsed: {
+            status: "idle",
+            activity: {
+                text: undefined,
+                tool: undefined,
+                filePath: undefined,
+                needsInput: false,
+                hasError: false
+            }
+        },
+        runtimeActivityText: undefined,
+        activeClaudeTask: undefined,
+        hasClaudeProgressSignal: false,
+        hasOpenCodePromptSignal: false,
+        hasOpenCodeActiveSignal: false,
+        isClaudeSession: false,
+        isOpenCodeSession: false,
+        outputQuietForMs: 200,
+        commandQuietForMs: 300,
+        workerAgeMs: 10_000,
+        ...overrides
+    };
+}
+(0, vitest_1.describe)("state machine helpers", () => {
+    (0, vitest_1.it)("normalizes and returns the latest non-empty lines", () => {
+        (0, vitest_1.expect)((0, helpers_1.recentNormalizedLines)("  One\n\n Two  \nTHREE\n", 2)).toEqual(["two", "three"]);
+    });
+    (0, vitest_1.it)("suppresses shell-history signals for non-agent interactive shells", () => {
+        const shellContext = createContext({
+            commandLower: "bash",
+            isClaudeSession: false,
+            isOpenCodeSession: false,
+            output: "prompt\nuser@host:~/repo$"
+        });
+        (0, vitest_1.expect)((0, helpers_1.shouldSuppressShellHistorySignals)(shellContext)).toBe(true);
+        const opencodeContext = createContext({
+            commandLower: "bash",
+            isOpenCodeSession: true,
+            output: "prompt\nuser@host:~/repo$"
+        });
+        (0, vitest_1.expect)((0, helpers_1.shouldSuppressShellHistorySignals)(opencodeContext)).toBe(false);
+    });
+    (0, vitest_1.it)("detects likely prompt tails in recent output", () => {
+        (0, vitest_1.expect)((0, helpers_1.hasLikelyInteractiveShellPrompt)("running\n$ ")).toBe(true);
+        (0, vitest_1.expect)((0, helpers_1.hasLikelyInteractiveShellPrompt)("running\nstill working")).toBe(false);
+    });
+    (0, vitest_1.it)("recognizes active runtime text and ignores waiting text", () => {
+        (0, vitest_1.expect)((0, helpers_1.looksLikeActiveRuntimeText)("Reading src/index.ts")).toBe(true);
+        (0, vitest_1.expect)((0, helpers_1.looksLikeActiveRuntimeText)("Waiting for approval")).toBe(false);
+    });
+    (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.it)("handles helper utility behavior", () => {
+        const values = [];
+        (0, helpers_1.pushMaybe)(values, "   ");
+        (0, helpers_1.pushMaybe)(values, "  value  ");
+        (0, vitest_1.expect)(values).toEqual(["value"]);
+        (0, vitest_1.expect)((0, helpers_1.firstDefined)(undefined, undefined, "chosen", "fallback")).toBe("chosen");
+        (0, vitest_1.expect)((0, helpers_1.firstDefined)(undefined, undefined)).toBeUndefined();
+        const evidence = {
+            strongReasons: [],
+            weakReasons: [{ code: "weak", message: "weak signal" }],
+            activityTextCandidates: [],
+            activityToolCandidates: [],
+            activityPathCandidates: [],
+            parsedStrongSignal: false
+        };
+        (0, vitest_1.expect)((0, helpers_1.hasAnyWorkingEvidence)(evidence)).toBe(true);
+    });
+});

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectIdleBlocker = detectIdleBlocker;
+exports.isPromptDominantOpenCodeIdle = isPromptDominantOpenCodeIdle;
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+function isPromptDominantOpenCodeIdle(context) {
+    return context.isOpenCodeSession && context.hasOpenCodePromptSignal && !context.hasOpenCodeActiveSignal;
+}
+function detectIdleBlocker(context, evidence) {
+    if (isPromptDominantOpenCodeIdle(context)) {
+        return {
+            reason: {
+                code: "opencode-prompt-idle",
+                message: "OpenCode prompt is visible without a fresh active execution signal."
+            }
+        };
+    }
+    if ((0, helpers_1.isShellCommand)(context.commandLower) && context.transcriptSnapshot?.status !== "working") {
+        if ((0, helpers_1.hasAnyWorkingEvidence)(evidence)) {
+            return undefined;
+        }
+        return {
+            reason: {
+                code: "shell-command-idle",
+                message: "Foreground command is shell; no explicit active-work transcript signal."
+            }
+        };
+    }
+    if (context.isClaudeSession &&
+        context.workerAgeMs <= constants_1.claudeSpawnGraceMs &&
+        context.transcriptSnapshot?.status !== "working" &&
+        !context.activeClaudeTask &&
+        !context.hasClaudeProgressSignal &&
+        !evidence.parsedStrongSignal) {
+        return {
+            reason: {
+                code: "claude-spawn-grace-idle",
+                message: "During early Claude 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 {
+            reason: {
+                code: "output-stale-idle",
+                message: "Output has been quiet longer than active-work freshness window.",
+                detail: `${Math.round(context.outputQuietForMs)}ms quiet (> ${activeWindowMs}ms)`
+            }
+        };
+    }
+    return undefined;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyParserError = classifyParserError;
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+function classifyParserError(context) {
+    if ((0, helpers_1.shouldSuppressShellHistorySignals)(context)) {
+        return "none";
+    }
+    const hasRecentParserErrorSignal = context.parsed.activity.hasError && context.outputQuietForMs <= constants_1.recentErrorSignalWindowMs;
+    if (!hasRecentParserErrorSignal) {
+        return "none";
+    }
+    if (!(0, helpers_1.isAgentRuntime)(context)) {
+        return "fatal";
+    }
+    if (hasRecentFatalRuntimeError(context.output)) {
+        return "fatal";
+    }
+    if (hasRecoverableAgentToolError(context)) {
+        return "recoverable";
+    }
+    if (context.worker.status === "working" && context.outputQuietForMs <= constants_1.stickyWorkingWindowMs) {
+        return "recoverable";
+    }
+    return "recoverable";
+}
+function hasRecentFatalRuntimeError(output) {
+    return (0, helpers_1.recentNormalizedLines)(output, 30).some((line) => constants_1.fatalRuntimeErrorMatchers.some((matcher) => matcher.test(line)));
+}
+function hasRecoverableAgentToolError(context) {
+    const recentLines = (0, helpers_1.recentNormalizedLines)(context.output, 40);
+    if (recentLines.some((line) => constants_1.recoverableToolErrorMatchers.some((matcher) => matcher.test(line)))) {
+        return true;
+    }
+    const hasLikelyWebToolContext = context.parsed.activity.tool === "web" ||
+        recentLines.some((line) => /\b(?:webfetch|read-url|curl|wget|http:\/\/|https:\/\/|status code\s*:?\s*\d{3})\b/i.test(line));
+    if (hasLikelyWebToolContext && recentLines.some((line) => /^error:\s+/i.test(line))) {
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectWorkingEvidence = collectWorkingEvidence;
+exports.shouldKeepStickyWorking = shouldKeepStickyWorking;
+const runtimeSignals_1 = require("../../runtimeSignals");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+function collectWorkingEvidence(context, hasRecoverableParserError) {
+    const strongReasons = [];
+    const weakReasons = [];
+    const activityTextCandidates = [];
+    const activityToolCandidates = [];
+    const activityPathCandidates = [];
+    const suppressShellHistorySignals = (0, helpers_1.shouldSuppressShellHistorySignals)(context);
+    const parsedStrongSignal = !suppressShellHistorySignals &&
+        (Boolean(context.parsed.activity.filePath) ||
+            (Boolean(context.parsed.activity.tool) && context.parsed.activity.tool !== "terminal"));
+    if (context.transcriptSnapshot?.status === "working") {
+        strongReasons.push({ code: "transcript-working", message: "Transcript reports active work." });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.transcriptSnapshot.activityText);
+        activityToolCandidates.push(context.transcriptSnapshot.activityTool);
+        (0, helpers_1.pushMaybe)(activityPathCandidates, context.transcriptSnapshot.activityPath);
+    }
+    if (context.activeClaudeTask) {
+        strongReasons.push({ code: "claude-active-task", message: "Claude task summary indicates active work." });
+        activityTextCandidates.push(context.activeClaudeTask);
+        activityToolCandidates.push("terminal");
+    }
+    if (context.hasClaudeProgressSignal) {
+        strongReasons.push({ code: "claude-progress-signal", message: "Claude live progress signal detected." });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.runtimeActivityText);
+    }
+    if (context.hasOpenCodeActiveSignal) {
+        strongReasons.push({ code: "opencode-active-signal", message: "OpenCode active execution signal detected." });
+        activityTextCandidates.push(context.runtimeActivityText ?? "Responding");
+        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);
+    }
+    if (parsedStrongSignal && context.outputQuietForMs <= constants_1.parsedStrongEvidenceWindowMs) {
+        strongReasons.push({
+            code: "parsed-activity-signal",
+            message: "Parsed tool/path signal indicates active work.",
+            detail: `${Math.round(context.outputQuietForMs)}ms since output change`
+        });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.parsed.activity.text);
+        activityToolCandidates.push(context.parsed.activity.tool);
+        (0, helpers_1.pushMaybe)(activityPathCandidates, context.parsed.activity.filePath);
+    }
+    if (hasRecoverableParserError) {
+        weakReasons.push({
+            code: "recoverable-tool-error",
+            message: "Recent tool error appears recoverable while the runtime remains active."
+        });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.runtimeActivityText ?? context.parsed.activity.text ?? context.worker.activityText);
+        activityToolCandidates.push(context.parsed.activity.tool ?? context.worker.activityTool ?? "terminal");
+        (0, helpers_1.pushMaybe)(activityPathCandidates, context.parsed.activity.filePath ?? context.worker.activityPath);
+    }
+    if ((0, runtimeSignals_1.hasActiveWorkActivityText)(context.worker.activityText) && context.outputQuietForMs <= constants_1.cachedActivityWindowMs) {
+        weakReasons.push({ code: "cached-working-activity", message: "Recent activity text still suggests active work." });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.worker.activityText);
+        activityToolCandidates.push(context.worker.activityTool);
+        (0, helpers_1.pushMaybe)(activityPathCandidates, context.worker.activityPath);
+    }
+    if (context.commandQuietForMs <= constants_1.commandWarmupWindowMs &&
+        !(0, helpers_1.isShellCommand)(context.commandLower) &&
+        !context.parsed.activity.needsInput &&
+        !context.parsed.activity.hasError) {
+        weakReasons.push({
+            code: "recent-command-change",
+            message: "Command changed recently; allowing short warmup period.",
+            detail: `${Math.round(context.commandQuietForMs)}ms since command change`
+        });
+        (0, helpers_1.pushMaybe)(activityTextCandidates, context.runtimeActivityText ?? context.parsed.activity.text);
+        activityToolCandidates.push(context.parsed.activity.tool);
+        (0, helpers_1.pushMaybe)(activityPathCandidates, context.parsed.activity.filePath);
+    }
+    return {
+        strongReasons,
+        weakReasons,
+        activityTextCandidates,
+        activityToolCandidates,
+        activityPathCandidates,
+        parsedStrongSignal
+    };
+}
+function shouldKeepStickyWorking(context, evidence) {
+    if (context.worker.status !== "working") {
+        return false;
+    }
+    if (context.outputQuietForMs > constants_1.stickyWorkingWindowMs) {
+        return false;
+    }
+    return (0, helpers_1.hasAnyWorkingEvidence)(evidence);
+}

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveWorkerStatusDecision = void 0;
+var decision_1 = require("./stateMachine/decision");
+Object.defineProperty(exports, "deriveWorkerStatusDecision", { enumerable: true, get: function () { return decision_1.deriveWorkerStatusDecision; } });

package/dist/server/server/status/engine/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellCommands = void 0;
+exports.shellCommands = new Set(["bash", "zsh", "fish", "sh", "nu", "pwsh"]);

package/dist/server/server/status/paneObservation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observePane = observePane;
+function observePane(observations, workerId, currentCommand, output) {
+    const now = Date.now();
+    const signature = outputSignature(output);
+    const existing = observations.get(workerId);
+    if (!existing) {
+        const initial = {
+            lastCommand: currentCommand,
+            lastCommandChangeAtMs: now,
+            lastOutputSignature: signature,
+            lastOutputChangeAtMs: now
+        };
+        observations.set(workerId, initial);
+        return initial;
+    }
+    if (existing.lastCommand !== currentCommand) {
+        existing.lastCommand = currentCommand;
+        existing.lastCommandChangeAtMs = now;
+    }
+    if (existing.lastOutputSignature !== signature) {
+        existing.lastOutputSignature = signature;
+        existing.lastOutputChangeAtMs = now;
+    }
+    return existing;
+}
+function outputSignature(output) {
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-40)
+        .join("\n");
+}