arcane-agents 0.1.0

package/dist/server/server/status/statusMonitor.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusMonitor = void 0;
+const claudeTranscriptTracker_1 = require("./claudeTranscriptTracker");
+const statusPipeline_1 = require("./statusPipeline");
+const defaultDecisionFacts = {
+    command: "",
+    commandQuietForMs: 0,
+    outputQuietForMs: 0,
+    workerAgeMs: 0,
+    isClaudeSession: false,
+    isOpenCodeSession: false,
+    hasOpenCodePromptSignal: false,
+    hasOpenCodeActiveSignal: false,
+    hasClaudeProgressSignal: false,
+    hasActiveClaudeTask: false,
+    hasRuntimeActivityText: false,
+    hasParsedStrongSignal: false,
+    hasParsedNeedsInput: false,
+    hasParsedError: false
+};
+const maxTransitionHistoryEntries = 40;
+const maxPollTimingHistoryEntries = 40;
+const defaultStatusPollConcurrency = 4;
+class StatusMonitor {
+    workers;
+    tmux;
+    pollIntervalMs;
+    onWorkerUpdated;
+    onWorkerRemoved;
+    intervalId;
+    requestedPollTimer;
+    pollInFlight = false;
+    pollRequestedWhileInFlight = false;
+    claudeTranscript = new claudeTranscriptTracker_1.ClaudeTranscriptTracker();
+    paneObservation = new Map();
+    statusDebugByWorker = new Map();
+    statusTransitionHistoryByWorker = new Map();
+    workerTimingByWorker = new Map();
+    recentPollTiming = [];
+    traceMode = resolveStatusTraceMode();
+    workerPollConcurrency = resolveStatusPollConcurrency();
+    constructor(workers, tmux, pollIntervalMs, onWorkerUpdated, onWorkerRemoved) {
+        this.workers = workers;
+        this.tmux = tmux;
+        this.pollIntervalMs = pollIntervalMs;
+        this.onWorkerUpdated = onWorkerUpdated;
+        this.onWorkerRemoved = onWorkerRemoved;
+    }
+    start() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(() => {
+            void this.pollOnce();
+        }, this.pollIntervalMs);
+        void this.pollOnce();
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+        if (this.requestedPollTimer) {
+            clearTimeout(this.requestedPollTimer);
+            this.requestedPollTimer = undefined;
+        }
+    }
+    requestPollSoon(delayMs = 35) {
+        if (this.requestedPollTimer) {
+            return;
+        }
+        this.requestedPollTimer = setTimeout(() => {
+            this.requestedPollTimer = undefined;
+            void this.pollOnce();
+        }, Math.max(0, delayMs));
+    }
+    listWorkerStatusDebug() {
+        return [...this.statusDebugByWorker.values()].sort((a, b) => a.workerName.localeCompare(b.workerName));
+    }
+    getWorkerStatusDebug(workerId) {
+        return this.statusDebugByWorker.get(workerId);
+    }
+    getWorkerStatusHistory(workerId) {
+        return this.statusTransitionHistoryByWorker.get(workerId) ?? [];
+    }
+    getStatusPerformanceDebug() {
+        return {
+            concurrency: this.workerPollConcurrency,
+            latestPoll: this.recentPollTiming[this.recentPollTiming.length - 1],
+            recentPolls: [...this.recentPollTiming],
+            workers: [...this.workerTimingByWorker.values()].sort((a, b) => a.workerName.localeCompare(b.workerName))
+        };
+    }
+    async pollOnce() {
+        if (this.pollInFlight) {
+            this.pollRequestedWhileInFlight = true;
+            return;
+        }
+        this.pollInFlight = true;
+        try {
+            const pollStartedAtMs = Date.now();
+            const currentWorkers = this.workers.listWorkers();
+            const workerTimings = await mapWithConcurrency(currentWorkers, this.workerPollConcurrency, async (worker) => this.evaluateWorkerWithTiming(worker));
+            this.recordPollTiming(pollStartedAtMs, currentWorkers.length, workerTimings);
+        }
+        finally {
+            this.pollInFlight = false;
+            if (this.pollRequestedWhileInFlight) {
+                this.pollRequestedWhileInFlight = false;
+                this.requestPollSoon(0);
+            }
+        }
+    }
+    async evaluateWorkerWithTiming(worker) {
+        const startedAtMs = Date.now();
+        let outcome = "failed";
+        let toStatus = worker.status;
+        try {
+            const updateOutcome = await this.updateWorkerStatus(worker);
+            outcome = updateOutcome.outcome;
+            toStatus = updateOutcome.nextStatus;
+        }
+        catch {
+            outcome = "failed";
+            toStatus = "error";
+        }
+        const snapshot = {
+            workerId: worker.id,
+            workerName: worker.displayName ?? worker.name,
+            fromStatus: worker.status,
+            toStatus,
+            outcome,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            evaluatedAt: new Date().toISOString()
+        };
+        if (outcome === "removed") {
+            this.workerTimingByWorker.delete(worker.id);
+        }
+        else {
+            this.workerTimingByWorker.set(worker.id, snapshot);
+        }
+        return snapshot;
+    }
+    async updateWorkerStatus(worker) {
+        const live = await this.tmux.windowExists(worker.tmuxRef);
+        if (!live) {
+            this.removeWorker(worker.id);
+            return {
+                outcome: "removed",
+                nextStatus: "stopped"
+            };
+        }
+        let evaluation = {
+            status: worker.status,
+            activityText: worker.activityText,
+            activityTool: worker.activityTool,
+            activityPath: worker.activityPath,
+            confidence: 0,
+            reasons: [{ code: "not-evaluated", message: "Status evaluation did not run." }],
+            facts: {
+                ...defaultDecisionFacts
+            }
+        };
+        try {
+            const signals = await (0, statusPipeline_1.collectWorkerStatusSignals)({
+                worker,
+                tmux: this.tmux,
+                paneObservation: this.paneObservation,
+                claudeTranscript: this.claudeTranscript
+            });
+            if (!signals) {
+                this.removeWorker(worker.id);
+                return {
+                    outcome: "removed",
+                    nextStatus: "stopped"
+                };
+            }
+            evaluation = (0, statusPipeline_1.normalizeWorkerStatusEvaluation)((0, statusPipeline_1.evaluateWorkerStatusSignals)(worker, signals));
+        }
+        catch {
+            evaluation = {
+                status: "error",
+                activityText: "Status check failed",
+                activityTool: "unknown",
+                activityPath: undefined,
+                confidence: 0.25,
+                reasons: [{ code: "status-check-failed", message: "Status monitoring raised an exception." }],
+                facts: {
+                    ...defaultDecisionFacts
+                }
+            };
+        }
+        this.recordStatusDebug(worker, evaluation);
+        this.traceStatusEvaluation(worker, evaluation);
+        this.recordStatusTransition(worker, evaluation);
+        if (evaluation.status === worker.status &&
+            evaluation.activityText === worker.activityText &&
+            evaluation.activityTool === worker.activityTool &&
+            evaluation.activityPath === worker.activityPath) {
+            return {
+                outcome: "unchanged",
+                nextStatus: worker.status
+            };
+        }
+        if (evaluation.status === "stopped") {
+            this.removeWorker(worker.id);
+            return {
+                outcome: "removed",
+                nextStatus: "stopped"
+            };
+        }
+        const updated = this.workers.updateStatus(worker.id, {
+            status: evaluation.status,
+            activityText: evaluation.activityText,
+            activityTool: evaluation.activityTool,
+            activityPath: evaluation.activityPath
+        });
+        if (updated) {
+            this.onWorkerUpdated(updated);
+            return {
+                outcome: "updated",
+                nextStatus: updated.status
+            };
+        }
+        return {
+            outcome: "failed",
+            nextStatus: evaluation.status
+        };
+    }
+    removeWorker(workerId) {
+        const removed = this.workers.deleteWorker(workerId);
+        if (removed) {
+            this.claudeTranscript.forget(workerId);
+            this.paneObservation.delete(workerId);
+            this.statusDebugByWorker.delete(workerId);
+            this.statusTransitionHistoryByWorker.delete(workerId);
+            this.workerTimingByWorker.delete(workerId);
+            this.onWorkerRemoved(workerId);
+        }
+    }
+    recordPollTiming(pollStartedAtMs, workerCount, workerTimings) {
+        const pollFinishedAtMs = Date.now();
+        const totalWorkerDurationMs = workerTimings.reduce((sum, timing) => sum + timing.durationMs, 0);
+        const maxWorkerDurationMs = workerTimings.reduce((max, timing) => Math.max(max, timing.durationMs), 0);
+        const averageWorkerDurationMs = workerTimings.length > 0 ? totalWorkerDurationMs / workerTimings.length : 0;
+        const outcomeCounts = {
+            unchanged: 0,
+            updated: 0,
+            removed: 0,
+            failed: 0
+        };
+        for (const timing of workerTimings) {
+            outcomeCounts[timing.outcome] += 1;
+        }
+        const pollTiming = {
+            startedAt: new Date(pollStartedAtMs).toISOString(),
+            finishedAt: new Date(pollFinishedAtMs).toISOString(),
+            durationMs: Math.max(0, pollFinishedAtMs - pollStartedAtMs),
+            workerCount,
+            concurrency: this.workerPollConcurrency,
+            averageWorkerDurationMs,
+            maxWorkerDurationMs,
+            outcomeCounts
+        };
+        this.recentPollTiming.push(pollTiming);
+        if (this.recentPollTiming.length > maxPollTimingHistoryEntries) {
+            this.recentPollTiming.splice(0, this.recentPollTiming.length - maxPollTimingHistoryEntries);
+        }
+        this.tracePollTiming(pollTiming);
+    }
+    tracePollTiming(timing) {
+        if (this.traceMode !== "verbose") {
+            return;
+        }
+        console.log(`[arcane-agents][status] poll workers=${timing.workerCount} duration=${Math.round(timing.durationMs)}ms ` +
+            `avgWorker=${Math.round(timing.averageWorkerDurationMs)}ms maxWorker=${Math.round(timing.maxWorkerDurationMs)}ms ` +
+            `outcomes={updated:${timing.outcomeCounts.updated},unchanged:${timing.outcomeCounts.unchanged},removed:${timing.outcomeCounts.removed},failed:${timing.outcomeCounts.failed}}`);
+    }
+    recordStatusDebug(worker, evaluation) {
+        this.statusDebugByWorker.set(worker.id, {
+            workerId: worker.id,
+            workerName: worker.displayName ?? worker.name,
+            previousStatus: worker.status,
+            evaluatedAt: new Date().toISOString(),
+            decision: evaluation
+        });
+    }
+    traceStatusEvaluation(worker, evaluation) {
+        if (this.traceMode === "off") {
+            return;
+        }
+        const changed = evaluation.status !== worker.status;
+        if (this.traceMode === "transitions" && !changed) {
+            return;
+        }
+        const fromTo = changed ? `${worker.status} -> ${evaluation.status}` : `${evaluation.status}`;
+        const reasonText = evaluation.reasons.map((reason) => formatReason(reason.code, reason.detail)).join(", ");
+        const activityText = evaluation.activityText ? ` activity="${truncateForTrace(evaluation.activityText, 84)}"` : "";
+        const commandText = truncateForTrace(evaluation.facts.command, 32);
+        const traceFacts = `cmd=${JSON.stringify(commandText)} ` +
+            `outQuiet=${Math.round(evaluation.facts.outputQuietForMs)}ms ` +
+            `cmdQuiet=${Math.round(evaluation.facts.commandQuietForMs)}ms ` +
+            `claude=${evaluation.facts.isClaudeSession ? 1 : 0} ` +
+            `opencode=${evaluation.facts.isOpenCodeSession ? 1 : 0}`;
+        console.log(`[arcane-agents][status] ${worker.displayName ?? worker.name} ${fromTo} (${Math.round(evaluation.confidence * 100)}%)${activityText} reasons=[${reasonText}] ${traceFacts}`);
+    }
+    recordStatusTransition(worker, evaluation) {
+        if (evaluation.status === worker.status) {
+            return;
+        }
+        const transition = {
+            workerId: worker.id,
+            workerName: worker.displayName ?? worker.name,
+            fromStatus: worker.status,
+            toStatus: evaluation.status,
+            at: new Date().toISOString(),
+            confidence: evaluation.confidence,
+            reasons: evaluation.reasons,
+            facts: evaluation.facts
+        };
+        const history = this.statusTransitionHistoryByWorker.get(worker.id) ?? [];
+        history.push(transition);
+        if (history.length > maxTransitionHistoryEntries) {
+            history.splice(0, history.length - maxTransitionHistoryEntries);
+        }
+        this.statusTransitionHistoryByWorker.set(worker.id, history);
+    }
+}
+exports.StatusMonitor = StatusMonitor;
+function resolveStatusPollConcurrency() {
+    const rawValue = (process.env.ARCANE_AGENTS_STATUS_POLL_CONCURRENCY ?? "").trim();
+    const parsed = Number.parseInt(rawValue, 10);
+    if (Number.isFinite(parsed) && parsed >= 1) {
+        return Math.min(32, parsed);
+    }
+    return defaultStatusPollConcurrency;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    if (items.length === 0) {
+        return [];
+    }
+    const limit = Math.max(1, Math.min(concurrency, items.length));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const run = async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    };
+    await Promise.all(Array.from({ length: limit }, () => run()));
+    return results;
+}
+function resolveStatusTraceMode() {
+    const rawValue = (process.env.ARCANE_AGENTS_STATUS_TRACE ?? "").trim().toLowerCase();
+    if (rawValue === "verbose" || rawValue === "2") {
+        return "verbose";
+    }
+    if (rawValue === "transitions" ||
+        rawValue === "1" ||
+        rawValue === "true" ||
+        rawValue === "on" ||
+        rawValue === "yes") {
+        return "transitions";
+    }
+    if (rawValue === "off" || rawValue === "0" || rawValue === "false" || rawValue === "no") {
+        return "off";
+    }
+    return "off";
+}
+function formatReason(code, detail) {
+    if (!detail) {
+        return code;
+    }
+    return `${code}:${truncateForTrace(detail, 48)}`;
+}
+function truncateForTrace(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    if (maxLength <= 1) {
+        return value.slice(0, Math.max(0, maxLength));
+    }
+    return `${value.slice(0, maxLength - 1).trimEnd()}…`;
+}

