arcane-agents 0.1.0

package/dist/server/server/status/claudeTranscript/io.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTranscriptPath = resolveTranscriptPath;
+exports.collectTranscriptInputLines = collectTranscriptInputLines;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+const accumulator_1 = require("./accumulator");
+async function resolveTranscriptPath({ worker, state, paneCurrentPath, nowMs }) {
+    if (state.transcriptPath && (await isPathToFile(state.transcriptPath))) {
+        state.nextTranscriptLookupAtMs = 0;
+        return state.transcriptPath;
+    }
+    if (nowMs < state.nextTranscriptLookupAtMs) {
+        return undefined;
+    }
+    const candidateDirs = buildTranscriptCandidateDirs(worker.projectPath, paneCurrentPath);
+    const sessionId = extractSessionId(worker.command);
+    for (const transcriptDir of candidateDirs) {
+        if (!(await isPathToDirectory(transcriptDir))) {
+            continue;
+        }
+        if (sessionId) {
+            const directPath = node_path_1.default.join(transcriptDir, `${sessionId}.jsonl`);
+            if (await isPathToFile(directPath)) {
+                state.nextTranscriptLookupAtMs = 0;
+                return directPath;
+            }
+        }
+        const latest = await findLatestTranscriptFile(transcriptDir, nowMs);
+        if (latest) {
+            state.nextTranscriptLookupAtMs = 0;
+            return latest;
+        }
+    }
+    state.nextTranscriptLookupAtMs = nowMs + constants_1.transcriptLookupRetryMs;
+    return undefined;
+}
+async function collectTranscriptInputLines(state) {
+    const transcriptPath = state.transcriptPath;
+    if (!transcriptPath) {
+        return [];
+    }
+    const stats = await promises_1.default.stat(transcriptPath);
+    if (!stats.isFile()) {
+        return [];
+    }
+    if (!state.initialized || stats.size < state.fileOffset) {
+        return bootstrapFromTail(state, transcriptPath, stats.size);
+    }
+    if (stats.size === state.fileOffset) {
+        return [];
+    }
+    const chunk = await readFileRange(transcriptPath, state.fileOffset, stats.size - state.fileOffset);
+    state.fileOffset = stats.size;
+    return collectLinesFromChunk(state, chunk, false);
+}
+function buildTranscriptCandidateDirs(workerProjectPath, paneCurrentPath) {
+    const candidates = [paneCurrentPath, workerProjectPath]
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .map((projectPathValue) => node_path_1.default.join(constants_1.claudeProjectRoot, projectPathValue.replace(/[^a-zA-Z0-9-]/g, "-")));
+    const unique = new Set();
+    for (const candidate of candidates) {
+        unique.add(candidate);
+    }
+    return [...unique];
+}
+async function findLatestTranscriptFile(directoryPath, nowMs) {
+    let latestPath;
+    let latestMtimeMs = 0;
+    const entries = await promises_1.default.readdir(directoryPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        const fullPath = node_path_1.default.join(directoryPath, entry.name);
+        const stats = await promises_1.default.stat(fullPath);
+        if (!stats.isFile()) {
+            continue;
+        }
+        if (stats.mtimeMs > latestMtimeMs) {
+            latestMtimeMs = stats.mtimeMs;
+            latestPath = fullPath;
+        }
+    }
+    if (!latestPath) {
+        return undefined;
+    }
+    if (nowMs - latestMtimeMs > constants_1.maxRecentTranscriptAgeMs) {
+        return undefined;
+    }
+    return latestPath;
+}
+async function readFileRange(filePath, startOffset, length) {
+    if (length <= 0) {
+        return "";
+    }
+    const fileHandle = await promises_1.default.open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        await fileHandle.read(buffer, 0, length, startOffset);
+        return buffer.toString("utf8");
+    }
+    finally {
+        await fileHandle.close();
+    }
+}
+async function bootstrapFromTail(state, transcriptPath, fileSize) {
+    const readLength = Math.min(fileSize, constants_1.bootstrapTailBytes);
+    const startOffset = fileSize - readLength;
+    const chunk = await readFileRange(transcriptPath, startOffset, readLength);
+    (0, accumulator_1.resetTranscriptState)(state);
+    state.fileOffset = fileSize;
+    state.initialized = true;
+    return collectLinesFromChunk(state, chunk, startOffset > 0);
+}
+function collectLinesFromChunk(state, chunk, dropFirstLine) {
+    const combined = state.lineBuffer + chunk;
+    const lines = combined.split("\n");
+    state.lineBuffer = lines.pop() ?? "";
+    if (dropFirstLine && lines.length > 0) {
+        lines.shift();
+    }
+    return lines;
+}
+async function isPathToFile(filePath) {
+    try {
+        const stats = await promises_1.default.stat(filePath);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isPathToDirectory(directoryPath) {
+    try {
+        const stats = await promises_1.default.stat(directoryPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function extractSessionId(command) {
+    for (let index = 0; index < command.length; index += 1) {
+        const token = command[index];
+        if (token === "--session-id") {
+            const nextToken = command[index + 1];
+            return typeof nextToken === "string" && nextToken.trim().length > 0 ? nextToken : undefined;
+        }
+        if (token.startsWith("--session-id=")) {
+            const value = token.slice("--session-id=".length).trim();
+            return value.length > 0 ? value : undefined;
+        }
+    }
+    return undefined;
+}

package/dist/server/server/status/claudeTranscript/parser.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTranscriptRecords = extractTranscriptRecords;
+exports.parseRecord = parseRecord;
+exports.readRecord = readRecord;
+exports.readArray = readArray;
+exports.readString = readString;
+function extractTranscriptRecords(lines) {
+    const records = [];
+    for (const rawLine of lines) {
+        const trimmed = rawLine.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const record = parseRecord(trimmed);
+        if (!record) {
+            continue;
+        }
+        const recordType = readString(record.type);
+        if (recordType !== "assistant" && recordType !== "user" && recordType !== "system" && recordType !== "progress") {
+            continue;
+        }
+        records.push({
+            type: recordType,
+            record
+        });
+    }
+    return records;
+}
+function parseRecord(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return readRecord(parsed) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function readArray(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/server/server/status/claudeTranscript/snapshot.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSnapshot = buildSnapshot;
+const constants_1 = require("./constants");
+const accumulator_1 = require("./accumulator");
+function buildSnapshot(state, nowMs) {
+    if (!state.seenTranscriptRecord) {
+        return undefined;
+    }
+    const activeTools = listFreshActiveTools(state, nowMs);
+    const mostRecentTool = activeTools.reduce((latest, current) => {
+        if (!latest) {
+            return current;
+        }
+        if (current.lastProgressAtMs >= latest.lastProgressAtMs) {
+            return current;
+        }
+        return latest;
+    }, undefined);
+    const hasAskUserQuestion = activeTools.some((entry) => (0, accumulator_1.normalizeToolName)(entry.toolName) === "askuserquestion");
+    const hasNonExemptActiveTools = activeTools.some((entry) => !constants_1.permissionExemptTools.has((0, accumulator_1.normalizeToolName)(entry.toolName)));
+    const isPermissionWait = hasNonExemptActiveTools && nowMs - state.lastEventAtMs >= constants_1.permissionIdleDelayMs;
+    const isActivelyWorking = activeTools.length > 0 || nowMs <= state.busyUntilMs;
+    let status = "idle";
+    if (hasAskUserQuestion || isPermissionWait) {
+        status = "attention";
+    }
+    else if (isActivelyWorking && !state.waiting) {
+        status = "working";
+    }
+    else {
+        status = "idle";
+    }
+    let activityText = mostRecentTool?.statusText ?? state.lastActivityText;
+    let activityTool = mostRecentTool?.activityTool ?? state.lastActivityTool;
+    let activityPath = mostRecentTool?.activityPath ?? state.lastActivityPath;
+    if (hasAskUserQuestion) {
+        activityText = "Waiting for your answer";
+        activityTool = "terminal";
+    }
+    else if (isPermissionWait) {
+        activityText = activityText ?? "Waiting for approval";
+        activityTool = activityTool ?? "terminal";
+    }
+    if (status === "idle" && activityText === "Waiting for approval") {
+        activityText = undefined;
+        activityTool = undefined;
+        activityPath = undefined;
+    }
+    return {
+        status,
+        activityText,
+        activityTool,
+        activityPath
+    };
+}
+function listActiveTools(state) {
+    const entries = [];
+    for (const entry of state.activeTools.values()) {
+        entries.push(entry);
+    }
+    for (const subagentTools of state.activeSubagentTools.values()) {
+        for (const entry of subagentTools.values()) {
+            entries.push(entry);
+        }
+    }
+    return entries;
+}
+function listFreshActiveTools(state, nowMs) {
+    const entries = listActiveTools(state);
+    if (entries.length === 0) {
+        return entries;
+    }
+    if (state.lastEventAtMs <= 0) {
+        return entries;
+    }
+    const transcriptQuietForMs = nowMs - state.lastEventAtMs;
+    if (transcriptQuietForMs <= constants_1.activeToolStaleAfterMs) {
+        return entries;
+    }
+    return entries.filter((entry) => nowMs - entry.lastProgressAtMs <= constants_1.activeToolStaleAfterMs);
+}

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

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

package/dist/server/server/status/claudeTranscriptTracker.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeTranscriptTracker = void 0;
+const accumulator_1 = require("./claudeTranscript/accumulator");
+const io_1 = require("./claudeTranscript/io");
+const parser_1 = require("./claudeTranscript/parser");
+const snapshot_1 = require("./claudeTranscript/snapshot");
+const sessionDetection_1 = require("./runtime/sessionDetection");
+class ClaudeTranscriptTracker {
+    states = new Map();
+    async poll(worker, paneCurrentCommand, paneCurrentPath) {
+        if (!(0, sessionDetection_1.isLikelyClaudeSession)(worker, paneCurrentCommand.toLowerCase())) {
+            this.states.delete(worker.id);
+            return undefined;
+        }
+        const state = this.getState(worker.id);
+        let transcriptPath;
+        try {
+            transcriptPath = await (0, io_1.resolveTranscriptPath)({
+                worker,
+                state,
+                paneCurrentPath,
+                nowMs: Date.now()
+            });
+        }
+        catch {
+            return undefined;
+        }
+        if (!transcriptPath) {
+            return undefined;
+        }
+        if (state.transcriptPath !== transcriptPath) {
+            state.transcriptPath = transcriptPath;
+            (0, accumulator_1.resetTranscriptState)(state);
+        }
+        try {
+            const lines = await (0, io_1.collectTranscriptInputLines)(state);
+            const records = (0, parser_1.extractTranscriptRecords)(lines);
+            (0, accumulator_1.applyParsedTranscriptRecords)(state, records);
+        }
+        catch {
+            return undefined;
+        }
+        return (0, snapshot_1.buildSnapshot)(state, Date.now());
+    }
+    forget(workerId) {
+        this.states.delete(workerId);
+    }
+    getState(workerId) {
+        const existing = this.states.get(workerId);
+        if (existing) {
+            return existing;
+        }
+        const next = (0, accumulator_1.createTranscriptState)();
+        this.states.set(workerId, next);
+        return next;
+    }
+}
+exports.ClaudeTranscriptTracker = ClaudeTranscriptTracker;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWorkerStatusSignalContext = buildWorkerStatusSignalContext;
+const activityParser_1 = require("../activityParser");
+const runtimeSignals_1 = require("../runtimeSignals");
+function buildWorkerStatusSignalContext({ worker, currentCommand, output, observation, transcriptSnapshot, nowMs }) {
+    const parsed = (0, activityParser_1.parseActivity)(currentCommand, output);
+    const commandLower = currentCommand.toLowerCase();
+    const isClaude = (0, runtimeSignals_1.isLikelyClaudeSession)(worker, commandLower);
+    const openCodeSignals = (0, runtimeSignals_1.detectOpenCodeSignals)(output);
+    const isOpenCode = (0, runtimeSignals_1.isLikelyOpenCodeSession)(worker, commandLower) || openCodeSignals.prompt || openCodeSignals.active;
+    const runtimeActivityText = (0, runtimeSignals_1.extractRuntimeActivityText)(output, { isClaude, isOpenCode });
+    const activeClaudeTask = (0, runtimeSignals_1.extractClaudeActiveTask)(output);
+    const hasClaudeProgressSignal = isClaude && (0, runtimeSignals_1.hasClaudeLiveProgressSignal)(output);
+    const openCodePromptSignal = isOpenCode && openCodeSignals.prompt;
+    const openCodeActiveSignal = isOpenCode && openCodeSignals.active;
+    const outputQuietForMs = Math.max(0, nowMs - observation.lastOutputChangeAtMs);
+    const commandQuietForMs = Math.max(0, nowMs - observation.lastCommandChangeAtMs);
+    const createdAtMs = Date.parse(worker.createdAt);
+    const workerAgeMs = Number.isFinite(createdAtMs) ? Math.max(0, nowMs - createdAtMs) : Number.POSITIVE_INFINITY;
+    return {
+        worker,
+        nowMs,
+        currentCommand,
+        commandLower,
+        output,
+        observation,
+        transcriptSnapshot,
+        parsed,
+        runtimeActivityText,
+        activeClaudeTask,
+        hasClaudeProgressSignal,
+        hasOpenCodePromptSignal: openCodePromptSignal,
+        hasOpenCodeActiveSignal: openCodeActiveSignal,
+        isClaudeSession: isClaude,
+        isOpenCodeSession: isOpenCode,
+        outputQuietForMs,
+        commandQuietForMs,
+        workerAgeMs
+    };
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkingActivity = resolveWorkingActivity;
+const runtimeSignals_1 = require("../../runtimeSignals");
+const helpers_1 = require("./helpers");
+function resolveWorkingActivity(context, evidence) {
+    const fallbackText = (0, helpers_1.firstDefined)(...evidence.activityTextCandidates, context.transcriptSnapshot?.activityText, context.runtimeActivityText, context.activeClaudeTask, context.parsed.activity.text, context.worker.activityText);
+    const activityText = context.isOpenCodeSession
+        ? (0, runtimeSignals_1.preferOpenCodeSpecificActivityText)(context.worker.activityText, fallbackText)
+        : fallbackText;
+    const activityTool = (0, helpers_1.firstDefined)(...evidence.activityToolCandidates, context.transcriptSnapshot?.activityTool, context.parsed.activity.tool, context.worker.activityTool, "terminal");
+    const activityPath = (0, helpers_1.firstDefined)(...evidence.activityPathCandidates, context.transcriptSnapshot?.activityPath, context.parsed.activity.filePath);
+    return {
+        activityText: activityText ?? "Working",
+        activityTool,
+        activityPath
+    };
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellPromptTailMatchers = exports.recoverableToolErrorMatchers = exports.fatalRuntimeErrorMatchers = exports.openCodeWorkingFreshWindowMs = exports.claudeWorkingFreshWindowMs = exports.genericWorkingFreshWindowMs = exports.claudeSpawnGraceMs = exports.cachedActivityWindowMs = exports.stickyWorkingWindowMs = exports.commandWarmupWindowMs = exports.recentErrorSignalWindowMs = exports.parsedStrongEvidenceWindowMs = void 0;
+const parsedStrongEvidenceWindowMs = 8_000;
+exports.parsedStrongEvidenceWindowMs = parsedStrongEvidenceWindowMs;
+const recentErrorSignalWindowMs = 15_000;
+exports.recentErrorSignalWindowMs = recentErrorSignalWindowMs;
+const commandWarmupWindowMs = 2_250;
+exports.commandWarmupWindowMs = commandWarmupWindowMs;
+const stickyWorkingWindowMs = 3_500;
+exports.stickyWorkingWindowMs = stickyWorkingWindowMs;
+const cachedActivityWindowMs = 12_000;
+exports.cachedActivityWindowMs = cachedActivityWindowMs;
+const claudeSpawnGraceMs = 5_000;
+exports.claudeSpawnGraceMs = claudeSpawnGraceMs;
+const genericWorkingFreshWindowMs = 12_000;
+exports.genericWorkingFreshWindowMs = genericWorkingFreshWindowMs;
+const claudeWorkingFreshWindowMs = 10_000;
+exports.claudeWorkingFreshWindowMs = claudeWorkingFreshWindowMs;
+const openCodeWorkingFreshWindowMs = 12_000;
+exports.openCodeWorkingFreshWindowMs = openCodeWorkingFreshWindowMs;
+const fatalRuntimeErrorMatchers = [
+    /^traceback\b/i,
+    /^unhandled(?:\s+\w+)?\s+exception\b/i,
+    /^panic\b/i,
+    /^fatal\b/i,
+    /\b(out of memory|oom)\b/i,
+    /\bsig(?:segv|kill|term)\b/i
+];
+exports.fatalRuntimeErrorMatchers = fatalRuntimeErrorMatchers;
+const recoverableToolErrorMatchers = [
+    /request failed with status code\s*:?\s*\d{3}/i,
+    /\b(?:unauthorized|forbidden|rate limit|too many requests)\b/i,
+    /\b(?:timed?\s*out|timeout)\b/i,
+    /\b(?:network error|connection reset|connection refused|econnreset|econnrefused|enotfound)\b/i,
+    /\bhttp(?:\s+status)?\s*(?:code)?\s*:?\s*(?:401|403|404|408|409|410|422|429|500|502|503|504)\b/i
+];
+exports.recoverableToolErrorMatchers = recoverableToolErrorMatchers;
+const shellPromptTailMatchers = [
+    /[$#%]\s*$/,
+    /(?:❯|›|»|λ|➜|❱)\s*$/,
+    /^ps\s+[^>]*>\s*$/i,
+    /^[A-Za-z]:\\[^>]*>\s*$/
+];
+exports.shellPromptTailMatchers = shellPromptTailMatchers;

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveWorkerStatusDecision = deriveWorkerStatusDecision;
+const idleBlockers_1 = require("./idleBlockers");
+const parserErrorRules_1 = require("./parserErrorRules");
+const activity_1 = require("./activity");
+const workingEvidence_1 = require("./workingEvidence");
+const helpers_1 = require("./helpers");
+const constants_1 = require("./constants");
+function deriveWorkerStatusDecision(context) {
+    const reasons = [];
+    const pushReason = (reason) => {
+        reasons.push(reason);
+    };
+    const transcriptStatus = context.transcriptSnapshot?.status;
+    if (transcriptStatus === "attention") {
+        pushReason({ code: "transcript-attention", message: "Transcript reports attention." });
+        const activityText = context.transcriptSnapshot?.activityText ?? "Waiting for input";
+        return finalizeDecision(context, {
+            status: "attention",
+            activityText,
+            activityTool: context.transcriptSnapshot?.activityTool ?? "terminal",
+            activityPath: context.transcriptSnapshot?.activityPath,
+            confidence: 0.96,
+            reasons,
+            parsedStrongSignal: false
+        });
+    }
+    if (context.parsed.activity.needsInput) {
+        pushReason({ code: "parser-input-prompt", message: "Terminal output indicates input is required." });
+        return finalizeDecision(context, {
+            status: "attention",
+            activityText: context.parsed.activity.text ?? "Waiting for input",
+            activityTool: context.parsed.activity.tool ?? "terminal",
+            activityPath: context.parsed.activity.filePath,
+            confidence: 0.9,
+            reasons,
+            parsedStrongSignal: false
+        });
+    }
+    if (transcriptStatus === "error") {
+        pushReason({ code: "transcript-error", message: "Transcript reports error." });
+        return finalizeDecision(context, {
+            status: "error",
+            activityText: context.transcriptSnapshot?.activityText ?? "Error",
+            activityTool: context.transcriptSnapshot?.activityTool ?? "terminal",
+            activityPath: context.transcriptSnapshot?.activityPath,
+            confidence: 0.92,
+            reasons,
+            parsedStrongSignal: false
+        });
+    }
+    if ((0, idleBlockers_1.isPromptDominantOpenCodeIdle)(context)) {
+        pushReason({
+            code: "opencode-prompt-idle",
+            message: "OpenCode prompt is visible without a fresh active execution signal."
+        });
+        return finalizeDecision(context, {
+            status: "idle",
+            activityText: undefined,
+            activityTool: undefined,
+            activityPath: undefined,
+            confidence: 0.9,
+            reasons,
+            parsedStrongSignal: false
+        });
+    }
+    const parserErrorClassification = (0, parserErrorRules_1.classifyParserError)(context);
+    if (parserErrorClassification === "fatal" && transcriptStatus !== "working") {
+        pushReason({
+            code: "parser-error-signal",
+            message: "Recent fatal error pattern detected in terminal output.",
+            detail: `${Math.round(context.outputQuietForMs)}ms since output change`
+        });
+        return finalizeDecision(context, {
+            status: "error",
+            activityText: context.parsed.activity.text ?? "Error",
+            activityTool: context.parsed.activity.tool ?? "terminal",
+            activityPath: context.parsed.activity.filePath,
+            confidence: 0.87,
+            reasons,
+            parsedStrongSignal: false
+        });
+    }
+    if (parserErrorClassification === "recoverable") {
+        pushReason({
+            code: "parser-recoverable-error",
+            message: "Tool-level error detected but considered recoverable.",
+            detail: `${Math.round(context.outputQuietForMs)}ms since output change`
+        });
+    }
+    const evidence = (0, workingEvidence_1.collectWorkingEvidence)(context, parserErrorClassification === "recoverable");
+    const idleBlocker = (0, idleBlockers_1.detectIdleBlocker)(context, evidence);
+    if (idleBlocker) {
+        pushReason(idleBlocker.reason);
+        return finalizeDecision(context, {
+            status: "idle",
+            activityText: undefined,
+            activityTool: undefined,
+            activityPath: undefined,
+            confidence: 0.86,
+            reasons,
+            parsedStrongSignal: evidence.parsedStrongSignal
+        });
+    }
+    if (evidence.strongReasons.length > 0) {
+        for (const reason of evidence.strongReasons) {
+            pushReason(reason);
+        }
+        const workingActivity = (0, activity_1.resolveWorkingActivity)(context, evidence);
+        return finalizeDecision(context, {
+            status: "working",
+            activityText: workingActivity.activityText,
+            activityTool: workingActivity.activityTool,
+            activityPath: workingActivity.activityPath,
+            confidence: 0.88,
+            reasons,
+            parsedStrongSignal: evidence.parsedStrongSignal
+        });
+    }
+    if ((0, workingEvidence_1.shouldKeepStickyWorking)(context, evidence)) {
+        pushReason({
+            code: "sticky-working-window",
+            message: "Keeps working status during a short stabilization window.",
+            detail: `${Math.round(context.outputQuietForMs)}ms quiet`
+        });
+        const workingActivity = (0, activity_1.resolveWorkingActivity)(context, evidence);
+        return finalizeDecision(context, {
+            status: "working",
+            activityText: workingActivity.activityText,
+            activityTool: workingActivity.activityTool,
+            activityPath: workingActivity.activityPath,
+            confidence: 0.66,
+            reasons,
+            parsedStrongSignal: evidence.parsedStrongSignal
+        });
+    }
+    if (context.worker.status === "working" &&
+        evidence.weakReasons.length > 0 &&
+        context.outputQuietForMs <= (0, helpers_1.statusFreshnessWindowMs)(context)) {
+        for (const reason of evidence.weakReasons) {
+            pushReason(reason);
+        }
+        pushReason({
+            code: "working-evidence-window",
+            message: "Keeps working status while weak evidence remains within freshness window.",
+            detail: `${Math.round(context.outputQuietForMs)}ms quiet`
+        });
+        const workingActivity = (0, activity_1.resolveWorkingActivity)(context, evidence);
+        return finalizeDecision(context, {
+            status: "working",
+            activityText: workingActivity.activityText,
+            activityTool: workingActivity.activityTool,
+            activityPath: workingActivity.activityPath,
+            confidence: 0.62,
+            reasons,
+            parsedStrongSignal: evidence.parsedStrongSignal
+        });
+    }
+    if (evidence.weakReasons.length > 0) {
+        for (const reason of evidence.weakReasons) {
+            pushReason(reason);
+        }
+        if (context.commandQuietForMs <= constants_1.commandWarmupWindowMs) {
+            const workingActivity = (0, activity_1.resolveWorkingActivity)(context, evidence);
+            return finalizeDecision(context, {
+                status: "working",
+                activityText: workingActivity.activityText,
+                activityTool: workingActivity.activityTool,
+                activityPath: workingActivity.activityPath,
+                confidence: 0.56,
+                reasons,
+                parsedStrongSignal: evidence.parsedStrongSignal
+            });
+        }
+    }
+    pushReason({ code: "no-active-evidence", message: "No active work evidence remained within freshness windows." });
+    return finalizeDecision(context, {
+        status: "idle",
+        activityText: undefined,
+        activityTool: undefined,
+        activityPath: undefined,
+        confidence: 0.74,
+        reasons,
+        parsedStrongSignal: evidence.parsedStrongSignal
+    });
+}
+function finalizeDecision(context, partial) {
+    return {
+        status: partial.status,
+        activityText: partial.status === "idle" ? undefined : partial.activityText,
+        activityTool: partial.status === "idle" ? undefined : partial.activityTool,
+        activityPath: partial.status === "idle" ? undefined : partial.activityPath,
+        confidence: partial.confidence,
+        reasons: partial.reasons.length > 0 ? partial.reasons : [{ code: "no-reason", message: "No explicit reason captured." }],
+        facts: {
+            command: context.currentCommand,
+            commandQuietForMs: context.commandQuietForMs,
+            outputQuietForMs: context.outputQuietForMs,
+            workerAgeMs: context.workerAgeMs,
+            isClaudeSession: context.isClaudeSession,
+            isOpenCodeSession: context.isOpenCodeSession,
+            hasOpenCodePromptSignal: context.hasOpenCodePromptSignal,
+            hasOpenCodeActiveSignal: context.hasOpenCodeActiveSignal,
+            hasClaudeProgressSignal: context.hasClaudeProgressSignal,
+            hasActiveClaudeTask: Boolean(context.activeClaudeTask),
+            hasRuntimeActivityText: Boolean(context.runtimeActivityText),
+            hasParsedStrongSignal: partial.parsedStrongSignal,
+            hasParsedNeedsInput: context.parsed.activity.needsInput,
+            hasParsedError: context.parsed.activity.hasError
+        }
+    };
+}