pilotswarm-cli 0.1.10 → 0.1.12

package/cli/tui.js

@@ -20,10 +20,18 @@ import { markedTerminal } from "marked-terminal";
 import chalk from "chalk";
 import fs from "node:fs";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { performance } from "node:perf_hooks";
 import os from "node:os";
+import {
+    computeContextPercent,
+    formatTokenCount,
+    formatContextHeaderBadge,
+    formatContextListBadge,
+    formatContextCompactionBadge,
+    formatCompactionActivityMarkup,
+} from "./context-usage.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -56,6 +64,102 @@ const BASE_TUI_TITLE = (process.env._TUI_TITLE || "PilotSwarm").trim() || "Pilot
 const CUSTOM_TUI_SPLASH = process.env._TUI_SPLASH?.trim() || "";
 const ACTIVE_STARTUP_SPLASH_CONTENT = CUSTOM_TUI_SPLASH || STARTUP_SPLASH_CONTENT;
 const HAS_CUSTOM_TUI_BRANDING = BASE_TUI_TITLE !== "PilotSwarm" || Boolean(CUSTOM_TUI_SPLASH);
+const TERMINAL_RESET_ESCAPE = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1049l\x1b[?25h";
+const SIGNAL_EXIT_CODES = {
+    SIGINT: 130,
+    SIGTERM: 143,
+    SIGHUP: 129,
+};
+
+let localEmbeddedRuntimeLockPath = null;
+let shutdownInProgress = false;
+
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+
+function getLocalEmbeddedRuntimeLockPath() {
+    const sessionStateDir = process.env.SESSION_STATE_DIR || path.join(os.homedir(), ".copilot", "session-state");
+    return path.join(path.dirname(sessionStateDir), "embedded-local-runtime.lock.json");
+}
+
+function releaseLocalEmbeddedRuntimeLock() {
+    if (!localEmbeddedRuntimeLockPath) return;
+
+    try {
+        const raw = fs.readFileSync(localEmbeddedRuntimeLockPath, "utf-8");
+        const owner = JSON.parse(raw);
+        if (Number(owner?.pid) && Number(owner.pid) !== process.pid) {
+            return;
+        }
+    } catch {}
+
+    try {
+        fs.rmSync(localEmbeddedRuntimeLockPath, { force: true });
+    } catch {}
+    localEmbeddedRuntimeLockPath = null;
+}
+
+function acquireLocalEmbeddedRuntimeLock(store) {
+    const lockPath = getLocalEmbeddedRuntimeLockPath();
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+
+    const lockBody = JSON.stringify({
+        pid: process.pid,
+        mode: "local-embedded",
+        cwd: process.cwd(),
+        store,
+        acquiredAt: new Date().toISOString(),
+    }, null, 2);
+
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const fd = fs.openSync(lockPath, "wx");
+            fs.writeFileSync(fd, lockBody, "utf-8");
+            fs.closeSync(fd);
+            localEmbeddedRuntimeLockPath = lockPath;
+            return;
+        } catch (err) {
+            if (err?.code !== "EEXIST") throw err;
+
+            let owner = null;
+            try {
+                owner = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+            } catch {}
+
+            const ownerPid = Number(owner?.pid);
+            if (ownerPid && ownerPid !== process.pid && isProcessAlive(ownerPid)) {
+                const ownerStore = owner?.store ? ` (${owner.store})` : "";
+                throw new Error(
+                    `Another embedded local PilotSwarm TUI is already running (pid ${ownerPid})${ownerStore}. ` +
+                    `Close it before starting a second local TUI. Remote mode still supports multiple windows.`,
+                );
+            }
+
+            try {
+                fs.rmSync(lockPath, { force: true });
+            } catch {}
+        }
+    }
+
+    throw new Error("Failed to acquire the embedded local runtime lock.");
+}
+
+function exitProcessNow(code) {
+    releaseLocalEmbeddedRuntimeLock();
+    try { fs.writeSync(1, Buffer.from(TERMINAL_RESET_ESCAPE)); } catch {}
+    process.exit(code);
+}
+
+process.on("exit", () => {
+    releaseLocalEmbeddedRuntimeLock();
+});
 
 function formatWindowTitle(detail) {
     return detail ? `${BASE_TUI_TITLE} (${detail})` : BASE_TUI_TITLE;
@@ -79,6 +183,102 @@ function applyWindowTitle(title) {
     applyTerminalTitle(title);
 }
 
+function enableMouseTracking(screenInstance) {
+    if (!screenInstance?.program?.input?.isTTY || !screenInstance?.program?.output?.isTTY) {
+        return;
+    }
+
+    try {
+        // neo-blessed only auto-enables mouse for a narrow set of TERM values.
+        // Request the common xterm-compatible modes explicitly so drag selection
+        // still works in newer terminals and IDE-integrated terminals.
+        screenInstance.enableMouse();
+        screenInstance.program.setMouse({
+            vt200Mouse: true,
+            utfMouse: true,
+            sgrMouse: true,
+            cellMotion: true,
+            allMotion: true,
+        }, true);
+    } catch {}
+}
+
+function openPathInDefaultApp(targetPath) {
+    if (!targetPath) return;
+
+    let command;
+    let args;
+
+    if (process.platform === "darwin") {
+        command = "open";
+        args = [targetPath];
+    } else if (process.platform === "win32") {
+        command = "cmd";
+        args = ["/c", "start", "", targetPath];
+    } else {
+        command = "xdg-open";
+        args = [targetPath];
+    }
+
+    try {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        child.once("error", (err) => {
+            appendLog(`{red-fg}Open failed: ${err.message}{/red-fg}`);
+            setStatus("Open failed — check logs");
+            scheduleRender();
+        });
+        child.unref();
+        setStatus(`Opened: ${targetPath}`);
+    } catch (err) {
+        appendLog(`{red-fg}Open failed: ${err.message}{/red-fg}`);
+        setStatus("Open failed — check logs");
+    }
+}
+
+let suppressPaneClicksUntil = 0;
+
+function copyTextToClipboard(text, { onError } = {}) {
+    if (!text) return false;
+
+    let command;
+    let args;
+
+    if (process.platform === "darwin") {
+        command = "pbcopy";
+        args = [];
+    } else if (process.platform === "win32") {
+        command = "clip";
+        args = [];
+    } else if (process.env.WAYLAND_DISPLAY) {
+        command = "wl-copy";
+        args = [];
+    } else {
+        command = "xclip";
+        args = ["-selection", "clipboard"];
+    }
+
+    try {
+        const result = spawnSync(command, args, {
+            input: text,
+            encoding: "utf8",
+            stdio: ["pipe", "ignore", "pipe"],
+        });
+        if (result.error) throw result.error;
+        if (typeof result.status === "number" && result.status !== 0) {
+            throw new Error((result.stderr || "").trim() || `${command} exited with status ${result.status}`);
+        }
+        return true;
+    } catch (err) {
+        try {
+            if (screen?.copyToClipboard?.(text)) {
+                return true;
+            }
+        } catch {}
+        onError?.(err);
+        return false;
+    }
+}
+
 function hideTerminalCursor() {
     try { screen?.program?.hideCursor(); } catch {}
 }
@@ -137,6 +337,7 @@ const require = createRequire(import.meta.url);
 const _origStderr = process.stderr.write.bind(process.stderr);
 process.stderr.write = () => true;
 const blessed = require("neo-blessed");
+const blessedColors = require("neo-blessed/lib/colors");
 process.stderr.write = _origStderr;
 
 // ─── Monkey-patch neo-blessed emoji width ────────────────────────
@@ -212,6 +413,234 @@ function isMarkdownTableLine(line) {
         || /^\s*\|?[:\- ]+\|[:\-| ]+\|?\s*$/.test(line);
 }
 
+function getRenderablePaneWidth(pane, fallbackWidth) {
+    const numericWidth = typeof pane?.width === "number" ? pane.width : fallbackWidth;
+    const innerWidth = numericWidth - (pane?.iwidth || 2) - (pane?.scrollbar ? 1 : 0);
+    return Math.max(20, innerWidth);
+}
+
+function splitMarkdownTableCells(line) {
+    const trimmed = String(line || "").trim().replace(/^\|/, "").replace(/\|$/, "");
+    const cells = [];
+    let current = "";
+    let escaping = false;
+
+    for (const ch of trimmed) {
+        if (escaping) {
+            current += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaping = true;
+            continue;
+        }
+        if (ch === "|") {
+            cells.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+
+function isMarkdownTableSeparatorRow(cells) {
+    return cells.length > 0 && cells.every(cell => /^:?-{3,}:?$/.test(String(cell || "").replace(/\s+/g, "")));
+}
+
+function sliceTextToDisplayWidth(text, maxWidth) {
+    if (maxWidth <= 0) return "";
+    let out = "";
+    let used = 0;
+    for (const ch of String(text || "")) {
+        const chWidth = Math.max(1, displayWidth(ch));
+        if (used + chWidth > maxWidth) break;
+        out += ch;
+        used += chWidth;
+    }
+    return out;
+}
+
+function wrapTableCellText(text, width) {
+    const normalized = String(text || "").replace(/\s+/g, " ").trim();
+    if (!normalized) return [""];
+
+    const words = normalized.split(" ");
+    const lines = [];
+    let current = "";
+
+    const appendWord = (word) => {
+        let remaining = word;
+        while (displayWidth(remaining) > width) {
+            const chunk = sliceTextToDisplayWidth(remaining, width);
+            if (!chunk) break;
+            if (current) {
+                lines.push(current);
+                current = "";
+            }
+            lines.push(chunk);
+            remaining = remaining.slice(chunk.length);
+        }
+        return remaining;
+    };
+
+    for (const word of words) {
+        const fittedWord = appendWord(word);
+        if (!fittedWord) continue;
+        if (!current) {
+            current = fittedWord;
+            continue;
+        }
+        const candidate = `${current} ${fittedWord}`;
+        if (displayWidth(candidate) <= width) {
+            current = candidate;
+        } else {
+            lines.push(current);
+            current = fittedWord;
+        }
+    }
+
+    if (current) lines.push(current);
+    return lines.length > 0 ? lines : [""];
+}
+
+function computeMarkdownTableColumnWidths(rows, maxWidth, separatorWidth) {
+    const columnCount = Math.max(1, ...rows.map(row => row.length));
+    const totalSeparatorWidth = typeof separatorWidth === "number"
+        ? separatorWidth
+        : (columnCount - 1) * 3;
+    const availableWidth = Math.max(columnCount * 3, maxWidth - totalSeparatorWidth);
+    const preferred = Array.from({ length: columnCount }, (_, index) => Math.max(
+        3,
+        ...rows.map(row => displayWidth(row[index] || "")),
+    ));
+    const minimum = Array.from({ length: columnCount }, (_, index) => Math.max(
+        3,
+        Math.min(displayWidth(rows[0]?.[index] || "") || 3, 18),
+    ));
+
+    if (columnCount === 2) {
+        const secondMinimum = Math.max(minimum[1], 16);
+        const firstCap = Math.max(minimum[0], Math.min(24, Math.floor(availableWidth * 0.32)));
+        let firstWidth = Math.min(preferred[0], firstCap);
+        let secondWidth = availableWidth - firstWidth;
+        if (secondWidth < secondMinimum) {
+            firstWidth = Math.max(minimum[0], availableWidth - secondMinimum);
+            secondWidth = availableWidth - firstWidth;
+        }
+        return [firstWidth, secondWidth];
+    }
+
+    const widths = minimum.slice();
+    let remaining = availableWidth - widths.reduce((sum, width) => sum + width, 0);
+    if (remaining < 0) {
+        const equalShare = Math.max(3, Math.floor(availableWidth / columnCount));
+        return widths.map((_, index) => index === columnCount - 1
+            ? Math.max(3, availableWidth - equalShare * (columnCount - 1))
+            : equalShare);
+    }
+
+    while (remaining > 0) {
+        let bestIndex = 0;
+        let bestNeed = -Infinity;
+        for (let index = 0; index < columnCount; index++) {
+            const need = preferred[index] - widths[index];
+            if (need > bestNeed) {
+                bestNeed = need;
+                bestIndex = index;
+            }
+        }
+        widths[bestIndex] += 1;
+        remaining -= 1;
+    }
+
+    return widths;
+}
+
+function estimateMarkdownTableWidth(rows) {
+    const columnCount = Math.max(1, ...rows.map(row => row.length));
+    const preferred = Array.from({ length: columnCount }, (_, index) => Math.max(
+        3,
+        ...rows.map(row => displayWidth(row[index] || "")),
+    ));
+    return preferred.reduce((sum, width) => sum + width, 0) + (columnCount * 3 + 1);
+}
+
+function renderPlainMarkdownTable(rows, maxWidth) {
+    if (!rows || rows.length === 0) return "";
+    const columnCount = Math.max(1, ...rows.map(row => row.length));
+    const normalizedRows = rows.map(row => Array.from({ length: columnCount }, (_, index) => row[index] || ""));
+    const borderOverhead = columnCount * 3 + 1; // | cell | cell |
+    const widths = computeMarkdownTableColumnWidths(normalizedRows, maxWidth, borderOverhead);
+    const out = [];
+
+    const topBorder = `┌${widths.map(width => "─".repeat(width + 2)).join("┬")}┐`;
+    const middleBorder = `├${widths.map(width => "─".repeat(width + 2)).join("┼")}┤`;
+    const bottomBorder = `└${widths.map(width => "─".repeat(width + 2)).join("┴")}┘`;
+
+    const renderRow = (cells) => {
+        const wrapped = cells.map((cell, index) => wrapTableCellText(cell, widths[index]));
+        const height = Math.max(...wrapped.map(lines => lines.length));
+        for (let lineIndex = 0; lineIndex < height; lineIndex++) {
+            const parts = wrapped.map((lines, index) => padToWidth(lines[lineIndex] || "", widths[index]));
+            out.push(`│ ${parts.join(" │ ")} │`);
+        }
+    };
+
+    out.push(topBorder);
+    renderRow(normalizedRows[0]);
+    out.push(middleBorder);
+    for (const row of normalizedRows.slice(1)) {
+        renderRow(row);
+    }
+    out.push(bottomBorder);
+    return out.join("\n");
+}
+
+function formatMarkdownTables(md, maxWidth) {
+    const lines = String(md || "").split("\n");
+    const out = [];
+
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const nextLine = lines[index + 1];
+        if (!isMarkdownTableLine(line) || !isMarkdownTableLine(nextLine)) {
+            out.push(line);
+            continue;
+        }
+
+        const headerCells = splitMarkdownTableCells(line);
+        const separatorCells = splitMarkdownTableCells(nextLine);
+        if (!isMarkdownTableSeparatorRow(separatorCells) || headerCells.length !== separatorCells.length) {
+            out.push(line);
+            continue;
+        }
+
+        const rows = [headerCells];
+        const tableLines = [line, nextLine];
+        index += 1;
+        while (index + 1 < lines.length && isMarkdownTableLine(lines[index + 1])) {
+            index += 1;
+            tableLines.push(lines[index]);
+            const rowCells = splitMarkdownTableCells(lines[index]);
+            if (isMarkdownTableSeparatorRow(rowCells)) continue;
+            rows.push(rowCells);
+        }
+
+        if (estimateMarkdownTableWidth(rows) <= maxWidth) {
+            out.push(...tableLines);
+            continue;
+        }
+
+        const renderedTable = renderPlainMarkdownTable(rows, maxWidth);
+        out.push("```text", renderedTable, "```");
+    }
+
+    return out.join("\n");
+}
+
 function isAsciiArtCandidateLine(line) {
     if (!line || !line.trim()) return false;
     if (isMarkdownTableLine(line)) return false;
@@ -296,14 +725,14 @@ function preserveAsciiArtBlocks(md) {
     return out.join("\n");
 }
 
-function renderMarkdown(md) {
+function renderMarkdown(md, widthOverride) {
     const _ph = perfStart("renderMarkdown");
     try {
-        // Dynamically set width to match chat pane (minus borders/padding)
-        const mdWidth = Math.max(40, leftW() - 4);
-            marked.use(markedTerminal({ reflowText: true, width: mdWidth, showSectionPrefix: false, tab: 2, blockquote: chalk.whiteBright.italic, html: chalk.white, codespan: chalk.yellowBright }, { theme: cliHighlightTheme }));
+        const fallbackWidth = Math.max(40, leftW() - 4);
+        const mdWidth = Math.max(40, widthOverride || getRenderablePaneWidth(typeof chatBox !== "undefined" ? chatBox : null, fallbackWidth));
+        marked.use(markedTerminal({ reflowText: true, width: mdWidth, showSectionPrefix: false, tab: 2, blockquote: chalk.whiteBright.italic, html: chalk.white, codespan: chalk.yellowBright }, { theme: cliHighlightTheme }));
         const unescaped = md.replace(/\\n/g, "\n");
-        const preprocessed = preserveAsciiArtBlocks(unescaped);
+        const preprocessed = preserveAsciiArtBlocks(formatMarkdownTables(unescaped, mdWidth));
         let rendered = marked(preprocessed).replace(/\n{3,}/g, "\n\n").trimEnd();
         // marked-terminal uses ANSI codes for styling, not blessed tags.
         // Strip curly braces so blessed doesn't misinterpret them as tags.
@@ -333,6 +762,32 @@ function renderMarkdown(md) {
 // Format: artifact://sessionId/filename.md
 const ARTIFACT_URI_RE = /artifact:\/\/([a-f0-9-]+)\/([^\s"'{}]+)/g;
 
+function normalizeArtifactFilename(filename) {
+    if (!filename) return filename;
+
+    let normalized = filename;
+    while (true) {
+        const next = normalized
+            // Common markdown wrappers: **artifact://...**, _artifact://..._, `artifact://...`
+            .replace(/[*_`]+$/g, "")
+            // Common trailing punctuation when the URI appears in prose or markdown links
+            .replace(/[)\]}>!,;:?]+$/g, "")
+            // Sentence-ending periods: artifact://.../report.md.
+            .replace(/(\.[A-Za-z0-9]{1,16})\.+$/g, "$1");
+        if (next === normalized) return normalized;
+        normalized = next;
+    }
+}
+
+function renderArtifactLinks(text) {
+    if (!text) return text;
+    ARTIFACT_URI_RE.lastIndex = 0;
+    return text.replace(ARTIFACT_URI_RE, (_match, _sessionId, rawFilename) => {
+        const filename = normalizeArtifactFilename(rawFilename);
+        return `📎 **${filename}** _(press 'a' to download)_`;
+    });
+}
+
 /** Per-session artifact link registry. orchId → [{ sessionId, filename }] */
 const sessionArtifacts = new Map();
 
@@ -341,16 +796,18 @@ const _registeredArtifacts = new Set();
 const MAX_ARTIFACT_REGISTRY = 500;
 
 /** TUI-level artifact store for on-demand downloads. Created lazily.
- *  Uses Azure Blob when configured, otherwise falls back to local filesystem. */
+ *  Remote mode uses Azure Blob when configured; local mode stays on the
+ *  repo-local filesystem artifact store.
+ */
 let _tuiArtifactStore = null;
 function getTuiArtifactStore() {
     if (_tuiArtifactStore) return _tuiArtifactStore;
     const connStr = process.env.AZURE_STORAGE_CONNECTION_STRING;
-    if (connStr) {
+    if (isRemote && connStr) {
         const container = process.env.AZURE_STORAGE_CONTAINER || "copilot-sessions";
         _tuiArtifactStore = new SessionBlobStore(connStr, container);
     } else {
-        _tuiArtifactStore = new FilesystemArtifactStore();
+        _tuiArtifactStore = new FilesystemArtifactStore(process.env.ARTIFACT_DIR);
     }
     return _tuiArtifactStore;
 }
@@ -364,7 +821,9 @@ function detectArtifactLinks(text, orchId) {
     ARTIFACT_URI_RE.lastIndex = 0;
     const matches = [...text.matchAll(ARTIFACT_URI_RE)];
     for (const m of matches) {
-        const [, sessionId, filename] = m;
+        const [, sessionId, rawFilename] = m;
+        const filename = normalizeArtifactFilename(rawFilename);
+        if (!filename) continue;
         const key = `${sessionId}/${filename}`;
         if (_registeredArtifacts.has(key)) continue;
         _registeredArtifacts.add(key);
@@ -386,17 +845,18 @@ function detectArtifactLinks(text, orchId) {
  */
 async function downloadArtifact(sessionId, filename) {
     const store = getTuiArtifactStore();
+    const normalizedFilename = normalizeArtifactFilename(filename);
     const sessionDir = path.join(EXPORTS_DIR, sessionId.slice(0, 8));
     fs.mkdirSync(sessionDir, { recursive: true });
-    const localPath = path.join(sessionDir, filename);
+    const localPath = path.join(sessionDir, normalizedFilename);
 
     try {
-        const content = await store.downloadArtifact(sessionId, filename);
+        const content = await store.downloadArtifact(sessionId, normalizedFilename);
         fs.writeFileSync(localPath, content, "utf-8");
         appendLog(`{green-fg}📥 Downloaded: ~/${path.relative(os.homedir(), localPath)} (${(content.length / 1024).toFixed(1)}KB){/green-fg}`);
         return localPath;
     } catch (err) {
-        appendLog(`{red-fg}📥 Download error for ${filename}: ${err.message}{/red-fg}`);
+        appendLog(`{red-fg}📥 Download error for ${normalizedFilename}: ${err.message}{/red-fg}`);
         return null;
     }
 }
@@ -441,7 +901,7 @@ function showArtifactPicker() {
         const items = artifacts.map(a => {
             const icon = a.downloaded ? " ✓" : " ↓";
             const sid = shortId(a.sessionId);
-            return `${icon} ${sid}/${a.filename}`;
+            return `${icon} ${sid}/${normalizeArtifactFilename(a.filename)}`;
         });
         if (hasMultiple) items.push(" ⬇  Download All");
         return items;
@@ -635,7 +1095,7 @@ function showFileAttachPrompt() {
 
             // Show a snipped preview in chat (first 3 lines)
             const lines = content.split("\n");
-            const preview = lines.slice(0, 3).map(l => `  ${l.slice(0, 80)}`).join("\n");
+            const preview = lines.slice(0, 3).map(l => `  ${safeSlice(l, 0, 80)}`).join("\n");
             const suffix = lines.length > 3 ? `\n  {gray-fg}… (${lines.length - 3} more lines){/gray-fg}` : "";
             appendChatRaw(
                 `{yellow-fg}📄 Attached: ${displayName} (${(content.length / 1024).toFixed(1)}KB){/yellow-fg}\n${preview}${suffix}`,
@@ -684,9 +1144,57 @@ function ts() {
     return formatDisplayTime(Date.now());
 }
 
+function formatHumanDurationSeconds(totalSeconds) {
+    const numeric = Number(totalSeconds);
+    if (!Number.isFinite(numeric)) {
+        return `${asDisplayText(totalSeconds, "?")}s`;
+    }
+
+    const roundedSeconds = Math.max(0, Math.round(numeric));
+    if (roundedSeconds >= 86400) {
+        const days = Math.floor(roundedSeconds / 86400);
+        const hours = Math.floor((roundedSeconds % 86400) / 3600);
+        const minutes = Math.floor((roundedSeconds % 3600) / 60);
+        const seconds = roundedSeconds % 60;
+        return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+    }
+    if (roundedSeconds >= 3600) {
+        const hours = Math.floor(roundedSeconds / 3600);
+        const minutes = Math.floor((roundedSeconds % 3600) / 60);
+        const seconds = roundedSeconds % 60;
+        return `${hours}h ${minutes}m ${seconds}s`;
+    }
+    if (roundedSeconds >= 60) {
+        const minutes = Math.floor(roundedSeconds / 60);
+        const seconds = roundedSeconds % 60;
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${roundedSeconds}s`;
+}
+
+function asDisplayText(value, fallback = "") {
+    if (typeof value === "string") return value;
+    if (value == null) return fallback;
+    return String(value);
+}
+
+function safeSlice(value, start, end, fallback = "") {
+    return asDisplayText(value, fallback).slice(start, end);
+}
+
+function safeTail(value, count, fallback = "") {
+    return safeSlice(value, -Math.abs(count), undefined, fallback);
+}
+
+function normalizePodName(podName) {
+    const normalized = asDisplayText(podName, "unknown").trim();
+    return normalized || "unknown";
+}
+
 /** Extract short display ID (last 8 chars of session UUID) from an orchId or sessionId. */
 function shortId(id) {
-    const sid = id.startsWith("session-") ? id.slice(8) : id;
+    const rawId = asDisplayText(id);
+    const sid = rawId.startsWith("session-") ? rawId.slice(8) : rawId;
     return sid.slice(-8);
 }
 
@@ -702,10 +1210,11 @@ const screen = blessed.screen({
     title: BASE_TUI_TITLE,
     fullUnicode: true,
     forceUnicode: true,
-    mouse: false,
+    mouse: true,
 });
 process.stderr.write = _origStderr;
 applyWindowTitle(BASE_TUI_TITLE);
+enableMouseTracking(screen);
 
 // ─── Coalescing render loop (Option B) ───────────────────────────
 // Instead of rendering on every screen.render() call (80+ sites),
@@ -817,6 +1326,10 @@ setInterval(() => {
         _screenDirty = false;
         const t0 = performance.now();
         _origRender();
+        const selectionDrawRange = applyPaneSelectionOverlay();
+        if (selectionDrawRange) {
+            screen.draw(selectionDrawRange.startY, selectionDrawRange.endY);
+        }
         const dur = performance.now() - t0;
         _perfRenderCount++;
         _perfRenderTotalMs += dur;
@@ -832,23 +1345,35 @@ setInterval(() => {
 // ─── Layout calculations ─────────────────────────────────────────
 // Left column: sessions (top) + chat (bottom). Right column: full-height logs.
 
-let rightPaneAdjust = Math.floor(screen.width * 0.55 * 0.25); // start right pane at 3/4 of default
-function leftW() { return Math.floor(screen.width * 0.45) + rightPaneAdjust; }
-function rightW() { return screen.width - leftW(); }
+const DEFAULT_LEFT_PANE_RATIO = 0.70;
+const MIN_LEFT_PANE_WIDTH = 30;
+const MIN_RIGHT_PANE_WIDTH = 20;
+let rightPaneAdjust = 0;
+
+function baseLeftW() {
+    return Math.floor(screen.width * DEFAULT_LEFT_PANE_RATIO);
+}
+
+function leftW() {
+    const desired = baseLeftW() + rightPaneAdjust;
+    return Math.max(MIN_LEFT_PANE_WIDTH, Math.min(desired, screen.width - MIN_RIGHT_PANE_WIDTH));
+}
+
+function rightW() {
+    return Math.max(MIN_RIGHT_PANE_WIDTH, screen.width - leftW());
+}
 const MIN_PROMPT_EDITOR_ROWS = 1;
 const MAX_PROMPT_EDITOR_ROWS = 8;
 let promptValueCache = "";
+let inputBar = null;
 
 function promptLineCount(text) {
     const str = String(text || "");
     if (!str) return 1;
-    // Count visual lines: each \n-delimited line may wrap across multiple visual rows
-    const width = Math.max(1, screen.width - 2); // input bar inner width (full width minus borders)
-    let visualLines = 0;
-    for (const line of str.split("\n")) {
-        visualLines += Math.max(1, Math.ceil((line.length + 1) / width));
+    if (inputBar?._clines && inputBar._clines.content === str) {
+        return Math.max(1, inputBar._clines.length || 1);
     }
-    return Math.max(1, visualLines);
+    return Math.max(1, getCursorVisualPosition(str, str.length).row + 1);
 }
 
 function promptEditorRows() {
@@ -917,7 +1442,7 @@ const orchList = blessed.list({
     scrollbar: { style: { bg: "yellow" } },
     keys: false,
     vi: false,
-    mouse: false,
+    mouse: true,
     interactive: true,
 });
 
@@ -991,7 +1516,7 @@ const chatBox = blessed.log({
     scrollbar: { style: { bg: "cyan" } },
     keys: true,
     vi: true,
-    mouse: false,
+    mouse: true,
 });
 
 // ─── Clickable URLs in chat ──────────────────────────────────────
@@ -1022,6 +1547,8 @@ function extractUrlFromLine(line) {
 
 // Mouse click → open URL in browser
 chatBox.on("click", function (_mouse) {
+    if (Date.now() < suppressPaneClicksUntil) return;
+    if (paneTextSelection.pane === this && paneTextSelection.active && paneTextSelection.dragging) return;
     // Calculate which content line was clicked
     // _mouse.y is absolute screen coordinate
     const absTop = this.atop != null ? this.atop : this.top;
@@ -1049,7 +1576,7 @@ const paneColors = ["yellow", "magenta", "green", "blue"];
 let nextColorIdx = 0;
 
 // Log viewing mode: "workers" | "orchestration" | "sequence" | "nodemap"
-let logViewMode = "orchestration";
+let logViewMode = "sequence";
 // Markdown viewer overlay — toggled independently via 'v' key.
 // When active, replaces the entire right side (log panes + activity pane).
 let mdViewActive = false;
@@ -1088,25 +1615,20 @@ const orchLogPane = blessed.log({
     scrollbar: { style: { bg: "cyan" } },
     keys: true,
     vi: true,
-    mouse: false,
+    mouse: true,
     hidden: true,
 });
 
 // ─── Sequence Diagram Mode (swimlane) ────────────────────────────
 // Vertical scrolling swimlane: one column per worker node.
-// Activity boxes stay in the same column (session affinity).
-// Migration arrows show when affinity resets after dehydrate.
+// Backed by CMS events (worker_node_id per event, seq-ordered).
 
 const TIME_W = 10; // "HH:MM:SS  " — time + trailing space
 
-const seqEventBuffers = new Map(); // orchId → [event]
 const seqNodes = [];               // ordered short node names
 const seqNodeSet = new Set();
 const MAX_SEQ_RENDER_EVENTS = 120;
 
-// Track per-session state for rendering
-const seqLastActivityNode = new Map(); // orchId → last node that ran activity
-
 const seqHeaderBox = blessed.box({
     parent: screen,
     tags: true,
@@ -1143,7 +1665,7 @@ const nodeMapPane = blessed.box({
     scrollbar: { style: { bg: "yellow" } },
     keys: true,
     vi: true,
-    mouse: false,
+    mouse: true,
     hidden: true,
 });
 
@@ -1174,7 +1696,7 @@ const mdFileListPane = blessed.list({
     },
     keys: false,
     vi: false,
-    mouse: false,
+    mouse: true,
     interactive: true,
     hidden: true,
 });
@@ -1199,7 +1721,7 @@ const mdPreviewPane = blessed.box({
     scrollbar: { style: { bg: "green" } },
     keys: true,
     vi: true,
-    mouse: false,
+    mouse: true,
     hidden: true,
 });
 
@@ -1261,7 +1783,7 @@ function refreshMarkdownViewer() {
         const f = files[mdViewerSelectedIdx];
         try {
             const raw = fs.readFileSync(f.localPath, "utf-8");
-            const rendered = renderMarkdown(raw);
+            const rendered = renderMarkdown(raw, getRenderablePaneWidth(mdPreviewPane, Math.max(40, leftW() - 4)));
             mdPreviewPane.setLabel(` ${f.filename} `);
             mdPreviewPane.setContent(rendered);
             mdPreviewPane.scrollTo(0);
@@ -1301,7 +1823,7 @@ function toggleMdViewOff() {
 
 // ─── Vim keybindings for markdown preview ────────────────────────
 // g = top, G = bottom, Ctrl-d = page down, Ctrl-u = page up
-// o = open in $EDITOR, y = copy path
+// o = open in default app, y = copy path
 mdPreviewPane.key(["g"], () => { mdPreviewPane.scrollTo(0); scheduleRender(); });
 mdPreviewPane.key(["S-g"], () => { mdPreviewPane.setScrollPerc(100); scheduleRender(); });
 mdPreviewPane.key(["C-d"], () => {
@@ -1318,19 +1840,18 @@ mdPreviewPane.key(["o"], () => {
     const files = scanExportFiles();
     const f = files[mdViewerSelectedIdx];
     if (!f) return;
-    const editor = process.env.EDITOR || (process.platform === "darwin" ? "open" : "xdg-open");
-    spawn(editor, [f.localPath], { detached: true, stdio: "ignore" }).unref();
+    openPathInDefaultApp(f.localPath);
 });
 mdPreviewPane.key(["y"], () => {
     const files = scanExportFiles();
     const f = files[mdViewerSelectedIdx];
     if (!f) return;
-    // Copy path to clipboard (macOS pbcopy, Linux xclip)
-    const cmd = process.platform === "darwin" ? "pbcopy" : "xclip -selection clipboard";
-    const proc = spawn(process.platform === "darwin" ? "pbcopy" : "xclip", process.platform === "darwin" ? [] : ["-selection", "clipboard"], { stdio: ["pipe", "ignore", "ignore"] });
-    proc.stdin.write(f.localPath);
-    proc.stdin.end();
-    setStatus(`{green-fg}Copied: ${f.localPath}{/green-fg}`);
+    const copied = copyTextToClipboard(f.localPath, {
+        onError: (err) => appendLog(`{red-fg}Copy failed: ${err.message}{/red-fg}`),
+    });
+    setStatus(copied
+        ? `{green-fg}Copied: ${f.localPath}{/green-fg}`
+        : "Copy failed — check logs");
 });
 
 // ─── Activity pane (sticky, bottom-right) ────────────────────────
@@ -1356,7 +1877,7 @@ const activityPane = blessed.log({
     scrollbar: { style: { bg: "gray" } },
     keys: true,
     vi: true,
-    mouse: false,
+    mouse: true,
 });
 
 // Per-session activity buffers
@@ -1408,6 +1929,14 @@ function formatToolArgsSummary(toolName, args) {
             : "";
         return ` ${seconds}${preserve}${reason}`;
     }
+    if (toolName === "cron") {
+        if (args.action === "cancel") return " cancel";
+        const seconds = args.seconds != null ? `${args.seconds}s` : "?";
+        const reason = typeof args.reason === "string" && args.reason
+            ? ` reason=${JSON.stringify(args.reason)}`
+            : "";
+        return ` ${seconds}${reason}`;
+    }
 
     const entries = Object.entries(args)
         .slice(0, 4)
@@ -1456,10 +1985,30 @@ function ensureSessionSplashBuffer(orchId) {
  * Refresh the node map pane — vertical columns, one per worker node,
  * with sessions stacked underneath, color-coded by live status.
  */
+let _nodeMapTimelineLoadPending = false;
+
 function refreshNodeMap() {
     const lines = [];
     nodeMapPane.setContent("");
 
+    // Ensure CMS timelines are loaded for all sessions so we can map them to
+    // worker columns.  Only the active session's timeline is loaded eagerly;
+    // kick off background loads for every other session the first time the
+    // Node Map is opened (and whenever new sessions appear).
+    const missingTimelines = [];
+    for (const orchId of knownOrchestrationIds) {
+        const sid = orchId.startsWith("session-") ? orchId.slice(8) : orchId;
+        if (!cmsSeqTimelines.has(sid)) missingTimelines.push(sid);
+    }
+    if (missingTimelines.length > 0 && !_nodeMapTimelineLoadPending) {
+        _nodeMapTimelineLoadPending = true;
+        Promise.allSettled(missingTimelines.map(sid => loadCmsSeqTimeline(sid)))
+            .then(() => {
+                _nodeMapTimelineLoadPending = false;
+                if (logViewMode === "nodemap") refreshNodeMap();
+            });
+    }
+
     // Gather all known nodes from seqNodes (worker pane names)
     // Filter out synthetic nodes like "cms" that aren't real workers.
     const SYNTHETIC_NODES = new Set(["cms"]);
@@ -1480,9 +2029,20 @@ function refreshNodeMap() {
     const UNASSIGNED = "(unknown)";
     nodeSessionMap.set(UNASSIGNED, []);
 
-    // Walk all known orchestrations and assign to their last-known node
+    // Walk all known orchestrations and assign to their last-known node (from CMS events).
     for (const orchId of knownOrchestrationIds) {
-        const node = seqLastActivityNode.get(orchId);
+        const sid = orchId.startsWith("session-") ? orchId.slice(8) : orchId;
+        const cmsTimeline = cmsSeqTimelines.get(sid);
+        let node;
+        if (cmsTimeline && cmsTimeline.length > 0) {
+            for (let i = cmsTimeline.length - 1; i >= 0; i--) {
+                const nodeId = getSeqEventNodeId(cmsTimeline[i]);
+                if (nodeId && nodeId !== "(unknown)") {
+                    node = safeTail(nodeId, 5);
+                    break;
+                }
+            }
+        }
         const status = getSessionVisualState(orchId);
         const uuid4 = shortId(orchId);
         const title = sessionHeadings.get(orchId);
@@ -1507,8 +2067,9 @@ function refreshNodeMap() {
 
     // Pad/clip text to column width (plain text, no tags)
     const fitCol = (text, w) => {
-        if (text.length > w) return text.slice(0, w);
-        return text + " ".repeat(w - text.length);
+        const displayText = asDisplayText(text);
+        if (displayText.length > w) return safeSlice(displayText, 0, w);
+        return displayText + " ".repeat(w - displayText.length);
     };
 
     // Render header row: node names
@@ -1574,6 +2135,7 @@ function refreshNodeMap() {
     lines.push("");
     lines.push(
         "{green-fg}* running{/green-fg}  " +
+        "{magenta-fg}~ cron{/magenta-fg}  " +
         "{yellow-fg}~ waiting{/yellow-fg}  " +
         "{white-fg}. idle{/white-fg}  " +
         "{cyan-fg}? input{/cyan-fg}  " +
@@ -1607,10 +2169,233 @@ const seqPane = blessed.log({
     scrollbar: { style: { bg: "magenta" } },
     keys: true,
     vi: true,
-    mouse: false,
+    mouse: true,
     hidden: true,
 });
 
+const selectablePaneLabels = new Map();
+const selectablePaneMouseBindings = new WeakSet();
+const SELECTION_BG = blessedColors.convert("yellow");
+const SELECTION_FG = blessedColors.convert("black");
+const paneTextSelection = {
+    pane: null,
+    anchor: null,
+    head: null,
+    active: false,
+    dragging: false,
+    visible: false,
+};
+
+function selectionInteractionBlocked() {
+    return Boolean(_fileAttachModal || startupLandingVisible || slashPicker);
+}
+
+function registerSelectablePane(pane, label) {
+    selectablePaneLabels.set(pane, label);
+    try {
+        pane.enableMouse?.();
+    } catch {}
+    if (!pane || selectablePaneMouseBindings.has(pane)) return;
+    selectablePaneMouseBindings.add(pane);
+    pane.on("mousedown", (data) => {
+        if (selectionInteractionBlocked()) return;
+        if (paneTextSelection.active && paneTextSelection.pane === pane) return;
+        beginPaneSelection(data, pane);
+    });
+    pane.onScreenEvent("mouse", (data) => {
+        if (selectionInteractionBlocked()) return;
+        if (paneTextSelection.pane !== pane || !paneTextSelection.active) return;
+        if (data.action === "mousemove" || data.action === "mousedown") {
+            updatePaneSelection(data);
+            return;
+        }
+        if (data.action === "mouseup") {
+            updatePaneSelection(data);
+            finalizePaneSelection();
+        }
+    });
+}
+
+function getSelectablePaneLabel(pane) {
+    return selectablePaneLabels.get(pane) || "pane";
+}
+
+function clearPaneSelection({ render = true } = {}) {
+    paneTextSelection.pane = null;
+    paneTextSelection.anchor = null;
+    paneTextSelection.head = null;
+    paneTextSelection.active = false;
+    paneTextSelection.dragging = false;
+    paneTextSelection.visible = false;
+    if (render) scheduleRender();
+}
+
+function getPaneInnerBounds(pane) {
+    if (!pane || pane.hidden || pane.visible === false || !pane.lpos) return null;
+
+    const xi = pane.lpos.xi + (pane.ileft || 0);
+    const xl = pane.lpos.xl - (pane.iright || 0) - 1;
+    const yi = pane.lpos.yi + (pane.itop || 0);
+    const yl = pane.lpos.yl - (pane.ibottom || 0) - 1;
+
+    if (xi > xl || yi > yl) return null;
+    return { xi, xl, yi, yl };
+}
+
+function clampSelectionPoint(bounds, x, y) {
+    return {
+        x: Math.max(bounds.xi, Math.min(bounds.xl, x)),
+        y: Math.max(bounds.yi, Math.min(bounds.yl, y)),
+    };
+}
+
+function normalizeSelectionRange(anchor, head) {
+    if (head.y < anchor.y || (head.y === anchor.y && head.x < anchor.x)) {
+        return { start: head, end: anchor };
+    }
+    return { start: anchor, end: head };
+}
+
+function extractPaneSelectionText(selection = paneTextSelection) {
+    if (!selection.pane || !selection.anchor || !selection.head) return "";
+
+    const bounds = getPaneInnerBounds(selection.pane);
+    if (!bounds) return "";
+
+    const anchor = clampSelectionPoint(bounds, selection.anchor.x, selection.anchor.y);
+    const head = clampSelectionPoint(bounds, selection.head.x, selection.head.y);
+    const { start, end } = normalizeSelectionRange(anchor, head);
+    const rows = [];
+
+    for (let y = start.y; y <= end.y; y++) {
+        const fromX = y === start.y ? start.x : bounds.xi;
+        const toX = y === end.y ? end.x : bounds.xl;
+        const line = screen.lines[y] || [];
+        let row = "";
+        for (let x = fromX; x <= toX; x++) {
+            const ch = line[x]?.[1];
+            row += ch && ch !== "\x00" ? ch : " ";
+        }
+        rows.push(row.replace(/[ \t]+$/u, ""));
+    }
+
+    return rows.join("\n").replace(/\n+$/u, "");
+}
+
+function applyPaneSelectionOverlay() {
+    if (!paneTextSelection.visible || !paneTextSelection.pane) return null;
+
+    const bounds = getPaneInnerBounds(paneTextSelection.pane);
+    if (!bounds) {
+        clearPaneSelection({ render: false });
+        return null;
+    }
+
+    const anchor = clampSelectionPoint(bounds, paneTextSelection.anchor.x, paneTextSelection.anchor.y);
+    const head = clampSelectionPoint(bounds, paneTextSelection.head.x, paneTextSelection.head.y);
+    const { start, end } = normalizeSelectionRange(anchor, head);
+
+    for (let y = start.y; y <= end.y; y++) {
+        const fromX = y === start.y ? start.x : bounds.xi;
+        const toX = y === end.y ? end.x : bounds.xl;
+        const line = screen.lines[y];
+        if (!line) continue;
+
+        for (let x = fromX; x <= toX; x++) {
+            if (!line[x]) continue;
+            const attr = line[x][0];
+            line[x][0] = (attr & ~((0x1ff << 9) | 0x1ff | (8 << 18)))
+                | (1 << 18)
+                | (SELECTION_FG << 9)
+                | SELECTION_BG;
+        }
+        line.dirty = true;
+    }
+
+    return { startY: start.y, endY: end.y };
+}
+
+function beginPaneSelection(mouse, pane) {
+    const bounds = getPaneInnerBounds(pane);
+    const hadVisibleSelection = paneTextSelection.visible;
+
+    clearPaneSelection({ render: false });
+
+    if (!bounds) {
+        if (hadVisibleSelection) scheduleRender();
+        return;
+    }
+
+    const point = clampSelectionPoint(bounds, mouse.x, mouse.y);
+    paneTextSelection.pane = pane;
+    paneTextSelection.anchor = point;
+    paneTextSelection.head = point;
+    paneTextSelection.active = true;
+    paneTextSelection.dragging = false;
+    paneTextSelection.visible = false;
+    if (typeof pane.focus === "function" && screen.focused !== pane) {
+        pane.focus();
+    }
+    hideTerminalCursor();
+    setStatus(`Drag to select text in ${getSelectablePaneLabel(pane)}...`);
+
+    scheduleRender();
+}
+
+function updatePaneSelection(mouse) {
+    if (!paneTextSelection.active || !paneTextSelection.pane || !paneTextSelection.anchor) return;
+
+    const bounds = getPaneInnerBounds(paneTextSelection.pane);
+    if (!bounds) {
+        clearPaneSelection();
+        return;
+    }
+
+    const next = clampSelectionPoint(bounds, mouse.x, mouse.y);
+    if (paneTextSelection.head
+        && paneTextSelection.head.x === next.x
+        && paneTextSelection.head.y === next.y) {
+        return;
+    }
+
+    paneTextSelection.head = next;
+    paneTextSelection.dragging = true;
+    paneTextSelection.visible = paneTextSelection.anchor.x !== next.x
+        || paneTextSelection.anchor.y !== next.y;
+    scheduleRender();
+}
+
+function finalizePaneSelection() {
+    if (!paneTextSelection.pane) return;
+    paneTextSelection.active = false;
+
+    if (!paneTextSelection.visible || !paneTextSelection.dragging) {
+        clearPaneSelection();
+        return;
+    }
+
+    const text = extractPaneSelectionText();
+    suppressPaneClicksUntil = Date.now() + 250;
+
+    if (!text) {
+        clearPaneSelection();
+        setStatus("Nothing to copy");
+        return;
+    }
+
+    const copied = copyTextToClipboard(text, {
+        onError: (err) => appendLog(`{red-fg}Copy failed: ${err.message}{/red-fg}`),
+    });
+    const paneLabel = getSelectablePaneLabel(paneTextSelection.pane);
+    const charCount = text.length;
+    paneTextSelection.dragging = false;
+    paneTextSelection.visible = true;
+    setStatus(copied
+        ? `Copied ${charCount} chars from ${paneLabel}`
+        : "Copy failed — check logs");
+    scheduleRender();
+}
+
 // ─── Register focus ring on all panes ────────────────────────────
 registerFocusRing(orchList, "yellow");
 registerFocusRing(chatBox, "cyan");
@@ -1629,17 +2414,15 @@ activityPane.on("focus", () => setNavigationStatusForPane("activity"));
 seqPane.on("focus", () => setNavigationStatusForPane("sequence"));
 // Worker panes are created dynamically — registered in getOrCreateWorkerPane()
 
-function addSeqNode(podName) {
-    const short = podName.slice(-5);
-    if (seqNodeSet.has(short)) return short;
-    seqNodeSet.add(short);
-    seqNodes.push(short);
-    // Update sticky header when a new node is discovered
-    if (logViewMode === "sequence") {
-        updateSeqHeader();
-    }
-    return short;
-}
+registerSelectablePane(orchList, "sessions");
+registerSelectablePane(chatBox, "chat");
+registerSelectablePane(orchLogPane, "orchestration logs");
+registerSelectablePane(seqHeaderBox, "sequence header");
+registerSelectablePane(seqPane, "sequence");
+registerSelectablePane(nodeMapPane, "node map");
+registerSelectablePane(mdFileListPane, "markdown file list");
+registerSelectablePane(mdPreviewPane, "markdown preview");
+registerSelectablePane(activityPane, "activity");
 
 // Compute column width dynamically from pane inner width
 // Returns an array of per-column widths so remaining pixels are distributed
@@ -1657,13 +2440,6 @@ function seqColWidths() {
     return widths;
 }
 
-// Legacy helper — returns the base column width (used in separator/header)
-function seqColW() {
-    const innerW = (seqPane.width || 60) - 4;
-    const ncols = seqNodes.length || 1;
-    return Math.max(8, Math.floor((innerW - TIME_W) / ncols));
-}
-
 // Measure display width of a string (emoji = 2 cells)
 // eslint-disable-next-line no-control-regex
 const EMOJI_RE = /[\u{1F300}-\u{1FAD6}\u{2600}-\u{27BF}\u{FE00}-\u{FE0F}\u{200D}\u{20E3}\u{E0020}-\u{E007F}]/gu;
@@ -1697,16 +2473,19 @@ function displayWidth(str) {
 
 // Pad string to target display width
 function padToWidth(str, targetW) {
-    const w = displayWidth(str);
+    const text = asDisplayText(str);
+    const w = displayWidth(text);
     const need = Math.max(0, targetW - w);
-    return str + " ".repeat(need);
+    return text + " ".repeat(need);
 }
 
 // Build one swimlane line: place content in a specific column
-function seqLine(time, colIdx, content, color) {
+function seqLine(time, colIdx, content, color, options = {}) {
     const ncols = seqNodes.length || 1;
     const widths = seqColWidths();
     const timeStr = (time || "").padEnd(TIME_W);
+    const displayContent = asDisplayText(content);
+    const underline = options.underline === true;
     let line = `{white-fg}${timeStr}{/white-fg}`;
 
     for (let i = 0; i < ncols; i++) {
@@ -1714,11 +2493,15 @@ function seqLine(time, colIdx, content, color) {
         if (i === colIdx) {
             // Content cell — clip to fit
             const maxContent = w - 2; // 1 space padding each side
-            const clipped = content.length > maxContent ? content.slice(0, maxContent) : content;
-            // Pad the clipped text to maxContent BEFORE applying color tags
-            const padded = padToWidth(clipped, maxContent);
-            const colored = color ? `{${color}-fg}${padded}{/${color}-fg}` : padded;
-            line += ` ${colored} `;
+            const clipped = displayContent.length > maxContent
+                ? safeSlice(displayContent, 0, maxContent)
+                : displayContent;
+            const remaining = Math.max(0, maxContent - displayWidth(clipped));
+            const leftPadding = " ".repeat(Math.floor(remaining / 2));
+            const rightPadding = " ".repeat(remaining - Math.floor(remaining / 2));
+            let styled = color ? `{${color}-fg}${clipped}{/${color}-fg}` : clipped;
+            if (underline) styled = `{underline}${styled}{/underline}`;
+            line += ` ${leftPadding}${styled}${rightPadding} `;
         } else {
             // Empty cell — vertical bar for the swimlane (ASCII | avoids
             // ambiguous-width issues with Unicode box-drawing characters)
@@ -1729,17 +2512,6 @@ function seqLine(time, colIdx, content, color) {
     return line;
 }
 
-// Full-width separator line for CAN / migration events
-function seqSeparator(label, color) {
-    const widths = seqColWidths();
-    const totalW = TIME_W + widths.reduce((a, b) => a + b, 0);
-    const labelStr = ` ${label} `;
-    const dashCount = Math.max(0, totalW - labelStr.length);
-    const left = Math.floor(dashCount / 2);
-    const right = dashCount - left;
-    return `{${color}-fg}${"-".repeat(left)}${labelStr}${"-".repeat(right)}{/${color}-fg}`;
-}
-
 function seqHeader() {
     const widths = seqColWidths();
     let header = "{bold}" + "TIME".padEnd(TIME_W);
@@ -1758,324 +2530,322 @@ function seqHeader() {
 }
 
 /**
- * Parse a raw log line into a sequence event.
- * Returns null if the line isn't relevant for the sequence diagram.
+ * Update the sticky header box with current node columns.
  */
-function parseSeqEvent(plain, podName) {
-    const iMatch = plain.match(/instance_id=(\S+)/);
-    if (!iMatch) return null;
-    const orchId = iMatch[1].replace(/,.*$/, "");
-    if (!orchId.startsWith("session-")) return null;
-
-    const tMatch = plain.match(/\d{4}-\d{2}-\d{2}T(\d{2}:\d{2}:\d{2})/);
-    const time = tMatch ? tMatch[1] : "";
-
-    const orchNode = addSeqNode(podName);
+function updateSeqHeader() {
+    if (seqNodes.length > 0) {
+        const [header, divider] = seqHeader();
+        seqHeaderBox.setContent(`${header}\n${divider}`);
+    } else {
+        seqHeaderBox.setContent("{bold}TIME      (waiting for events){/bold}");
+    }
+}
 
-    // Extract worker node from activity logs
-    // Try local-mode pattern first (local-rt-N), then remote pod pattern
-    const wMatch = plain.match(/worker_id=\S*?(local-rt-\d+)/)
-              || plain.match(/worker_id=work-\d+-(\S+)-rt-\d+/);
-    const actNode = wMatch ? addSeqNode(wMatch[1]) : orchNode;
+/**
+ * Full re-render of the sequence pane for the active session.
+ */
+function refreshSeqPane() {
+    refreshCmsSeqPane();
+}
 
-    // ─── Orchestration events (dots) ──────────
-    if (plain.includes("[turn ")) {
-        const turnMatch = plain.match(/\[turn (\d+)\]/);
-        const promptMatch = plain.match(/prompt="([^"]{0,30})/);
-        return { orchId, time, type: "turn", orchNode, actNode,
-            turn: turnMatch?.[1] || "?",
-            prompt: promptMatch?.[1] || "" };
-    }
-    if (plain.includes("execution start") || plain.includes("[orch] start:")) {
-        const iterMatch = plain.match(/iteration=(\d+)/) || plain.match(/iter=(\d+)/);
-        const hydrate = plain.includes("needsHydration=true") || plain.includes("hydrate=true");
-        return { orchId, time, type: "exec_start", orchNode, actNode,
-            iteration: parseInt(iterMatch?.[1] || "0", 10),
-            hydrate };
-    }
-    if (plain.includes("timer completed")) {
-        const sMatch = plain.match(/seconds=(\d+)/);
-        return { orchId, time, type: "timer_fired", orchNode, actNode,
-            seconds: sMatch?.[1] || "?" };
-    }
-    if (plain.includes("idle timeout")) {
-        return { orchId, time, type: "dehydrate", orchNode, actNode };
-    }
-    if (plain.includes("user responded within idle")) {
-        return { orchId, time, type: "user_idle", orchNode, actNode };
-    }
-    if (plain.includes("wait interrupted")) {
-        return { orchId, time, type: "interrupt", orchNode, actNode };
-    }
+// ─── CMS-Backed Sequence Diagram ─────────────────────────────────
+// Replaces log-parsed sequence data with CMS events from the management client.
+// CMS events have: seq (ordering), created_at (display time), event_type, data, worker_node_id.
 
-    // ─── Activity events (boxes) ──────────
-    if (plain.includes("[activity]") && (plain.includes("activity_name=runAgentTurn") || plain.includes("activity_name=runTurn"))) {
-        if (plain.includes("resuming session")) {
-            return { orchId, time, type: "resume", orchNode, actNode };
-        }
-        if (plain.includes("re-hydrating")) {
-            return { orchId, time, type: "resume", orchNode, actNode };
-        }
-        return { orchId, time, type: "activity_start", orchNode, actNode };
-    }
-    if (plain.includes("activity_name=dehydrateSession")) {
-        return { orchId, time, type: "dehydrate_act", orchNode, actNode };
-    }
-    if (plain.includes("activity_name=hydrateSession")) {
-        return { orchId, time, type: "hydrate_act", orchNode, actNode };
-    }
-    if (plain.includes("activity_name=listModels")) {
-        return { orchId, time, type: "listmodels_act", orchNode, actNode };
-    }
+const cmsSeqTimelines = new Map(); // sessionId → SeqEvent[]
+const cmsSeqLastSeq = new Map();   // sessionId → last seq seen (for incremental poll)
+const ORCHESTRATOR_SEQ_TYPES = new Set([
+    "wait",
+    "timer",
+    "cron_start",
+    "cron_fire",
+    "cron_cancel",
+    "spawn",
+    "cmd_recv",
+    "cmd_done",
+]);
 
-    // ─── Command dispatch events ──────────
-    if (plain.includes("[orch-cmd]")) {
-        const cmdMatch = plain.match(/received command: (\S+)/);
-        if (cmdMatch) {
-            return { orchId, time, type: "cmd_recv", orchNode, actNode,
-                cmd: cmdMatch[1] };
-        }
-        const modelMatch = plain.match(/model changed: (.+)/);
-        if (modelMatch) {
-            return { orchId, time, type: "cmd_done", orchNode, actNode,
-                detail: modelMatch[1] };
-        }
-    }
+function isOrchestratorSeqEventType(type) {
+    return ORCHESTRATOR_SEQ_TYPES.has(type);
+}
 
-    // ─── Grace period dehydration ──────────
-    if (plain.includes("Grace period elapsed, dehydrating")) {
-        return { orchId, time, type: "dehydrate", orchNode, actNode };
-    }
-    // explicit dehydrate log from orchestration
-    if (plain.includes("[orch] dehydrating session")) {
-        return { orchId, time, type: "dehydrate", orchNode, actNode };
-    }
+function getSeqEventNodeId(event) {
+    return event?.displayWorkerNodeId || event?.workerNodeId || "(unknown)";
+}
 
-    // ─── Agent output events ──────────
-    if (plain.includes("[durable-agent] Durable timer") || plain.includes("[orch] durable timer:")) {
-        const sMatch = plain.match(/(?:Durable timer|durable timer):\s*(\d+)s/);
-        return { orchId, time, type: "wait", orchNode, actNode,
-            seconds: sMatch?.[1] || "?" };
-    }
-    if (plain.includes("[durable-agent] Intermediate content") || plain.includes("[orch] intermediate:")) {
-        const cMatch = plain.match(/(?:Intermediate content|intermediate):\s*(.{0,25})/);
-        return { orchId, time, type: "content", orchNode, actNode,
-            snippet: cMatch?.[1] || "…" };
-    }
-    if (plain.includes("[response]")) {
-        const rMatch = plain.match(/\[response\] (.{0,25})/);
-        return { orchId, time, type: "response", orchNode, actNode,
-            snippet: rMatch?.[1] || "" };
+function findPriorActivitySeqNodeId(timeline) {
+    for (let i = timeline.length - 1; i >= 0; i--) {
+        const candidate = timeline[i];
+        if (!candidate || isOrchestratorSeqEventType(candidate.type)) continue;
+        const nodeId = getSeqEventNodeId(candidate);
+        if (nodeId && nodeId !== "(unknown)") return nodeId;
     }
-    // [runTurn] activity log
-    if (plain.includes("[runTurn]")) {
-        return { orchId, time, type: "activity_start", orchNode, actNode };
-    }
-
     return null;
 }
 
-/**
- * Inject a synthetic "user sent a message" marker into the sequence diagram.
- * Called from handleInput so the interaction is visible immediately,
- * without waiting for kubectl logs to stream back.
- */
-function injectSeqUserEvent(orchId, label) {
-    const now = formatDisplayTime(Date.now(), { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    // Find the last node that ran an activity for this session, or fall back to first node
-    const lastAct = seqLastActivityNode.get(orchId) || seqNodes[0];
-    if (!lastAct) return; // no nodes yet
-    const col = seqNodes.indexOf(lastAct);
-    if (col < 0) return;
-
-    const synth = { orchId, time: now, type: "user_msg_synth", orchNode: lastAct, actNode: lastAct, label };
-    appendSeqEvent(orchId, synth);
+function placeCmsSeqEvent(timeline, event) {
+    if (!event) return null;
+    const next = { ...event };
+    if (isOrchestratorSeqEventType(next.type)) {
+        const priorActivityNodeId = findPriorActivitySeqNodeId(timeline);
+        if (priorActivityNodeId) next.displayWorkerNodeId = priorActivityNodeId;
+        next.underline = true;
+    }
+    return next;
 }
 
 /**
- * Append a parsed event and render it if sequence mode is active.
+ * Map a CMS event to a sequence diagram event.
+ * Returns null for event types that shouldn't appear in the diagram.
  */
-function appendSeqEvent(orchId, event) {
-    if (!seqEventBuffers.has(orchId)) seqEventBuffers.set(orchId, []);
-    const buf = seqEventBuffers.get(orchId);
-    buf.push(event);
-    if (buf.length > 300) buf.splice(0, buf.length - 300);
-
-    // Always track which node each session is on (for node map view),
-    // not just when the sequence pane is rendering.
-    if (event.type === "activity_start" || event.type === "resume" || event.type === "hydrate_act") {
-        seqLastActivityNode.set(orchId, event.actNode);
-    } else if (event.actNode && !seqLastActivityNode.has(orchId)) {
-        // First event for this session — use whatever node we see
-        seqLastActivityNode.set(orchId, event.actNode);
-    }
-
-    if (logViewMode === "sequence" && orchId === activeOrchId) {
-        renderSeqEventLine(event, orchId);
-        screen.render();
+function cmsEventToSeqEvent(evt) {
+    const time = evt.createdAt instanceof Date
+        ? formatDisplayTime(evt.createdAt.getTime(), { hour: "2-digit", minute: "2-digit", second: "2-digit" })
+        : "";
+    const node = evt.workerNodeId || "(unknown)";
+    const base = { seq: evt.seq, time, workerNodeId: node };
+
+    switch (evt.eventType) {
+        case "session.turn_started":
+            return { ...base, type: "turn_start", detail: `turn ${evt.data?.iteration ?? "?"}` };
+        case "session.turn_completed":
+            return { ...base, type: "turn_end", detail: `turn ${evt.data?.iteration ?? "?"} done` };
+        case "user.message": {
+            const content = typeof evt.data?.content === "string" ? evt.data.content : "";
+            const snip = summarizeActivityPreview(content, 20);
+            return { ...base, type: "user_msg", detail: snip };
+        }
+        case "assistant.message": {
+            const content = typeof evt.data?.content === "string" ? evt.data.content : "";
+            const snip = summarizeActivityPreview(content, 20);
+            return { ...base, type: "response", detail: snip };
+        }
+        case "session.wait_started":
+            return { ...base, type: "wait", detail: `wait ${evt.data?.seconds ?? "?"}s` };
+        case "session.wait_completed":
+            return { ...base, type: "timer", detail: `${evt.data?.seconds ?? "?"}s up` };
+        case "session.dehydrated":
+            return { ...base, type: "dehydrate", detail: `ZZ ${evt.data?.reason ?? ""}` };
+        case "session.hydrated":
+            return { ...base, type: "hydrate", detail: "^^ rehydrated" };
+        case "session.agent_spawned": {
+            const who = evt.data?.agentId || evt.data?.childSessionId?.slice(0, 8) || "agent";
+            return { ...base, type: "spawn", detail: `spawn ${who}` };
+        }
+        case "session.cron_started":
+            return { ...base, type: "cron_start", detail: `cron ${formatHumanDurationSeconds(evt.data?.intervalSeconds ?? "?")}` };
+        case "session.cron_fired":
+            return { ...base, type: "cron_fire", detail: "cron fired" };
+        case "session.cron_cancelled":
+            return { ...base, type: "cron_cancel", detail: "cron off" };
+        case "session.command_received":
+            return { ...base, type: "cmd_recv", detail: `/${evt.data?.cmd ?? "?"}` };
+        case "session.command_completed":
+            return { ...base, type: "cmd_done", detail: `/${evt.data?.cmd ?? "?"} ok` };
+        case "session.compaction_start":
+            return { ...base, type: "compaction", detail: "compaction…" };
+        case "session.compaction_complete":
+            return { ...base, type: "compaction", detail: "compacted" };
+        case "session.error":
+            return { ...base, type: "error", detail: `err: ${(evt.data?.message || "").slice(0, 20)}` };
+        // Skip purely-data events that don't add visual value
+        case "assistant.usage":
+        case "session.usage_info":
+            return null;
+        default:
+            return null;
     }
 }
 
 /**
- * Render a single event into the sequence pane.
+ * Render a CMS-derived SeqEvent into the sequence pane.
  */
-function renderSeqEventLine(event, orchId) {
-    const lastAct = seqLastActivityNode.get(orchId);
+function renderCmsSeqEventLine(event) {
+    const col = cmsSeqNodeIndex(getSeqEventNodeId(event));
+    const detail = event.detail || "";
+    const lineStyle = event.underline ? { underline: true } : undefined;
 
     switch (event.type) {
-        case "exec_start":
-            // Suppress standalone exec_start — the turn event that always
-            // follows provides enough context. This halves the vertical
-            // density of the diagram.
+        case "turn_start":
+            seqPane.log(seqLine(event.time, col, detail, "gray", lineStyle));
             break;
-
-        case "turn": {
-            const orchCol = seqNodes.indexOf(event.orchNode);
-            seqPane.log(seqLine(event.time, orchCol, `turn ${event.turn}`, "gray"));
+        case "turn_end":
+            // Suppress — turn_start is enough (same as existing log-based behavior)
             break;
-        }
-
-        case "activity_start": {
-            const col = seqNodes.indexOf(event.actNode);
-            if (lastAct !== undefined && lastAct !== event.actNode) {
-                seqPane.log(seqLine(event.time, col, `> ${lastAct}->${event.actNode}`, "yellow"));
-            }
-            seqLastActivityNode.set(orchId, event.actNode);
-            seqPane.log(seqLine(event.time, col, "> agent", "cyan"));
+        case "user_msg":
+            seqPane.log(seqLine(event.time, col, `>> ${detail}`, "white", lineStyle));
             break;
-        }
-
-        case "resume": {
-            const col = seqNodes.indexOf(event.actNode);
-            if (lastAct !== undefined && lastAct !== event.actNode) {
-                seqPane.log(seqLine(event.time, col, `> ${lastAct}->${event.actNode}`, "yellow"));
-            }
-            seqLastActivityNode.set(orchId, event.actNode);
-            seqPane.log(seqLine(event.time, col, "^ resume", "green"));
+        case "response":
+            seqPane.log(seqLine(event.time, col, `< ${detail}`, "green", lineStyle));
             break;
-        }
-
-        case "content": {
-            // Skip verbose streaming-content rows in sequence mode to keep
-            // vertical density high; full content remains in chat pane.
+        case "wait":
+            seqPane.log(seqLine(event.time, col, detail, "yellow", lineStyle));
             break;
-        }
-
-        case "response": {
-            const col = seqNodes.indexOf(lastAct || event.orchNode);
-            const colW = seqColW();
-            const maxSnip = Math.max(3, colW - 8);
-            const snip = (event.snippet || "ok").slice(0, maxSnip);
-            seqPane.log(seqLine(event.time, col, `< ${snip}`, "green"));
+        case "timer":
+            seqPane.log(seqLine(event.time, col, detail, "yellow", lineStyle));
             break;
-        }
-
-        case "wait": {
-            const col = seqNodes.indexOf(lastAct || event.orchNode);
-            seqPane.log(seqLine(event.time, col, `wait ${event.seconds}s`, "yellow"));
+        case "dehydrate":
+            seqPane.log(seqLine(event.time, col, detail, "red", lineStyle));
             break;
-        }
-
-        case "timer_fired": {
-            const col = seqNodes.indexOf(lastAct || event.orchNode);
-            seqPane.log(seqLine(event.time, col, `${event.seconds}s up`, "yellow"));
+        case "hydrate":
+            seqPane.log(seqLine(event.time, col, detail, "green", lineStyle));
             break;
-        }
-
-        case "dehydrate": {
-            const col = seqNodes.indexOf(lastAct || event.orchNode);
-            seqPane.log(seqLine(event.time, col, "ZZ dehydrate", "red"));
+        case "spawn":
+            seqPane.log(seqLine(event.time, col, detail, "cyan", lineStyle));
             break;
-        }
-
-        case "dehydrate_act": {
-            const col = seqNodes.indexOf(event.actNode);
-            seqPane.log(seqLine(event.time, col, "ZZ > blob", "red"));
+        case "cron_start":
+            seqPane.log(seqLine(event.time, col, detail, "magenta", lineStyle));
             break;
-        }
-
-        case "hydrate_act": {
-            const col = seqNodes.indexOf(event.actNode);
-            seqPane.log(seqLine(event.time, col, "^^ < blob", "green"));
+        case "cron_fire":
+            seqPane.log(seqLine(event.time, col, detail, "magenta", lineStyle));
             break;
-        }
-
-        case "user_idle": {
-            const col = seqNodes.indexOf(lastAct || event.orchNode);
-            seqPane.log(seqLine(event.time, col, ">> user msg", "cyan"));
+        case "cron_cancel":
+            seqPane.log(seqLine(event.time, col, detail, "magenta", lineStyle));
             break;
-        }
-
-        case "interrupt": {
-            const col = seqNodes.indexOf(lastAct || event.orchNode);
-            seqPane.log(seqLine(event.time, col, ">> interrupt", "cyan"));
+        case "cmd_recv":
+            seqPane.log(seqLine(event.time, col, `>> ${detail}`, "magenta", lineStyle));
             break;
-        }
-
-        case "user_msg_synth": {
-            const col = seqNodes.indexOf(event.orchNode);
-            const snip = event.label && event.label.length > 12 ? event.label.slice(0, 12) + "…" : (event.label || "msg");
-            seqPane.log(seqLine(event.time, col, `>> ${snip}`, "white"));
+        case "cmd_done":
+            seqPane.log(seqLine(event.time, col, `<< ${detail}`, "magenta", lineStyle));
             break;
-        }
-
-        case "cmd_recv": {
-            const col = seqNodes.indexOf(event.orchNode);
-            seqPane.log(seqLine(event.time, col, `>> /${event.cmd}`, "magenta"));
+        case "compaction":
+            seqPane.log(seqLine(event.time, col, detail, "gray", lineStyle));
+            break;
+        case "error":
+            seqPane.log(seqLine(event.time, col, detail, "red", lineStyle));
             break;
+    }
+}
+
+function getSeqAggregationKey(event) {
+    if (!event) return null;
+    const nodeId = getSeqEventNodeId(event);
+    if (event.type === "spawn") {
+        return `spawn:${nodeId}`;
+    }
+    if (isOrchestratorSeqEventType(event.type) && event.detail) {
+        return `${event.type}:${nodeId}:${event.detail}`;
+    }
+    return null;
+}
+
+function collapseSeqEventsForRender(events) {
+    const collapsed = [];
+    for (const event of events) {
+        const prev = collapsed[collapsed.length - 1];
+        const eventKey = getSeqAggregationKey(event);
+        const prevKey = getSeqAggregationKey(prev);
+
+        if (eventKey && prevKey && eventKey === prevKey) {
+            prev.aggregateCount = (prev.aggregateCount || 1) + 1;
+            if (prev.type === "spawn") {
+                prev.detail = `spawn ×${prev.aggregateCount}`;
+            } else {
+                prev.detail = `${prev.baseDetail || prev.detail} ×${prev.aggregateCount}`;
+            }
+            continue;
         }
 
-        case "cmd_done": {
-            const col = seqNodes.indexOf(event.orchNode);
-            seqPane.log(seqLine(event.time, col, `<< ${(event.detail || "ok").slice(0, 15)}`, "magenta"));
-            break;
+        const next = { ...event, aggregateCount: 1, baseDetail: event.detail };
+        collapsed.push(next);
+    }
+    return collapsed;
+}
+
+/** Ensure a worker node is tracked in the sequence column list. Returns its index. */
+function cmsSeqNodeIndex(workerNodeId) {
+    const short = workerNodeId ? safeTail(workerNodeId, 5) : "(unk)";
+    if (!seqNodeSet.has(short)) {
+        seqNodeSet.add(short);
+        seqNodes.push(short);
+        if (logViewMode === "sequence") updateSeqHeader();
+    }
+    return seqNodes.indexOf(short);
+}
+
+/**
+ * Load the full CMS event timeline for a session.
+ * Called on session switch and TUI startup.
+ */
+async function loadCmsSeqTimeline(sessionId) {
+    try {
+        const events = await mgmt.getSessionEvents(sessionId);
+        const timeline = [];
+        for (const evt of events) {
+            const seqEvt = placeCmsSeqEvent(timeline, cmsEventToSeqEvent(evt));
+            if (seqEvt) timeline.push(seqEvt);
         }
+        cmsSeqTimelines.set(sessionId, timeline);
+        cmsSeqLastSeq.set(sessionId, events.length > 0 ? events[events.length - 1].seq : 0);
 
-        case "listmodels_act": {
-            const col = seqNodes.indexOf(event.actNode);
-            seqPane.log(seqLine(event.time, col, "[= listModels]", "magenta"));
-            break;
+        // Discover worker nodes from events
+        for (const evt of timeline) {
+            const nodeId = getSeqEventNodeId(evt);
+            if (nodeId) cmsSeqNodeIndex(nodeId);
         }
+    } catch (err) {
+        // CMS not available — the log-based path will still work as fallback
     }
-    // Don't render here — callers batch renders
 }
 
 /**
- * Update the sticky header box with current node columns.
+ * Incrementally poll for new CMS events for a session.
+ * Appends to existing timeline and renders if sequence mode is active.
  */
-function updateSeqHeader() {
-    if (seqNodes.length > 0) {
-        const [header, divider] = seqHeader();
-        seqHeaderBox.setContent(`${header}\n${divider}`);
-    } else {
-        seqHeaderBox.setContent("{bold}TIME      (waiting for events){/bold}");
-    }
+async function pollCmsSeqEvents(sessionId) {
+    try {
+        const afterSeq = cmsSeqLastSeq.get(sessionId) || 0;
+        const events = await mgmt.getSessionEvents(sessionId, afterSeq, 100);
+        if (events.length === 0) return;
+
+        const timeline = cmsSeqTimelines.get(sessionId) || [];
+        for (const evt of events) {
+            const seqEvt = placeCmsSeqEvent(timeline, cmsEventToSeqEvent(evt));
+            if (seqEvt) {
+                const nodeId = getSeqEventNodeId(seqEvt);
+                if (nodeId) cmsSeqNodeIndex(nodeId);
+                timeline.push(seqEvt);
+                // Render incrementally if this is the active session in sequence mode
+                const orchId = `session-${sessionId}`;
+                if (logViewMode === "sequence" && orchId === activeOrchId) {
+                    refreshCmsSeqPane();
+                }
+            }
+        }
+        cmsSeqTimelines.set(sessionId, timeline);
+        cmsSeqLastSeq.set(sessionId, events[events.length - 1].seq);
+
+        // Cap timeline at 300 events
+        if (timeline.length > 300) timeline.splice(0, timeline.length - 300);
+
+        if (logViewMode === "sequence" && `session-${sessionId}` === activeOrchId) {
+            screen.render();
+        }
+    } catch {}
 }
 
 /**
- * Full re-render of the sequence pane for the active session.
+ * Full re-render of the CMS-backed sequence pane for the active session.
  */
-function refreshSeqPane() {
+function refreshCmsSeqPane() {
     seqPane.setContent("");
     const seqShortId = shortId(activeOrchId);
     seqPane.setLabel(` Sequence: ${seqShortId} `);
-
-    // Update sticky header
     updateSeqHeader();
 
-    // Reset tracking state for this render pass
-    seqLastActivityNode.delete(activeOrchId);
+    const sessionId = activeOrchId?.replace("session-", "");
+    const timeline = sessionId ? cmsSeqTimelines.get(sessionId) : null;
 
-    const events = seqEventBuffers.get(activeOrchId);
-    if (events && events.length > 0) {
-        const renderEvents = events.length > MAX_SEQ_RENDER_EVENTS
-            ? events.slice(-MAX_SEQ_RENDER_EVENTS)
-            : events;
-        if (events.length > MAX_SEQ_RENDER_EVENTS) {
-            seqPane.log(`{gray-fg}… showing last ${MAX_SEQ_RENDER_EVENTS} of ${events.length} events …{/gray-fg}`);
+    if (timeline && timeline.length > 0) {
+        const renderEvents = timeline.length > MAX_SEQ_RENDER_EVENTS
+            ? timeline.slice(-MAX_SEQ_RENDER_EVENTS)
+            : timeline;
+        const collapsedEvents = collapseSeqEventsForRender(renderEvents);
+        if (timeline.length > MAX_SEQ_RENDER_EVENTS) {
+            seqPane.log(`{gray-fg}… showing last ${MAX_SEQ_RENDER_EVENTS} of ${timeline.length} events …{/gray-fg}`);
         }
-        for (const event of renderEvents) {
-            renderSeqEventLine(event, activeOrchId);
+        for (const event of collapsedEvents) {
+            renderCmsSeqEventLine(event);
         }
     } else {
         seqPane.log("{white-fg}No events yet — interact with this session to populate{/white-fg}");
@@ -2088,8 +2858,9 @@ function refreshSeqPane() {
 
 function appendOrchLog(orchId, podName, text) {
     if (!orchLogBuffers.has(orchId)) orchLogBuffers.set(orchId, []);
-    const color = getPodColor(podName);
-    const shortPod = podName.slice(-5);
+    const normalizedPodName = normalizePodName(podName);
+    const color = getPodColor(normalizedPodName);
+    const shortPod = safeTail(normalizedPodName, 5);
     const coloredLine = `{${color}-fg}[${shortPod}]{/${color}-fg} ${text}`;
     orchLogBuffers.get(orchId).push(coloredLine);
     // Cap buffer at 500 lines
@@ -2236,11 +3007,12 @@ function backfillOrchLogs(orchId) {
 }
 
 function getOrCreateWorkerPane(podName) {
+    podName = normalizePodName(podName);
     if (workerPanes.has(podName)) return workerPanes.get(podName);
 
     const color = paneColors[nextColorIdx++ % paneColors.length];
     // Short name: last 5 chars of pod name
-    const shortName = podName.slice(-5);
+    const shortName = safeTail(podName, 5);
 
     const pane = blessed.log({
         parent: screen,
@@ -2262,17 +3034,18 @@ function getOrCreateWorkerPane(podName) {
         scrollbar: { style: { bg: color } },
         keys: true,
         vi: true,
-        mouse: false,
+        mouse: true,
     });
 
     workerPanes.set(podName, pane);
     workerPaneOrder.push(podName);
+    registerSelectablePane(pane, `worker ${shortName}`);
     registerFocusRing(pane, color);
     pane.on("focus", () => setNavigationStatusForPane("workers"));
 
     // Register this pod as a sequence diagram column so all nodes
     // appear regardless of whether the active session has used them.
-    addSeqNode(podName);
+    cmsSeqNodeIndex(podName);
 
     relayoutAll();
     return pane;
@@ -2423,7 +3196,7 @@ function redrawActiveViews() {
 
 // ─── Input bar ───────────────────────────────────────────────────
 
-const inputBar = blessed.textarea({
+inputBar = blessed.textarea({
     parent: screen,
     label: " {bold}you:{/bold} ",
     tags: true,
@@ -2464,13 +3237,69 @@ function clampInputCursor(index, value = inputBar.getValue()) {
 }
 
 function getInputInnerWidth() {
+    if (!inputBar) return Math.max(1, screen.width - 2);
     const numericWidth = typeof inputBar.width === "number" ? inputBar.width : screen.width;
     return Math.max(1, numericWidth - (inputBar.iwidth || 2));
 }
 
+function getInputWrapWidth() {
+    // neo-blessed textarea reserves one extra cell of right margin for the
+    // cursor, so wrapping happens at innerWidth - 1 rather than innerWidth.
+    const margin = 1 + (inputBar?.scrollbar ? 1 : 0);
+    return Math.max(1, getInputInnerWidth() - margin);
+}
+
+function getInputStringWidth(text) {
+    if (typeof inputBar?.strWidth === "function") {
+        return inputBar.strWidth(String(text || ""));
+    }
+    return displayWidth(text);
+}
+
+function getRawInputCursorPosition(value, cursorIndex) {
+    const text = String(value || "");
+    const target = clampInputCursor(cursorIndex, text);
+    let line = 0;
+    let column = 0;
+
+    for (let i = 0; i < target; i++) {
+        if (text[i] === "\n") {
+            line += 1;
+            column = 0;
+            continue;
+        }
+        column += 1;
+    }
+
+    return { line, column };
+}
+
 function getCursorVisualPosition(value, cursorIndex) {
     const text = String(value || "");
-    const width = getInputInnerWidth();
+    const clines = inputBar?._clines;
+    if (clines?.ftor && clines.content === text) {
+        const { line: rawLineIndex, column: rawColumn } = getRawInputCursorPosition(text, cursorIndex);
+        const wrappedIndexes = clines.ftor[rawLineIndex] || [];
+
+        if (wrappedIndexes.length > 0) {
+            let remaining = rawColumn;
+            for (let index = 0; index < wrappedIndexes.length; index++) {
+                const wrappedLineIndex = wrappedIndexes[index];
+                const wrappedText = clines[wrappedLineIndex] || "";
+                const segmentLength = wrappedText.length;
+                const isLastSegment = index === wrappedIndexes.length - 1;
+
+                if (remaining <= segmentLength || isLastSegment) {
+                    const visiblePrefix = wrappedText.slice(0, Math.min(remaining, segmentLength));
+                    return { row: wrappedLineIndex, col: getInputStringWidth(visiblePrefix) };
+                }
+
+                remaining -= segmentLength;
+            }
+        }
+    }
+
+    const width = getInputWrapWidth();
     let row = 0;
     let col = 0;
 
@@ -2481,11 +3310,12 @@ function getCursorVisualPosition(value, cursorIndex) {
             col = 0;
             continue;
         }
-        col += 1;
-        if (col >= width) {
+        const chWidth = Math.max(1, displayWidth(ch));
+        if (col > 0 && col + chWidth > width) {
             row += 1;
             col = 0;
         }
+        col += chWidth;
     }
 
     return { row, col };
@@ -3010,6 +3840,7 @@ function appendLog(text) {
 }
 
 function appendWorkerLog(podName, text, orchId) {
+    podName = normalizePodName(podName);
     const pane = getOrCreateWorkerPane(podName);
     // Buffer raw entry for recoloring on session switch
     if (!workerLogBuffers.has(podName)) workerLogBuffers.set(podName, []);
@@ -3058,42 +3889,167 @@ function recolorWorkerPanes() {
         });
         totalLines += Math.min(buf.length, MAX_WORKER_RENDER_LINES);
     }
-    screen.render();
-    perfEnd(_ph, { panes: paneCount, lines: totalLines });
+    screen.render();
+    perfEnd(_ph, { panes: paneCount, lines: totalLines });
+}
+
+function showCopilotMessage(raw, orchId) {
+    const _ph = perfStart("showCopilotMessage");
+    stopChatSpinner(orchId);
+    const prefix = `{white-fg}[${ts()}]{/white-fg} {cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`;
+    const { lines } = buildAssistantChatLines(raw, orchId, prefix);
+
+    // Try to replace the preview lines in-place so the frame loop sees a
+    // single buffer mutation instead of a shrink-then-grow.  This avoids
+    // the scroll-position jump that setContent() causes when the total
+    // line count changes between frames.
+    if (!replaceAssistantPreviewInPlace(orchId, raw, lines)) {
+        // No matching preview — append normally.
+        for (const line of lines) {
+            appendChatRaw(line, orchId);
+        }
+    }
+    perfEnd(_ph, { len: raw?.length || 0 });
+}
+
+function isRenderedTableLikeLine(line) {
+    const trimmed = String(line || "").trim();
+    if (!trimmed) return false;
+    if (isMarkdownTableLine(trimmed)) return true;
+    return /^[┌├└│+|]/.test(trimmed);
+}
+
+function buildPrefixedRenderedLines(prefix, rendered, options = {}) {
+    const trailingBlank = options.trailingBlank !== false;
+    const renderedLines = String(rendered || "").split("\n");
+    const firstContentLineIndex = renderedLines.findIndex((line) => line.trim() !== "");
+    const startsWithTable = firstContentLineIndex >= 0
+        && isRenderedTableLikeLine(renderedLines[firstContentLineIndex]);
+    const lines = startsWithTable
+        ? [prefix, ...renderedLines]
+        : (() => {
+            const [firstLine = "", ...rest] = renderedLines;
+            return [firstLine ? `${prefix} ${firstLine}` : prefix, ...rest];
+        })();
+    if (trailingBlank) lines.push("");
+    return lines;
+}
+
+function stripAssistantHeadingLine(text) {
+    return typeof text === "string"
+        ? text.replace(/^HEADING:.*\n?/m, "").trim()
+        : "";
+}
+
+function normalizeObserverChatText(text) {
+    if (typeof text !== "string") return "";
+    return text.replace(/\r\n/g, "\n").trim();
+}
+
+function normalizeAssistantPreviewText(text) {
+    return normalizeObserverChatText(stripAssistantHeadingLine(text));
+}
+
+function removeChatLineSequence(buffer, lines, replacementLines) {
+    if (!Array.isArray(buffer) || !Array.isArray(lines) || lines.length === 0) return false;
+    for (let start = buffer.length - lines.length; start >= 0; start--) {
+        let matches = true;
+        for (let offset = 0; offset < lines.length; offset++) {
+            if (buffer[start + offset] !== lines[offset]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            if (replacementLines) {
+                buffer.splice(start, lines.length, ...replacementLines);
+            } else {
+                buffer.splice(start, lines.length);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+function stripRenderedChatFormatting(text) {
+    return String(text || "")
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-9;]*m/g, "")
+        .replace(/\{[^}]*\}/g, "");
+}
+
+function prepareAssistantChatRender(raw, orchId, options = {}) {
+    const sourceText = typeof raw === "string" ? raw : "";
+    const bodyText = options.stripHeading === true
+        ? stripAssistantHeadingLine(sourceText)
+        : sourceText;
+
+    detectArtifactLinks(sourceText, orchId);
+
+    const renderedText = renderMarkdown(renderArtifactLinks(bodyText));
+    return {
+        sourceText,
+        bodyText,
+        renderedText: options.stripFormatting === true
+            ? stripRenderedChatFormatting(renderedText)
+            : renderedText,
+    };
+}
+
+function buildAssistantChatLines(raw, orchId, prefix, options = {}) {
+    const { trailingBlank, lineDecorator } = options;
+    const { bodyText, renderedText } = prepareAssistantChatRender(raw, orchId, options);
+    let lines = buildPrefixedRenderedLines(prefix, renderedText, { trailingBlank });
+    if (typeof lineDecorator === "function") {
+        lines = lines.map((line) => lineDecorator(line, bodyText));
+    }
+    return { bodyText, renderedText, lines };
 }
 
-function showCopilotMessage(raw, orchId) {
-    const _ph = perfStart("showCopilotMessage");
-    stopChatSpinner(orchId);
+function replaceAssistantPreviewInPlace(orchId, matchingText, replacementLines) {
+    const preview = sessionPendingAssistantPreview.get(orchId);
+    if (!preview) return false;
 
-    appendActivity(`{green-fg}[obs] showCopilotMessage called for ${orchId === activeOrchId ? "ACTIVE" : "background"} session, len=${raw?.length || 0}{/green-fg}`, orchId);
+    if (matchingText != null) {
+        const normalized = normalizeAssistantPreviewText(matchingText);
+        if (!normalized || normalized !== preview.normalized) return false;
+    }
 
-    // Detect and register artifact links before rendering
-    detectArtifactLinks(raw, orchId);
+    const buffer = sessionChatBuffers.get(orchId);
+    if (!buffer) return false;
 
-    // Replace artifact:// URIs with highlighted display before markdown rendering
-    let displayRaw = raw;
-    if (displayRaw) {
-        displayRaw = displayRaw.replace(
-            /artifact:\/\/[a-f0-9-]+\/([^\s"'{}]+)/g,
-            "📎 **$1** _(press 'a' to download)_",
-        );
-    }
+    const spliced = removeChatLineSequence(buffer, preview.lines, replacementLines);
+    sessionPendingAssistantPreview.delete(orchId);
+    if (spliced && orchId === activeOrchId) invalidateChat();
+    return spliced;
+}
 
-    const rendered = renderMarkdown(displayRaw);
-    const prefix = `{white-fg}[${ts()}]{/white-fg} {cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`;
-    appendChatRaw(prefix, orchId);
-    // Always show on separate lines for readability
-    for (const line of rendered.split("\n")) {
-        appendChatRaw(line, orchId);
-    }
-    appendChatRaw("", orchId); // blank line after each message
-    perfEnd(_ph, { len: raw?.length || 0 });
+function clearPendingAssistantPreview(orchId, matchingText) {
+    return replaceAssistantPreviewInPlace(orchId, matchingText, null);
 }
 
-function normalizeObserverChatText(text) {
-    if (typeof text !== "string") return "";
-    return text.replace(/\r\n/g, "\n").trim();
+function showLiveAssistantPreview(raw, orchId) {
+    const normalized = normalizeAssistantPreviewText(raw);
+    if (!normalized) return;
+    if (sessionPromotedIntermediate.get(orchId) === normalized) return;
+    if (sessionRecoveredTurnResult.get(orchId) === normalized) return;
+
+    const existing = sessionPendingAssistantPreview.get(orchId);
+    if (existing?.normalized === normalized) return;
+
+    clearPendingAssistantPreview(orchId);
+
+    const { lines: previewLines } = buildAssistantChatLines(raw, orchId, `[${ts()}] Copilot [preview]:`, {
+        stripHeading: true,
+        stripFormatting: true,
+        lineDecorator: (line) => line ? `{gray-fg}${line}{/gray-fg}` : "",
+    });
+
+    for (const line of previewLines) {
+        appendChatRaw(line, orchId);
+    }
+    sessionPendingAssistantPreview.set(orchId, { normalized, lines: previewLines });
 }
 
 function promoteIntermediateContent(raw, orchId) {
@@ -3106,6 +4062,7 @@ function promoteIntermediateContent(raw, orchId) {
 
 function shouldSkipCompletedTurnResult(raw, orchId) {
     const normalized = normalizeObserverChatText(raw);
+    clearPendingAssistantPreview(orchId);
     const promoted = sessionPromotedIntermediate.get(orchId);
     sessionPromotedIntermediate.delete(orchId);
     const recovered = sessionRecoveredTurnResult.get(orchId);
@@ -3130,8 +4087,7 @@ function isBootstrapPromptForSession(text, orchId) {
     });
 }
 
-// Track whether sequence view has been seeded from CMS for a session.
-const seqCmsSeededSessions = new Set();
+
 
 /**
  * Load conversation history from CMS and rebuild chat buffer for the session.
@@ -3203,6 +4159,8 @@ async function loadCmsHistory(orchId, options = {}) {
                         : liveStatus.customStatus;
                 } catch {}
             }
+            updateSessionCronSchedule(orchId, liveCustomStatus);
+            updateSessionContextUsageFromStatus(orchId, liveCustomStatus);
             if (liveCustomStatus?.responseVersion) {
                 liveResponsePayload = await fetchLatestResponsePayload(orchId, dc);
             }
@@ -3218,6 +4176,9 @@ async function loadCmsHistory(orchId, options = {}) {
                 sessionModels.set(orchId, info.model);
                 if (orchId === activeOrchId) updateChatLabel();
             }
+            if (info?.contextUsage) {
+                noteSessionContextUsage(orchId, info.contextUsage);
+            }
 
             if ((!events || events.length === 0) && !liveTurnContent) {
                 if (sessionHistoryLoadGeneration.get(orchId) !== generation) {
@@ -3255,7 +4216,10 @@ async function loadCmsHistory(orchId, options = {}) {
             const stripHostPrefix = (text) => text?.replace(/^\[SYSTEM: Running on host "[^"]*"\.\]\n\n/, "") || text;
 
             // Filter out internal timer continuation prompts — these aren't real user messages
-            const isTimerPrompt = (text) => /^The \d+ second wait is now complete\./i.test(text);
+            const isTimerPrompt = (text) =>
+                /^The \d+ second wait is now complete\./i.test(text)
+                || /^The wait was partially completed \(/i.test(text)
+                || /^Resume the wait for the remaining \d+/i.test(text);
 
             const lines = [];
             const fmtTime = (value) => {
@@ -3297,9 +4261,10 @@ async function loadCmsHistory(orchId, options = {}) {
                             const updateType = childMatch[2];
                             const body = (childMatch[4] || "").trim();
                             const childTitle = sessionHeadings.get(`session-${childMatch[1]}`) || `Agent ${childId}`;
-                            const typeColor = updateType === "completed" ? "green" : updateType === "error" ? "red" : "magenta";
+                            const typeIcon = updateType === "completed" ? "✅" : updateType === "error" ? "❌" : "📡";
+                            const typeColor = updateType === "completed" ? "green" : updateType === "error" ? "red" : "yellow";
                             lines.push(`{white-fg}[${timeStr}]{/white-fg}`);
-                            lines.push(`{${typeColor}-fg}┌─ {bold}${childTitle}{/bold} · ${updateType} ─┐{/${typeColor}-fg}`);
+                            lines.push(`{${typeColor}-fg}┌─ ${typeIcon} {bold}${childTitle}{/bold} · ${updateType} ${"─".repeat(Math.max(1, 30 - childTitle.length))}┐{/${typeColor}-fg}`);
                             if (body) {
                                 const bodyLines = body.split("\n");
                                 for (const bl of bodyLines.slice(0, 8)) {
@@ -3309,7 +4274,7 @@ async function loadCmsHistory(orchId, options = {}) {
                                     lines.push(`{${typeColor}-fg}│{/${typeColor}-fg}  {gray-fg}… ${bodyLines.length - 8} more lines{/gray-fg}`);
                                 }
                             }
-                            lines.push(`{${typeColor}-fg}└${"─".repeat(30)}┘{/${typeColor}-fg}`);
+                            lines.push(`{${typeColor}-fg}└${"─".repeat(40)}┘{/${typeColor}-fg}`);
                             lines.push("");
                         } else {
                             lines.push(`{white-fg}[${timeStr}]{/white-fg} {bold}You:{/bold} ${content}`);
@@ -3319,7 +4284,6 @@ async function loadCmsHistory(orchId, options = {}) {
                     const content = evt.data?.content;
                     if (content) {
                         lastAssistantContent = content;
-                        detectArtifactLinks(content, orchId);
                         if (renderedChars >= MAX_TOTAL_RENDER_CHARS) {
                             lines.push(`{gray-fg}── additional assistant output omitted to keep session switching fast ──{/gray-fg}`);
                             lines.push("");
@@ -3328,17 +4292,12 @@ async function loadCmsHistory(orchId, options = {}) {
                         const clipped = content.length > MAX_ASSISTANT_MESSAGE_CHARS
                             ? content.slice(0, MAX_ASSISTANT_MESSAGE_CHARS) + "\n\n[output truncated in TUI history view]"
                             : content;
-                        const displayClipped = clipped.replace(
-                            /artifact:\/\/[a-f0-9-]+\/([^\s"'{}]+)/g,
-                            "📎 **$1** _(press 'a' to download)_",
-                        );
-                        lines.push(`{white-fg}[${timeStr}]{/white-fg} {cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`);
-                        const rendered = renderMarkdown(displayClipped);
                         renderedChars += clipped.length;
-                        for (const line of rendered.split("\n")) {
-                            lines.push(line);
-                        }
-                        lines.push("");
+                        lines.push(...buildAssistantChatLines(
+                            clipped,
+                            orchId,
+                            `{white-fg}[${timeStr}]{/white-fg} {cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`,
+                        ).lines);
                     }
                 } else if (type === "tool.execution_start") {
                     activityLines.push(formatToolActivityLine(timeStr, evt, "start"));
@@ -3368,13 +4327,12 @@ async function loadCmsHistory(orchId, options = {}) {
                 const clippedLiveTurn = liveTurnContent.length > MAX_ASSISTANT_MESSAGE_CHARS
                     ? liveTurnContent.slice(0, MAX_ASSISTANT_MESSAGE_CHARS) + "\n\n[output truncated in TUI history view]"
                     : liveTurnContent;
-                lines.push(`{white-fg}[${fmtTime(Date.now())}]{/white-fg} {cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`);
-                const renderedLiveTurn = renderMarkdown(clippedLiveTurn);
                 renderedChars += clippedLiveTurn.length;
-                for (const line of renderedLiveTurn.split("\n")) {
-                    lines.push(line);
-                }
-                lines.push("");
+                lines.push(...buildAssistantChatLines(
+                    clippedLiveTurn,
+                    orchId,
+                    `{white-fg}[${fmtTime(Date.now())}]{/white-fg} {cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`,
+                ).lines);
                 sessionRecoveredTurnResult.set(orchId, normalizedLiveTurn);
                 noteSeenResponseVersion(orchId, liveResponsePayload?.version);
             } else {
@@ -3408,12 +4366,8 @@ async function loadCmsHistory(orchId, options = {}) {
             // replacement would nuke it without this check.
             const pendingQ = sessionPendingQuestions.get(orchId);
             if (pendingQ) {
-                lines.push(`{cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`);
                 const renderedQ = renderMarkdown(pendingQ);
-                for (const line of renderedQ.split("\n")) {
-                    lines.push(line);
-                }
-                lines.push("");
+                lines.push(...buildPrefixedRenderedLines(`{cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`, renderedQ));
             }
 
             // If CMS history produced no chat-visible lines (only the footer),
@@ -3441,7 +4395,19 @@ async function loadCmsHistory(orchId, options = {}) {
             } else {
                 sessionChatBuffers.set(orchId, lines);
             }
-            sessionActivityBuffers.set(orchId, activityLines);
+            // Guard: don't replace existing activity with an empty array.
+            // The observer may have already appended live entries; nuking
+            // them with an empty CMS result causes a blank Activity pane.
+            const existingActivity = sessionActivityBuffers.get(orchId);
+            const existingActivityHasContent = existingActivity && existingActivity.length > 0
+                && existingActivity.some(l => l && !/no recent/.test(l));
+            if (activityLines.length === 0 && existingActivityHasContent) {
+                // keep observer-written activity intact
+            } else if (activityLines.length === 0) {
+                sessionActivityBuffers.set(orchId, ["{gray-fg}(no recent activity yet){/gray-fg}"]);
+            } else {
+                sessionActivityBuffers.set(orchId, activityLines);
+            }
             sessionHistoryLoadedAt.set(orchId, Date.now());
             sessionRenderedCmsSeq.set(orchId, maxRenderedSeq);
 
@@ -3450,33 +4416,6 @@ async function loadCmsHistory(orchId, options = {}) {
                 invalidateActivity();
             }
 
-            if (!seqCmsSeededSessions.has(orchId)) {
-                const existingSeq = seqEventBuffers.get(orchId) ?? [];
-                if (existingSeq.length === 0) {
-                    const cmsNode = addSeqNode("cms");
-                    const seeded = [];
-                    for (const evt of events) {
-                        const t = fmtTime(evt.createdAt);
-                        if (evt.eventType === "user.message") {
-                            const txt = stripHostPrefix(evt.data?.content || "");
-                            if (txt && !isTimerPrompt(txt)) {
-                                seeded.push({ type: "user_msg_synth", time: t, orchNode: cmsNode, actNode: cmsNode, label: txt });
-                            }
-                        } else if (evt.eventType === "assistant.message") {
-                            const txt = evt.data?.content || "";
-                            if (txt) {
-                                seeded.push({ type: "response", time: t, orchNode: cmsNode, actNode: cmsNode, snippet: txt.slice(0, 40) });
-                            }
-                        } else if (evt.eventType === "tool.execution_start") {
-                            seeded.push({ type: "activity_start", time: t, orchNode: cmsNode, actNode: cmsNode });
-                        }
-                    }
-                    if (seeded.length > 0) {
-                        seqEventBuffers.set(orchId, seeded);
-                    }
-                }
-                seqCmsSeededSessions.add(orchId);
-            }
         } catch (err) {
             loadFailed = true;
             appendLog(`{yellow-fg}CMS history load failed: ${err.message}{/yellow-fg}`);
@@ -3508,6 +4447,62 @@ const duroxideSchema = process.env.DUROXIDE_SCHEMA || undefined;
 const numWorkers = parseInt(process.env.WORKERS ?? "4", 10);
 const isRemote = numWorkers === 0;
 
+// Register startup quit handlers before any embedded worker startup so the
+// first local run can always be interrupted, even if worker boot blocks.
+let _startupQuit = false;
+let _startupPhase = true;
+let _embeddedWorkerStartupInProgress = false;
+screen.key(["C-c"], () => {
+    if (_startupPhase) { _startupQuit = true; exitProcessNow(0); }
+});
+const _startupQHandler = () => {
+    if (_startupPhase) { _startupQuit = true; exitProcessNow(0); }
+};
+screen.key(["q"], _startupQHandler);
+
+async function failStartupAndExit(message) {
+    console.error(`[PilotSwarm TUI] ${message}`);
+    setStatus(`{red-fg}${message}{/red-fg}`);
+    chatBox.setContent(
+        `${ACTIVE_STARTUP_SPLASH_CONTENT}\n\n  {red-fg}${message}{/red-fg}\n\n  ` +
+        `{gray-fg}Embedded local mode only supports one TUI per workspace at a time. ` +
+        `Use remote mode for multiple concurrent windows.{/gray-fg}`,
+    );
+    _origRender();
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    exitProcessNow(1);
+}
+
+function handleTerminationSignal(signal) {
+    if (_startupPhase) {
+        _startupQuit = true;
+        exitProcessNow(SIGNAL_EXIT_CODES[signal] ?? 0);
+        return;
+    }
+    void requestQuit();
+}
+
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => {
+        handleTerminationSignal(signal);
+    });
+}
+
+setStatus(isRemote ? "Connecting to remote DB..." : `Starting ${numWorkers} local workers...`);
+chatBox.setContent(
+    `${ACTIVE_STARTUP_SPLASH_CONTENT}\n\n  {white-fg}${isRemote ? "Connecting..." : `Starting ${numWorkers} embedded workers...`}{/white-fg}`,
+);
+_origRender();
+
+if (!isRemote) {
+    try {
+        acquireLocalEmbeddedRuntimeLock(store);
+    } catch (err) {
+        const message = err?.message || String(err);
+        await failStartupAndExit(message);
+    }
+}
+
 if (isRemote) {
     const title = formatWindowTitle("Scaled — Remote Workers");
     screen.title = title;
@@ -3529,6 +4524,7 @@ appendLog("");
 const workers = [];
 let modelProviders = null;
 let logTailInterval = null;
+let firstLocalWorkerStarted = Promise.resolve();
 // Default model — prefer registry defaultModel, env override, then empty (worker picks default).
 let currentModel = process.env.COPILOT_MODEL || "";
 if (!isRemote) {
@@ -3550,6 +4546,31 @@ if (!isRemote) {
     process.stdout.write = () => true;
     process.stderr.write = () => true;
 
+    const restoreBootstrapStdio = () => {
+        process.stdout.write = origStdoutWrite;
+        process.stderr.write = origStderrWrite;
+    };
+
+    let resolveFirstLocalWorkerStarted;
+    let rejectFirstLocalWorkerStarted;
+    let firstLocalWorkerSettled = false;
+    firstLocalWorkerStarted = new Promise((resolve, reject) => {
+        resolveFirstLocalWorkerStarted = resolve;
+        rejectFirstLocalWorkerStarted = reject;
+    });
+
+    const noteFirstLocalWorkerStarted = () => {
+        if (firstLocalWorkerSettled) return;
+        firstLocalWorkerSettled = true;
+        resolveFirstLocalWorkerStarted();
+    };
+
+    const noteAllLocalWorkersFailed = (err) => {
+        if (firstLocalWorkerSettled) return;
+        firstLocalWorkerSettled = true;
+        rejectFirstLocalWorkerStarted(err);
+    };
+
     // System message: env override > worker module > default agent (from plugin)
     const WORKER_SYSTEM_MESSAGE = process.env._TUI_SYSTEM_MESSAGE || undefined;
 
@@ -3583,69 +4604,106 @@ if (!isRemote) {
         }),
     } : undefined;
 
-    setStatus(`Starting ${numWorkers} workers...`);
-    for (let i = 0; i < numWorkers; i++) {
-        const w = new PilotSwarmWorker({
-            store,
-            ...(duroxideSchema ? { duroxideSchema } : {}),
-            ...(cmsSchema ? { cmsSchema } : {}),
-            githubToken: process.env.GITHUB_TOKEN,
-            logLevel: process.env.LOG_LEVEL || "error",
-            sessionStateDir: process.env.SESSION_STATE_DIR || path.join(os.homedir(), ".copilot", "session-state"),
-            blobConnectionString: workerModuleConfig.blobConnectionString || process.env.AZURE_STORAGE_CONNECTION_STRING,
-            blobContainer: process.env.AZURE_STORAGE_CONTAINER || "copilot-sessions",
-            workerNodeId: `local-rt-${i}`,
-            systemMessage: workerModuleConfig.systemMessage || WORKER_SYSTEM_MESSAGE || undefined,
-            pluginDirs,
-            ...(llmProvider && { provider: llmProvider }),
-            ...(workerModuleConfig.skillDirectories && { skillDirectories: workerModuleConfig.skillDirectories }),
-            ...(workerModuleConfig.customAgents && { customAgents: workerModuleConfig.customAgents }),
-            ...(workerModuleConfig.mcpServers && { mcpServers: workerModuleConfig.mcpServers }),
-        });
-        // Register custom tools from worker module
-        const workerTools = typeof workerModuleConfig.createTools === "function"
-            ? await workerModuleConfig.createTools({ workerNodeId: `local-rt-${i}`, workerIndex: i })
-            : workerModuleConfig.tools;
-        if (workerTools?.length) {
-            w.registerTools(workerTools);
-        }
-        await w.start();
-        workers.push(w);
-        appendLog(`Worker local-rt-${i} started ✓`);
-    }
-
-    // Capture model provider registry from the first worker
-    modelProviders = workers[0]?.modelProviders || null;
-    if (modelProviders) {
-        const byProvider = modelProviders.getModelsByProvider();
-        for (const g of byProvider) {
-            const names = g.models.map(m => m.qualifiedName).join(", ");
-            appendLog(`{bold}${g.providerId}{/bold} (${g.type}): ${names}`);
+    try {
+        setStatus(`Starting ${numWorkers} workers...`);
+        for (let i = 0; i < numWorkers; i++) {
+            const w = new PilotSwarmWorker({
+                store,
+                ...(duroxideSchema ? { duroxideSchema } : {}),
+                ...(cmsSchema ? { cmsSchema } : {}),
+                githubToken: process.env.GITHUB_TOKEN,
+                logLevel: process.env.LOG_LEVEL || "error",
+                sessionStateDir: process.env.SESSION_STATE_DIR || path.join(os.homedir(), ".copilot", "session-state"),
+                // Embedded local workers always use the filesystem-based session store.
+                // Do not inherit Azure blob config from the shell environment here.
+                workerNodeId: `local-rt-${i}`,
+                systemMessage: workerModuleConfig.systemMessage || WORKER_SYSTEM_MESSAGE || undefined,
+                pluginDirs,
+                ...(llmProvider && { provider: llmProvider }),
+                ...(workerModuleConfig.skillDirectories && { skillDirectories: workerModuleConfig.skillDirectories }),
+                ...(workerModuleConfig.customAgents && { customAgents: workerModuleConfig.customAgents }),
+                ...(workerModuleConfig.mcpServers && { mcpServers: workerModuleConfig.mcpServers }),
+            });
+            // Register custom tools from worker module
+            const workerTools = typeof workerModuleConfig.createTools === "function"
+                ? await workerModuleConfig.createTools({ workerNodeId: `local-rt-${i}`, workerIndex: i })
+                : workerModuleConfig.tools;
+            if (workerTools?.length) {
+                w.registerTools(workerTools);
+            }
+            workers.push(w);
         }
-        // Use default model from registry if no explicit override
-        if (modelProviders.defaultModel && !currentModel) {
-            currentModel = modelProviders.defaultModel;
+
+        // Capture model provider registry from the first worker
+        modelProviders = workers[0]?.modelProviders || null;
+        if (modelProviders) {
+            const byProvider = modelProviders.getModelsByProvider();
+            for (const g of byProvider) {
+                const names = g.models.map(m => m.qualifiedName).join(", ");
+                appendLog(`{bold}${g.providerId}{/bold} (${g.type}): ${names}`);
+            }
+            // Use default model from registry if no explicit override
+            if (modelProviders.defaultModel && !currentModel) {
+                currentModel = modelProviders.defaultModel;
+            }
         }
-    }
 
-    // Restore stdout/stderr after all workers initialized
-    process.stdout.write = origStdoutWrite;
-    // Keep stderr intercepted — MCP subprocesses (filesystem server, etc.) write
-    // warnings (ExperimentalWarning: SQLite, etc.) that corrupt the TUI.
-    // Route them to the log file instead of the terminal.
-    const logFd = fs.openSync(logFile, "a");
-    process.stderr.write = (chunk, encoding, cb) => {
-        try { fs.appendFileSync(logFd, chunk); } catch {}
-        if (typeof cb === "function") cb();
-        return true;
-    };
+        // Restore stdout/stderr after all workers initialized
+        process.stdout.write = origStdoutWrite;
+        // Keep stderr intercepted — MCP subprocesses (filesystem server, etc.) write
+        // warnings (ExperimentalWarning: SQLite, etc.) that corrupt the TUI.
+        // Route them to the log file instead of the terminal.
+        const logFd = fs.openSync(logFile, "a");
+        process.stderr.write = (chunk, encoding, cb) => {
+            try { fs.appendFileSync(logFd, chunk); } catch {}
+            if (typeof cb === "function") cb();
+            return true;
+        };
 
-    // Rust native code writes directly to fd 1/2 during init, bypassing Node
-    // and corrupting blessed's alt-screen buffer. Wipe the terminal and force
-    // blessed to fully repaint from scratch.
-    process.stdout.write("\x1b[2J\x1b[H");
-    screen.realloc();
-    screen.render();
+        const repaintAfterWorkerStartup = () => {
+            if (_embeddedWorkerStartupInProgress) {
+                process.stdout.write("\x1b[2J\x1b[H");
+                screen.realloc();
+            }
+            screen.render();
+        };
+
+        // Rust native code writes directly to fd 1/2 during init, bypassing Node
+        // and corrupting blessed's alt-screen buffer. Repaint after construction,
+        // then start workers one-by-one in the background to avoid Postgres schema races.
+        _embeddedWorkerStartupInProgress = true;
+        repaintAfterWorkerStartup();
+
+        const startWorkersSequentially = async () => {
+            let startedWorkers = 0;
+            try {
+                for (let i = 0; i < workers.length; i++) {
+                    appendLog(`Starting worker local-rt-${i}…`);
+                    screen.render();
+                    try {
+                        await workers[i].start();
+                        startedWorkers++;
+                        noteFirstLocalWorkerStarted();
+                        appendLog(`Worker local-rt-${i} started ✓`);
+                    } catch (err) {
+                        appendLog(`{red-fg}Worker local-rt-${i} failed: ${err?.message || err}{/red-fg}`);
+                    }
+                    repaintAfterWorkerStartup();
+                }
+            } finally {
+                repaintAfterWorkerStartup();
+                _embeddedWorkerStartupInProgress = false;
+            }
+            if (startedWorkers === 0) {
+                noteAllLocalWorkersFailed(new Error("All local workers failed to start."));
+            }
+        };
+
+        void startWorkersSequentially();
+    } catch (err) {
+        restoreBootstrapStdio();
+        throw err;
+    }
 
     // Tail the log file into per-worker panes
     let tailPos = 0;
@@ -3724,11 +4782,6 @@ if (!isRemote) {
                     appendOrchLog(orchId, paneName, formatted);
                 }
 
-                // Feed sequence diagram
-                const seqEvtLocal = parseSeqEvent(plain, paneName);
-                if (seqEvtLocal) {
-                    appendSeqEvent(seqEvtLocal.orchId, seqEvtLocal);
-                }
                 routed++;
             }
             tailReads++;
@@ -3799,22 +4852,25 @@ const mgmt = new PilotSwarmManagementClient({
 const STARTUP_DB_RETRY_MS = 30_000;
 const STARTUP_DB_CONNECT_TIMEOUT_MS = 10_000;
 
+async function withStartupTimeout(label, work) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            work(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${label} timed out (10s deadline)`)), STARTUP_DB_CONNECT_TIMEOUT_MS);
+            }),
+        ]);
+    } finally {
+        if (timer) clearTimeout(timer);
+    }
+}
+
 function isStartupTransientDbError(err) {
     const msg = String(err?.message || err || "");
     return /ENOTFOUND|ETIMEDOUT|ECONNREFUSED|ECONNRESET|EHOSTUNREACH|socket hang up|getaddrinfo|timeout|network|pool timed out while waiting for an open connection/i.test(msg);
 }
 
-// Register quit handler BEFORE the connection loop so the user can always exit.
-let _startupQuit = false;
-let _startupPhase = true;
-screen.key(["C-c"], () => {
-    if (_startupPhase) { _startupQuit = true; process.exit(0); }
-});
-const _startupQHandler = () => {
-    if (_startupPhase) { _startupQuit = true; process.exit(0); }
-};
-screen.key(["q"], _startupQHandler);
-
 setStatus(isRemote ? "Connecting to remote DB..." : "Connecting client...");
 
 // Show splash immediately so the user sees something during DB connection
@@ -3827,41 +4883,35 @@ _origRender();
 while (true) {
     const _startPh = perfStart("startup.clientConnect");
 
-    // Race the connection against a timeout so unreachable hosts don't block for minutes
-    const timeoutPromise = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error("Connection timed out (10s deadline)")), STARTUP_DB_CONNECT_TIMEOUT_MS)
-    );
-    const results = await Promise.allSettled([
-        Promise.race([client.start(), timeoutPromise]),
-        Promise.race([mgmt.start(), timeoutPromise]),
-    ]);
-    const failure = results.find(r => r.status === "rejected");
-
-    if (!failure) {
+    try {
+        if (!isRemote) {
+            await withStartupTimeout("First local worker start", () => firstLocalWorkerStarted);
+        }
+        await withStartupTimeout("Client start", () => client.start());
+        await withStartupTimeout("Management client start", () => mgmt.start());
         perfEnd(_startPh);
         break;
-    }
-
-    const err = failure.reason;
-    perfEnd(_startPh, { err: true });
+    } catch (err) {
+        perfEnd(_startPh, { err: true });
 
-    try { await client.stop(); } catch {}
-    try { await mgmt.stop(); } catch {}
+        try { await client.stop(); } catch {}
+        try { await mgmt.stop(); } catch {}
 
-    if (!isStartupTransientDbError(err)) {
-        throw err;
-    }
+        if (!isStartupTransientDbError(err)) {
+            throw err;
+        }
 
-    const msg = String(err?.message || err || "Unknown database error");
-    setStatus(`Database unavailable — retrying in 30s (${msg.slice(0, 80)})`);
-    chatBox.setContent(`${ACTIVE_STARTUP_SPLASH_CONTENT}\n\n  {yellow-fg}Database unavailable.{/yellow-fg}\n  {white-fg}${msg}{/white-fg}\n\n  {gray-fg}Retrying connection in 30 seconds... (press q or Ctrl+C to quit){/gray-fg}`);
-    _origRender();
+        const msg = String(err?.message || err || "Unknown database error");
+        setStatus(`Database unavailable — retrying in 30s (${safeSlice(msg, 0, 80)})`);
+        chatBox.setContent(`${ACTIVE_STARTUP_SPLASH_CONTENT}\n\n  {yellow-fg}Database unavailable.{/yellow-fg}\n  {white-fg}${msg}{/white-fg}\n\n  {gray-fg}Retrying connection in 30 seconds... (press q or Ctrl+C to quit){/gray-fg}`);
+        _origRender();
 
-    // Interruptible sleep — check every 500ms if the user pressed quit
-    const retryEnd = Date.now() + STARTUP_DB_RETRY_MS;
-    while (Date.now() < retryEnd) {
-        if (_startupQuit) process.exit(0);
-        await new Promise(r => setTimeout(r, 500));
+        // Interruptible sleep — check every 500ms if the user pressed quit
+        const retryEnd = Date.now() + STARTUP_DB_RETRY_MS;
+        while (Date.now() < retryEnd) {
+            if (_startupQuit) process.exit(0);
+            await new Promise(r => setTimeout(r, 500));
+        }
     }
 }
 
@@ -3921,9 +4971,13 @@ const sessionRenderedCmsSeq = new Map(); // orchId → highest CMS seq already i
 const sessionExpandLevel = new Map(); // orchId → 0 (default) | 1 | 2 (how many times user expanded history)
 const sessionSplashApplied = new Set(); // orchIds that have had splash prepended (idempotency guard)
 const sessionPromotedIntermediate = new Map(); // orchId → normalized intermediate content already promoted to Chat
+const sessionPendingAssistantPreview = new Map(); // orchId → { normalized: string, lines: string[] } for provisional assistant.message preview
 const sessionRecoveredTurnResult = new Map(); // orchId → normalized completed turn recovered from live status during CMS load
 const sessionObservers = new Map(); // orchId → AbortController
+const sessionObserverPollState = new Map(); // orchId → { version: number }
 const sessionLiveStatus = new Map(); // orchId → "idle"|"running"|"waiting"|"input_required"
+const sessionCronSchedules = new Map(); // orchId → { interval: number, reason?: string }
+const sessionContextUsage = new Map(); // orchId → latest context usage snapshot
 const sessionPendingTurns = new Set(); // orchIds with a locally-sent turn awaiting first live status
 
 // ─── Inline chat spinner ─────────────────────────────────────────
@@ -4007,6 +5061,153 @@ function isTerminalSessionState(state) {
     return state === "completed" || state === "failed" || state === "error" || state === "terminated";
 }
 
+function sessionStateFromOrchestrationStatus(status) {
+    switch (status) {
+        case "Completed": return "completed";
+        case "Failed": return "error";
+        case "Terminated": return "terminated";
+        default: return null;
+    }
+}
+
+function updateSessionCronSchedule(orchId, customStatus) {
+    if (!orchId || !customStatus) return;
+    if (customStatus.cronActive === true && typeof customStatus.cronInterval === "number") {
+        const next = {
+            interval: customStatus.cronInterval,
+            reason: typeof customStatus.cronReason === "string" ? customStatus.cronReason : undefined,
+        };
+        const prev = sessionCronSchedules.get(orchId);
+        if (prev?.interval === next.interval && prev?.reason === next.reason) return;
+        sessionCronSchedules.set(orchId, next);
+        updateSessionListIcons();
+        return;
+    }
+    if (sessionCronSchedules.delete(orchId)) {
+        updateSessionListIcons();
+    }
+}
+
+function cloneContextUsageSnapshot(contextUsage) {
+    if (!contextUsage || typeof contextUsage !== "object") return null;
+    return {
+        ...contextUsage,
+        ...(contextUsage.compaction && typeof contextUsage.compaction === "object"
+            ? { compaction: { ...contextUsage.compaction } }
+            : {}),
+    };
+}
+
+function getContextHeaderBadge(orchId) {
+    return formatContextHeaderBadge(sessionContextUsage.get(orchId));
+}
+
+function getContextCompactionBadge(orchId) {
+    return formatContextCompactionBadge(sessionContextUsage.get(orchId));
+}
+
+function getSessionContextBadge(orchId) {
+    return formatContextListBadge(sessionContextUsage.get(orchId));
+}
+
+function noteSessionContextUsage(orchId, contextUsage) {
+    if (!orchId) return;
+    const snapshot = cloneContextUsageSnapshot(contextUsage);
+    if (!snapshot) return;
+    sessionContextUsage.set(orchId, snapshot);
+    if (orchId === activeOrchId) updateChatLabel();
+    updateSessionListIcons();
+}
+
+function updateSessionContextUsageFromStatus(orchId, customStatus) {
+    if (customStatus?.contextUsage && typeof customStatus.contextUsage === "object") {
+        noteSessionContextUsage(orchId, customStatus.contextUsage);
+    }
+}
+
+function applySessionUsageEvent(orchId, eventType, data) {
+    if (!orchId || !eventType || !data || typeof data !== "object") return;
+    const current = cloneContextUsageSnapshot(sessionContextUsage.get(orchId)) || {};
+
+    if (eventType === "session.usage_info") {
+        if (typeof data.tokenLimit !== "number" || typeof data.currentTokens !== "number" || typeof data.messagesLength !== "number") {
+            return;
+        }
+        current.tokenLimit = data.tokenLimit;
+        current.currentTokens = data.currentTokens;
+        current.messagesLength = data.messagesLength;
+        current.utilization = data.tokenLimit > 0 ? data.currentTokens / data.tokenLimit : 0;
+        if (typeof data.systemTokens === "number") current.systemTokens = data.systemTokens;
+        if (typeof data.conversationTokens === "number") current.conversationTokens = data.conversationTokens;
+        if (typeof data.toolDefinitionsTokens === "number") current.toolDefinitionsTokens = data.toolDefinitionsTokens;
+        if (typeof data.isInitial === "boolean") current.isInitial = data.isInitial;
+        noteSessionContextUsage(orchId, current);
+        return;
+    }
+
+    if (eventType === "assistant.usage") {
+        if (typeof data.inputTokens === "number") current.lastInputTokens = data.inputTokens;
+        if (typeof data.outputTokens === "number") current.lastOutputTokens = data.outputTokens;
+        if (typeof data.cacheReadTokens === "number") current.lastCacheReadTokens = data.cacheReadTokens;
+        if (typeof data.cacheWriteTokens === "number") current.lastCacheWriteTokens = data.cacheWriteTokens;
+        noteSessionContextUsage(orchId, current);
+        return;
+    }
+
+    if (eventType === "session.compaction_start") {
+        current.compaction = {
+            ...(current.compaction || {}),
+            state: "running",
+            startedAt: Date.now(),
+            completedAt: undefined,
+            error: undefined,
+        };
+        noteSessionContextUsage(orchId, current);
+        return;
+    }
+
+    if (eventType === "session.compaction_complete") {
+        current.compaction = {
+            ...(current.compaction || {}),
+            state: data.success === false ? "failed" : "succeeded",
+            completedAt: Date.now(),
+            error: typeof data.error === "string" ? data.error : undefined,
+            preCompactionTokens: typeof data.preCompactionTokens === "number" ? data.preCompactionTokens : undefined,
+            postCompactionTokens: typeof data.postCompactionTokens === "number" ? data.postCompactionTokens : undefined,
+            preCompactionMessagesLength: typeof data.preCompactionMessagesLength === "number" ? data.preCompactionMessagesLength : undefined,
+            messagesRemoved: typeof data.messagesRemoved === "number" ? data.messagesRemoved : undefined,
+            tokensRemoved: typeof data.tokensRemoved === "number" ? data.tokensRemoved : undefined,
+            systemTokens: typeof data.systemTokens === "number" ? data.systemTokens : undefined,
+            conversationTokens: typeof data.conversationTokens === "number" ? data.conversationTokens : undefined,
+            toolDefinitionsTokens: typeof data.toolDefinitionsTokens === "number" ? data.toolDefinitionsTokens : undefined,
+            inputTokens: typeof data.compactionTokensUsed?.input === "number" ? data.compactionTokensUsed.input : undefined,
+            outputTokens: typeof data.compactionTokensUsed?.output === "number" ? data.compactionTokensUsed.output : undefined,
+            cachedInputTokens: typeof data.compactionTokensUsed?.cachedInput === "number" ? data.compactionTokensUsed.cachedInput : undefined,
+        };
+        if (typeof data.postCompactionTokens === "number" && typeof current.tokenLimit === "number" && current.tokenLimit > 0) {
+            current.currentTokens = data.postCompactionTokens;
+            current.utilization = data.postCompactionTokens / current.tokenLimit;
+        }
+        if (typeof data.preCompactionMessagesLength === "number" && typeof data.messagesRemoved === "number") {
+            current.messagesLength = Math.max(0, data.preCompactionMessagesLength - data.messagesRemoved);
+        }
+        if (typeof data.systemTokens === "number") current.systemTokens = data.systemTokens;
+        if (typeof data.conversationTokens === "number") current.conversationTokens = data.conversationTokens;
+        if (typeof data.toolDefinitionsTokens === "number") current.toolDefinitionsTokens = data.toolDefinitionsTokens;
+        noteSessionContextUsage(orchId, current);
+    }
+}
+
+function formatCompactionActivityLine(t, evt) {
+    return formatCompactionActivityMarkup(t, evt.eventType, evt.data || {});
+}
+
+function getSessionCronBadge(orchId) {
+    const cron = sessionCronSchedules.get(orchId);
+    if (!cron) return "";
+    return ` {magenta-fg}[cron ${formatHumanDurationSeconds(cron.interval)}]{/magenta-fg}`;
+}
+
 function shouldObserveSession(orchId, cached = orchStatusCache.get(orchId)) {
     if (!orchId || sessionObservers.has(orchId)) return false;
     const visualState = getSessionVisualState(orchId, cached);
@@ -4014,8 +5215,15 @@ function shouldObserveSession(orchId, cached = orchStatusCache.get(orchId)) {
 }
 
 function getSessionVisualState(orchId, cached = orchStatusCache.get(orchId)) {
+    const terminalState = sessionStateFromOrchestrationStatus(cached?.status);
+    if (terminalState) {
+        return terminalState;
+    }
     const liveState = sessionLiveStatus.get(orchId) || cached?.liveState;
-    if (liveState) return liveState;
+    if (liveState) {
+        if (liveState === "waiting" && sessionCronSchedules.has(orchId)) return "cron_waiting";
+        return liveState;
+    }
     switch (cached?.status) {
         case "Completed": return "completed";
         case "Failed": return "failed";
@@ -4029,13 +5237,14 @@ function getSessionVisualState(orchId, cached = orchStatusCache.get(orchId)) {
 function getSessionStateColor(state) {
     switch (state) {
         case "running": return "green";
+        case "cron_waiting": return "magenta";
         case "waiting": return "yellow";
         case "idle": return "white";
         case "input_required": return "cyan";
         case "completed": return "gray";
         case "failed":
         case "error": return "red";
-        case "terminated": return "yellow";
+        case "terminated": return "red";
         default: return "white";
     }
 }
@@ -4043,21 +5252,42 @@ function getSessionStateColor(state) {
 function getSessionStateIcon(state) {
     switch (state) {
         case "running": return "{green-fg}*{/green-fg}";
+        case "cron_waiting": return "{magenta-fg}~{/magenta-fg}";
         case "waiting": return "{yellow-fg}~{/yellow-fg}";
         case "idle": return "{white-fg}.{/white-fg}";
         case "input_required": return "{cyan-fg}?{/cyan-fg}";
         case "failed":
-        case "error": return "{red-fg}!{/red-fg}";
+        case "error":
+        case "terminated": return "{red-fg}!{/red-fg}";
         default: return "";
     }
 }
 
+function getSessionListStateColor(state) {
+    return state === "cron_waiting" ? "yellow" : getSessionStateColor(state);
+}
+
+function getSessionListStateIcon(state) {
+    return state === "cron_waiting"
+        ? "{yellow-fg}~{/yellow-fg}"
+        : getSessionStateIcon(state);
+}
+
 function setSessionPendingTurn(orchId, pending) {
     if (!orchId) return;
     if (pending) sessionPendingTurns.add(orchId);
     else sessionPendingTurns.delete(orchId);
 }
 
+function formatWaitingLabel(statusLike) {
+    const reason = statusLike?.cronActive === true
+        ? (statusLike?.cronReason || statusLike?.waitReason || "timer")
+        : (statusLike?.waitReason || "timer");
+    return statusLike?.cronActive === true
+        ? `Cron waiting (${reason})…`
+        : `Waiting (${reason})…`;
+}
+
 function isTurnInProgressForSession(orchId) {
     if (!orchId) return false;
     const liveStatus = sessionLiveStatus.get(orchId);
@@ -4200,7 +5430,7 @@ function handleDbUnavailable(err) {
     if (!wasOffline || prevError !== msg) {
         appendLog(`{yellow-fg}Database unavailable — retrying in 30s.{/yellow-fg}`);
     }
-    setStatus(`Database unavailable — retrying in 30s (${msg.slice(0, 80)})`);
+    setStatus(`Database unavailable — retrying in 30s (${safeSlice(msg, 0, 80)})`);
 }
 
 function handleDbRecovered() {
@@ -4264,8 +5494,8 @@ function updateSessionListIcons() {
         const id = orchIdOrder[i];
         const cached = orchStatusCache.get(id);
         const visualState = getSessionVisualState(id, cached);
-        const statusIcon = getSessionStateIcon(visualState);
-        const color = getSessionStateColor(visualState);
+        const statusIcon = getSessionListStateIcon(visualState);
+        const color = getSessionListStateColor(visualState);
 
         // Rebuild just this item's label
         const uuid4 = shortId(id);
@@ -4278,11 +5508,10 @@ function updateSessionListIcons() {
             })
             : "";
 
-        const hasChanges = orchHasChanges.has(id);
         const isActive = id === activeOrchId;
         const marker = isActive ? "{bold}▸{/bold}" : " ";
-        const changeSuffix = hasChanges ? " {cyan-fg}{bold}●{/bold}{/cyan-fg}" : "";
         const statusIconSlot = statusIcon ? statusIcon + " " : "  ";
+        const badgeSuffix = formatSessionListSuffixes(id);
         const heading = sessionHeadings.get(id);
         // Use cached depth from last full refresh
         const depth = orchDepthMap?.get(id) ?? 0;
@@ -4290,16 +5519,14 @@ function updateSessionListIcons() {
 
         // System sessions get special rendering: yellow, ≋ icon
         if (systemSessionIds.has(id)) {
-            const collapseBadge = getCollapseBadge(id);
             const sysLabel = heading
-                ? `${heading} (${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`
-                : `System Agent (${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`;
+                ? `${heading} (${uuid4}) ${timeStr}${badgeSuffix}`
+                : `System Agent (${uuid4}) ${timeStr}${badgeSuffix}`;
             orchList.setItem(i, `${indent}${marker}{bold}{yellow-fg}≋ ${sysLabel}{/yellow-fg}{/bold}`);
         } else {
-            const collapseBadge = getCollapseBadge(id);
             const label = heading
-                ? `${heading} (${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`
-                : `(${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`;
+                ? `${heading} (${uuid4}) ${timeStr}${badgeSuffix}`
+                : `(${uuid4}) ${timeStr}${badgeSuffix}`;
             orchList.setItem(i, `${indent}${marker}${statusIconSlot}{${color}-fg}${label}{/${color}-fg}`);
         }
     }
@@ -4331,6 +5558,15 @@ function getCollapseBadge(orchId) {
     return hidden ? ` {cyan-fg}[+${hidden}]{/cyan-fg}` : "";
 }
 
+function formatSessionListSuffixes(orchId) {
+    const cronBadge = getSessionCronBadge(orchId);
+    const contextBadge = getSessionContextBadge(orchId);
+    const collapseBadge = getCollapseBadge(orchId);
+    const changeSuffix = orchHasChanges.has(orchId) ? " {cyan-fg}{bold}●{/bold}{/cyan-fg}" : "";
+    // Keep badge ordering stable across lightweight updates and full refreshes.
+    return `${cronBadge}${contextBadge}${collapseBadge}${changeSuffix}`;
+}
+
 function canonicalSystemTitleFromSessionView(sv, orchId) {
     const agentId = sv?.agentId || sessionAgentIds.get(orchId) || "";
     if (agentId === "pilotswarm") return HAS_CUSTOM_TUI_BRANDING ? BASE_TUI_TITLE : "PilotSwarm Agent";
@@ -4426,6 +5662,14 @@ async function refreshOrchestrations(force = false) {
         if (sv.agentId) {
             sessionAgentIds.set(id, sv.agentId);
         }
+        if (sv.cronActive === true && typeof sv.cronInterval === "number") {
+            sessionCronSchedules.set(id, {
+                interval: sv.cronInterval,
+                reason: typeof sv.cronReason === "string" ? sv.cronReason : undefined,
+            });
+        } else if (sv.cronActive === false) {
+            sessionCronSchedules.delete(id);
+        }
 
         // Splash from CMS — store and pre-populate chat buffer on first discovery
         const splashText = brandedSplashForSessionView(sv, id);
@@ -4443,7 +5687,12 @@ async function refreshOrchestrations(force = false) {
 
         // Seed sessionLiveStatus from CMS if no observer has set it yet.
         // This ensures status icons show correctly on initial load.
-        if (!sessionLiveStatus.has(id) && liveState && liveState !== "pending") {
+        const terminalState = sessionStateFromOrchestrationStatus(status);
+        if (terminalState) {
+            sessionLiveStatus.set(id, terminalState);
+            setSessionPendingTurn(id, false);
+            clearSessionPendingQuestion(id);
+        } else if (!sessionLiveStatus.has(id) && liveState && liveState !== "pending") {
             sessionLiveStatus.set(id, liveState);
         }
 
@@ -4581,33 +5830,30 @@ async function refreshOrchestrations(force = false) {
                 })
                 : "";
             const visualState = getSessionVisualState(id, orchStatusCache.get(id) || { status, createdAt });
-            const color = getSessionStateColor(visualState);
+            const color = getSessionListStateColor(visualState);
 
             // Highlight sessions with unseen changes
-            const hasChanges = orchHasChanges.has(id);
             const isActive = id === activeOrchId;
             const marker = isActive ? "{bold}▸{/bold}" : " ";
-            const changeSuffix = hasChanges ? " {cyan-fg}{bold}●{/bold}{/cyan-fg}" : "";
 
             // Live status indicator
-            const statusIcon = getSessionStateIcon(visualState);
+            const statusIcon = getSessionListStateIcon(visualState);
 
             const statusIconSlot = statusIcon ? statusIcon + " " : "  ";
+            const badgeSuffix = formatSessionListSuffixes(id);
             const heading = sessionHeadings.get(id);
             const indent = depth > 0 ? "   ".repeat(depth - 1) + "  └ " : "";
 
             // System sessions get special rendering: yellow, ≋ icon
             if (systemSessionIds.has(id)) {
-                const collapseBadge = getCollapseBadge(id);
                 const sysLabel = heading
-                    ? `${heading} (${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`
-                    : `System Agent (${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`;
+                    ? `${heading} (${uuid4}) ${timeStr}${badgeSuffix}`
+                    : `System Agent (${uuid4}) ${timeStr}${badgeSuffix}`;
                 orchList.addItem(`${indent}${marker}{bold}{yellow-fg}≋ ${sysLabel}{/yellow-fg}{/bold}`);
             } else {
-                const collapseBadge = getCollapseBadge(id);
                 const label = heading
-                    ? `${heading} (${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`
-                    : `(${uuid4}) ${timeStr}${collapseBadge}${changeSuffix}`;
+                    ? `${heading} (${uuid4}) ${timeStr}${badgeSuffix}`
+                    : `(${uuid4}) ${timeStr}${badgeSuffix}`;
                 orchList.addItem(`${indent}${marker}${statusIconSlot}{${color}-fg}${label}{/${color}-fg}`);
             }
         }
@@ -4660,6 +5906,14 @@ async function refreshOrchestrations(force = false) {
     perfEnd(_ph, { sessions: entries.length });
 }
 
+function renderWaitingForSessionsLanding() {
+    chatBox.setContent(
+        `${ACTIVE_STARTUP_SPLASH_CONTENT}\n\n  {white-fg}Waiting for local workers to publish sessions...{/white-fg}\n\n  {gray-fg}Press n to create a session immediately.{/gray-fg}`,
+    );
+    chatBox.setScrollPerc(0);
+    screen.render();
+}
+
 // Poll orchestrations every 10 seconds (observers handle live status updates, so
 // this only needs to catch new sessions and structural changes like title/parent).
 let orchPollTimer = setInterval(() => {
@@ -4677,7 +5931,7 @@ const perfSummaryInterval = setInterval(() => {
         for (const l of lines) totalBufferBytes += l.length;
     }
     let totalSeqEvents = 0;
-    for (const [, evts] of seqEventBuffers) totalSeqEvents += evts.length;
+    for (const [, evts] of cmsSeqTimelines) totalSeqEvents += evts.length;
     perfTrace("periodic_summary", {
         heapUsedMB: +(mem.heapUsed / 1024 / 1024).toFixed(1),
         heapTotalMB: +(mem.heapTotal / 1024 / 1024).toFixed(1),
@@ -4685,7 +5939,7 @@ const perfSummaryInterval = setInterval(() => {
         chatBuffers: sessionChatBuffers.size,
         chatBufferLines: totalBufferLines,
         chatBufferKB: +(totalBufferBytes / 1024).toFixed(1),
-        seqBuffers: seqEventBuffers.size,
+        seqBuffers: cmsSeqTimelines.size,
         seqEvents: totalSeqEvents,
         observers: sessionObservers.size,
         renders: _perfRenderCount,
@@ -4728,6 +5982,11 @@ orchList.key(["c"], async () => {
         const sessionId = id.startsWith("session-") ? id.slice(8) : id;
         try {
             await mgmt.cancelSession(sessionId);
+            sessionLiveStatus.set(id, "terminated");
+            setSessionPendingTurn(id, false);
+            clearSessionPendingQuestion(id);
+            sessionCronSchedules.delete(id);
+            updateSessionListIcons();
             appendLog(`{yellow-fg}Cancelled ${shortId(id)}{/yellow-fg}`);
             await refreshOrchestrations();
         } catch (err) {
@@ -4749,6 +6008,7 @@ orchList.key(["d"], async () => {
             await mgmt.deleteSession(sessionId);
             knownOrchestrationIds.delete(id);
             orchStatusCache.delete(id);
+            sessionCronSchedules.delete(id);
             appendLog(`{yellow-fg}Deleted ${shortId(id)}{/yellow-fg}`);
             await refreshOrchestrations();
         } catch (err) {
@@ -5202,11 +6462,6 @@ function startLogStream() {
                     appendOrchLog(orchId, podName, formatted);
                 }
 
-                // Feed sequence diagram
-                const seqEvt = parseSeqEvent(plain, podName);
-                if (seqEvt) {
-                    appendSeqEvent(seqEvt.orchId, seqEvt);
-                }
             }
             screen.render();
         });
@@ -5280,7 +6535,6 @@ if (isRemote) {
 // Map sessionId → PilotSwarmSession object
 const sessions = new Map();
 const sessionModels = new Map(); // orchId → model name used for that session
-let shutdownInProgress = false;
 
 // currentModel is declared earlier (before model providers loading)
 
@@ -5549,20 +6803,45 @@ function updateChatLabel() {
     const model = sessionModels.get(activeOrchId) || "";
     const shortModel = model.includes(":") ? model.split(":")[1] : model;
     const modelTag = shortModel ? ` {cyan-fg}${shortModel}{/cyan-fg}` : "";
+    const contextTag = getContextHeaderBadge(activeOrchId);
+    const compactionTag = getContextCompactionBadge(activeOrchId);
     const collapseBadge = getCollapseBadge(activeOrchId);
     const isSweeper = systemSessionIds.has(activeOrchId);
     if (isSweeper) {
         const sysTitle = sessionHeadings.get(activeOrchId) || "System Agent";
-        chatBox.setLabel(` {bold}{yellow-fg}≋ ${sysTitle}${collapseBadge}{/yellow-fg}{/bold} {white-fg}[${activeSessionShort}]{/white-fg}${modelTag} `);
+        chatBox.setLabel(` {bold}{yellow-fg}≋ ${sysTitle}${collapseBadge}{/yellow-fg}{/bold} {white-fg}[${activeSessionShort}]{/white-fg}${modelTag}${contextTag}${compactionTag} `);
         chatBox.style.border.fg = "yellow";
     } else {
         const title = sessionHeadings.get(activeOrchId) || "Chat";
-        chatBox.setLabel(` {bold}${title}${collapseBadge}{/bold} {white-fg}[${activeSessionShort}]{/white-fg}${modelTag} `);
+        chatBox.setLabel(` {bold}${title}${collapseBadge}{/bold} {white-fg}[${activeSessionShort}]{/white-fg}${modelTag}${contextTag}${compactionTag} `);
         chatBox.style.border.fg = "cyan";
     }
     screen.render();
 }
 
+function setObserverPollState(orchId, version) {
+    if (!orchId) return;
+    sessionObserverPollState.set(orchId, { version: Math.max(0, version || 0) });
+    if (orchId === activeOrchId) updateActivityLabel();
+}
+
+function clearObserverPollState(orchId) {
+    if (!orchId) return;
+    if (sessionObserverPollState.delete(orchId) && orchId === activeOrchId) {
+        updateActivityLabel();
+    }
+}
+
+function updateActivityLabel() {
+    const pollState = activeOrchId ? sessionObserverPollState.get(activeOrchId) : null;
+    const isPollingActiveSession = Boolean(activeOrchId && sessionObservers.has(activeOrchId) && pollState);
+    const pollingTag = isPollingActiveSession
+        ? ` {gray-fg}[polling current session v${pollState.version}]{/gray-fg}`
+        : "";
+    activityPane.setLabel(` {bold}Activity{/bold}${pollingTag} `);
+    scheduleRender();
+}
+
 /**
  * Start observing an orchestration's custom status and pipe turn results
  * into the chat buffer. Runs until aborted or the orchestration completes.
@@ -5578,6 +6857,7 @@ function startObserver(orchId) {
 
     const ac = new AbortController();
     sessionObservers.set(orchId, ac);
+    setObserverPollState(orchId, 0);
     let lastVersion = 0;
     let lastIteration = -1;
 
@@ -5657,10 +6937,14 @@ function startObserver(orchId) {
                     appendChatRaw("{bold}Session info:{/bold}", orchId);
                     appendChatRaw(`  Model:       {cyan-fg}${r.model}{/cyan-fg}`, orchId);
                     appendChatRaw(`  Iteration:   ${r.iteration}`, orchId);
-                    appendChatRaw(`  Session:     ${r.sessionId?.slice(0, 12)}…`, orchId);
+                    appendChatRaw(`  Session:     ${safeSlice(r.sessionId, 0, 12)}…`, orchId);
                     appendChatRaw(`  Affinity:    ${r.affinityKey}`, orchId);
                     appendChatRaw(`  Hydrated:    ${r.needsHydration ? "no (dehydrated)" : "yes"}`, orchId);
                     appendChatRaw(`  Blob:        ${r.blobEnabled ? "enabled" : "disabled"}`, orchId);
+                    if (r.contextUsage?.tokenLimit > 0 && typeof r.contextUsage?.currentTokens === "number") {
+                        const percent = computeContextPercent(r.contextUsage);
+                        appendChatRaw(`  Context:     ${formatTokenCount(r.contextUsage.currentTokens)}/${formatTokenCount(r.contextUsage.tokenLimit)}${percent != null ? ` (${percent}%)` : ""}`, orchId);
+                    }
                     break;
                 }
                 case "done": {
@@ -5685,7 +6969,7 @@ function startObserver(orchId) {
         if (!response) return;
         stopChatSpinner(orchId);
         if (response.type === "completed" && response.content) {
-            appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=completed content=${response.content.slice(0, 80)}{/green-fg}`, orchId);
+            appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=completed content=${safeSlice(response.content, 0, 80)}{/green-fg}`, orchId);
             renderCompletedContent(response.content);
             if (cs.status === "idle" || cs.status === "completed") {
                 setStatusIfActive(cs.status === "completed" ? "Session completed" : "Ready — type a message");
@@ -5696,11 +6980,15 @@ function startObserver(orchId) {
             return;
         }
         if (response.type === "wait" && response.content) {
-            appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=wait content=${response.content.slice(0, 80)}{/green-fg}`, orchId);
+            appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=wait content=${safeSlice(response.content, 0, 80)}{/green-fg}`, orchId);
             const preview = summarizeActivityPreview(response.content);
             appendActivity(`{white-fg}[${ts()}]{/white-fg} {gray-fg}[intermediate]{/gray-fg} ${preview}`, orchId);
             promoteIntermediateContent(response.content, orchId);
-            setStatusIfActive(`Waiting (${cs.waitReason || response.waitReason || "timer"})…`);
+            setStatusIfActive(formatWaitingLabel({
+                cronActive: cs?.cronActive === true,
+                cronReason: cs?.cronReason,
+                waitReason: cs?.waitReason || response.waitReason,
+            }));
             return;
         }
         if (response.type === "input_required") {
@@ -5723,6 +7011,8 @@ function startObserver(orchId) {
                     : statusSnapshot.customStatus;
             } catch {}
         }
+        updateSessionCronSchedule(orchId, cs);
+        updateSessionContextUsageFromStatus(orchId, cs);
         if (!cs) return null;
 
         lastVersion = Math.max(lastVersion, statusSnapshot.customStatusVersion || 0);
@@ -5790,6 +7080,7 @@ function startObserver(orchId) {
         sessionLoggedTerminalStatus.set(orchId, terminalStatus);
         setSessionPendingTurn(orchId, false);
         setTurnInProgressIfActive(false);
+        clearObserverPollState(orchId);
         sessionObservers.delete(orchId);
         return true;
     }
@@ -5804,6 +7095,7 @@ function startObserver(orchId) {
         try {
             const currentStatus = await dc.getStatus(orchId);
             if (ac.signal.aborted) return;
+            setObserverPollState(orchId, currentStatus?.customStatusVersion || 0);
 
             // Check for terminal states FIRST — before inspecting customStatus
             if (await stopObserverForTerminalStatus(currentStatus, "terminal")) {
@@ -5817,6 +7109,8 @@ function startObserver(orchId) {
                         ? JSON.parse(currentStatus.customStatus) : currentStatus.customStatus;
                 } catch {}
                 if (cs) {
+                    updateSessionCronSchedule(orchId, cs);
+                    updateSessionContextUsageFromStatus(orchId, cs);
                     lastVersion = currentStatus.customStatusVersion || 0;
                     if (cs.turnResult && cs.turnResult.type === "completed") {
                         lastIteration = cs.iteration || 0;
@@ -5847,7 +7141,7 @@ function startObserver(orchId) {
                         setTurnInProgressIfActive(true);
                         updateLiveStatus("running");
                     } else if (cs.status === "waiting") {
-                        setStatusIfActive(`Waiting (${cs.waitReason || "timer"})…`);
+                        setStatusIfActive(formatWaitingLabel(cs));
                         updateLiveStatus("waiting");
                     } else if (cs.status === "input_required") {
                         if (cs.turnResult?.type === "input_required") {
@@ -5888,7 +7182,7 @@ function startObserver(orchId) {
                 const _obsPh = perfStart("observer.waitForStatusChange");
                 const _waitStart = Date.now();
                 const statusResult = await dc.waitForStatusChange(
-                    orchId, lastVersion, 200, 30_000
+                    orchId, lastVersion, 1_000, 60_000
                 );
                 const _waitMs = Date.now() - _waitStart;
                 perfEnd(_obsPh, { orchId: orchId.slice(0, 12), ver: statusResult.customStatusVersion });
@@ -5907,10 +7201,8 @@ function startObserver(orchId) {
                     appendActivity(`{yellow-fg}🔄 [obs] continueAsNew detected in try: v${lastVersion}→v${statusResult.customStatusVersion}, resetting lastIter=${lastIteration}→-1 (${_waitMs}ms){/yellow-fg}`, orchId);
                     lastVersion = statusResult.customStatusVersion;
                     lastIteration = -1;
-                } else {
-                    // Same version — poll returned without change (shouldn't happen normally)
-                    appendActivity(`{gray-fg}[obs] poll returned same version v${lastVersion} (${_waitMs}ms){/gray-fg}`, orchId);
                 }
+                setObserverPollState(orchId, lastVersion);
 
                 let cs = null;
                 if (statusResult.customStatus) {
@@ -5919,6 +7211,8 @@ function startObserver(orchId) {
                             ? JSON.parse(statusResult.customStatus) : statusResult.customStatus;
                     } catch {}
                 }
+                updateSessionCronSchedule(orchId, cs);
+                updateSessionContextUsageFromStatus(orchId, cs);
 
                 if (cs) {
                     // Log every status change with key fields
@@ -5979,7 +7273,7 @@ function startObserver(orchId) {
                     } else if (cs.turnResult && cs.iteration <= lastIteration) {
                         appendActivity(`{yellow-fg}[obs] ⚠ SKIPPED turnResult: iter=${cs.iteration} <= lastIter=${lastIteration} (already shown){/yellow-fg}`, orchId);
                         if (cs.status === "waiting") {
-                            setStatusIfActive(`Waiting (${cs.waitReason || "timer"})…`);
+                            setStatusIfActive(formatWaitingLabel(cs));
                         }
                     } else if (cs.responseVersion) {
                         const latestResponse = await consumeLatestResponsePayload(orchId, cs, dc);
@@ -5999,7 +7293,7 @@ function startObserver(orchId) {
                             setStatusIfActive("Running…");
                             setTurnInProgressIfActive(true);
                         } else if (cs.status === "waiting") {
-                            setStatusIfActive(`Waiting (${cs.waitReason || "timer"})…`);
+                            setStatusIfActive(formatWaitingLabel(cs));
                         } else if (cs.status === "input_required") {
                             setStatusIfActive("Waiting for your answer...");
                             updateLiveStatus("input_required");
@@ -6017,7 +7311,7 @@ function startObserver(orchId) {
                         setStatusIfActive("Running…");
                         setTurnInProgressIfActive(true);
                     } else if (cs.status === "waiting") {
-                        setStatusIfActive(`Waiting (${cs.waitReason || "timer"})…`);
+                        setStatusIfActive(formatWaitingLabel(cs));
                     }
 
                     // Mark session as having unseen changes if not active
@@ -6029,20 +7323,23 @@ function startObserver(orchId) {
             } catch (err) {
                 // waitForStatusChange timed out or failed — check terminal state or continueAsNew
                 if (ac.signal.aborted) break;
-                appendActivity(`{yellow-fg}[obs] catch: ${err.message || "timeout"} lastVersion=${lastVersion} lastIteration=${lastIteration}{/yellow-fg}`, orchId);
+                const errMsg = err?.message || "timeout";
+                const isStatusTimeout = /timed out/i.test(errMsg);
+                if (!isStatusTimeout) {
+                    appendActivity(`{yellow-fg}[obs] catch: ${errMsg} lastVersion=${lastVersion} lastIteration=${lastIteration}{/yellow-fg}`, orchId);
+                }
                 try {
                     const info = await dc.getStatus(orchId);
+                    const currentVersion = info.customStatusVersion || 0;
+                    setObserverPollState(orchId, currentVersion);
                     if (await stopObserverForTerminalStatus(info, "terminal")) {
                         break;
                     }
                     // Detect continueAsNew: customStatusVersion went backwards
-                    const currentVersion = info.customStatusVersion || 0;
                     if (currentVersion < lastVersion) {
                         appendActivity(`{yellow-fg}🔄 [obs] continueAsNew in catch: v${lastVersion}→v${currentVersion}{/yellow-fg}`, orchId);
                         lastVersion = 0;
                         lastIteration = -1;
-                    } else {
-                        appendActivity(`{gray-fg}[obs] catch: no version reset (v${currentVersion} >= v${lastVersion}){/gray-fg}`, orchId);
                     }
                 } catch {}
                 await new Promise(r => setTimeout(r, 500));
@@ -6089,11 +7386,42 @@ function startCmsPoller(orchId) {
                 sessionRenderedCmsSeq.set(orchId, evt.seq);
             }
 
+            // ── Update CMS sequence timeline incrementally ────
+            if (evt.seq && evt.eventType) {
+                const timeline = cmsSeqTimelines.get(sid) || [];
+                const seqEvt = placeCmsSeqEvent(timeline, cmsEventToSeqEvent(evt));
+                if (seqEvt) {
+                    const nodeId = getSeqEventNodeId(seqEvt);
+                    if (nodeId) cmsSeqNodeIndex(nodeId);
+                    timeline.push(seqEvt);
+                    cmsSeqTimelines.set(sid, timeline);
+                    cmsSeqLastSeq.set(sid, evt.seq);
+                    if (timeline.length > 300) timeline.splice(0, timeline.length - 300);
+                    if (logViewMode === "sequence" && orchId === activeOrchId) {
+                        refreshCmsSeqPane();
+                        screen.render();
+                    }
+                }
+            }
+
             const t = formatDisplayTime(Date.now());
             const type = evt.eventType;
 
-            // Don't render events that the customStatus observer already handles
-            if (type === "assistant.message") return;
+            if (type === "session.usage_info" || type === "assistant.usage"
+                || type === "session.compaction_start" || type === "session.compaction_complete") {
+                applySessionUsageEvent(orchId, type, evt.data);
+            }
+
+            // assistant.message is shown as a provisional gray chat entry.
+            // The completed turn result clears that provisional copy.
+            if (type === "assistant.message") {
+                if (typeof evt.data?.content === "string" && evt.data.content.trim()) {
+                    showLiveAssistantPreview(evt.data.content, orchId);
+                }
+                return;
+            }
+            // user.message is already reflected by the local send path and the
+            // history rebuild path, so keep the live CMS subscription quiet here.
             if (type === "user.message") return;
 
             if (type === "tool.execution_start") {
@@ -6108,6 +7436,8 @@ function startCmsPoller(orchId) {
                 appendActivity(`{white-fg}[${t}]{/white-fg} {gray-fg}[reasoning]{/gray-fg}`, orchId);
             } else if (type === "assistant.turn_start") {
                 appendActivity(`{white-fg}[${t}]{/white-fg} {gray-fg}[turn start]{/gray-fg}`, orchId);
+            } else if (type === "session.compaction_start" || type === "session.compaction_complete") {
+                appendActivity(formatCompactionActivityLine(t, evt), orchId);
             } else if (type === "assistant.usage" || type === "session.info" || type === "session.idle"
                 || type === "session.usage_info" || type === "pending_messages.modified" || type === "abort") {
                 // skip internal/noisy events
@@ -6153,6 +7483,8 @@ async function switchToOrchestration(orchId) {
             if (!sessionModels.has(orchId) && info?.customStatus) {
                 try {
                     const cs = typeof info.customStatus === "string" ? JSON.parse(info.customStatus) : info.customStatus;
+                    updateSessionCronSchedule(orchId, cs);
+                    updateSessionContextUsageFromStatus(orchId, cs);
                     const turnResult = cs.turnResult || cs.lastTurnResult;
                     if (turnResult?.model) {
                         sessionModels.set(orchId, turnResult.model);
@@ -6171,6 +7503,8 @@ async function switchToOrchestration(orchId) {
             if (info?.customStatus) {
                 try {
                     const cs = typeof info.customStatus === "string" ? JSON.parse(info.customStatus) : info.customStatus;
+                    updateSessionCronSchedule(orchId, cs);
+                    updateSessionContextUsageFromStatus(orchId, cs);
                     if (cs?.status) {
                         sessionLiveStatus.set(orchId, cs.status);
                         updateSessionListIcons();
@@ -6193,6 +7527,7 @@ async function switchToOrchestration(orchId) {
     // Clear chat and show switch indicator (only when switching to a different session)
     if (!isSameSession) {
         updateChatLabel();
+        updateActivityLabel();
 
         // Show cached chat buffer instantly if available (no DB wait)
         const _cachePh = perfStart("switch.cachedRestore");
@@ -6248,6 +7583,14 @@ async function switchToOrchestration(orchId) {
             if (orchId === activeOrchId) startCmsPoller(orchId);
         });
 
+        // Load CMS event timeline for sequence diagram (background, non-blocking)
+        const sessionIdForSeq = orchId.replace("session-", "");
+        loadCmsSeqTimeline(sessionIdForSeq).then(() => {
+            if (orchId === activeOrchId && logViewMode === "sequence") {
+                refreshSeqPane();
+            }
+        }).catch(() => {});
+
         // Schedule list refresh in background too
         scheduleRefreshOrchestrations();
     } else {
@@ -6271,6 +7614,7 @@ async function switchToOrchestration(orchId) {
 }
 
 updateChatLabel();
+updateActivityLabel();
 const initialChatLines = ensureSessionSplashBuffer(activeOrchId) || sessionChatBuffers.get(activeOrchId) || [];
 if (initialChatLines.length > 0) {
     chatBox.setContent(initialChatLines.map(styleUrls).join("\n"));
@@ -6590,7 +7934,6 @@ async function handleInput(text) {
         appendActivity(`{cyan-fg}[send] interrupt: session busy, enqueuing to ${targetOrchId?.slice(0,20)}{/cyan-fg}`, targetOrchId);
         inputBar.clearValue();
         if (targetOrchId === activeOrchId) setStatus("Interrupting...");
-        injectSeqUserEvent(targetOrchId, trimmed);
         try {
             const dc = getDc();
             if (dc) await dc.enqueueEvent(targetOrchId, "messages", JSON.stringify({ prompt: trimmed }));
@@ -6609,7 +7952,6 @@ async function handleInput(text) {
     focusInput();
     setSessionPendingTurn(targetOrchId, true);
     if (targetOrchId === activeOrchId) setStatus("Thinking... (waiting for AKS worker)");
-    injectSeqUserEvent(targetOrchId, trimmed);
     screen.render();
 
     try {
@@ -6624,9 +7966,16 @@ async function handleInput(text) {
                             || orchStatus.output?.split("\n")[0]
                             || "Unknown error")
                         : orchStatus.status;
+                    const terminalState = sessionStateFromOrchestrationStatus(orchStatus.status);
+                    if (terminalState) {
+                        sessionLiveStatus.set(targetOrchId, terminalState);
+                    }
                     appendChatRaw(`{red-fg}❌ Cannot send — orchestration ${orchStatus.status}: ${reason}{/red-fg}`, targetOrchId);
                     appendChatRaw(`{white-fg}Create a new session with 'n' to continue.{/white-fg}`, targetOrchId);
+                    stopChatSpinner(targetOrchId);
                     setSessionPendingTurn(targetOrchId, false);
+                    clearSessionPendingQuestion(targetOrchId);
+                    updateSessionListIcons();
                     if (targetOrchId === activeOrchId) setStatus(`${orchStatus.status} — session is dead`);
                     screen.render();
                     return;
@@ -6700,6 +8049,7 @@ function showHelpOverlay() {
         "  {yellow-fg}u{/yellow-fg}           Dump active session to Markdown file",
         "  {yellow-fg}a{/yellow-fg}           Show artifact picker (download files)",
         "  {yellow-fg}Ctrl+A{/yellow-fg}      Attach local file to prompt",
+        "  {yellow-fg}Mouse drag{/yellow-fg}  Select visible text inside one pane and copy on release",
         "",
         "{bold}Sessions Pane{/bold}",
         "  {yellow-fg}j / k{/yellow-fg}       Navigate up / down",
@@ -6736,7 +8086,7 @@ function showHelpOverlay() {
         "  {yellow-fg}d{/yellow-fg}           Delete selected exported file",
         "  {yellow-fg}g / G{/yellow-fg}       Preview top / bottom",
         "  {yellow-fg}Ctrl+D/U{/yellow-fg}    Preview page down / up",
-        "  {yellow-fg}o{/yellow-fg}           Open selected file in $EDITOR",
+        "  {yellow-fg}o{/yellow-fg}           Open selected file in default app",
         "  {yellow-fg}y{/yellow-fg}           Copy selected file path",
         "  {yellow-fg}v{/yellow-fg}           Exit markdown viewer",
         "",
@@ -6817,8 +8167,8 @@ function showHelpOverlay() {
 async function cleanup() {
     // Force-exit after 15s — don't let a stuck shutdown hang forever
     const forceExitTimer = setTimeout(() => {
-        const buf = Buffer.from("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1049l\x1b[?25h");
-        try { fs.writeSync(1, buf); } catch {}
+        releaseLocalEmbeddedRuntimeLock();
+        try { fs.writeSync(1, Buffer.from(TERMINAL_RESET_ESCAPE)); } catch {}
         process.exit(0);
     }, 15000);
     forceExitTimer.unref();
@@ -6839,6 +8189,7 @@ async function cleanup() {
         client.stop(),
         mgmt.stop(),
     ]);
+    releaseLocalEmbeddedRuntimeLock();
 
     // Suppress ALL output before destroying — neo-blessed dumps terminfo
     // compilation junk (SetUlc) synchronously during destroy().
@@ -6847,8 +8198,7 @@ async function cleanup() {
     try { screen.destroy(); } catch {}
     // Write terminal reset directly to fd to bypass our suppression
     // Disable mouse tracking modes + exit alt-screen + show cursor
-    const buf = Buffer.from("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1049l\x1b[?25h");
-    try { fs.writeSync(1, buf); } catch {}
+    try { fs.writeSync(1, Buffer.from(TERMINAL_RESET_ESCAPE)); } catch {}
 }
 
 screen.key(["C-c"], async () => {
@@ -6958,6 +8308,13 @@ screen.on("keypress", (ch, key) => {
             screen.render();
             return;
         }
+        if (ch === "o") {
+            const files = scanExportFiles();
+            const f = files[mdViewerSelectedIdx];
+            if (!f) return;
+            openPathInDefaultApp(f.localPath);
+            return;
+        }
         // d: delete the selected file
         if (ch === "d") {
             const files = scanExportFiles();
@@ -6993,10 +8350,10 @@ screen.on("keypress", (ch, key) => {
     // [ / ]: resize right pane by 8 chars
     } else if ((ch === "[" || ch === "]") && screen.focused !== inputBar) {
         if (ch === "[") rightPaneAdjust += 8;  // shrink right (grow left)
-        else rightPaneAdjust = Math.max(0, rightPaneAdjust - 8); // grow right (shrink left)
+        else rightPaneAdjust -= 8; // grow right (shrink left)
         // Clamp: right pane min 20 chars, left pane min 30 chars
-        const maxAdj = screen.width - 20 - Math.floor(screen.width * 0.45);
-        rightPaneAdjust = Math.max(-(Math.floor(screen.width * 0.45) - 30), Math.min(rightPaneAdjust, maxAdj));
+        const maxAdj = screen.width - MIN_RIGHT_PANE_WIDTH - baseLeftW();
+        rightPaneAdjust = Math.max(-(baseLeftW() - MIN_LEFT_PANE_WIDTH), Math.min(rightPaneAdjust, maxAdj));
         relayoutAll();
         redrawActiveViews();
         return;
@@ -7166,6 +8523,7 @@ function buildFocusableList() {
 }
 
 screen.on("resize", () => {
+    clearPaneSelection({ render: false });
     relayoutAll();
     if (logViewMode === "sequence") refreshSeqPane();
     if (logViewMode === "nodemap") refreshNodeMap();
@@ -7177,6 +8535,23 @@ await refreshOrchestrations();
 // Trigger initial right-pane render (orch logs, sequence, etc.)
 redrawActiveViews();
 
+if (!activeOrchId) {
+    renderWaitingForSessionsLanding();
+    if (!isRemote) {
+        // Lazy worker startup means the first session list refresh can race ahead
+        // of system-agent/session creation. Re-check quickly before the normal
+        // 10s poll so the TUI does not appear stuck on the startup splash.
+        for (const delay of [250, 750, 1500, 3000, 5000]) {
+            setTimeout(() => {
+                if (activeOrchId) return;
+                refreshOrchestrations().then(() => {
+                    if (!activeOrchId) renderWaitingForSessionsLanding();
+                }).catch(() => {});
+            }, delay);
+        }
+    }
+}
+
 // ─── Auto-summarize all existing sessions on startup ─────────────
 async function summarizeSession(orchId) {
     if (sessionSummarized.has(orchId)) return;
@@ -7219,7 +8594,7 @@ async function summarizeSession(orchId) {
     let sawRunning = false;
     while (Date.now() < deadline) {
         try {
-            const result = await dc.waitForStatusChange(orchId, version, 200, 15_000);
+            const result = await dc.waitForStatusChange(orchId, version, 1_000, 60_000);
             if (result.customStatusVersion > version) {
                 version = result.customStatusVersion;
             }
@@ -7230,6 +8605,8 @@ async function summarizeSession(orchId) {
                         ? JSON.parse(result.customStatus) : result.customStatus;
                 } catch {}
             }
+            updateSessionCronSchedule(orchId, cs);
+            updateSessionContextUsageFromStatus(orchId, cs);
             if (cs?.status === "running") {
                 sawRunning = true;
                 continue; // wait for the completed result