package/dist/server/server/status/statusMonitor.test.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const statusMonitor_1 = require("./statusMonitor");
+const statusPipeline_1 = require("./statusPipeline");
+vitest_1.vi.mock("./statusPipeline", () => ({
+    collectWorkerStatusSignals: vitest_1.vi.fn(),
+    evaluateWorkerStatusSignals: vitest_1.vi.fn(),
+    normalizeWorkerStatusEvaluation: vitest_1.vi.fn((evaluation) => evaluation)
+}));
+const defaultFacts = {
+    command: "claude",
+    commandQuietForMs: 0,
+    outputQuietForMs: 0,
+    workerAgeMs: 0,
+    isClaudeSession: true,
+    isOpenCodeSession: false,
+    hasOpenCodePromptSignal: false,
+    hasOpenCodeActiveSignal: false,
+    hasClaudeProgressSignal: false,
+    hasActiveClaudeTask: false,
+    hasRuntimeActivityText: false,
+    hasParsedStrongSignal: false,
+    hasParsedNeedsInput: false,
+    hasParsedError: false
+};
+function createWorker(workerId, status = "idle") {
+    return {
+        id: workerId,
+        name: workerId,
+        displayName: workerId,
+        projectId: "project",
+        projectPath: "/tmp/project",
+        runtimeId: "claude",
+        runtimeLabel: "Claude",
+        command: ["claude"],
+        status,
+        activityText: undefined,
+        activityTool: undefined,
+        activityPath: undefined,
+        avatarType: "wizard",
+        movementMode: "hold",
+        position: { x: 10, y: 10 },
+        tmuxRef: { session: "arcane-agents", window: workerId, pane: `%${workerId}` },
+        createdAt: "2026-03-04T00:00:00.000Z",
+        updatedAt: "2026-03-04T00:00:00.000Z"
+    };
+}
+function createRepository(initialWorkers) {
+    const workers = new Map(initialWorkers.map((worker) => [worker.id, { ...worker }]));
+    const listWorkers = vitest_1.vi.fn(() => [...workers.values()].map((worker) => ({ ...worker })));
+    const updateStatus = vitest_1.vi.fn((workerId, update) => {
+        const existing = workers.get(workerId);
+        if (!existing) {
+            return undefined;
+        }
+        const updated = {
+            ...existing,
+            status: update.status,
+            activityText: update.activityText,
+            activityTool: update.activityTool,
+            activityPath: update.activityPath,
+            updatedAt: new Date().toISOString()
+        };
+        workers.set(workerId, updated);
+        return { ...updated };
+    });
+    const deleteWorker = vitest_1.vi.fn((workerId) => workers.delete(workerId));
+    return {
+        workers,
+        repo: {
+            listWorkers,
+            updateStatus,
+            deleteWorker
+        },
+        listWorkers,
+        updateStatus,
+        deleteWorker
+    };
+}
+function createSignals() {
+    return {
+        currentCommand: "claude",
+        output: "",
+        observation: {
+            lastCommand: "claude",
+            lastCommandChangeAtMs: Date.now(),
+            lastOutputSignature: "",
+            lastOutputChangeAtMs: Date.now()
+        },
+        transcriptSnapshot: undefined
+    };
+}
+function createEvaluation(status) {
+    return {
+        status,
+        activityText: status === "idle" || status === "stopped" ? undefined : `status-${status}`,
+        activityTool: status === "idle" || status === "stopped" ? undefined : "terminal",
+        activityPath: undefined,
+        confidence: 0.9,
+        reasons: [{ code: `status-${status}`, message: `Status ${status}` }],
+        facts: defaultFacts
+    };
+}
+(0, vitest_1.describe)("StatusMonitor", () => {
+    const collectMock = vitest_1.vi.mocked(statusPipeline_1.collectWorkerStatusSignals);
+    const evaluateMock = vitest_1.vi.mocked(statusPipeline_1.evaluateWorkerStatusSignals);
+    const normalizeMock = vitest_1.vi.mocked(statusPipeline_1.normalizeWorkerStatusEvaluation);
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        collectMock.mockResolvedValue(createSignals());
+        evaluateMock.mockImplementation((worker) => createEvaluation(worker.status));
+        normalizeMock.mockImplementation((evaluation) => evaluation);
+        delete process.env.ARCANE_AGENTS_STATUS_POLL_CONCURRENCY;
+    });
+    (0, vitest_1.it)("keeps expected status transitions including stopped removal", async () => {
+        const repository = createRepository([createWorker("worker-1", "idle")]);
+        const tmux = {
+            windowExists: vitest_1.vi.fn(async () => true)
+        };
+        const onWorkerUpdated = vitest_1.vi.fn();
+        const onWorkerRemoved = vitest_1.vi.fn();
+        const monitor = new statusMonitor_1.StatusMonitor(repository.repo, tmux, 1_000, onWorkerUpdated, onWorkerRemoved);
+        const statusSequence = ["working", "attention", "error", "idle", "stopped"];
+        let nextStatusIndex = 0;
+        evaluateMock.mockImplementation(() => {
+            const nextStatus = statusSequence[nextStatusIndex] ?? "stopped";
+            nextStatusIndex += 1;
+            return createEvaluation(nextStatus);
+        });
+        await monitor.pollOnce();
+        await monitor.pollOnce();
+        await monitor.pollOnce();
+        await monitor.pollOnce();
+        const transitionHistory = monitor.getWorkerStatusHistory("worker-1");
+        (0, vitest_1.expect)(transitionHistory.map((entry) => entry.toStatus)).toEqual(["working", "attention", "error", "idle"]);
+        (0, vitest_1.expect)(onWorkerUpdated).toHaveBeenCalledTimes(4);
+        await monitor.pollOnce();
+        (0, vitest_1.expect)(repository.workers.has("worker-1")).toBe(false);
+        (0, vitest_1.expect)(onWorkerRemoved).toHaveBeenCalledWith("worker-1");
+        (0, vitest_1.expect)(onWorkerRemoved).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("bounds concurrent worker evaluations", async () => {
+        process.env.ARCANE_AGENTS_STATUS_POLL_CONCURRENCY = "2";
+        const repository = createRepository([
+            createWorker("worker-1"),
+            createWorker("worker-2"),
+            createWorker("worker-3"),
+            createWorker("worker-4"),
+            createWorker("worker-5")
+        ]);
+        let inFlight = 0;
+        let maxInFlight = 0;
+        const tmux = {
+            windowExists: vitest_1.vi.fn(async () => {
+                inFlight += 1;
+                maxInFlight = Math.max(maxInFlight, inFlight);
+                await new Promise((resolve) => setTimeout(resolve, 8));
+                inFlight -= 1;
+                return true;
+            })
+        };
+        const monitor = new statusMonitor_1.StatusMonitor(repository.repo, tmux, 1_000, () => undefined, () => undefined);
+        await monitor.pollOnce();
+        (0, vitest_1.expect)(maxInFlight).toBeLessThanOrEqual(2);
+        (0, vitest_1.expect)(maxInFlight).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("tracks per-poll and per-worker timing metrics", async () => {
+        const repository = createRepository([createWorker("worker-1", "idle"), createWorker("worker-2", "working")]);
+        const tmux = {
+            windowExists: vitest_1.vi.fn(async () => true)
+        };
+        const monitor = new statusMonitor_1.StatusMonitor(repository.repo, tmux, 1_000, () => undefined, () => undefined);
+        evaluateMock.mockImplementation((worker) => {
+            if (worker.id === "worker-1") {
+                return createEvaluation("working");
+            }
+            return createEvaluation("stopped");
+        });
+        await monitor.pollOnce();
+        const performance = monitor.getStatusPerformanceDebug();
+        (0, vitest_1.expect)(performance.latestPoll).toBeDefined();
+        (0, vitest_1.expect)(performance.latestPoll?.workerCount).toBe(2);
+        (0, vitest_1.expect)(performance.latestPoll?.outcomeCounts.updated).toBe(1);
+        (0, vitest_1.expect)(performance.latestPoll?.outcomeCounts.removed).toBe(1);
+        (0, vitest_1.expect)(performance.recentPolls.length).toBe(1);
+        (0, vitest_1.expect)(performance.workers).toHaveLength(1);
+        (0, vitest_1.expect)(performance.workers[0]?.workerId).toBe("worker-1");
+        (0, vitest_1.expect)(performance.workers[0]?.durationMs).toBeGreaterThanOrEqual(0);
+    });
+});

package/dist/server/server/status/statusPipeline.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectWorkerStatusSignals = collectWorkerStatusSignals;
+exports.evaluateWorkerStatusSignals = evaluateWorkerStatusSignals;
+exports.normalizeWorkerStatusEvaluation = normalizeWorkerStatusEvaluation;
+const runtimeSignals_1 = require("./runtimeSignals");
+const statusEvaluator_1 = require("./statusEvaluator");
+const paneObservation_1 = require("./paneObservation");
+async function collectWorkerStatusSignals({ worker, tmux, paneObservation, claudeTranscript }) {
+    const paneState = await tmux.getPaneState(worker.tmuxRef);
+    if (paneState.isDead) {
+        return undefined;
+    }
+    const [output, transcriptSnapshot] = await Promise.all([
+        tmux.capturePane(worker.tmuxRef, (0, runtimeSignals_1.capturePaneLineCount)(worker, paneState.currentCommand.toLowerCase())),
+        claudeTranscript.poll(worker, paneState.currentCommand, paneState.currentPath)
+    ]);
+    const observation = (0, paneObservation_1.observePane)(paneObservation, worker.id, paneState.currentCommand, output);
+    return {
+        currentCommand: paneState.currentCommand,
+        output,
+        observation,
+        transcriptSnapshot
+    };
+}
+function evaluateWorkerStatusSignals(worker, signals) {
+    return (0, statusEvaluator_1.evaluateWorkerStatus)({
+        worker,
+        currentCommand: signals.currentCommand,
+        output: signals.output,
+        observation: signals.observation,
+        transcriptSnapshot: signals.transcriptSnapshot
+    });
+}
+function normalizeWorkerStatusEvaluation(evaluation) {
+    if (evaluation.status !== "idle") {
+        return evaluation;
+    }
+    return {
+        ...evaluation,
+        activityText: undefined,
+        activityTool: undefined,
+        activityPath: undefined
+    };
+}