@sireai/optimus 0.1.1

package/dist/task-environment/observability/runtime-panel.js

@@ -0,0 +1,1008 @@
+import process from "node:process";
+import { join } from "node:path";
+import { resolveDefaultRuntimeRootDir } from "../../config/optimus-paths.js";
+const LOGO_LINES = [
+    '      _____________',
+    '     /_/_/_/_/_/_/\\',
+    '    /_/_/_/_/_/_/  \\\\',
+    '   /_/_/____/_/ /\\  \\\\',
+    '  /_/_/ /___/_/ / /\\  \\\\',
+    ' /_/_/ /_____/ /_/ /\\  \\\\',
+    ' \\\\_\\/_____/\\___\\/ /  /',
+    '  \\\\_\\____/ /_/_/ /  /',
+    '   \\\\_\\__/ /_/_/ /  /',
+    '    \\\\___\\/____\\/  /',
+    '     \\\\_____________/',
+];
+const ANSI = {
+    reset: "\u001B[0m",
+    dim: "\u001B[2m",
+    bold: "\u001B[1m",
+    red: "\u001B[31m",
+    green: "\u001B[32m",
+    yellow: "\u001B[33m",
+    blue: "\u001B[34m",
+    magenta: "\u001B[35m",
+    cyan: "\u001B[36m",
+    gray: "\u001B[90m",
+    orange: "\u001B[38;5;208m",
+    orangeSoft: "\u001B[38;5;215m"
+};
+const ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
+import { OptimusLogger } from "./logger.js";
+// RuntimePanel is a terminal-only projection of runtime activity.
+// Persisted runtime logs and trace logs remain unchanged; the panel only renders a compact live view.
+export class RuntimePanel {
+    runtimeRootDir;
+    state;
+    activeTasks = new Map();
+    unsubscribers = [];
+    maxRecentEvents = 30;
+    maxAlerts = 6;
+    handleResize = () => {
+        if (!this.started) {
+            return;
+        }
+        this.renderedLineCount = 0;
+        process.stdout.write("\u001B[2J\u001B[H");
+        this.dirty = true;
+        this.render();
+    };
+    renderedLineCount = 0;
+    started = false;
+    dirty = true;
+    runtimeStartedAtMs = Date.now();
+    stdinDataHandler = (chunk) => {
+        // Swallow terminal input while the panel owns the screen so trackpad or arrow-key escape sequences do not leak into the UI.
+        const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (value.includes("")) {
+            process.kill(process.pid, "SIGINT");
+        }
+    };
+    stdinRawModeBeforeStart;
+    constructor(runtimeRootDir = resolveDefaultRuntimeRootDir()) {
+        this.runtimeRootDir = runtimeRootDir;
+        this.state = {
+            runtime: {
+                running: false,
+                queueDepth: 0,
+                activeWorkers: 0,
+                activeRuns: 0,
+                stalledRuns: 0,
+                triageStatus: "booting",
+                uptimeMs: 0,
+                databasePath: join(runtimeRootDir, "optimus.db")
+            },
+            activeTasks: [],
+            recentEvents: [],
+            alerts: []
+        };
+    }
+    // The panel is only useful in an interactive terminal.
+    canRender() {
+        return Boolean(process.stdout.isTTY);
+    }
+    // start() switches to the terminal alternate screen so the live panel does not pollute shell history.
+    start() {
+        if (this.started || !this.canRender()) {
+            return;
+        }
+        this.started = true;
+        this.renderedLineCount = 0;
+        this.stdinRawModeBeforeStart = process.stdin.isTTY ? process.stdin.isRaw : undefined;
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode?.(true);
+        }
+        process.stdin.resume();
+        process.stdin.on("data", this.stdinDataHandler);
+        process.stdout.write("[?1049h[?25l");
+        this.unsubscribers.push(OptimusLogger.subscribe((record) => {
+            this.record(record);
+        }));
+        OptimusLogger.setConsoleSink(() => {
+            // The panel owns the terminal while runtime is active.
+        });
+        process.stdout.on("resize", this.handleResize);
+        this.render();
+    }
+    // stop() restores the previous shell screen and default logger console behavior.
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        for (const unsubscribe of this.unsubscribers.splice(0)) {
+            unsubscribe();
+        }
+        process.stdout.off("resize", this.handleResize);
+        process.stdin.off("data", this.stdinDataHandler);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode?.(this.stdinRawModeBeforeStart ?? false);
+        }
+        process.stdin.pause();
+        OptimusLogger.setConsoleSink(undefined);
+        process.stdout.write("[?25h[?1049l");
+        this.stdinRawModeBeforeStart = undefined;
+        this.renderedLineCount = 0;
+        this.started = false;
+    }
+    // record() projects logger events into a readable operator snapshot.
+    record(record) {
+        this.state.runtime.lastEventAt = record.timestampShort;
+        if (record.event === "runtime.started") {
+            this.runtimeStartedAtMs = Date.parse(record.timestampIso) || Date.now();
+            this.state.runtime.running = true;
+        }
+        if (record.event === "runtime.stopped") {
+            this.state.runtime.running = false;
+        }
+        if (record.event === "runtime.health") {
+            this.projectRuntimeHealth(record.context);
+        }
+        if (record.event === "optimus.triage.starting") {
+            this.state.runtime.triageStatus = "starting";
+        }
+        if (record.event === "optimus.triage.ready") {
+            this.state.runtime.triageStatus = "ready";
+        }
+        if (record.event === "optimus.triage.start_failed") {
+            this.state.runtime.triageStatus = "failed";
+        }
+        this.state.runtime.uptimeMs = Math.max(0, (Date.parse(record.timestampIso) || Date.now()) - this.runtimeStartedAtMs);
+        this.projectTask(record);
+        this.pushPanelEvent(this.toPanelEvent(record));
+        this.dirty = true;
+        this.render();
+    }
+    projectRuntimeHealth(context) {
+        this.state.runtime.queueDepth = this.toNumber(context.queueDepth);
+        this.state.runtime.activeWorkers = this.toNumber(context.activeWorkers);
+        this.state.runtime.activeRuns = this.toNumber(context.activeRuns);
+        this.state.runtime.stalledRuns = this.toNumber(context.stalledRuns);
+    }
+    // Active tasks stay on screen until they reach a terminal state.
+    projectTask(record) {
+        const taskId = this.toString(record.context.taskId);
+        if (!taskId) {
+            return;
+        }
+        if (["task.completed", "task.failed", "task.canceled", "task.timed_out", "task.needs_human"].includes(record.event)) {
+            this.activeTasks.delete(taskId);
+            this.syncActiveTasks();
+            return;
+        }
+        if (!["task.received", "task.dispatched", "task.execution.started", "optimus.runner.stream_event", "optimus.runner.result_parsed", "task.fallback", "repo.execution_mode_resolved"].includes(record.event)) {
+            return;
+        }
+        const timestampMs = Date.parse(record.timestampIso) || Date.now();
+        const snapshot = this.activeTasks.get(taskId) ?? this.createTaskSnapshot(record, timestampMs);
+        const runId = this.toString(record.context.runId);
+        const taskType = this.toString(record.context.taskType);
+        const repo = this.toString(record.context.repo);
+        const health = this.resolveTaskHealth(record, snapshot.health);
+        if (runId) {
+            snapshot.runId = runId;
+        }
+        if (taskType) {
+            snapshot.taskType = taskType;
+        }
+        if (repo) {
+            snapshot.repo = repo;
+        }
+        if (health) {
+            snapshot.health = health;
+        }
+        snapshot.status = this.resolveTaskStatus(record, snapshot.status);
+        snapshot.phase = this.resolveTaskPhase(record, snapshot.phase);
+        snapshot.lastHeadline = this.buildTaskHeadline(record);
+        const currentAction = this.describeCurrentAction(record);
+        if (currentAction) {
+            snapshot.currentAction = currentAction;
+        }
+        snapshot.lastUpdatedAtMs = timestampMs;
+        if (typeof record.context.artifactCount === "number" && record.context.artifactCount > 0) {
+            snapshot.artifacts = [`artifacts:${record.context.artifactCount}`];
+        }
+        this.activeTasks.set(taskId, snapshot);
+        this.syncActiveTasks();
+    }
+    createTaskSnapshot(record, timestampMs) {
+        const runId = this.toString(record.context.runId);
+        const repo = this.toString(record.context.repo);
+        const currentAction = this.describeCurrentAction(record);
+        return {
+            taskId: this.toString(record.context.taskId) ?? "unknown-task",
+            ...(runId ? { runId } : {}),
+            taskType: this.toString(record.context.taskType) ?? "unknown",
+            status: "queued",
+            phase: "queued",
+            ...(repo ? { repo } : {}),
+            lastHeadline: this.buildTaskHeadline(record),
+            ...(currentAction ? { currentAction } : {}),
+            artifacts: [],
+            startedAtMs: timestampMs,
+            lastUpdatedAtMs: timestampMs
+        };
+    }
+    syncActiveTasks() {
+        const now = Date.now();
+        this.state.activeTasks = Array.from(this.activeTasks.values())
+            .map((snapshot) => this.toPublicSnapshot(snapshot, now))
+            .sort((left, right) => right.elapsedMs - left.elapsedMs);
+    }
+    toPublicSnapshot(snapshot, now) {
+        const projected = {
+            taskId: snapshot.taskId,
+            taskType: snapshot.taskType,
+            status: snapshot.status,
+            phase: snapshot.phase,
+            lastHeadline: snapshot.lastHeadline,
+            ...(snapshot.currentAction ? { currentAction: snapshot.currentAction } : {}),
+            elapsedMs: Math.max(0, now - snapshot.startedAtMs),
+            idleMs: Math.max(0, now - snapshot.lastUpdatedAtMs),
+            artifacts: snapshot.artifacts
+        };
+        if (snapshot.runId) {
+            projected.runId = snapshot.runId;
+        }
+        if (snapshot.health) {
+            projected.health = snapshot.health;
+        }
+        if (snapshot.repo) {
+            projected.repo = snapshot.repo;
+        }
+        return projected;
+    }
+    resolveTaskStatus(record, fallback) {
+        const explicit = this.toString(record.context.status);
+        if (this.isTaskStatus(explicit)) {
+            return explicit;
+        }
+        if (record.event === "task.received") {
+            return "queued";
+        }
+        if (["task.dispatched", "task.execution.started", "optimus.runner.stream_event", "optimus.runner.result_parsed"].includes(record.event)) {
+            return "running";
+        }
+        return fallback;
+    }
+    resolveTaskPhase(record, fallback) {
+        const runStatus = this.toString(record.context.runStatus);
+        if (this.isTaskRunStatus(runStatus)) {
+            return runStatus;
+        }
+        const eventType = this.toString(record.context.eventType);
+        if (this.isTaskRunStatus(eventType)) {
+            return eventType;
+        }
+        if (this.isTaskStatus(eventType)) {
+            return eventType;
+        }
+        if (record.event === "task.received") {
+            return "queued";
+        }
+        if (record.event === "task.execution.started") {
+            return "sdk_starting";
+        }
+        return fallback;
+    }
+    resolveTaskHealth(record, fallback) {
+        const explicit = this.toString(record.context.health);
+        if (this.isTaskRunHealth(explicit)) {
+            return explicit;
+        }
+        if (record.event === "optimus.runner.stream_event") {
+            return "healthy_running";
+        }
+        return fallback;
+    }
+    buildTaskHeadline(record) {
+        if (record.event === "optimus.runner.stream_event") {
+            return this.toString(record.context.headline) ?? "Execution update.";
+        }
+        if (record.event === "task.execution.started") {
+            return "Execution started.";
+        }
+        if (record.event === "task.dispatched") {
+            return "Worker dispatched task.";
+        }
+        if (record.event === "task.fallback") {
+            return `Fallback used: ${this.toString(record.context.reason) ?? "unknown"}.`;
+        }
+        if (record.event === "repo.execution_mode_resolved") {
+            const mode = this.toString(record.context.addressesResolvedExecutionMode) ?? "unknown";
+            return `Workspace prepared (${mode}).`;
+        }
+        return this.buildEventHeadline(record);
+    }
+    toPanelEvent(record) {
+        const detail = this.buildEventDetail(record);
+        const taskId = this.toString(record.context.taskId);
+        const runId = this.toString(record.context.runId);
+        const level = record.level === "debug" ? "info" : record.level;
+        return {
+            at: record.timestampShort,
+            scope: this.resolveScope(record.event),
+            level,
+            headline: this.buildEventHeadline(record),
+            ...(detail ? { detail } : {}),
+            ...(taskId ? { taskId } : {}),
+            ...(runId ? { runId } : {})
+        };
+    }
+    pushPanelEvent(event) {
+        if (this.shouldSuppressRecentEvent(event)) {
+            return;
+        }
+        const prioritizedEvents = this.prioritizeRecentEvents([...this.state.recentEvents, event]);
+        this.state.recentEvents = prioritizedEvents.slice(-this.maxRecentEvents);
+        if (event.level === "warn" || event.level === "error" || event.scope === "alert") {
+            this.state.alerts = [event, ...this.state.alerts].slice(0, this.maxAlerts);
+        }
+    }
+    prioritizeRecentEvents(events) {
+        // Keep arrival order so events render top-to-bottom in the same sequence they happened.
+        return events;
+    }
+    shouldSuppressRecentEvent(event) {
+        if (event.scope === "triage" && event.headline === "Optimus Triage Session Restored") {
+            return true;
+        }
+        if (event.scope === "runner" && event.level === "info" && !event.taskId) {
+            return true;
+        }
+        return false;
+    }
+    resolveScope(event) {
+        if (event.startsWith("runtime.")) {
+            return "runtime";
+        }
+        if (event.startsWith("optimus.triage.") || event.startsWith("triage.")) {
+            return "triage";
+        }
+        if (event.startsWith("optimus.runner.")) {
+            return "runner";
+        }
+        if (event.startsWith("repo.") || event.startsWith("skills.")) {
+            return "repo";
+        }
+        if (event.includes("failed") || event.includes("timed_out") || event.includes("rejected")) {
+            return "alert";
+        }
+        return "task";
+    }
+    buildEventHeadline(record) {
+        switch (record.event) {
+            case "runtime.started":
+                return "Runtime started.";
+            case "runtime.ready":
+                return "Runtime ready.";
+            case "runtime.health":
+                return `Health refresh: queue ${this.toNumber(record.context.queueDepth)}, workers ${this.toNumber(record.context.activeWorkers)}, runs ${this.toNumber(record.context.activeRuns)}.`;
+            case "optimus.triage.starting":
+                return "Triage resident worker starting.";
+            case "optimus.triage.ready":
+                return "Triage resident worker ready.";
+            case "optimus.triage.start_failed":
+                return `Triage startup failed: ${this.toString(record.context.reason) ?? "unknown"}.`;
+            case "triage.accepted":
+                return `Accepted as ${this.toString(record.context.taskType) ?? "unknown"}.`;
+            case "triage.rejected":
+                return `Rejected: ${this.toString(record.context.reason) ?? "unknown"}.`;
+            case "task.received":
+                return `Task queued for ${this.toString(record.context.taskType) ?? "unknown"}.`;
+            case "task.dispatched":
+                return "Task dispatched to worker.";
+            case "task.execution.started":
+                return "Optimus execution started.";
+            case "task.publication.review_submit.started":
+                return "Code review submission started.";
+            case "task.publication.review_submit.completed":
+                return `Code review submission ${this.toString(record.context.publicationStatus) === "submitted" ? "completed" : "finished"}.`;
+            case "task.publication.review_submit.failed":
+                return `Code review submission failed: ${this.toString(record.context.reason) ?? "unknown"}.`;
+            case "optimus.runner.stream_event":
+                return this.toString(record.context.headline) ?? "Execution update.";
+            case "optimus.runner.result_parsed":
+                return `Execution result parsed: ${this.toString(record.context.status) ?? "unknown"}.`;
+            case "optimus.runner.turn_completed":
+                return "Execution turn completed.";
+            case "task.completed":
+                return "Task completed.";
+            case "task.cancel_requested":
+                return "Cancellation requested.";
+            case "task.cancel_forced":
+                return "Forced cancellation applied.";
+            case "task.canceled":
+                return "Task canceled.";
+            case "task.cancel_cleanup_completed":
+                return "Cancellation cleanup completed.";
+            case "task.cancel_cleanup_failed":
+                return `Cancellation cleanup failed: ${this.toString(record.context.reason) ?? "unknown"}.`;
+            case "task.failed":
+                return `Task failed: ${this.toString(record.context.reason) ?? "unknown"}.`;
+            case "task.timed_out":
+                return `Task timed out: ${this.toString(record.context.timeoutKind) ?? "unknown"}.`;
+            default:
+                return this.humanizeEventName(record.event);
+        }
+    }
+    buildEventDetail(record) {
+        if (record.event === "optimus.runner.stream_event") {
+            const itemType = this.toString(record.context.itemType);
+            const detail = this.toString(record.context.detail);
+            if (detail && itemType) {
+                return `${itemType}: ${detail}`;
+            }
+            if (detail) {
+                return detail;
+            }
+            return itemType ? `item=${itemType}` : undefined;
+        }
+        if (["task.failed", "triage.rejected", "optimus.triage.start_failed", "task.cancel_cleanup_failed", "task.publication.review_submit.failed"].includes(record.event)) {
+            return this.toString(record.context.reason) ?? this.toString(record.context.summary);
+        }
+        if (record.event === "task.publication.review_submit.started") {
+            const strategy = this.toString(record.context.publicationStrategy);
+            const topic = this.toString(record.context.topic);
+            return [strategy ? `strategy ${strategy}` : undefined, topic ? `topic ${topic}` : undefined].filter(Boolean).join(", ");
+        }
+        if (record.event === "task.publication.review_submit.completed") {
+            const status = this.toString(record.context.publicationStatus);
+            const reviewUrl = this.toString(record.context.reviewUrl);
+            const topic = this.toString(record.context.topic);
+            return [
+                status ? `status ${status}` : undefined,
+                topic ? `topic ${topic}` : undefined,
+                reviewUrl ? `review ${reviewUrl}` : undefined
+            ].filter(Boolean).join(", ");
+        }
+        if (["task.cancel_requested", "task.cancel_forced"].includes(record.event)) {
+            const source = this.toString(record.context.cancelSource);
+            const abortedRunCount = this.toNumber(record.context.abortedRunCount);
+            const parts = [];
+            if (source) {
+                parts.push(`source ${source}`);
+            }
+            if (abortedRunCount > 0) {
+                parts.push(`aborted runs ${abortedRunCount}`);
+            }
+            if (record.context.force === true) {
+                parts.push("force");
+            }
+            return parts.length > 0 ? parts.join(", ") : undefined;
+        }
+        if (record.event === "task.cancel_cleanup_completed") {
+            const removed = record.context.workspaceRemoved === true ? "workspace removed" : "workspace kept";
+            const artifacts = this.toNumber(record.context.artifactCount);
+            const duration = this.formatDuration(this.toNumber(record.context.durationMs));
+            const source = this.toString(record.context.cancelSource);
+            return [source ? `source ${source}` : undefined, removed, `artifacts ${artifacts}`, `time ${duration}`].filter(Boolean).join(", ");
+        }
+        return undefined;
+    }
+    // render() redraws only the panel area below the startup banner.
+    render(includeFooter = false) {
+        if (!this.started || !this.canRender()) {
+            return;
+        }
+        this.syncActiveTasks();
+        if (!includeFooter && !this.dirty) {
+            return;
+        }
+        const width = this.getTerminalWidth();
+        const lines = this.buildPanelLines(includeFooter, width).map((line) => this.fitLine(line, width));
+        const output = `${lines.join("\n")}\n`;
+        if (this.renderedLineCount > 0) {
+            process.stdout.write(`\u001B[${this.renderedLineCount}A\u001B[0J`);
+        }
+        process.stdout.write(output);
+        this.renderedLineCount = lines.length + 1;
+        this.dirty = false;
+    }
+    buildPanelLines(includeFooter, width) {
+        const focusedTask = this.state.activeTasks[0];
+        const recentEventLines = this.state.recentEvents.length === 0
+            ? ["  none"]
+            : this.state.recentEvents.map((event) => this.buildRecentEventLine(event));
+        const lines = [
+            ...this.buildHeaderLines(width),
+            "",
+            ...this.buildStatusBlockLines(focusedTask),
+            "",
+            ...this.buildRecentEventBlockLines(recentEventLines)
+        ];
+        if (includeFooter) {
+            lines.push('', `${ANSI.bold}RUNTIME${ANSI.reset}`, '  panel stopped');
+        }
+        return lines;
+    }
+    buildStatusBlockLines(focusedTask) {
+        const values = [
+            this.colorPresence(`runtime ${this.state.runtime.running ? 'running' : 'stopped'}`, this.state.runtime.running),
+            this.colorPresence(`triage ${this.state.runtime.triageStatus}`, this.state.runtime.triageStatus === 'ready'),
+            this.colorPresence(`queue ${this.state.runtime.queueDepth}`, this.state.runtime.queueDepth > 0),
+            this.colorPresence(`workers ${this.state.runtime.activeWorkers}`, this.state.runtime.activeWorkers > 0),
+            this.colorPresence(`runs ${this.state.runtime.activeRuns}`, this.state.runtime.activeRuns > 0),
+            `uptime ${this.formatDuration(this.state.runtime.uptimeMs)}`
+        ];
+        if (focusedTask) {
+            values.push(this.colorPresence(`focus ${focusedTask.taskId} ${focusedTask.taskType}`, true));
+            values.push(this.colorPresence(focusedTask.currentAction ?? 'processing', true));
+        }
+        else {
+            values.push(this.colorPresence('focus none', false));
+        }
+        return [
+            `${ANSI.bold}STATUS${ANSI.reset}`,
+            ...this.wrapStatusValues(values, this.getTerminalWidth())
+        ];
+    }
+    wrapStatusValues(values, width) {
+        const indent = '  ';
+        const separator = `${ANSI.gray} · ${ANSI.reset}`;
+        const maxWidth = Math.max(24, width - 2);
+        const lines = [];
+        let currentLine = indent;
+        for (const value of values) {
+            const candidate = currentLine === indent ? `${indent}${value}` : `${currentLine}${separator}${value}`;
+            if (this.visibleWidth(candidate) <= maxWidth) {
+                currentLine = candidate;
+                continue;
+            }
+            if (currentLine !== indent) {
+                lines.push(currentLine);
+            }
+            const singleLine = `${indent}${value}`;
+            currentLine = this.visibleWidth(singleLine) <= maxWidth
+                ? singleLine
+                : `${indent}${this.truncateAnsiAware(value, Math.max(8, maxWidth - this.visibleWidth(indent)), true)}`;
+        }
+        if (currentLine !== indent) {
+            lines.push(currentLine);
+        }
+        return lines.length > 0 ? lines : [indent];
+    }
+    buildRecentEventBlockLines(eventLines) {
+        return [
+            `${ANSI.bold}RECENT EVENTS${ANSI.reset}`,
+            ...eventLines
+        ];
+    }
+    buildRecentEventLine(event) {
+        const owner = event.taskId ? ` ${this.shortenId(event.taskId, "task#")}` : "";
+        const level = event.level === "info" ? "" : `/${event.level}`;
+        const scopeLabel = `[${event.scope}${level}]`;
+        const detail = event.detail ? ` ${ANSI.gray}·${ANSI.reset} ${this.formatRecentEventDetail(event.detail)}` : "";
+        return `  ${ANSI.gray}${event.at}${ANSI.reset} ${scopeLabel}${owner} ${event.headline}${detail}`;
+    }
+    formatRecentEventDetail(detail) {
+        const separatorIndex = detail.indexOf(": ");
+        if (separatorIndex <= 0) {
+            return detail;
+        }
+        const itemType = detail.slice(0, separatorIndex);
+        const payload = detail.slice(separatorIndex + 2);
+        switch (itemType) {
+            case "command_execution":
+                return `${ANSI.yellow}Command${ANSI.reset} ${payload}`;
+            case "reasoning":
+                return `${ANSI.blue}Thinking${ANSI.reset} ${payload}`;
+            case "agent_message":
+                return `${ANSI.green}Message${ANSI.reset} ${payload}`;
+            case "mcp_tool_call":
+                return `${ANSI.magenta}Tool${ANSI.reset} ${payload}`;
+            case "web_search":
+                return `${ANSI.yellow}Search${ANSI.reset} ${payload}`;
+            case "todo_list":
+                return `${ANSI.blue}Plan${ANSI.reset} ${payload}`;
+            case "file_change":
+                return `${ANSI.magenta}Edit${ANSI.reset} ${payload}`;
+            default:
+                return `${this.humanizeItemType(itemType)} ${payload}`;
+        }
+    }
+    buildHeaderLines(_width) {
+        const brand = `${ANSI.bold}${ANSI.orange}OPTIMUS${ANSI.reset}`;
+        return [
+            '',
+            ...this.buildLogoLines(),
+            '',
+            `            ${brand}`
+        ];
+    }
+    buildLogoLines() {
+        return LOGO_LINES.map((line, index) => `  ${this.colorLogoLine(line, index, LOGO_LINES.length)}`);
+    }
+    colorLogoLine(line, index, totalLines) {
+        const accent = index === Math.floor(totalLines / 2) ? ANSI.bold : '';
+        const color = index < 2 ? ANSI.orangeSoft : ANSI.orange;
+        return `${accent}${color}${line}${ANSI.reset}`;
+    }
+    colorRuntimeState(state) {
+        return state === "running" ? `${ANSI.green}${state}${ANSI.reset}` : `${ANSI.gray}${state}${ANSI.reset}`;
+    }
+    colorTriageState(state) {
+        switch (state) {
+            case "ready":
+                return `${ANSI.green}${state}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${state}${ANSI.reset}`;
+        }
+    }
+    colorPresence(value, active) {
+        return active ? `${ANSI.green}${value}${ANSI.reset}` : `${ANSI.gray}${value}${ANSI.reset}`;
+    }
+    colorStrong(value) {
+        return `${ANSI.bold}${value}${ANSI.reset}`;
+    }
+    colorTaskType(taskType) {
+        return `${ANSI.bold}${taskType}${ANSI.reset}`;
+    }
+    colorTaskStatus(status) {
+        switch (status) {
+            case "completed":
+                return `${ANSI.green}${status}${ANSI.reset}`;
+            case "failed":
+            case "canceled":
+                return `${ANSI.red}${status}${ANSI.reset}`;
+            case "patch_generated":
+            case "validating":
+                return `${ANSI.magenta}${status}${ANSI.reset}`;
+            case "running":
+            case "preparing":
+                return `${ANSI.yellow}${status}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${status}${ANSI.reset}`;
+        }
+    }
+    colorHealth(health) {
+        switch (health) {
+            case "healthy_running":
+            case "completed":
+            case "recovered":
+                return `${ANSI.green}${health}${ANSI.reset}`;
+            case "slow_running":
+            case "waiting_start":
+            case "cancel_requested":
+                return `${ANSI.yellow}${health}${ANSI.reset}`;
+            case "suspected_stall":
+            case "failed":
+            case "timed_out":
+            case "canceled":
+                return `${ANSI.red}${health}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${health}${ANSI.reset}`;
+        }
+    }
+    colorValidationState(state) {
+        switch (state) {
+            case "completed":
+                return `${ANSI.green}${state}${ANSI.reset}`;
+            case "in_progress":
+            case "active":
+                return `${ANSI.yellow}${state}${ANSI.reset}`;
+            case "pending":
+                return `${ANSI.magenta}${state}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${state}${ANSI.reset}`;
+        }
+    }
+    colorPhase(phase) {
+        const label = this.describePhase(phase);
+        if (label.includes("running")) {
+            return `${ANSI.blue}${label}${ANSI.reset}`;
+        }
+        if (label.includes("verify") || label.includes("patch")) {
+            return `${ANSI.magenta}${label}${ANSI.reset}`;
+        }
+        if (label.includes("preparing") || label.includes("starting")) {
+            return `${ANSI.yellow}${label}${ANSI.reset}`;
+        }
+        if (label.includes("cancel")) {
+            return `${ANSI.red}${label}${ANSI.reset}`;
+        }
+        return `${ANSI.gray}${label}${ANSI.reset}`;
+    }
+    colorAction(action) {
+        if (action.includes("planning") || action.includes("plan")) {
+            return `${ANSI.blue}${action}${ANSI.reset}`;
+        }
+        if (action.includes("running command") || action.includes("calling tool") || action.includes("searching")) {
+            return `${ANSI.yellow}${action}${ANSI.reset}`;
+        }
+        if (action.includes("editing") || action.includes("fallback")) {
+            return `${ANSI.magenta}${action}${ANSI.reset}`;
+        }
+        if (action.includes("finalizing")) {
+            return `${ANSI.green}${action}${ANSI.reset}`;
+        }
+        return `${ANSI.gray}${action}${ANSI.reset}`;
+    }
+    colorScope(scope) {
+        switch (scope) {
+            case "runtime":
+                return `${ANSI.bold}${scope}${ANSI.reset}`;
+            case "triage":
+                return `${ANSI.yellow}${scope}${ANSI.reset}`;
+            case "runner":
+                return `${ANSI.blue}${scope}${ANSI.reset}`;
+            case "alert":
+                return `${ANSI.red}${scope}${ANSI.reset}`;
+            case "repo":
+                return `${ANSI.magenta}${scope}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${scope}${ANSI.reset}`;
+        }
+    }
+    colorLevel(level) {
+        switch (level) {
+            case "error":
+                return `${ANSI.red}${level}${ANSI.reset}`;
+            case "warn":
+                return `${ANSI.yellow}${level}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${level}${ANSI.reset}`;
+        }
+    }
+    colorAlertHeadline(headline) {
+        return `${ANSI.bold}${headline}${ANSI.reset}`;
+    }
+    colorIdle(idleMs) {
+        const value = this.formatDuration(idleMs);
+        if (idleMs >= 300000) {
+            return `${ANSI.red}${value}${ANSI.reset}`;
+        }
+        if (idleMs >= 60000) {
+            return `${ANSI.yellow}${value}${ANSI.reset}`;
+        }
+        return `${ANSI.gray}${value}${ANSI.reset}`;
+    }
+    colorCount(value, color) {
+        return `${ANSI[color]}${value}${ANSI.reset}`;
+    }
+    describeCurrentAction(record) {
+        if (record.event === "task.execution.started") {
+            return "starting execution";
+        }
+        if (record.event === "task.dispatched") {
+            return "waiting for agent progress";
+        }
+        if (record.event === "repo.execution_mode_resolved") {
+            return "preparing workspace";
+        }
+        if (record.event === "task.fallback") {
+            return "using result fallback";
+        }
+        if (record.event !== "optimus.runner.stream_event") {
+            return undefined;
+        }
+        const itemType = this.toString(record.context.itemType);
+        switch (itemType) {
+            case "reasoning":
+                return "planning";
+            case "command_execution":
+                return "running command";
+            case "mcp_tool_call":
+                return "calling tool";
+            case "web_search":
+                return "searching";
+            case "file_change":
+                return "editing files";
+            case "agent_message":
+                return "finalizing result";
+            case "todo_list":
+                return "updating plan";
+            default:
+                return "processing";
+        }
+    }
+    resolvePipelineStage(focusedTask) {
+        if (!focusedTask) {
+            return "triage";
+        }
+        const action = (focusedTask.currentAction ?? "").toLowerCase();
+        const phase = String(focusedTask.phase).toLowerCase();
+        const status = focusedTask.status.toLowerCase();
+        if (status === "queued") {
+            return "triage";
+        }
+        if (action.includes("preparing") || phase.includes("starting") || phase.includes("preparing")) {
+            return "prepare";
+        }
+        if (action.includes("editing") || phase.includes("patch") || status === "patch_generated") {
+            return "patch";
+        }
+        if (phase.includes("validat") || status === "validating") {
+            return "validate";
+        }
+        if (action.includes("review")) {
+            return "review";
+        }
+        if (action.includes("final") || status === "completed") {
+            return "finalize";
+        }
+        return "inspect";
+    }
+    colorPipelineStage(stage, active) {
+        const label = active ? `[${stage.toUpperCase()}]` : stage.toUpperCase();
+        if (!active) {
+            return `${ANSI.gray}${label}${ANSI.reset}`;
+        }
+        switch (stage) {
+            case "triage":
+                return `${ANSI.yellow}${label}${ANSI.reset}`;
+            case "prepare":
+                return `${ANSI.cyan}${label}${ANSI.reset}`;
+            case "inspect":
+                return `${ANSI.blue}${label}${ANSI.reset}`;
+            case "patch":
+                return `${ANSI.magenta}${label}${ANSI.reset}`;
+            case "validate":
+                return `${ANSI.green}${label}${ANSI.reset}`;
+            case "review":
+                return `${ANSI.yellow}${label}${ANSI.reset}`;
+            case "finalize":
+                return `${ANSI.green}${label}${ANSI.reset}`;
+            default:
+                return `${ANSI.gray}${label}${ANSI.reset}`;
+        }
+    }
+    describeValidationState(task) {
+        const phase = String(task.phase).toLowerCase();
+        const headline = task.lastHeadline.toLowerCase();
+        if (task.status === "completed") {
+            return "completed";
+        }
+        if (phase.includes("validat")) {
+            return "in_progress";
+        }
+        if (headline.includes("compile") || headline.includes("test") || headline.includes("verify")) {
+            return "active";
+        }
+        if (task.status === "patch_generated") {
+            return "pending";
+        }
+        return "not_started";
+    }
+    describePhase(phase) {
+        switch (phase) {
+            case "created":
+            case "leased":
+            case "bootstrapping":
+                return "preparing";
+            case "sdk_starting":
+                return "optimus_starting";
+            case "sdk_running":
+            case "sdk_streaming":
+                return "optimus_running";
+            case "validating":
+                return "verifying";
+            case "patch_generated":
+                return "patch_ready";
+            case "cancel_requested":
+                return "canceling";
+            default:
+                return phase;
+        }
+    }
+    humanizeItemType(itemType) {
+        return itemType
+            .replace(/_/g, " ")
+            .replace(/\b\w/g, (char) => char.toUpperCase());
+    }
+    humanizeEventName(event) {
+        return event
+            .replace(/[._]/g, " ")
+            .replace(/\b\w/g, (char) => char.toUpperCase());
+    }
+    formatDuration(valueMs) {
+        const totalSeconds = Math.max(0, Math.floor(valueMs / 1000));
+        const hours = Math.floor(totalSeconds / 3600);
+        const minutes = Math.floor((totalSeconds % 3600) / 60);
+        const seconds = totalSeconds % 60;
+        if (hours > 0) {
+            return `${hours}h${String(minutes).padStart(2, "0")}m${String(seconds).padStart(2, "0")}s`;
+        }
+        return `${String(minutes).padStart(2, "0")}m${String(seconds).padStart(2, "0")}s`;
+    }
+    fitLine(value, width) {
+        const availableWidth = Math.max(20, width - 1);
+        if (this.visibleWidth(value) <= availableWidth) {
+            return value;
+        }
+        return this.truncateAnsiAware(value, Math.max(4, availableWidth - 3), true);
+    }
+    getTerminalWidth() {
+        return Math.max(24, process.stdout.columns ?? 120);
+    }
+    visibleWidth(value) {
+        let width = 0;
+        for (const char of value.replace(ANSI_PATTERN, "")) {
+            width += this.charDisplayWidth(char);
+        }
+        return width;
+    }
+    truncateAnsiAware(value, maxWidth, withEllipsis = false) {
+        let width = 0;
+        let index = 0;
+        let output = "";
+        const suffix = withEllipsis ? "..." : "";
+        const suffixWidth = withEllipsis ? 3 : 0;
+        while (index < value.length) {
+            if (value[index] === "\u001B") {
+                const ansiMatch = value.slice(index).match(/^\u001B\[[0-9;]*m/);
+                if (ansiMatch) {
+                    output += ansiMatch[0];
+                    index += ansiMatch[0].length;
+                    continue;
+                }
+            }
+            const codePoint = value.codePointAt(index);
+            if (codePoint === undefined) {
+                break;
+            }
+            const char = String.fromCodePoint(codePoint);
+            const charWidth = this.charDisplayWidth(char);
+            if (width + charWidth + suffixWidth > maxWidth) {
+                break;
+            }
+            output += char;
+            width += charWidth;
+            index += char.length;
+        }
+        const needsReset = output.includes("\u001B[");
+        return `${output}${suffix}${needsReset ? ANSI.reset : ""}`;
+    }
+    charDisplayWidth(char) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined) {
+            return 0;
+        }
+        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) {
+            return 0;
+        }
+        if (codePoint >= 0x1100 && (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd))) {
+            return 2;
+        }
+        return 1;
+    }
+    shortenId(value, prefix) {
+        const parts = value.split("-").filter(Boolean);
+        return `${prefix}${parts[parts.length - 1] ?? value}`;
+    }
+    shortenPath(value) {
+        const home = process.env.HOME;
+        if (home && value.startsWith(home)) {
+            return `~${value.slice(home.length)}`;
+        }
+        return value;
+    }
+    toString(value) {
+        return typeof value === "string" && value.length > 0 ? value : undefined;
+    }
+    toNumber(value) {
+        return typeof value === "number" && Number.isFinite(value) ? value : 0;
+    }
+    isTaskStatus(value) {
+        return value === "queued" || value === "preparing" || value === "running" || value === "patch_generated" || value === "validating" || value === "completed" || value === "needs_human" || value === "failed" || value === "canceled";
+    }
+    isTaskRunStatus(value) {
+        return value === "created" || value === "leased" || value === "bootstrapping" || value === "sdk_starting" || value === "sdk_running" || value === "sdk_streaming" || value === "validating" || value === "completed" || value === "failed" || value === "timed_out" || value === "cancel_requested" || value === "canceled" || value === "recovered";
+    }
+    isTaskRunHealth(value) {
+        return value === "waiting_start" || value === "healthy_running" || value === "slow_running" || value === "suspected_stall" || value === "completed" || value === "failed" || value === "timed_out" || value === "cancel_requested" || value === "canceled" || value === "recovered";
+    }
+}
+//# sourceMappingURL=runtime-panel.js.map