@mandipadk7/kavi 0.1.0 → 0.1.2

package/dist/tui.js

@@ -1,91 +1,1672 @@
+import path from "node:path";
 import readline from "node:readline";
 import process from "node:process";
-import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
-import { appendCommand } from "./command-queue.js";
-import { loadSessionRecord, readRecentEvents } from "./session.js";
-function divider(title) {
-    return `\n=== ${title} ${"=".repeat(Math.max(1, 60 - title.length))}`;
-}
-function render(session, events, approvals) {
-    const agentLines = Object.values(session.agentStatus).map((status)=>`- ${status.agent}: ${status.transport} | last_exit=${status.lastExitCode ?? "-"} | last_run=${status.lastRunAt ?? "-"}`).join("\n");
-    const worktreeLines = session.worktrees.map((worktree)=>`- ${worktree.agent}: ${worktree.path} (${worktree.branch})`).join("\n");
-    const taskLines = session.tasks.map((task)=>`- ${task.id} | ${task.owner} | ${task.status} | ${task.title}${task.summary ? ` | ${task.summary}` : ""}`).join("\n");
-    const messageLines = session.peerMessages.slice(-8).map((message)=>`- ${message.from} -> ${message.to} [${message.intent}] ${message.subject}`).join("\n");
-    const approvalLines = approvals.slice(-6).map((request)=>`- ${request.id} | ${request.agent} | ${request.summary}`).join("\n");
-    const eventLines = events.slice(-8).map((event)=>`- ${event.timestamp} ${event.type}`).join("\n");
+import { extractPromptPathHints, routeTask } from "./router.js";
+import { pingRpc, readSnapshot, rpcEnqueueTask, rpcResolveApproval, rpcShutdown, rpcTaskArtifact, rpcWorktreeDiff, subscribeSnapshotRpc } from "./rpc.js";
+const RESET = "\u001b[0m";
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+const SUBSCRIPTION_RETRY_MS = 1_000;
+const TOAST_DURATION_MS = 4_500;
+const STYLES = {
+    accent: "\u001b[36m",
+    muted: "\u001b[90m",
+    good: "\u001b[32m",
+    warn: "\u001b[33m",
+    bad: "\u001b[31m",
+    strong: "\u001b[1m",
+    reverse: "\u001b[7m"
+};
+export const OPERATOR_TABS = [
+    "tasks",
+    "approvals",
+    "claims",
+    "decisions",
+    "events",
+    "messages",
+    "worktrees"
+];
+const TASK_DETAIL_SECTIONS = [
+    "overview",
+    "prompt",
+    "replay",
+    "output",
+    "diff"
+];
+function styleLine(text, ...tones) {
+    if (tones.length === 0) {
+        return text;
+    }
+    return `${tones.map((tone)=>STYLES[tone]).join("")}${text}${RESET}`;
+}
+function stripAnsi(value) {
+    return value.replaceAll(ANSI_PATTERN, "");
+}
+function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+function sliceAnsi(value, width) {
+    if (width <= 0) {
+        return "";
+    }
+    let output = "";
+    let visible = 0;
+    let index = 0;
+    while(index < value.length && visible < width){
+        if (value[index] === "\u001b") {
+            const remainder = value.slice(index);
+            const match = remainder.match(/^\u001b\[[0-9;]*m/);
+            if (match) {
+                output += match[0];
+                index += match[0].length;
+                continue;
+            }
+        }
+        output += value[index];
+        visible += 1;
+        index += 1;
+    }
+    if (output.includes("\u001b[") && !output.endsWith(RESET)) {
+        output += RESET;
+    }
+    return output;
+}
+function fitAnsiLine(value, width) {
+    if (width <= 0) {
+        return "";
+    }
+    const trimmed = value.replaceAll(/\r/g, "");
+    const length = visibleLength(trimmed);
+    if (length === width) {
+        return trimmed;
+    }
+    if (length > width) {
+        return sliceAnsi(trimmed, width);
+    }
+    return `${trimmed}${" ".repeat(width - length)}`;
+}
+export function wrapText(value, width) {
+    const targetWidth = Math.max(8, width);
+    const source = value.replaceAll("\r", "");
+    if (!source.trim()) {
+        return [
+            ""
+        ];
+    }
+    const lines = [];
+    for (const paragraph of source.split("\n")){
+        if (!paragraph.trim()) {
+            lines.push("");
+            continue;
+        }
+        let current = "";
+        for (const word of paragraph.split(/\s+/)){
+            if (!word) {
+                continue;
+            }
+            if (word.length > targetWidth) {
+                if (current) {
+                    lines.push(current);
+                    current = "";
+                }
+                for(let index = 0; index < word.length; index += targetWidth){
+                    lines.push(word.slice(index, index + targetWidth));
+                }
+                continue;
+            }
+            const candidate = current ? `${current} ${word}` : word;
+            if (candidate.length > targetWidth) {
+                lines.push(current);
+                current = word;
+            } else {
+                current = candidate;
+            }
+        }
+        if (current) {
+            lines.push(current);
+        }
+    }
+    return lines.length > 0 ? lines : [
+        ""
+    ];
+}
+function wrapPreformatted(value, width) {
+    const targetWidth = Math.max(8, width);
+    const lines = [];
+    for (const sourceLine of value.replaceAll("\r", "").split("\n")){
+        if (sourceLine.length === 0) {
+            lines.push("");
+            continue;
+        }
+        if (sourceLine.length <= targetWidth) {
+            lines.push(sourceLine);
+            continue;
+        }
+        for(let index = 0; index < sourceLine.length; index += targetWidth){
+            lines.push(sourceLine.slice(index, index + targetWidth));
+        }
+    }
+    return lines.length > 0 ? lines : [
+        ""
+    ];
+}
+function section(title, lines) {
+    return [
+        `-- ${title} --`,
+        ...lines
+    ];
+}
+function truncateValue(value, width) {
+    if (width <= 0) {
+        return "";
+    }
+    if (value.length <= width) {
+        return value;
+    }
+    if (width <= 3) {
+        return ".".repeat(width);
+    }
+    return `${value.slice(0, width - 3)}...`;
+}
+function shortTime(value) {
+    if (!value) {
+        return "-";
+    }
+    return value.replace("T", " ").replace(/\.\d+Z$/, "Z");
+}
+function statusTone(status) {
+    switch(status){
+        case "completed":
+        case "approved":
+            return "good";
+        case "pending":
+        case "running":
+        case "blocked":
+            return "warn";
+        case "failed":
+        case "denied":
+            return "bad";
+        default:
+            return "muted";
+    }
+}
+function toneLine(value, tone, selected) {
+    if (selected) {
+        return styleLine(value, "reverse");
+    }
+    switch(tone){
+        case "good":
+            return styleLine(value, "good");
+        case "warn":
+            return styleLine(value, "warn");
+        case "bad":
+            return styleLine(value, "bad");
+        case "muted":
+            return styleLine(value, "muted");
+        default:
+            return value;
+    }
+}
+function countTasks(tasks, status) {
+    return tasks.filter((task)=>task.status === status).length;
+}
+function changedPathCount(diff) {
+    return diff?.paths.length ?? 0;
+}
+function findWorktreeDiff(snapshot, agent) {
+    return snapshot.worktreeDiffs.find((diff)=>diff.agent === agent);
+}
+function taskPriority(task) {
+    switch(task.status){
+        case "running":
+            return 0;
+        case "blocked":
+            return 1;
+        case "pending":
+            return 2;
+        case "failed":
+            return 3;
+        case "completed":
+            return 4;
+        default:
+            return 5;
+    }
+}
+export function buildTabItems(snapshot, tab) {
+    if (!snapshot) {
+        return [];
+    }
+    const { session } = snapshot;
+    switch(tab){
+        case "tasks":
+            return [
+                ...session.tasks
+            ].sort((left, right)=>{
+                const priority = taskPriority(left) - taskPriority(right);
+                if (priority !== 0) {
+                    return priority;
+                }
+                return right.updatedAt.localeCompare(left.updatedAt);
+            }).map((task)=>({
+                    id: task.id,
+                    title: `[${task.status}] ${task.owner} ${task.title}`,
+                    detail: task.summary ?? task.routeReason ?? task.prompt,
+                    tone: statusTone(task.status)
+                }));
+        case "approvals":
+            return [
+                ...snapshot.approvals
+            ].sort((left, right)=>{
+                const pendingDelta = Number(right.status === "pending") - Number(left.status === "pending");
+                if (pendingDelta !== 0) {
+                    return pendingDelta;
+                }
+                return right.updatedAt.localeCompare(left.updatedAt);
+            }).map((approval)=>({
+                    id: approval.id,
+                    title: `[${approval.status}] ${approval.agent} ${approval.toolName}`,
+                    detail: approval.summary,
+                    tone: statusTone(approval.status === "approved" ? "approved" : approval.status === "denied" ? "denied" : approval.status)
+                }));
+        case "claims":
+            return [
+                ...session.pathClaims
+            ].sort((left, right)=>{
+                const activeDelta = Number(right.status === "active") - Number(left.status === "active");
+                if (activeDelta !== 0) {
+                    return activeDelta;
+                }
+                return right.updatedAt.localeCompare(left.updatedAt);
+            }).map((claim)=>({
+                    id: claim.id,
+                    title: `[${claim.status}] ${claim.agent} ${claim.source}`,
+                    detail: claim.paths.join(", ") || "(no paths)",
+                    tone: claim.status === "active" ? "warn" : "muted"
+                }));
+        case "decisions":
+            return [
+                ...session.decisions
+            ].sort((left, right)=>right.createdAt.localeCompare(left.createdAt)).map((decision)=>({
+                    id: decision.id,
+                    title: `[${decision.kind}] ${decision.summary}`,
+                    detail: decision.detail,
+                    tone: decision.kind === "integration" ? "warn" : "normal"
+                }));
+        case "events":
+            return [
+                ...snapshot.events
+            ].sort((left, right)=>right.timestamp.localeCompare(left.timestamp)).map((event)=>({
+                    id: event.id,
+                    title: event.type,
+                    detail: shortTime(event.timestamp),
+                    tone: "muted"
+                }));
+        case "messages":
+            return [
+                ...session.peerMessages
+            ].sort((left, right)=>right.createdAt.localeCompare(left.createdAt)).map((message)=>({
+                    id: message.id,
+                    title: `${message.from} -> ${message.to} [${message.intent}]`,
+                    detail: message.subject,
+                    tone: "normal"
+                }));
+        case "worktrees":
+            return session.worktrees.map((worktree)=>({
+                    id: worktree.agent,
+                    title: `${worktree.agent} ${worktree.branch}`,
+                    detail: `${changedPathCount(findWorktreeDiff(snapshot, worktree.agent))} changed | ${path.basename(worktree.path)}`,
+                    tone: changedPathCount(findWorktreeDiff(snapshot, worktree.agent)) > 0 ? "warn" : "good"
+                }));
+        default:
+            return [];
+    }
+}
+function emptySelectionMap() {
+    return {
+        tasks: null,
+        approvals: null,
+        claims: null,
+        decisions: null,
+        events: null,
+        messages: null,
+        worktrees: null
+    };
+}
+export function moveSelectionId(items, currentId, delta) {
+    if (items.length === 0) {
+        return null;
+    }
+    const currentIndex = Math.max(0, items.findIndex((item)=>item.id === currentId));
+    const nextIndex = (currentIndex + delta + items.length) % items.length;
+    return items[nextIndex]?.id ?? items[0]?.id ?? null;
+}
+export function nextTab(current, delta) {
+    const index = OPERATOR_TABS.indexOf(current);
+    const nextIndex = (index + delta + OPERATOR_TABS.length) % OPERATOR_TABS.length;
+    return OPERATOR_TABS[nextIndex] ?? current;
+}
+function defaultSelectionForTab(snapshot, tab) {
+    const items = buildTabItems(snapshot, tab);
+    return items[0]?.id ?? null;
+}
+function syncSelections(selectedIds, snapshot) {
+    if (!snapshot) {
+        return emptySelectionMap();
+    }
+    const next = {
+        ...selectedIds
+    };
+    for (const tab of OPERATOR_TABS){
+        const items = buildTabItems(snapshot, tab);
+        next[tab] = items.some((item)=>item.id === selectedIds[tab]) ? selectedIds[tab] : defaultSelectionForTab(snapshot, tab);
+    }
+    return next;
+}
+function selectedItem(snapshot, ui) {
+    const items = buildTabItems(snapshot, ui.activeTab);
+    return items.find((item)=>item.id === ui.selectedIds[ui.activeTab]) ?? items[0] ?? null;
+}
+function selectedTask(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.tasks;
+    return snapshot.session.tasks.find((task)=>task.id === selectedId) ?? null;
+}
+function selectedApproval(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.approvals;
+    return snapshot.approvals.find((approval)=>approval.id === selectedId) ?? latestPendingApproval(snapshot.approvals);
+}
+function selectedClaim(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.claims;
+    return snapshot.session.pathClaims.find((claim)=>claim.id === selectedId) ?? null;
+}
+function selectedDecision(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.decisions;
+    return snapshot.session.decisions.find((decision)=>decision.id === selectedId) ?? null;
+}
+function selectedEvent(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.events;
+    return snapshot.events.find((event)=>event.id === selectedId) ?? null;
+}
+function selectedMessage(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.messages;
+    return snapshot.session.peerMessages.find((message)=>message.id === selectedId) ?? null;
+}
+function selectedWorktree(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    const selectedId = ui.selectedIds.worktrees;
+    return snapshot.session.worktrees.find((worktree)=>worktree.agent === selectedId) ?? snapshot.session.worktrees[0] ?? null;
+}
+function managedAgentForTask(task) {
+    if (task?.owner === "codex" || task?.owner === "claude") {
+        return task.owner;
+    }
+    return null;
+}
+function reviewAgentForUi(snapshot, ui) {
+    if (!snapshot) {
+        return null;
+    }
+    if (ui.activeTab === "worktrees") {
+        return selectedWorktree(snapshot, ui)?.agent ?? null;
+    }
+    if (ui.activeTab === "tasks" && ui.taskDetailSection === "diff") {
+        return managedAgentForTask(selectedTask(snapshot, ui));
+    }
+    return null;
+}
+function changedPathsForAgent(snapshot, agent) {
+    return findWorktreeDiff(snapshot ?? null, agent)?.paths ?? [];
+}
+function changedPathSignature(paths) {
+    return paths.join("\n");
+}
+function firstMatchingPath(candidates, availablePaths) {
+    for (const candidate of candidates){
+        if (availablePaths.includes(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function syncDiffSelections(current, snapshot, task = null) {
+    const next = {
+        ...current
+    };
+    for (const agent of [
+        "codex",
+        "claude"
+    ]){
+        const changedPaths = changedPathsForAgent(snapshot, agent);
+        const currentSelection = current[agent];
+        const taskPreferred = task?.owner === agent ? firstMatchingPath(task.claimedPaths, changedPaths) : null;
+        if (changedPaths.length === 0) {
+            next[agent] = null;
+            continue;
+        }
+        if (taskPreferred) {
+            next[agent] = taskPreferred;
+            continue;
+        }
+        next[agent] = currentSelection && changedPaths.includes(currentSelection) ? currentSelection : changedPaths[0] ?? null;
+    }
+    return next;
+}
+function diffEntryForAgent(ui, agent) {
+    return agent ? ui.diffReviews[agent] ?? null : null;
+}
+function selectedDiffPath(snapshot, ui, agent) {
+    const changedPaths = changedPathsForAgent(snapshot, agent);
+    if (changedPaths.length === 0) {
+        return null;
+    }
+    return ui.diffSelections[agent] && changedPaths.includes(ui.diffSelections[agent]) ? ui.diffSelections[agent] : changedPaths[0] ?? null;
+}
+function diffFooter(agent) {
+    if (!agent) {
+        return styleLine("Diff review is available for managed Codex and Claude worktrees.", "muted");
+    }
+    return styleLine(`Diff keys: , previous file | . next file | { previous hunk | } next hunk | current agent ${agent}`, "muted");
+}
+export function parseDiffHunks(patch) {
+    const lines = patch.replaceAll("\r", "").split("\n");
+    const hunks = [];
+    let current = null;
+    for (const line of lines){
+        if (line.startsWith("@@")) {
+            if (current) {
+                hunks.push(current);
+            }
+            current = {
+                header: line,
+                lines: []
+            };
+            continue;
+        }
+        if (current) {
+            current.lines.push(line);
+        }
+    }
+    if (current) {
+        hunks.push(current);
+    }
+    return hunks;
+}
+function selectedHunkIndex(ui, agent, review) {
+    const hunks = parseDiffHunks(review?.patch ?? "");
+    if (hunks.length === 0) {
+        return null;
+    }
+    const current = ui.hunkSelections[agent] ?? 0;
+    return Math.max(0, Math.min(current, hunks.length - 1));
+}
+function latestPendingApproval(approvals) {
+    return [
+        ...approvals
+    ].filter((request)=>request.status === "pending").sort((left, right)=>left.createdAt.localeCompare(right.createdAt)).pop() ?? null;
+}
+function tabLabel(tab) {
+    switch(tab){
+        case "tasks":
+            return "Tasks";
+        case "approvals":
+            return "Approvals";
+        case "claims":
+            return "Claims";
+        case "decisions":
+            return "Decisions";
+        case "events":
+            return "Events";
+        case "messages":
+            return "Messages";
+        case "worktrees":
+            return "Worktrees";
+        default:
+            return tab;
+    }
+}
+function toneForPanel(title, focused) {
+    if (focused) {
+        return styleLine(title, "accent", "strong");
+    }
+    return styleLine(title, "strong");
+}
+function renderPanel(title, width, height, content, options = {}) {
+    const safeWidth = Math.max(12, width);
+    const safeHeight = Math.max(3, height);
+    const titleLine = ` ${truncateValue(title, safeWidth - 6)} `;
+    const border = "-".repeat(Math.max(0, safeWidth - 2 - titleLine.length));
+    const top = `+${titleLine}${border}+`;
+    const bottom = `+${"-".repeat(safeWidth - 2)}+`;
+    const visibleRows = safeHeight - 2;
+    const paddedContent = [
+        ...content
+    ];
+    while(paddedContent.length < visibleRows){
+        paddedContent.push("");
+    }
+    const body = paddedContent.slice(0, visibleRows).map((line)=>`|${fitAnsiLine(line, safeWidth - 2)}|`);
+    const styledTop = options.focused ? styleLine(top, "accent") : options.muted ? styleLine(top, "muted") : top;
+    const styledBottom = options.focused ? styleLine(bottom, "accent") : options.muted ? styleLine(bottom, "muted") : bottom;
     return [
-        "\u001bc",
-        `Kavi Session ${session.id}`,
-        `Repo: ${session.repoRoot}`,
-        `Goal: ${session.goal ?? "-"}`,
-        `Status: ${session.status}`,
-        divider("Agents"),
-        agentLines || "- none",
-        divider("Worktrees"),
-        worktreeLines || "- none",
-        divider("Tasks"),
-        taskLines || "- none",
-        divider("Approvals"),
-        approvalLines || "- none",
-        divider("Peer Messages"),
-        messageLines || "- none",
-        divider("Events"),
-        eventLines || "- none",
-        "\nKeys: q quit | r refresh | y approve latest | n deny latest | s shutdown daemon"
-    ].join("\n");
+        styledTop,
+        ...body,
+        styledBottom
+    ];
+}
+function combineColumns(columns) {
+    const height = Math.max(...columns.map((column)=>column.lines.length), 0);
+    const rows = [];
+    for(let index = 0; index < height; index += 1){
+        rows.push(columns.map((column)=>column.lines[index] ?? " ".repeat(column.width)).join(" "));
+    }
+    return rows;
+}
+function renderListPanel(snapshot, ui, width, height) {
+    const items = buildTabItems(snapshot, ui.activeTab);
+    const currentId = ui.selectedIds[ui.activeTab];
+    const selectedIndex = Math.max(0, items.findIndex((item)=>item.id === currentId));
+    const title = `Board | ${tabLabel(ui.activeTab)} (${items.length})`;
+    const visibleRows = Math.max(1, height - 2);
+    const start = Math.max(0, Math.min(selectedIndex - Math.floor(visibleRows / 2), Math.max(0, items.length - visibleRows)));
+    const content = items.length === 0 ? [
+        styleLine("No items in this view.", "muted")
+    ] : items.slice(start, start + visibleRows).map((item)=>{
+        const selected = item.id === currentId;
+        const prefix = selected ? ">" : " ";
+        const plain = `${prefix} ${item.title}${item.detail ? ` | ${item.detail}` : ""}`;
+        return toneLine(plain, item.tone, selected);
+    });
+    return renderPanel(title, width, height, content, {
+        focused: true
+    });
+}
+function formatJson(value, width) {
+    return wrapPreformatted(JSON.stringify(value, null, 2), width);
+}
+function artifactForTask(ui, task) {
+    if (!task) {
+        return null;
+    }
+    return ui.artifacts[task.id] ?? null;
+}
+function taskDetailTitle(ui) {
+    return `Inspector | Task ${ui.taskDetailSection}`;
+}
+function renderTaskInspector(task, artifactEntry, loading, diffEntry, loadingDiff, ui, width, height) {
+    if (!task) {
+        return renderPanel("Inspector", width, height, [
+            styleLine("No task selected.", "muted")
+        ]);
+    }
+    const innerWidth = Math.max(16, width - 2);
+    const artifact = artifactEntry?.artifact ?? null;
+    const lines = [];
+    if (ui.taskDetailSection === "overview") {
+        lines.push(...section("Task", [
+            `Id: ${task.id}`,
+            `Owner: ${task.owner}`,
+            `Status: ${task.status}`,
+            `Updated: ${shortTime(task.updatedAt)}`,
+            `Route: ${task.routeReason ?? "-"}`,
+            `Claimed paths: ${task.claimedPaths.join(", ") || "-"}`,
+            `Summary: ${task.summary ?? "-"}`
+        ].flatMap((line)=>wrapText(line, innerWidth))));
+        if (loading) {
+            lines.push(...section("Artifact", [
+                "Loading task artifact..."
+            ]));
+        } else if (artifactEntry?.error) {
+            lines.push(...section("Artifact", wrapText(`Artifact load failed: ${artifactEntry.error}`, innerWidth)));
+        } else if (artifact) {
+            lines.push(...section("Artifact", [
+                `Started: ${shortTime(artifact.startedAt)}`,
+                `Finished: ${shortTime(artifact.finishedAt)}`,
+                `Envelope status: ${artifact.envelope?.status ?? "-"}`,
+                `Next recommendation: ${artifact.envelope?.nextRecommendation ?? "-"}`,
+                `Error: ${artifact.error ?? "-"}`
+            ].flatMap((line)=>wrapText(line, innerWidth))));
+            lines.push(...section("Blockers", artifact.envelope?.blockers.length ? artifact.envelope.blockers.flatMap((blocker)=>wrapText(`- ${blocker}`, innerWidth)) : [
+                "- none"
+            ]));
+            lines.push(...section("Peer Messages", artifact.envelope?.peerMessages.length ? artifact.envelope.peerMessages.flatMap((message)=>wrapText(`- ${message.to} [${message.intent}] ${message.subject}`, innerWidth)) : [
+                "- none"
+            ]));
+        } else {
+            lines.push(...section("Artifact", [
+                "No artifact recorded for this task yet."
+            ]));
+        }
+    } else if (ui.taskDetailSection === "prompt") {
+        lines.push(...section("Prompt", wrapText(task.prompt, innerWidth)));
+    } else if (ui.taskDetailSection === "replay") {
+        if (loading) {
+            lines.push("Loading task artifact...");
+        } else if (artifactEntry?.error) {
+            lines.push(...wrapText(`Artifact load failed: ${artifactEntry.error}`, innerWidth));
+        } else if (artifact?.decisionReplay.length) {
+            lines.push(...artifact.decisionReplay.flatMap((line)=>wrapText(line, innerWidth)));
+        } else {
+            lines.push("No decision replay available.");
+        }
+    } else if (ui.taskDetailSection === "output") {
+        if (loading) {
+            lines.push("Loading task artifact...");
+        } else if (artifactEntry?.error) {
+            lines.push(...wrapText(`Artifact load failed: ${artifactEntry.error}`, innerWidth));
+        } else if (artifact?.rawOutput) {
+            lines.push(...wrapPreformatted(artifact.rawOutput, innerWidth));
+        } else {
+            lines.push("No raw output captured.");
+        }
+    } else {
+        const agent = managedAgentForTask(task);
+        lines.push(...section("Task Scope", [
+            `Owner: ${task.owner}`,
+            `Claimed paths: ${task.claimedPaths.join(", ") || "-"}`,
+            `Route reason: ${task.routeReason ?? "-"}`
+        ].flatMap((line)=>wrapText(line, innerWidth))));
+        if (!agent) {
+            lines.push(...section("Diff Review", [
+                "Diff review is only available for Codex and Claude managed tasks."
+            ]));
+        } else if (loadingDiff) {
+            lines.push(...section("Diff Review", [
+                "Loading worktree diff..."
+            ]));
+        } else if (diffEntry?.error) {
+            lines.push(...section("Diff Review", wrapText(`Diff load failed: ${diffEntry.error}`, innerWidth)));
+        } else if (diffEntry?.review) {
+            const review = diffEntry.review;
+            const hunks = parseDiffHunks(review.patch);
+            const hunkIndex = agent ? selectedHunkIndex(ui, agent, review) : null;
+            const selectedHunk = hunkIndex === null ? null : hunks[hunkIndex] ?? null;
+            lines.push(...section("Review", [
+                `Agent: ${review.agent}`,
+                `Selected file: ${review.selectedPath ?? "-"}`,
+                `Changed files: ${review.changedPaths.length}`,
+                `Hunks: ${hunks.length}`,
+                `Selected hunk: ${hunkIndex === null ? "-" : `${hunkIndex + 1}/${hunks.length}`}`,
+                `Stat: ${review.stat}`
+            ].flatMap((line)=>wrapText(line, innerWidth))));
+            lines.push(...section("Changed Files", review.changedPaths.length ? review.changedPaths.flatMap((filePath)=>wrapText(`${filePath === review.selectedPath ? ">" : "-"} ${filePath}`, innerWidth)) : [
+                "- clean"
+            ]));
+            if (selectedHunk) {
+                lines.push(...section("Current Hunk", wrapPreformatted([
+                    selectedHunk.header,
+                    ...selectedHunk.lines
+                ].join("\n"), innerWidth)));
+            }
+            lines.push(...section("Patch", review.patch ? wrapPreformatted(review.patch, innerWidth) : [
+                "No textual patch available."
+            ]));
+        } else {
+            lines.push(...section("Diff Review", [
+                "No diff review available yet."
+            ]));
+        }
+    }
+    const footerLines = [
+        styleLine("Detail keys: [ ] cycle task sections", "muted")
+    ];
+    if (ui.taskDetailSection === "diff") {
+        footerLines.push(diffFooter(managedAgentForTask(task)));
+    }
+    return renderPanel(taskDetailTitle(ui), width, height, [
+        ...lines,
+        "",
+        ...footerLines
+    ], {
+        focused: true
+    });
+}
+function renderApprovalInspector(approval, width, height) {
+    if (!approval) {
+        return renderPanel("Inspector | Approval", width, height, [
+            styleLine("No approval selected.", "muted")
+        ]);
+    }
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Approval", [
+            `Id: ${approval.id}`,
+            `Agent: ${approval.agent}`,
+            `Status: ${approval.status}`,
+            `Tool: ${approval.toolName}`,
+            `Remembered: ${approval.remember ? "yes" : "no"}`,
+            `Created: ${shortTime(approval.createdAt)}`,
+            `Updated: ${shortTime(approval.updatedAt)}`,
+            `Match key: ${approval.matchKey}`,
+            `Summary: ${approval.summary}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Payload", formatJson(approval.payload, innerWidth)),
+        "",
+        styleLine("Actions: y allow | Y allow+remember | n deny | N deny+remember", "muted")
+    ];
+    return renderPanel("Inspector | Approval", width, height, lines, {
+        focused: true
+    });
+}
+function renderClaimInspector(claim, width, height) {
+    if (!claim) {
+        return renderPanel("Inspector | Claim", width, height, [
+            styleLine("No claim selected.", "muted")
+        ]);
+    }
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Claim", [
+            `Id: ${claim.id}`,
+            `Task: ${claim.taskId}`,
+            `Agent: ${claim.agent}`,
+            `Source: ${claim.source}`,
+            `Status: ${claim.status}`,
+            `Created: ${shortTime(claim.createdAt)}`,
+            `Updated: ${shortTime(claim.updatedAt)}`,
+            `Note: ${claim.note ?? "-"}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Paths", claim.paths.length > 0 ? claim.paths.flatMap((filePath)=>wrapText(`- ${filePath}`, innerWidth)) : [
+            "- none"
+        ])
+    ];
+    return renderPanel("Inspector | Claim", width, height, lines, {
+        focused: true
+    });
+}
+function renderDecisionInspector(decision, width, height) {
+    if (!decision) {
+        return renderPanel("Inspector | Decision", width, height, [
+            styleLine("No decision selected.", "muted")
+        ]);
+    }
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Decision", [
+            `Id: ${decision.id}`,
+            `Kind: ${decision.kind}`,
+            `Agent: ${decision.agent ?? "-"}`,
+            `Task: ${decision.taskId ?? "-"}`,
+            `Created: ${shortTime(decision.createdAt)}`,
+            `Summary: ${decision.summary}`,
+            `Detail: ${decision.detail}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Metadata", formatJson(decision.metadata, innerWidth))
+    ];
+    return renderPanel("Inspector | Decision", width, height, lines, {
+        focused: true
+    });
+}
+function renderEventInspector(event, width, height) {
+    if (!event) {
+        return renderPanel("Inspector | Event", width, height, [
+            styleLine("No event selected.", "muted")
+        ]);
+    }
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Event", [
+            `Id: ${event.id}`,
+            `Type: ${event.type}`,
+            `Timestamp: ${shortTime(event.timestamp)}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Payload", formatJson(event.payload, innerWidth))
+    ];
+    return renderPanel("Inspector | Event", width, height, lines, {
+        focused: true
+    });
+}
+function renderMessageInspector(message, width, height) {
+    if (!message) {
+        return renderPanel("Inspector | Message", width, height, [
+            styleLine("No peer message selected.", "muted")
+        ]);
+    }
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Message", [
+            `Id: ${message.id}`,
+            `Task: ${message.taskId}`,
+            `From: ${message.from}`,
+            `To: ${message.to}`,
+            `Intent: ${message.intent}`,
+            `Created: ${shortTime(message.createdAt)}`,
+            `Subject: ${message.subject}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Body", wrapText(message.body, innerWidth))
+    ];
+    return renderPanel("Inspector | Message", width, height, lines, {
+        focused: true
+    });
+}
+function renderWorktreeInspector(snapshot, worktree, diffEntry, loadingDiff, ui, width, height) {
+    if (!snapshot || !worktree) {
+        return renderPanel("Inspector | Worktree", width, height, [
+            styleLine("No worktree selected.", "muted")
+        ]);
+    }
+    const diff = findWorktreeDiff(snapshot, worktree.agent);
+    const status = snapshot.session.agentStatus[worktree.agent];
+    const ownedTasks = snapshot.session.tasks.filter((task)=>task.owner === worktree.agent).sort((left, right)=>right.updatedAt.localeCompare(left.updatedAt)).slice(0, 4);
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Worktree", [
+            `Agent: ${worktree.agent}`,
+            `Branch: ${worktree.branch}`,
+            `Path: ${worktree.path}`,
+            `Transport: ${status.transport}`,
+            `Last run: ${shortTime(status.lastRunAt)}`,
+            `Last exit: ${status.lastExitCode ?? "-"}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Changed Paths", diff?.paths.length ? diff.paths.flatMap((filePath)=>wrapText(`${filePath === diffEntry?.review?.selectedPath ? ">" : "-"} ${filePath}`, innerWidth)) : [
+            "- clean"
+        ]),
+        ...section("Recent Tasks", ownedTasks.length ? ownedTasks.flatMap((task)=>wrapText(`- [${task.status}] ${task.title}`, innerWidth)) : [
+            "- none"
+        ])
+    ];
+    if (loadingDiff) {
+        lines.push(...section("Diff Review", [
+            "Loading worktree diff..."
+        ]));
+    } else if (diffEntry?.error) {
+        lines.push(...section("Diff Review", wrapText(`Diff load failed: ${diffEntry.error}`, innerWidth)));
+    } else if (diffEntry?.review) {
+        const hunks = parseDiffHunks(diffEntry.review.patch);
+        const hunkIndex = selectedHunkIndex(ui, worktree.agent, diffEntry.review);
+        const selectedHunk = hunkIndex === null ? null : hunks[hunkIndex] ?? null;
+        lines.push(...section("Review", [
+            `Selected file: ${diffEntry.review.selectedPath ?? "-"}`,
+            `Hunks: ${hunks.length}`,
+            `Selected hunk: ${hunkIndex === null ? "-" : `${hunkIndex + 1}/${hunks.length}`}`,
+            `Stat: ${diffEntry.review.stat}`
+        ].flatMap((line)=>wrapText(line, innerWidth))));
+        if (selectedHunk) {
+            lines.push(...section("Current Hunk", wrapPreformatted([
+                selectedHunk.header,
+                ...selectedHunk.lines
+            ].join("\n"), innerWidth)));
+        }
+        lines.push(...section("Patch", diffEntry.review.patch ? wrapPreformatted(diffEntry.review.patch, innerWidth) : [
+            "No textual patch available."
+        ]));
+    } else {
+        lines.push(...section("Diff Review", [
+            "No diff review available yet."
+        ]));
+    }
+    lines.push("");
+    lines.push(diffFooter(worktree.agent));
+    return renderPanel("Inspector | Worktree", width, height, lines, {
+        focused: true
+    });
+}
+function renderInspector(snapshot, ui, width, height) {
+    switch(ui.activeTab){
+        case "tasks":
+            return renderTaskInspector(selectedTask(snapshot, ui), artifactForTask(ui, selectedTask(snapshot, ui)), selectedTask(snapshot, ui) ? ui.loadingArtifacts[selectedTask(snapshot, ui)?.id ?? ""] === true : false, diffEntryForAgent(ui, managedAgentForTask(selectedTask(snapshot, ui))), managedAgentForTask(selectedTask(snapshot, ui)) ? ui.loadingDiffReviews[managedAgentForTask(selectedTask(snapshot, ui)) ?? "codex"] === true : false, ui, width, height);
+        case "approvals":
+            return renderApprovalInspector(selectedApproval(snapshot, ui), width, height);
+        case "claims":
+            return renderClaimInspector(selectedClaim(snapshot, ui), width, height);
+        case "decisions":
+            return renderDecisionInspector(selectedDecision(snapshot, ui), width, height);
+        case "events":
+            return renderEventInspector(selectedEvent(snapshot, ui), width, height);
+        case "messages":
+            return renderMessageInspector(selectedMessage(snapshot, ui), width, height);
+        case "worktrees":
+            return renderWorktreeInspector(snapshot, selectedWorktree(snapshot, ui), diffEntryForAgent(ui, selectedWorktree(snapshot, ui)?.agent ?? null), selectedWorktree(snapshot, ui) ? ui.loadingDiffReviews[selectedWorktree(snapshot, ui)?.agent ?? "codex"] === true : false, ui, width, height);
+        default:
+            return renderPanel("Inspector", width, height, [
+                styleLine("No inspector data.", "muted")
+            ]);
+    }
+}
+function renderLane(snapshot, agent, width, height) {
+    if (!snapshot) {
+        return renderPanel(`${agent === "codex" ? "Codex" : "Claude"} Lane`, width, height, [
+            styleLine("No session snapshot available.", "muted")
+        ]);
+    }
+    const status = snapshot.session.agentStatus[agent];
+    const worktree = snapshot.session.worktrees.find((item)=>item.agent === agent);
+    const diff = findWorktreeDiff(snapshot, agent);
+    const tasks = snapshot.session.tasks.filter((task)=>task.owner === agent).sort((left, right)=>right.updatedAt.localeCompare(left.updatedAt));
+    const approvals = snapshot.approvals.filter((approval)=>approval.agent === agent && approval.status === "pending");
+    const claims = snapshot.session.pathClaims.filter((claim)=>claim.agent === agent && claim.status === "active");
+    const innerWidth = Math.max(16, width - 2);
+    const lines = [
+        ...section("Status", [
+            `Transport: ${status.transport}`,
+            `Available: ${status.available ? "yes" : "no"}`,
+            `Last run: ${shortTime(status.lastRunAt)}`,
+            `Last exit: ${status.lastExitCode ?? "-"}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Session", [
+            `Runtime session: ${status.sessionId ?? "-"}`,
+            `Worktree: ${worktree ? path.basename(worktree.path) : "-"}`,
+            `Branch: ${worktree?.branch ?? "-"}`,
+            `Pending approvals: ${approvals.length}`,
+            `Changed paths: ${diff?.paths.length ?? 0}`
+        ].flatMap((line)=>wrapText(line, innerWidth))),
+        ...section("Summary", wrapText(status.summary ?? "No summary yet.", innerWidth)),
+        ...section("Tasks", tasks.length ? tasks.slice(0, 4).flatMap((task)=>wrapText(`- [${task.status}] ${task.title}`, innerWidth)) : [
+            "- none"
+        ]),
+        ...section("Claims", claims.length ? claims.slice(0, 3).flatMap((claim)=>wrapText(`- ${claim.paths.join(", ")}`, innerWidth)) : [
+            "- none"
+        ]),
+        ...section("Diff", diff?.paths.length ? diff.paths.slice(0, 4).flatMap((filePath)=>wrapText(`- ${filePath}`, innerWidth)) : [
+            "- clean"
+        ])
+    ];
+    return renderPanel(`${agent === "codex" ? "Codex" : "Claude"} Lane`, width, height, lines);
+}
+function renderHeader(view, ui, width) {
+    const snapshot = view.snapshot;
+    const session = snapshot?.session ?? null;
+    const repoName = path.basename(session?.repoRoot ?? process.cwd());
+    const line1 = fitAnsiLine(`${toneForPanel("Kavi Operator", true)} | session=${session?.id ?? "-"} | repo=${repoName} | rpc=${view.connected ? "connected" : "disconnected"}`, width);
+    const line2 = fitAnsiLine(`Goal: ${session?.goal ?? "-"} | status=${session?.status ?? "-"} | refresh=${shortTime(view.refreshedAt)}`, width);
+    const line3 = fitAnsiLine(session ? `Tasks P:${countTasks(session.tasks, "pending")} R:${countTasks(session.tasks, "running")} B:${countTasks(session.tasks, "blocked")} C:${countTasks(session.tasks, "completed")} F:${countTasks(session.tasks, "failed")} | approvals=${snapshot?.approvals.filter((approval)=>approval.status === "pending").length ?? 0} | claims=${session.pathClaims.filter((claim)=>claim.status === "active").length} | decisions=${session.decisions.length}` : "Waiting for session snapshot...", width);
+    const tabs = OPERATOR_TABS.map((tab, index)=>{
+        const count = buildTabItems(snapshot, tab).length;
+        const label = `[${index + 1}] ${tabLabel(tab)} ${count}`;
+        return tab === ui.activeTab ? styleLine(label, "reverse") : label;
+    }).join("  ");
+    const line4 = fitAnsiLine(tabs, width);
+    return [
+        line1,
+        line2,
+        line3,
+        line4
+    ];
+}
+function currentToast(ui) {
+    if (!ui.toast) {
+        return null;
+    }
+    return ui.toast.expiresAt > Date.now() ? ui.toast : null;
+}
+function footerSelectionSummary(snapshot, ui, width) {
+    const item = selectedItem(snapshot, ui);
+    if (!item) {
+        return fitAnsiLine("Selection: none", width);
+    }
+    return fitAnsiLine(`Selection: ${item.title}${item.detail ? ` | ${item.detail}` : ""}`, width);
+}
+function renderFooter(snapshot, ui, width) {
+    const toast = currentToast(ui);
+    if (ui.composer) {
+        const composerHeader = fitAnsiLine(styleLine("Compose Task", "accent", "strong"), width);
+        const composerLine = fitAnsiLine(`Route: ${ui.composer.owner} | 1 auto 2 codex 3 claude | Enter submit | Esc cancel | Ctrl+U clear`, width);
+        const promptLine = fitAnsiLine(`> ${ui.composer.prompt}`, width);
+        return [
+            composerHeader,
+            composerLine,
+            promptLine,
+            fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine("Composer accepts free text; tasks are routed or assigned when you press Enter.", "muted"), width)
+        ];
+    }
+    return [
+        fitAnsiLine("Keys: 1-7 tabs | h/l or Tab cycle tabs | j/k move | [ ] task detail | ,/. diff file | { } diff hunk | c compose | r refresh", width),
+        fitAnsiLine("Actions: y/Y allow approval | n/N deny approval | g/G top/bottom | s stop daemon | q quit", width),
+        footerSelectionSummary(snapshot, ui, width),
+        fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine("Operator surface is live over the daemon socket with pushed snapshots.", "muted"), width)
+    ];
+}
+function buildLayout(width, height) {
+    if (width >= 120) {
+        const left = Math.max(32, Math.min(44, Math.floor(width * 0.34)));
+        const middle = Math.max(28, Math.min(38, Math.floor(width * 0.26)));
+        const right = Math.max(36, width - left - middle - 2);
+        return [
+            {
+                kind: "wide",
+                columns: [
+                    left,
+                    middle,
+                    right
+                ]
+            }
+        ];
+    }
+    if (width >= 88) {
+        const left = Math.max(28, Math.floor(width * 0.4));
+        const right = Math.max(36, width - left - 1);
+        return [
+            {
+                kind: "narrow",
+                columns: [
+                    left,
+                    right
+                ]
+            }
+        ];
+    }
+    return [
+        {
+            kind: "compact"
+        }
+    ];
+}
+function renderBody(view, ui, width, height) {
+    const layout = buildLayout(width, height)[0];
+    if (!layout) {
+        return [];
+    }
+    if (layout.kind === "wide" && layout.columns) {
+        const [leftWidth, middleWidth, rightWidth] = layout.columns;
+        const topHeight = Math.max(7, Math.floor(height / 2));
+        const bottomHeight = Math.max(7, height - topHeight);
+        return combineColumns([
+            {
+                width: leftWidth,
+                lines: renderListPanel(view.snapshot, ui, leftWidth, height)
+            },
+            {
+                width: middleWidth,
+                lines: [
+                    ...renderLane(view.snapshot, "codex", middleWidth, topHeight),
+                    ...renderLane(view.snapshot, "claude", middleWidth, bottomHeight)
+                ]
+            },
+            {
+                width: rightWidth,
+                lines: renderInspector(view.snapshot, ui, rightWidth, height)
+            }
+        ]);
+    }
+    if (layout.kind === "narrow" && layout.columns) {
+        const [leftWidth, rightWidth] = layout.columns;
+        const inspectorHeight = Math.max(9, Math.floor(height * 0.58));
+        const laneHeight = Math.max(6, Math.floor((height - inspectorHeight) / 2));
+        const remaining = Math.max(6, height - inspectorHeight - laneHeight);
+        return combineColumns([
+            {
+                width: leftWidth,
+                lines: renderListPanel(view.snapshot, ui, leftWidth, height)
+            },
+            {
+                width: rightWidth,
+                lines: [
+                    ...renderInspector(view.snapshot, ui, rightWidth, inspectorHeight),
+                    ...renderLane(view.snapshot, "codex", rightWidth, laneHeight),
+                    ...renderLane(view.snapshot, "claude", rightWidth, remaining)
+                ]
+            }
+        ]);
+    }
+    const listHeight = Math.max(8, Math.floor(height * 0.34));
+    const inspectorHeight = Math.max(8, Math.floor(height * 0.34));
+    const laneHeight = Math.max(6, Math.floor((height - listHeight - inspectorHeight) / 2));
+    const finalLaneHeight = Math.max(6, height - listHeight - inspectorHeight - laneHeight);
+    return [
+        ...renderListPanel(view.snapshot, ui, width, listHeight),
+        ...renderInspector(view.snapshot, ui, width, inspectorHeight),
+        ...renderLane(view.snapshot, "codex", width, laneHeight),
+        ...renderLane(view.snapshot, "claude", width, finalLaneHeight)
+    ];
+}
+function renderScreen(view, ui, paths) {
+    const width = process.stdout.columns ?? 120;
+    const height = process.stdout.rows ?? 36;
+    const header = renderHeader(view, ui, width);
+    const footer = renderFooter(view.snapshot, ui, width);
+    const bodyHeight = Math.max(12, height - header.length - footer.length);
+    const body = renderBody(view, ui, width, bodyHeight);
+    return `\u001b[?25l\u001b[H\u001b[2J${[
+        ...header,
+        ...body,
+        ...footer
+    ].slice(0, height).join("\n")}`;
+}
+function setToast(ui, level, message) {
+    ui.toast = {
+        level,
+        message,
+        expiresAt: Date.now() + TOAST_DURATION_MS
+    };
+}
+async function queueManualTask(paths, view, ui) {
+    const snapshot = view.snapshot;
+    const composer = ui.composer;
+    if (!snapshot || !composer) {
+        throw new Error("No live session snapshot is available for task composition.");
+    }
+    const prompt = composer.prompt.trim();
+    if (!prompt) {
+        throw new Error("Task prompt cannot be empty.");
+    }
+    const routeDecision = composer.owner === "auto" ? await routeTask(prompt, snapshot.session, paths) : {
+        owner: composer.owner,
+        strategy: "manual",
+        confidence: 1,
+        reason: `Operator manually assigned the task to ${composer.owner}.`,
+        claimedPaths: extractPromptPathHints(prompt)
+    };
+    await rpcEnqueueTask(paths, {
+        owner: routeDecision.owner,
+        prompt,
+        routeReason: routeDecision.reason,
+        claimedPaths: routeDecision.claimedPaths,
+        routeStrategy: routeDecision.strategy,
+        routeConfidence: routeDecision.confidence
+    });
+    ui.composer = null;
+    ui.activeTab = "tasks";
+    setToast(ui, "info", `Queued ${routeDecision.owner} task via ${routeDecision.strategy}: ${routeDecision.reason}`);
+}
+async function resolveApprovalSelection(paths, snapshot, ui, decision, remember) {
+    const approval = ui.activeTab === "approvals" ? selectedApproval(snapshot, ui) : snapshot ? latestPendingApproval(snapshot.approvals) : null;
+    if (!approval) {
+        throw new Error("No approval request is available to resolve.");
+    }
+    await rpcResolveApproval(paths, {
+        requestId: approval.id,
+        decision,
+        remember
+    });
+    setToast(ui, "info", `${decision === "allow" ? "Approved" : "Denied"} ${approval.toolName}${remember ? " with remembered rule" : ""}.`);
+}
+async function ensureSelectedTaskArtifact(paths, view, ui, render) {
+    if (!view.connected || ui.activeTab !== "tasks") {
+        return;
+    }
+    const task = selectedTask(view.snapshot, ui);
+    if (!task) {
+        return;
+    }
+    const existing = ui.artifacts[task.id];
+    if (existing && existing.taskUpdatedAt === task.updatedAt) {
+        return;
+    }
+    if (ui.loadingArtifacts[task.id]) {
+        return;
+    }
+    ui.loadingArtifacts[task.id] = true;
+    render();
+    try {
+        const artifact = await rpcTaskArtifact(paths, task.id);
+        ui.artifacts[task.id] = {
+            taskUpdatedAt: task.updatedAt,
+            artifact,
+            error: null
+        };
+    } catch (error) {
+        ui.artifacts[task.id] = {
+            taskUpdatedAt: task.updatedAt,
+            artifact: null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    } finally{
+        delete ui.loadingArtifacts[task.id];
+        render();
+    }
+}
+async function ensureSelectedDiffReview(paths, view, ui, render) {
+    if (!view.connected) {
+        return;
+    }
+    const agent = reviewAgentForUi(view.snapshot, ui);
+    if (!agent) {
+        return;
+    }
+    const changedPaths = changedPathsForAgent(view.snapshot, agent);
+    const selectedPath = selectedDiffPath(view.snapshot, ui, agent);
+    const changedSignature = changedPathSignature(changedPaths);
+    const existing = ui.diffReviews[agent];
+    if (existing && existing.selectedPath === selectedPath && existing.changedSignature === changedSignature) {
+        return;
+    }
+    if (ui.loadingDiffReviews[agent]) {
+        return;
+    }
+    ui.loadingDiffReviews[agent] = true;
+    render();
+    try {
+        const review = await rpcWorktreeDiff(paths, agent, selectedPath);
+        ui.diffSelections[agent] = review.selectedPath;
+        ui.hunkSelections[agent] = 0;
+        ui.diffReviews[agent] = {
+            selectedPath: review.selectedPath,
+            changedSignature: changedPathSignature(review.changedPaths),
+            review,
+            error: null
+        };
+    } catch (error) {
+        ui.diffReviews[agent] = {
+            selectedPath,
+            changedSignature,
+            review: null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    } finally{
+        ui.loadingDiffReviews[agent] = false;
+        render();
+    }
+}
+function cycleDiffSelection(snapshot, ui, delta) {
+    const agent = reviewAgentForUi(snapshot, ui);
+    if (!agent) {
+        return null;
+    }
+    const changedPaths = changedPathsForAgent(snapshot, agent);
+    if (changedPaths.length === 0) {
+        ui.diffSelections[agent] = null;
+        return agent;
+    }
+    const current = selectedDiffPath(snapshot, ui, agent);
+    const currentIndex = Math.max(0, changedPaths.findIndex((filePath)=>filePath === current));
+    const nextIndex = (currentIndex + delta + changedPaths.length) % changedPaths.length;
+    ui.diffSelections[agent] = changedPaths[nextIndex] ?? changedPaths[0] ?? null;
+    ui.hunkSelections[agent] = 0;
+    return agent;
+}
+function cycleDiffHunk(snapshot, ui, delta) {
+    const agent = reviewAgentForUi(snapshot, ui);
+    if (!agent) {
+        return null;
+    }
+    const review = ui.diffReviews[agent]?.review ?? null;
+    const hunks = parseDiffHunks(review?.patch ?? "");
+    if (hunks.length === 0) {
+        ui.hunkSelections[agent] = 0;
+        return agent;
+    }
+    const currentIndex = selectedHunkIndex(ui, agent, review) ?? 0;
+    ui.hunkSelections[agent] = (currentIndex + delta + hunks.length) % hunks.length;
+    return agent;
 }
 export async function attachTui(paths) {
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("The operator UI requires an interactive terminal.");
     }
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
     let closed = false;
-    const refresh = async ()=>{
-        const session = await loadSessionRecord(paths);
-        const events = await readRecentEvents(paths, 30);
-        const approvals = await listApprovalRequests(paths);
-        process.stdout.write(render(session, events, approvals));
-    };
-    const interval = setInterval(()=>{
-        void refresh();
-    }, 1500);
-    await refresh();
-    await new Promise((resolve)=>{
-        process.stdin.on("keypress", async (_str, key)=>{
-            if (key.name === "q" || key.ctrl && key.name === "c") {
-                closed = true;
-                clearInterval(interval);
-                if (process.stdin.isTTY) {
-                    process.stdin.setRawMode(false);
-                }
-                process.stdout.write("\n");
-                resolve();
-                return;
+    let refreshing = false;
+    let subscribing = false;
+    let actionQueue = Promise.resolve();
+    let closeResolver = null;
+    let reconnectTimer = null;
+    let snapshotSubscription = null;
+    const view = {
+        snapshot: null,
+        connected: false,
+        error: null,
+        refreshedAt: null
+    };
+    const ui = {
+        activeTab: "tasks",
+        selectedIds: emptySelectionMap(),
+        taskDetailSection: "overview",
+        composer: null,
+        toast: null,
+        artifacts: {},
+        loadingArtifacts: {},
+        diffSelections: {
+            codex: null,
+            claude: null
+        },
+        diffReviews: {
+            codex: null,
+            claude: null
+        },
+        loadingDiffReviews: {
+            codex: false,
+            claude: false
+        },
+        hunkSelections: {
+            codex: 0,
+            claude: 0
+        }
+    };
+    const render = ()=>{
+        process.stdout.write(renderScreen(view, ui, paths));
+    };
+    const syncUiForSnapshot = (snapshot)=>{
+        ui.selectedIds = syncSelections(ui.selectedIds, snapshot);
+        ui.diffSelections = syncDiffSelections(ui.diffSelections, snapshot, ui.activeTab === "tasks" ? selectedTask(snapshot, ui) : null);
+    };
+    const applySnapshot = (snapshot, reason)=>{
+        view.snapshot = snapshot;
+        view.connected = true;
+        view.error = null;
+        view.refreshedAt = new Date().toISOString();
+        syncUiForSnapshot(snapshot);
+        render();
+        void ensureSelectedTaskArtifact(paths, view, ui, render);
+        void ensureSelectedDiffReview(paths, view, ui, render);
+        if (reason !== "subscribe") {
+            ui.toast = currentToast(ui);
+        }
+    };
+    const scheduleReconnect = ()=>{
+        if (closed || reconnectTimer) {
+            return;
+        }
+        reconnectTimer = setTimeout(()=>{
+            reconnectTimer = null;
+            runAction(connectSubscription);
+        }, SUBSCRIPTION_RETRY_MS);
+    };
+    const markDisconnected = (message)=>{
+        view.connected = false;
+        view.error = message;
+        view.refreshedAt = new Date().toISOString();
+        render();
+        scheduleReconnect();
+    };
+    const connectSubscription = async ()=>{
+        if (closed || subscribing || snapshotSubscription) {
+            return;
+        }
+        subscribing = true;
+        const candidate = subscribeSnapshotRpc(paths, {
+            onSnapshot: (event)=>{
+                if (snapshotSubscription !== candidate || closed) {
+                    return;
+                }
+                applySnapshot(event.snapshot, event.reason);
+            },
+            onError: (error)=>{
+                if (snapshotSubscription !== candidate || closed) {
+                    return;
+                }
+                snapshotSubscription = null;
+                markDisconnected(error.message);
+            },
+            onDisconnect: ()=>{
+                if (snapshotSubscription !== candidate || closed) {
+                    return;
+                }
+                snapshotSubscription = null;
+                markDisconnected("RPC subscription disconnected.");
             }
-            if (key.name === "r") {
-                await refresh();
-                return;
+        });
+        snapshotSubscription = candidate;
+        try {
+            await candidate.connected;
+        } catch (error) {
+            if (snapshotSubscription === candidate && !closed) {
+                snapshotSubscription = null;
+                markDisconnected(error instanceof Error ? error.message : String(error));
             }
-            if (key.name === "s") {
-                await appendCommand(paths, "shutdown", {});
-                await refresh();
-                return;
+        } finally{
+            subscribing = false;
+            render();
+        }
+    };
+    const refresh = async ()=>{
+        if (refreshing || closed) {
+            return;
+        }
+        refreshing = true;
+        try {
+            const snapshot = await readSnapshot(paths);
+            applySnapshot(snapshot, "manual.refresh");
+        } catch (error) {
+            view.connected = await pingRpc(paths);
+            view.error = error instanceof Error ? error.message : String(error);
+            view.refreshedAt = new Date().toISOString();
+            if (!view.connected && snapshotSubscription) {
+                snapshotSubscription.close();
+                snapshotSubscription = null;
+                scheduleReconnect();
             }
-            if (key.name === "y" || key.name === "n") {
-                const approvals = await listApprovalRequests(paths);
-                const latest = approvals.sort((left, right)=>left.createdAt.localeCompare(right.createdAt)).pop();
-                if (!latest) {
+            render();
+        } finally{
+            refreshing = false;
+        }
+    };
+    const runAction = (fn)=>{
+        actionQueue = actionQueue.then(async ()=>{
+            try {
+                await fn();
+            } catch (error) {
+                setToast(ui, "error", error instanceof Error ? error.message : String(error));
+                render();
+            }
+        });
+    };
+    const close = ()=>{
+        if (closed) {
+            return;
+        }
+        closed = true;
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+        snapshotSubscription?.close();
+        snapshotSubscription = null;
+        process.stdin.setRawMode(false);
+        process.stdin.off("keypress", keypressHandler);
+        process.stdout.off("resize", resizeHandler);
+        process.stdout.write("\u001b[0m\u001b[?25h\n");
+        closeResolver?.();
+    };
+    const selectTab = (tab)=>{
+        ui.activeTab = tab;
+        syncUiForSnapshot(view.snapshot);
+        render();
+        void ensureSelectedTaskArtifact(paths, view, ui, render);
+        void ensureSelectedDiffReview(paths, view, ui, render);
+    };
+    const moveSelection = (delta)=>{
+        const items = buildTabItems(view.snapshot, ui.activeTab);
+        ui.selectedIds[ui.activeTab] = moveSelectionId(items, ui.selectedIds[ui.activeTab], delta);
+        ui.diffSelections = syncDiffSelections(ui.diffSelections, view.snapshot, ui.activeTab === "tasks" ? selectedTask(view.snapshot, ui) : null);
+        render();
+        void ensureSelectedTaskArtifact(paths, view, ui, render);
+        void ensureSelectedDiffReview(paths, view, ui, render);
+    };
+    const keypressHandler = (input, key)=>{
+        if (closed) {
+            return;
+        }
+        if (ui.composer) {
+            runAction(async ()=>{
+                if (key.name === "escape") {
+                    ui.composer = null;
+                    setToast(ui, "info", "Task composition cancelled.");
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "u") {
+                    ui.composer.prompt = "";
+                    render();
+                    return;
+                }
+                if (key.name === "backspace") {
+                    ui.composer.prompt = ui.composer.prompt.slice(0, -1);
+                    render();
+                    return;
+                }
+                if (key.name === "return") {
+                    await queueManualTask(paths, view, ui);
                     await refresh();
+                    ui.selectedIds.tasks = buildTabItems(view.snapshot, "tasks")[0]?.id ?? null;
+                    ui.diffSelections = syncDiffSelections(ui.diffSelections, view.snapshot, selectedTask(view.snapshot, ui));
+                    render();
+                    void ensureSelectedTaskArtifact(paths, view, ui, render);
+                    void ensureSelectedDiffReview(paths, view, ui, render);
+                    return;
+                }
+                if (key.name === "tab" || input === "\t") {
+                    ui.composer.owner = ui.composer.owner === "auto" ? "codex" : ui.composer.owner === "codex" ? "claude" : "auto";
+                    render();
+                    return;
+                }
+                if (input === "1") {
+                    ui.composer.owner = "auto";
+                    render();
+                    return;
+                }
+                if (input === "2") {
+                    ui.composer.owner = "codex";
+                    render();
                     return;
                 }
-                await resolveApprovalRequest(paths, latest.id, key.name === "y" ? "allow" : "deny", false);
+                if (input === "3") {
+                    ui.composer.owner = "claude";
+                    render();
+                    return;
+                }
+                if (input.length === 1 && !key.ctrl && !key.meta) {
+                    ui.composer.prompt += input;
+                    render();
+                }
+            });
+            return;
+        }
+        if (key.name === "q" || key.ctrl && key.name === "c") {
+            close();
+            return;
+        }
+        if (input >= "1" && input <= "7") {
+            const tab = OPERATOR_TABS[Number(input) - 1];
+            if (tab) {
+                selectTab(tab);
+            }
+            return;
+        }
+        if (key.name === "tab") {
+            selectTab(nextTab(ui.activeTab, key.shift ? -1 : 1));
+            return;
+        }
+        if (key.name === "left" || input === "h") {
+            selectTab(nextTab(ui.activeTab, -1));
+            return;
+        }
+        if (key.name === "right" || input === "l") {
+            selectTab(nextTab(ui.activeTab, 1));
+            return;
+        }
+        if (key.name === "down" || input === "j") {
+            moveSelection(1);
+            return;
+        }
+        if (key.name === "up" || input === "k") {
+            moveSelection(-1);
+            return;
+        }
+        if (input === "g" && !key.shift) {
+            const items = buildTabItems(view.snapshot, ui.activeTab);
+            ui.selectedIds[ui.activeTab] = items[0]?.id ?? null;
+            ui.diffSelections = syncDiffSelections(ui.diffSelections, view.snapshot, ui.activeTab === "tasks" ? selectedTask(view.snapshot, ui) : null);
+            render();
+            void ensureSelectedTaskArtifact(paths, view, ui, render);
+            void ensureSelectedDiffReview(paths, view, ui, render);
+            return;
+        }
+        if (key.name === "g" && key.shift) {
+            const items = buildTabItems(view.snapshot, ui.activeTab);
+            ui.selectedIds[ui.activeTab] = items.at(-1)?.id ?? null;
+            ui.diffSelections = syncDiffSelections(ui.diffSelections, view.snapshot, ui.activeTab === "tasks" ? selectedTask(view.snapshot, ui) : null);
+            render();
+            void ensureSelectedTaskArtifact(paths, view, ui, render);
+            void ensureSelectedDiffReview(paths, view, ui, render);
+            return;
+        }
+        if (input === "[" || input === "]") {
+            if (ui.activeTab !== "tasks") {
+                return;
+            }
+            const currentIndex = TASK_DETAIL_SECTIONS.indexOf(ui.taskDetailSection);
+            const delta = input === "[" ? -1 : 1;
+            const nextIndex = (currentIndex + delta + TASK_DETAIL_SECTIONS.length) % TASK_DETAIL_SECTIONS.length;
+            ui.taskDetailSection = TASK_DETAIL_SECTIONS[nextIndex] ?? ui.taskDetailSection;
+            ui.diffSelections = syncDiffSelections(ui.diffSelections, view.snapshot, selectedTask(view.snapshot, ui));
+            render();
+            void ensureSelectedTaskArtifact(paths, view, ui, render);
+            void ensureSelectedDiffReview(paths, view, ui, render);
+            return;
+        }
+        if (input === "r") {
+            runAction(refresh);
+            return;
+        }
+        if (input === "c") {
+            ui.composer = {
+                owner: "auto",
+                prompt: ""
+            };
+            render();
+            return;
+        }
+        if (input === "s") {
+            runAction(async ()=>{
+                await rpcShutdown(paths);
+                close();
+            });
+            return;
+        }
+        if (input === "y" || input === "n") {
+            runAction(async ()=>{
+                await resolveApprovalSelection(paths, view.snapshot, ui, input === "y" ? "allow" : "deny", key.shift === true);
                 await refresh();
+            });
+            return;
+        }
+        if (input === "," || input === ".") {
+            const agent = cycleDiffSelection(view.snapshot, ui, input === "," ? -1 : 1);
+            if (!agent) {
+                return;
             }
-        });
-    });
-    if (!closed) {
-        clearInterval(interval);
+            render();
+            void ensureSelectedDiffReview(paths, view, ui, render);
+            return;
+        }
+        if (input === "{" || input === "}") {
+            const agent = cycleDiffHunk(view.snapshot, ui, input === "{" ? -1 : 1);
+            if (!agent) {
+                return;
+            }
+            render();
+            return;
+        }
+        if (key.name === "return" && ui.activeTab === "tasks") {
+            const currentIndex = TASK_DETAIL_SECTIONS.indexOf(ui.taskDetailSection);
+            ui.taskDetailSection = TASK_DETAIL_SECTIONS[(currentIndex + 1) % TASK_DETAIL_SECTIONS.length] ?? ui.taskDetailSection;
+            ui.diffSelections = syncDiffSelections(ui.diffSelections, view.snapshot, selectedTask(view.snapshot, ui));
+            render();
+            void ensureSelectedTaskArtifact(paths, view, ui, render);
+            void ensureSelectedDiffReview(paths, view, ui, render);
+        }
+    };
+    const resizeHandler = ()=>{
+        render();
+    };
+    process.stdin.on("keypress", keypressHandler);
+    process.stdout.on("resize", resizeHandler);
+    await connectSubscription();
+    if (!view.snapshot) {
+        await refresh();
     }
+    render();
+    await new Promise((resolve)=>{
+        closeResolver = resolve;
+    });
 }