@creativeintelligence/abbie 0.1.6 → 0.1.8

package/dist/cli/commands/daemon.js

@@ -1,1465 +0,0 @@
-import { execSync, spawn as spawnProcess } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir, hostname } from "node:os";
-import { join } from "node:path";
-import { api, closeClients, getHttpClient, isConvexConfigured, subscribe } from "@creativeintelligence/sdk/convex";
-import { Flags } from "@oclif/core";
-import { getActiveSessionManager } from "../../lib/active-sessions.js";
-import { discoverProjects, loadConfig } from "../../lib/config-loader.js";
-import { getDeviceId } from "../../lib/device.js";
-import * as nvim from "../../lib/nvim/remote.js";
-import { capturePane, isRunning, isSensitiveCommand, redactContent, sendKeys, } from "../../lib/tmux/index.js";
-import { AGENTS } from "../../lib/types.js";
-import * as windows from "../../lib/windows/index.js";
-import { ConfigSyncRunner } from "../../lib/config-sync/index.js";
-import { ContentSyncRunner } from "../../lib/content-sync/index.js";
-import { BaseCommand } from "../base-command.js";
-function sleep(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted)
-            return resolve();
-        const timer = setTimeout(resolve, ms);
-        signal.addEventListener("abort", () => {
-            clearTimeout(timer);
-            resolve();
-        }, { once: true });
-    });
-}
-function truncate(value, max) {
-    if (value.length <= max)
-        return value;
-    return `${value.slice(0, max - 1)}…`;
-}
-function isSessionNotFoundError(err, sessionId) {
-    const message = err instanceof Error ? err.message : String(err);
-    return (message.includes(`Session not found: ${sessionId}`) || message.includes("Session not found"));
-}
-/** Best-effort git rev-parse HEAD in a directory. Returns undefined if not a git repo. */
-function getHeadSha(cwd) {
-    try {
-        return execSync("git rev-parse HEAD", { cwd, timeout: 3000, stdio: "pipe" }).toString().trim();
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Best-effort git diff --name-status between two commits. Returns parsed file changes. */
-function getGitDiff(cwd, fromSha, toSha) {
-    try {
-        const to = toSha ?? "HEAD";
-        const raw = execSync(`git diff --name-status ${fromSha}..${to}`, {
-            cwd,
-            timeout: 5000,
-            stdio: "pipe",
-        })
-            .toString()
-            .trim();
-        if (!raw)
-            return [];
-        return raw.split("\n").map((line) => {
-            const [status, ...fileParts] = line.split("\t");
-            return { status: status || "M", file: fileParts.join("\t") };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-export default class DaemonCommand extends BaseCommand {
-    static description = "Run daemon to sync local state to Convex";
-    static hidden = false;
-    static flags = {
-        ...BaseCommand.baseFlags,
-        interval: Flags.integer({
-            description: "Sync interval in seconds",
-            default: 5,
-        }),
-        "tmux-session": Flags.string({
-            description: 'Tmux session to sync (default: ABBIE_TMUX_SESSION or "abbie"). Use --all-sessions to sync everything.',
-        }),
-        "all-sessions": Flags.boolean({
-            description: "Sync all tmux sessions (legacy behavior; can be noisy)",
-            default: false,
-        }),
-        "windows-only": Flags.boolean({
-            description: "Only sync windows, not sessions",
-            default: false,
-        }),
-        redact: Flags.string({
-            description: "Redaction mode for pane content published to Convex",
-            options: ["none", "balanced", "strict"],
-            default: "balanced",
-        }),
-        "enable-input": Flags.boolean({
-            description: "Enable processing remote terminal input events from Convex (DANGEROUS without a token)",
-            default: false,
-        }),
-        "input-token": Flags.string({
-            description: "Shared secret token required to accept terminal input events (recommended; otherwise input is ignored)",
-        }),
-    };
-    async execute() {
-        const { flags } = await this.parse(DaemonCommand);
-        this.parsedFlags = flags;
-        if (!isConvexConfigured()) {
-            this.error("Convex not configured. Run `abbie login` to authenticate, or set CONVEX_URL env var.");
-        }
-        const intervalSec = flags.interval;
-        if (!Number.isInteger(intervalSec) || intervalSec <= 0) {
-            this.error("--interval must be a positive integer (seconds)");
-        }
-        const deviceId = getDeviceId();
-        const tmuxSessionFilter = flags["all-sessions"]
-            ? undefined
-            : flags["tmux-session"] || process.env.ABBIE_TMUX_SESSION || "abbie";
-        const stopController = new AbortController();
-        const startedAt = new Date().toISOString();
-        const sessionSyncState = new Map();
-        let lastWindowsHash = null;
-        const paneHashByPaneId = new Map();
-        const bufferContentHashByKey = new Map(); // "paneId:bufnr" -> hash
-        const inventoryByPaneId = new Map();
-        const inputEnabled = Boolean(flags["enable-input"]);
-        const inputToken = flags["input-token"] || process.env.AGENTS_INPUT_TOKEN || null;
-        const inputState = {
-            received: 0,
-            sent: 0,
-            skipped: 0,
-            error: null,
-        };
-        const inputUnsubscribers = [];
-        const seenInputEventIds = new Set();
-        let processingInput = false;
-        const pendingInputEvents = [];
-        const enqueueInput = (id, payload) => {
-            if (seenInputEventIds.has(id))
-                return;
-            seenInputEventIds.add(id);
-            // Bound memory.
-            if (seenInputEventIds.size > 500) {
-                const first = seenInputEventIds.values().next().value;
-                if (first)
-                    seenInputEventIds.delete(first);
-            }
-            pendingInputEvents.push({ id, payload });
-            inputState.received++;
-        };
-        const sendToTmux = async (payload) => {
-            const target = inventoryByPaneId.get(payload.paneId);
-            if (!target) {
-                inputState.skipped++;
-                return;
-            }
-            // Split on newlines and send Enter for each newline boundary.
-            const parts = payload.data.split(/\r\n|\r|\n/);
-            for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                if (part.length > 0) {
-                    await sendKeys(target.window, target.pane, part, {
-                        session: target.session,
-                        literal: true,
-                    });
-                }
-                if (i < parts.length - 1) {
-                    // newline boundary
-                    await sendKeys(target.window, target.pane, "Enter", { session: target.session });
-                }
-            }
-            inputState.sent++;
-        };
-        const processInputQueue = async () => {
-            if (processingInput)
-                return;
-            processingInput = true;
-            try {
-                while (pendingInputEvents.length > 0 && !stopController.signal.aborted) {
-                    const next = pendingInputEvents.shift();
-                    if (!next)
-                        break;
-                    await sendToTmux(next.payload);
-                }
-            }
-            catch (err) {
-                inputState.error = err instanceof Error ? err.message : String(err);
-            }
-            finally {
-                processingInput = false;
-            }
-        };
-        const requestStop = (signal) => {
-            if (stopController.signal.aborted)
-                return;
-            this.logInfo(`Daemon stopping... (${signal})`);
-            stopController.abort();
-        };
-        const onSigint = () => requestStop("SIGINT");
-        const onSigterm = () => requestStop("SIGTERM");
-        process.on("SIGINT", onSigint);
-        process.on("SIGTERM", onSigterm);
-        let cmdQueueWorker = null;
-        let sandboxCmdWorker = null;
-        // Sync subscription state (declared outside try for finally cleanup)
-        let configSyncUnsub = null;
-        let contentSyncUnsub = null;
-        try {
-            this.logInfo(`Daemon started (deviceId=${deviceId}, interval=${intervalSec}s)`);
-            await this.syncDeviceHeartbeat(deviceId);
-            if (inputEnabled) {
-                if (!inputToken) {
-                    this.logWarn("Remote input enabled but no token configured; will ignore terminal input events. Set --input-token or AGENTS_INPUT_TOKEN.");
-                }
-                else {
-                    this.logInfo("Remote input enabled (token gated).");
-                }
-                // Subscribe to a small tail of recent terminal input events. This is a temporary bus that
-                // avoids adding new Convex API surface before auth is wired up.
-                const unsubscribe = subscribe(api.events.listRecent, { eventType: "terminal.input", limit: 50 }, (events) => {
-                    // listRecent returns newest-first; process oldest-first.
-                    for (const evt of [...events].reverse()) {
-                        const id = evt._id;
-                        const eventId = typeof id === "string" ? id : null;
-                        if (!eventId)
-                            continue;
-                        const payload = evt.payload;
-                        if (!payload || typeof payload !== "object")
-                            continue;
-                        const p = payload;
-                        if (p.deviceId !== deviceId)
-                            continue;
-                        if (typeof p.paneId !== "string")
-                            continue;
-                        if (typeof p.data !== "string")
-                            continue;
-                        // Token gate: if inputToken configured, only accept matching events.
-                        if (inputToken && p.token !== inputToken)
-                            continue;
-                        // If token is not configured, ignore everything (fail closed).
-                        if (!inputToken)
-                            continue;
-                        enqueueInput(eventId, {
-                            deviceId: p.deviceId,
-                            paneId: p.paneId,
-                            data: p.data,
-                            token: p.token,
-                        });
-                    }
-                    void processInputQueue();
-                });
-                inputUnsubscribers.push(unsubscribe);
-            }
-            // Command queue worker - always enabled.
-            // Process commands enqueued by the chat agent (e.g., "abbie session start").
-            const cmdQueueState = {
-                processed: 0,
-                failed: 0,
-                error: null,
-                inFlight: false,
-            };
-            cmdQueueWorker = this.runCommandQueueWorker(deviceId, cmdQueueState, stopController.signal);
-            this.logInfo("Command queue worker active");
-            // Sandbox command worker state — processes sandbox commands from Convex.
-            // Launched on first successful desktop heartbeat (needs connectionId).
-            const sandboxCmdState = {
-                processed: 0,
-                failed: 0,
-                error: null,
-            };
-            // Config sync — subscribes to Convex for MCP connections, writes agent config files.
-            // Fires instantly on change via Convex reactive subscription.
-            let configSyncRunner = null;
-            let configSyncInFlight = false;
-            let lastConfigSyncResult = undefined;
-            // Content sync — subscribes to Convex for rules/skills/hooks, writes to ~/.abbie/.
-            // Fires instantly on change via Convex reactive subscription.
-            let contentSyncRunner = null;
-            let contentSyncInFlight = false;
-            let lastContentSyncResult = undefined;
-            // Set up decrypt function for apiKey values (best-effort)
-            let configSyncDecrypt;
-            try {
-                const { decryptIfEncrypted } = await import("@lnittman/convex-encryption");
-                configSyncDecrypt = async (v) => {
-                    const result = await decryptIfEncrypted(v);
-                    return result ?? v;
-                };
-            }
-            catch {
-                // Encryption package not available — pass through
-            }
-            while (!stopController.signal.aborted) {
-                const tickAt = new Date().toISOString();
-                const tick = {
-                    at: tickAt,
-                    tmuxRunning: false,
-                    windows: { synced: false, count: 0 },
-                    panes: { enabled: true, synced: false, count: 0, redacted: 0 },
-                    input: {
-                        enabled: inputEnabled,
-                        received: inputState.received,
-                        sent: inputState.sent,
-                        skipped: inputState.skipped,
-                        ...(inputState.error ? { error: inputState.error } : {}),
-                    },
-                    commandQueue: {
-                        enabled: true,
-                        processed: cmdQueueState.processed,
-                        failed: cmdQueueState.failed,
-                        pending: cmdQueueState.inFlight ? 1 : 0,
-                        ...(cmdQueueState.error ? { error: cmdQueueState.error } : {}),
-                    },
-                    bufferContent: { enabled: true, synced: false, count: 0 },
-                    sessions: { enabled: !flags["windows-only"], created: 0, updated: 0 },
-                    projects: { enabled: true, synced: false, count: 0 },
-                    heartbeat: { ok: false },
-                    desktopHeartbeat: { ok: false },
-                    sandboxCommands: {
-                        enabled: this.desktopConnectionId !== null,
-                        processed: sandboxCmdState.processed,
-                        failed: sandboxCmdState.failed,
-                        activeServers: this.sandboxServerProcesses.size,
-                        ...(sandboxCmdState.error ? { error: sandboxCmdState.error } : {}),
-                    },
-                };
-                // Device heartbeat (best-effort)
-                try {
-                    await this.syncDeviceHeartbeat(deviceId);
-                    tick.heartbeat.ok = true;
-                }
-                catch (err) {
-                    tick.heartbeat.ok = false;
-                    tick.heartbeat.error = err instanceof Error ? err.message : String(err);
-                    this.logWarn(`Device heartbeat failed: ${tick.heartbeat.error}`);
-                }
-                // tmux windows
-                try {
-                    tick.tmuxRunning = await isRunning();
-                }
-                catch (err) {
-                    tick.tmuxRunning = false;
-                    tick.windows.error = err instanceof Error ? err.message : String(err);
-                    this.logWarn(`tmux check failed: ${tick.windows.error}`);
-                }
-                // Windows sync: always clear on transition to not-running, otherwise only sync on changes.
-                try {
-                    const shouldClear = !tick.tmuxRunning && lastWindowsHash !== "[]";
-                    const shouldInventory = tick.tmuxRunning;
-                    if (shouldInventory) {
-                        const inventory = await windows.inventory({
-                            session: tmuxSessionFilter,
-                            includeNvim: true,
-                            includeAgent: true,
-                            includeBuffers: true,
-                        });
-                        // Update paneId -> window mapping for input.
-                        inventoryByPaneId.clear();
-                        for (const state of inventory) {
-                            inventoryByPaneId.set(state.window.paneId, state.window);
-                        }
-                        const syncResult = await this.syncWindows(deviceId, {
-                            lastHash: lastWindowsHash,
-                            inventory,
-                        });
-                        tick.windows.synced = syncResult.synced;
-                        tick.windows.count = syncResult.count;
-                        lastWindowsHash = syncResult.hash;
-                        if (syncResult.synced) {
-                            this.logInfo(`Synced ${syncResult.count} windows`);
-                        }
-                        // Pane snapshots: sync every tick while tmux is running.
-                        try {
-                            const panesResult = await this.syncPanes(deviceId, inventory, paneHashByPaneId, flags.redact);
-                            tick.panes.synced = panesResult.synced;
-                            tick.panes.count = panesResult.count;
-                            tick.panes.redacted = panesResult.redacted;
-                        }
-                        catch (err) {
-                            tick.panes.error = err instanceof Error ? err.message : String(err);
-                            this.logWarn(`Panes sync failed: ${tick.panes.error}`);
-                        }
-                        // Nvim buffer content: sync terminal buffer scrollback via nvim RPC
-                        try {
-                            const bufResult = await this.syncNvimBufferContent(deviceId, inventory, bufferContentHashByKey);
-                            tick.bufferContent.synced = bufResult.synced;
-                            tick.bufferContent.count = bufResult.count;
-                            if (bufResult.synced) {
-                                this.logInfo(`Synced ${bufResult.count} nvim buffers`);
-                            }
-                        }
-                        catch (err) {
-                            tick.bufferContent.error = err instanceof Error ? err.message : String(err);
-                            this.logWarn(`Buffer content sync failed: ${tick.bufferContent.error}`);
-                        }
-                    }
-                    else if (shouldClear) {
-                        const syncResult = await this.syncWindows(deviceId, { clear: true });
-                        tick.windows.synced = syncResult.synced;
-                        tick.windows.count = syncResult.count;
-                        lastWindowsHash = syncResult.hash;
-                        if (syncResult.synced) {
-                            this.logInfo("tmux not running; cleared windows");
-                        }
-                        // Best-effort: clear panes when tmux stops.
-                        try {
-                            await getHttpClient().mutation(api.panes.clearByDevice, { deviceId });
-                            paneHashByPaneId.clear();
-                            tick.panes.synced = true;
-                            tick.panes.count = 0;
-                        }
-                        catch (err) {
-                            tick.panes.error = err instanceof Error ? err.message : String(err);
-                            this.logWarn(`Panes clear failed: ${tick.panes.error}`);
-                        }
-                    }
-                }
-                catch (err) {
-                    tick.windows.error = err instanceof Error ? err.message : String(err);
-                    this.logWarn(`Windows sync failed: ${tick.windows.error}`);
-                }
-                // Session sync (best-effort)
-                if (!flags["windows-only"]) {
-                    try {
-                        const sessionResult = await this.syncSessions(deviceId, sessionSyncState);
-                        tick.sessions.created = sessionResult.created;
-                        tick.sessions.updated = sessionResult.updated;
-                        if (sessionResult.created || sessionResult.updated) {
-                            this.logInfo(`Synced sessions (created=${sessionResult.created}, updated=${sessionResult.updated})`);
-                        }
-                    }
-                    catch (err) {
-                        tick.sessions.error = err instanceof Error ? err.message : String(err);
-                        this.logWarn(`Session sync failed: ${tick.sessions.error}`);
-                    }
-                }
-                // Projects sync (Convex → local cache)
-                try {
-                    const projectsResult = await this.syncProjects(deviceId);
-                    tick.projects.synced = projectsResult.synced;
-                    tick.projects.count = projectsResult.count;
-                    if (projectsResult.synced) {
-                        this.logInfo(`Synced ${projectsResult.count} projects to local cache`);
-                    }
-                }
-                catch (err) {
-                    tick.projects.error = err instanceof Error ? err.message : String(err);
-                    // Don't warn every tick - user might not be logged in
-                }
-                // Config sync + Content sync — set up Convex subscriptions once when clerkId is available.
-                // Subscriptions fire instantly on change (no polling). Runners are initialized lazily.
-                if (this.clerkId && !configSyncUnsub) {
-                    const clerkId = this.clerkId;
-                    // Initialize config sync runner
-                    configSyncRunner = new ConfigSyncRunner({
-                        fetchSnapshot: async () => {
-                            return await getHttpClient().query(api.configSync.getSnapshot, { clerkId });
-                        },
-                        decrypt: configSyncDecrypt,
-                    });
-                    this.logInfo("Config sync: subscription active");
-                    // Subscribe — fires immediately with current state, then on every change
-                    configSyncUnsub = subscribe(api.configSync.getSnapshot, { clerkId }, (snapshot) => {
-                        if (configSyncInFlight)
-                            return;
-                        configSyncInFlight = true;
-                        configSyncRunner.tick({ snapshot }).then((result) => {
-                            lastConfigSyncResult = {
-                                ok: result.ok,
-                                reason: result.reason,
-                                agents: result.changes,
-                            };
-                            if (result.changes.length > 0) {
-                                const updated = result.changes.filter((c) => c.action === "updated");
-                                if (updated.length > 0) {
-                                    this.logInfo(`Config sync: ${updated.map((c) => c.agent).join(", ")} updated`);
-                                }
-                            }
-                        }).catch((err) => {
-                            lastConfigSyncResult = {
-                                ok: false,
-                                reason: "error",
-                                agents: [],
-                                error: err instanceof Error ? err.message : String(err),
-                            };
-                        }).finally(() => {
-                            configSyncInFlight = false;
-                        });
-                    });
-                    // Initialize content sync runner
-                    contentSyncRunner = new ContentSyncRunner({
-                        fetchSnapshot: async () => {
-                            return await getHttpClient().query(api.contentSync.getSnapshot, { clerkId });
-                        },
-                    });
-                    this.logInfo("Content sync: subscription active");
-                    // Subscribe
-                    contentSyncUnsub = subscribe(api.contentSync.getSnapshot, { clerkId }, (snapshot) => {
-                        if (contentSyncInFlight)
-                            return;
-                        contentSyncInFlight = true;
-                        contentSyncRunner.tick({ snapshot }).then((result) => {
-                            lastContentSyncResult = {
-                                ok: result.ok,
-                                reason: result.reason,
-                                changes: result.changes,
-                            };
-                            if (result.changes.length > 0) {
-                                const actionable = result.changes.filter((c) => c.action !== "unchanged");
-                                if (actionable.length > 0) {
-                                    this.logInfo(`Content sync: ${actionable.map((c) => `${c.type}/${c.name}:${c.action}`).join(", ")}`);
-                                }
-                            }
-                        }).catch((err) => {
-                            lastContentSyncResult = {
-                                ok: false,
-                                reason: "error",
-                                changes: [],
-                                error: err instanceof Error ? err.message : String(err),
-                            };
-                        }).finally(() => {
-                            contentSyncInFlight = false;
-                        });
-                    });
-                }
-                // Report last subscription sync results in tick
-                if (lastConfigSyncResult) {
-                    tick.configSync = lastConfigSyncResult;
-                }
-                if (lastContentSyncResult) {
-                    tick.contentSync = lastContentSyncResult;
-                }
-                // Desktop provider heartbeat bridge (best-effort)
-                try {
-                    await this.syncDesktopHeartbeat(deviceId);
-                    if (this.desktopProviderRegistered) {
-                        tick.desktopHeartbeat.ok = true;
-                    }
-                }
-                catch (err) {
-                    tick.desktopHeartbeat.ok = false;
-                    tick.desktopHeartbeat.error = err instanceof Error ? err.message : String(err);
-                    this.logWarn(`Desktop heartbeat failed: ${tick.desktopHeartbeat.error}`);
-                }
-                // Launch sandbox command worker once we have a connectionId
-                if (this.desktopConnectionId && !sandboxCmdWorker) {
-                    sandboxCmdWorker = this.runSandboxCommandWorker(this.desktopConnectionId, sandboxCmdState, stopController.signal);
-                    this.logInfo("Sandbox command worker active");
-                }
-                // Update tick with live sandbox state
-                tick.sandboxCommands.enabled = this.desktopConnectionId !== null;
-                tick.sandboxCommands.processed = sandboxCmdState.processed;
-                tick.sandboxCommands.failed = sandboxCmdState.failed;
-                tick.sandboxCommands.activeServers = this.sandboxServerProcesses.size;
-                if (this.ndjsonEnabled()) {
-                    this.outputNdjson([tick]);
-                }
-                await sleep(intervalSec * 1000, stopController.signal);
-            }
-        }
-        finally {
-            process.off("SIGINT", onSigint);
-            process.off("SIGTERM", onSigterm);
-            stopController.abort();
-            try {
-                if (cmdQueueWorker)
-                    await cmdQueueWorker;
-            }
-            catch {
-                // ignore
-            }
-            try {
-                if (sandboxCmdWorker)
-                    await sandboxCmdWorker;
-            }
-            catch {
-                // ignore
-            }
-            // Kill any spawned server processes
-            for (const [, proc] of this.sandboxServerProcesses) {
-                try {
-                    proc.kill("SIGTERM");
-                }
-                catch {
-                    // ignore
-                }
-            }
-            this.sandboxServerProcesses.clear();
-            for (const unsub of inputUnsubscribers) {
-                try {
-                    unsub();
-                }
-                catch {
-                    // ignore
-                }
-            }
-            // Clean up sync subscriptions
-            if (configSyncUnsub) {
-                try {
-                    configSyncUnsub();
-                }
-                catch { /* ignore */ }
-            }
-            if (contentSyncUnsub) {
-                try {
-                    contentSyncUnsub();
-                }
-                catch { /* ignore */ }
-            }
-            closeClients();
-        }
-        const stoppedAt = new Date().toISOString();
-        const result = { status: "stopped", deviceId, startedAt, stoppedAt };
-        if (this.ndjsonEnabled()) {
-            this.outputNdjson([result]);
-        }
-        return result;
-    }
-    async syncWindows(deviceId, options) {
-        if (options?.clear) {
-            const result = await getHttpClient().mutation(api.windows.sync, { deviceId, windows: [] });
-            return { synced: true, count: result.synced, hash: "[]" };
-        }
-        const states = options?.inventory ??
-            (await windows.inventory({
-                includeNvim: true,
-                includeAgent: true,
-                includeBuffers: true,
-            }));
-        const sorted = states.sort((a, b) => {
-            if (a.window.session !== b.window.session)
-                return a.window.session.localeCompare(b.window.session);
-            if (a.window.window !== b.window.window)
-                return a.window.window - b.window.window;
-            return a.window.pane - b.window.pane;
-        });
-        // Build PID → sessionId map for agent↔session linkage
-        const pidToSessionId = new Map();
-        try {
-            const activeSessions = getActiveSessionManager().list();
-            for (const s of activeSessions) {
-                if (s.pid && s.status === "running") {
-                    pidToSessionId.set(s.pid, s.session_id);
-                }
-            }
-        }
-        catch {
-            // Best-effort — don't block sync if session manager fails
-        }
-        const windowData = sorted.map((state) => ({
-            paneId: state.window.paneId ||
-                `${state.window.session}:${state.window.window}.${state.window.pane}`,
-            tmuxSession: state.window.session,
-            windowIndex: state.window.window,
-            windowName: state.window.windowName,
-            paneIndex: state.window.pane,
-            cwd: state.window.cwd || "",
-            title: state.window.title || undefined,
-            isActive: state.window.active,
-            cols: state.window.size.cols,
-            rows: state.window.size.rows,
-            hasNvim: state.nvim?.available ?? false,
-            nvimPid: state.nvim?.pid ?? undefined,
-            nvimServerAddr: state.nvim?.serverAddr ?? undefined,
-            agentType: state.agent?.type ?? undefined,
-            agentPid: state.agent?.pid ?? undefined,
-            sessionId: state.agent?.pid ? pidToSessionId.get(state.agent.pid) : undefined,
-            nvimCurrentBuffer: state.nvim?.currentBuffer
-                ? {
-                    name: state.nvim.currentBuffer.name,
-                    path: state.nvim.currentBuffer.path,
-                    modified: state.nvim.currentBuffer.modified,
-                    filetype: state.nvim.currentBuffer.filetype,
-                    lineCount: state.nvim.currentBuffer.lineCount,
-                }
-                : undefined,
-            nvimBuffers: state.buffers.length > 0
-                ? state.buffers.map((b) => ({
-                    name: b.name,
-                    path: b.path,
-                    modified: b.modified,
-                    filetype: b.filetype,
-                    lineCount: b.lineCount,
-                }))
-                : undefined,
-        }));
-        const hash = JSON.stringify(windowData);
-        if (options?.lastHash === hash) {
-            return { synced: false, count: windowData.length, hash };
-        }
-        const syncResult = await getHttpClient().mutation(api.windows.sync, {
-            deviceId,
-            windows: windowData,
-        });
-        return { synced: true, count: syncResult.synced, hash };
-    }
-    async syncPanes(deviceId, inventory, lastHashByPaneId, redactMode) {
-        const updates = [];
-        let redacted = 0;
-        for (const state of inventory) {
-            const paneId = state.window.paneId ||
-                `${state.window.session}:${state.window.window}.${state.window.pane}`;
-            const raw = await capturePane(state.window.window, state.window.pane, {
-                session: state.window.session,
-                lines: 100,
-            });
-            let content = raw;
-            if (redactMode !== "none") {
-                const title = state.window.title ?? "";
-                if (title && isSensitiveCommand(title)) {
-                    content = "***REDACTED***";
-                    redacted++;
-                }
-                else {
-                    const result = redactContent(raw, redactMode);
-                    content = result.content;
-                    if (result.wasRedacted)
-                        redacted++;
-                }
-            }
-            const hash = createHash("sha1").update(content).digest("hex");
-            const prev = lastHashByPaneId.get(paneId);
-            if (prev === hash)
-                continue;
-            lastHashByPaneId.set(paneId, hash);
-            updates.push({ paneId, paneIndex: state.window.pane, content });
-        }
-        if (updates.length === 0) {
-            return { synced: false, count: 0, redacted: 0 };
-        }
-        const result = await getHttpClient().mutation(api.panes.sync, {
-            deviceId,
-            panes: updates,
-        });
-        return { synced: true, count: result.total, redacted };
-    }
-    async syncNvimBufferContent(deviceId, inventory, hashByKey) {
-        let totalSynced = 0;
-        for (const state of inventory) {
-            const serverAddr = state.nvim?.serverAddr;
-            if (!serverAddr)
-                continue;
-            const paneId = state.window.paneId ||
-                `${state.window.session}:${state.window.window}.${state.window.pane}`;
-            const buffers = await nvim.listBuffers(serverAddr);
-            if (!buffers || buffers.length === 0)
-                continue;
-            const bufferData = [];
-            let anyChanged = false;
-            for (const buf of buffers) {
-                const isTerminal = buf.name.startsWith("term://");
-                // Read last 200 lines — enough for context, bounded storage
-                const lines = await nvim.getBufferLines(serverAddr, buf.bufnr, 1, "$");
-                if (!lines)
-                    continue;
-                const tail = lines.length > 200 ? lines.slice(-200) : lines;
-                const content = tail.join("\n");
-                // Track if content changed via hash
-                const key = `${paneId}:${buf.bufnr}`;
-                const hash = createHash("sha1").update(content).digest("hex");
-                if (hashByKey.get(key) !== hash) {
-                    hashByKey.set(key, hash);
-                    anyChanged = true;
-                }
-                bufferData.push({
-                    bufnr: buf.bufnr,
-                    name: buf.name,
-                    content,
-                    lineCount: lines.length,
-                    isTerminal,
-                });
-            }
-            // Only sync if something changed (but always send ALL buffers so stale removal works)
-            if (!anyChanged || bufferData.length === 0)
-                continue;
-            await getHttpClient().mutation(api.nvimBufferContent.sync, {
-                deviceId,
-                paneId,
-                buffers: bufferData,
-            });
-            totalSynced += bufferData.length;
-        }
-        return { synced: totalSynced > 0, count: totalSynced };
-    }
-    async syncDeviceHeartbeat(deviceId) {
-        await getHttpClient().mutation(api.devices.upsert, {
-            deviceId,
-            hostname: hostname(),
-            platform: process.platform,
-            metadata: {
-                user: process.env.USER || process.env.LOGNAME || undefined,
-                version: this.config.version || undefined,
-            },
-        });
-    }
-    async syncDesktopHeartbeat(deviceId) {
-        if (!this.desktopProviderRegistered)
-            return;
-        if (!this.clerkId) {
-            throw new Error("Desktop provider registered, but clerkId is missing");
-        }
-        if (!this.desktopProviderId) {
-            throw new Error("Desktop provider registered, but providerId is missing");
-        }
-        const result = await getHttpClient().mutation(api["functions/sandbox/desktop"].heartbeat, {
-            clerkId: this.clerkId,
-            providerId: this.desktopProviderId,
-            machineId: deviceId,
-            machineName: hostname(),
-            platform: process.platform,
-        });
-        if (result?.connectionId) {
-            this.desktopConnectionId = result.connectionId;
-        }
-    }
-    async syncSessions(deviceId, stateBySessionId) {
-        const manager = getActiveSessionManager();
-        // Avoid scanning huge histories every tick.
-        // Note: manager.list() already reaps orphaned terminal-mode sessions
-        // (marks them "failed" if their tmux pane is gone — see isTmuxPaneAlive check).
-        const sessions = manager.list().slice(0, 200);
-        let created = 0;
-        let updated = 0;
-        for (const session of sessions) {
-            const prev = stateBySessionId.get(session.session_id);
-            if (prev?.status === session.status) {
-                if (session.status === "running")
-                    continue;
-                if (prev.endedAt !== undefined)
-                    continue;
-            }
-            const next = {
-                status: session.status,
-                cwd: prev?.cwd ?? session.cwd,
-                traceId: prev?.traceId ?? session.trace_id,
-                sessionId: session.session_id,
-                project: session.project,
-                startCommitSha: prev?.startCommitSha ?? session.start_commit_sha,
-            };
-            if (session.status !== "running") {
-                next.endedAt = prev?.endedAt ?? Date.now();
-            }
-            const updateArgs = {
-                sessionId: session.session_id,
-                status: session.status,
-                pid: session.pid || undefined,
-                endedAt: next.endedAt,
-                metadata: session.exit_code !== undefined || session.read_only !== undefined
-                    ? {
-                        exitCode: session.exit_code,
-                        readOnly: session.read_only,
-                    }
-                    : undefined,
-            };
-            let updatedRemote = false;
-            try {
-                const res = await getHttpClient().mutation(api.sessions.update, updateArgs);
-                // Newer backend returns `{ updated: false }` instead of throwing when missing.
-                if (res &&
-                    typeof res === "object" &&
-                    "updated" in res &&
-                    res.updated === false) {
-                    updatedRemote = false;
-                }
-                else {
-                    updatedRemote = true;
-                }
-            }
-            catch (err) {
-                if (!isSessionNotFoundError(err, session.session_id)) {
-                    throw err;
-                }
-                updatedRemote = false;
-            }
-            if (updatedRemote) {
-                // Emit file_activity on session completion (Agent Trace producer)
-                if (prev?.status === "running" &&
-                    session.status !== "running" &&
-                    prev.startCommitSha &&
-                    prev.cwd &&
-                    prev.traceId) {
-                    try {
-                        const changes = getGitDiff(prev.cwd, prev.startCommitSha);
-                        if (changes.length > 0) {
-                            await getHttpClient().mutation(api.contextBus.publish, {
-                                traceId: prev.traceId,
-                                sessionId: session.session_id,
-                                project: session.project,
-                                type: "file_activity",
-                                title: `${changes.length} file(s) changed`,
-                                content: JSON.stringify(changes),
-                                metadata: {
-                                    startCommitSha: prev.startCommitSha,
-                                    endCommitSha: getHeadSha(prev.cwd),
-                                    agent: session.agent,
-                                    sessionStatus: session.status,
-                                },
-                            });
-                        }
-                    }
-                    catch {
-                        // Best-effort — never block session sync
-                    }
-                }
-                updated++;
-                stateBySessionId.set(session.session_id, next);
-                continue;
-            }
-            // Create (only if not found)
-            const goal = session.goal?.trim();
-            // Prefer sha captured at spawn time (from active-sessions.ts start()),
-            // fall back to current HEAD if not available (e.g. old session format)
-            const headSha = session.start_commit_sha || getHeadSha(session.cwd);
-            next.startCommitSha = headSha;
-            await getHttpClient().mutation(api.sessions.create, {
-                sessionId: session.session_id,
-                agent: session.agent,
-                project: session.project,
-                goal: goal ? truncate(goal, 1000) : undefined,
-                issue: session.issue,
-                status: session.status,
-                pid: session.pid || undefined,
-                cwd: session.cwd,
-                deviceId,
-                parentSessionId: session.parent_session_id,
-                traceId: session.trace_id,
-                promptPath: session.prompt_path,
-                outputPath: session.output_path,
-                startCommitSha: headSha,
-                metadata: session.exit_code !== undefined || session.read_only !== undefined
-                    ? {
-                        exitCode: session.exit_code,
-                        readOnly: session.read_only,
-                    }
-                    : undefined,
-            });
-            created++;
-            stateBySessionId.set(session.session_id, next);
-        }
-        return { created, updated };
-    }
-    lastProjectsHash = null;
-    desktopProviderRegistered = false;
-    clerkId = null;
-    desktopProviderId = null;
-    desktopConnectionId = null;
-    sandboxServerProcesses = new Map();
-    async syncProjects(deviceId) {
-        // Query Convex for projects associated with this device's user
-        let result = await getHttpClient().query(api.projects.listByDeviceId, { deviceId });
-        if (!result.clerkId) {
-            // User not logged in — can't sync
-            return { synced: false, count: 0 };
-        }
-        // Store clerkId for other operations
-        this.clerkId = result.clerkId;
-        // Register this machine as a Desktop sandbox provider (once per daemon lifecycle)
-        if (!this.desktopProviderRegistered) {
-            try {
-                const reg = await getHttpClient().mutation(api["functions/sandbox/providers"].registerDesktopProvider, {
-                    clerkId: result.clerkId,
-                    deviceId,
-                    machineName: hostname(),
-                    platform: process.platform,
-                });
-                this.desktopProviderId = reg.providerId;
-                this.desktopProviderRegistered = true;
-                this.logInfo(`Desktop sandbox provider registered${reg.isNew ? "" : " (existing)"}.`);
-            }
-            catch (err) {
-                this.logWarn(`Desktop provider registration failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        // Push local project configs UP to Convex (idempotent, hash-deduped)
-        try {
-            const pushResult = await this.pushLocalProjects(result.clerkId);
-            if (pushResult.pushed > 0) {
-                this.logInfo(`Pushed ${pushResult.pushed} projects to Convex`);
-                // Re-fetch to get the updated list
-                result = await getHttpClient().query(api.projects.listByDeviceId, { deviceId });
-            }
-        }
-        catch (err) {
-            this.logWarn(`Project push failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        if (result.projects.length === 0) {
-            this.logWarn(`syncProjects: 0 projects after push (clerkId=${result.clerkId})`);
-            return { synced: false, count: 0 };
-        }
-        // Build the projects.json structure matching existing format
-        const projectsMap = {};
-        for (const project of result.projects) {
-            projectsMap[project.name] = {
-                name: project.name,
-                emoji: project.emoji || "📁",
-                linearTeam: project.linearTeam || null,
-                color: project.color || "#bec2c8",
-            };
-        }
-        const projectsJson = {
-            projects: projectsMap,
-            defaultEmoji: "📁",
-            lastUpdated: new Date().toISOString(),
-        };
-        // Check if content changed
-        const hash = createHash("sha1").update(JSON.stringify(projectsMap)).digest("hex");
-        if (hash === this.lastProjectsHash) {
-            return { synced: false, count: result.projects.length };
-        }
-        // Write to ~/.abbie/projects.json
-        const abbieDir = join(homedir(), ".abbie");
-        if (!existsSync(abbieDir)) {
-            mkdirSync(abbieDir, { recursive: true });
-        }
-        const projectsPath = join(abbieDir, "projects.json");
-        writeFileSync(projectsPath, JSON.stringify(projectsJson, null, 2), "utf-8");
-        this.lastProjectsHash = hash;
-        return { synced: true, count: result.projects.length };
-    }
-    lastProjectsPushHash = null;
-    /**
-     * Push local project configs (.abbie/config.json) UP to Convex projects table.
-     * Idempotent — uses hash dedup to avoid redundant mutations.
-     */
-    async pushLocalProjects(clerkId) {
-        const discovered = discoverProjects().filter((p) => p.hasConfig && p.configPath);
-        // Build normalized config data for hashing
-        const configData = [];
-        for (const p of discovered) {
-            const loaded = loadConfig(p.configPath);
-            if (!loaded?.config?.name)
-                continue;
-            configData.push({
-                name: loaded.config.name,
-                emoji: loaded.config.emoji?.trim() || "📁",
-                color: "#bec2c8",
-                team: loaded.config.team,
-                path: p.path,
-            });
-        }
-        const hash = createHash("sha1").update(JSON.stringify(configData)).digest("hex");
-        if (hash === this.lastProjectsPushHash) {
-            return { pushed: 0 };
-        }
-        let pushed = 0;
-        for (const cfg of configData) {
-            try {
-                await getHttpClient().mutation(api.projects.upsert, {
-                    clerkId,
-                    name: cfg.name,
-                    emoji: cfg.emoji,
-                    color: cfg.color,
-                    linearTeam: cfg.team,
-                    path: cfg.path,
-                });
-                pushed++;
-            }
-            catch (err) {
-                this.logWarn(`Failed to push project ${cfg.name}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        this.lastProjectsPushHash = hash;
-        return { pushed };
-    }
-    async runCommandQueueWorker(deviceId, state, signal) {
-        while (!signal.aborted) {
-            if (state.inFlight) {
-                await sleep(250, signal);
-                continue;
-            }
-            let claimed = null;
-            try {
-                const next = await getHttpClient().mutation(api.commandQueue.claim, { deviceId });
-                if (!next) {
-                    await sleep(1000, signal);
-                    continue;
-                }
-                claimed = next;
-                state.inFlight = true;
-                const result = await this.executeQueuedCommand(claimed.command, claimed.args);
-                if (result.success) {
-                    await getHttpClient().mutation(api.commandQueue.complete, { id: claimed.id, result });
-                    state.processed++;
-                    state.error = null;
-                    this.logInfo(`Command executed: ${claimed.command}`);
-                }
-                else {
-                    const errorMsg = result.error || "Unknown error";
-                    await getHttpClient().mutation(api.commandQueue.fail, {
-                        id: claimed.id,
-                        error: errorMsg,
-                    });
-                    state.failed++;
-                    state.error = errorMsg;
-                    this.logWarn(`Command failed: ${claimed.command} - ${errorMsg}`);
-                }
-            }
-            catch (err) {
-                const errorMsg = err instanceof Error ? err.message : String(err);
-                state.failed++;
-                state.error = errorMsg;
-                if (claimed) {
-                    try {
-                        await getHttpClient().mutation(api.commandQueue.fail, {
-                            id: claimed.id,
-                            error: errorMsg,
-                        });
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-                await sleep(1000, signal);
-            }
-            finally {
-                state.inFlight = false;
-            }
-        }
-    }
-    /**
-     * Background worker that polls the sandbox command queue for pending
-     * commands (startServer, stopServer, exec) and executes them locally.
-     */
-    async runSandboxCommandWorker(connectionId, state, signal) {
-        while (!signal.aborted) {
-            try {
-                const pending = await getHttpClient().query(api["functions/sandbox/desktop"].listPendingCommands, { connectionId });
-                if (!pending || pending.length === 0) {
-                    await sleep(2000, signal);
-                    continue;
-                }
-                for (const cmd of pending) {
-                    if (signal.aborted)
-                        break;
-                    const { _id: commandId, commandType } = cmd;
-                    // Claim the command
-                    try {
-                        await getHttpClient().mutation(api["functions/sandbox/desktop"].claimCommand, {
-                            commandId,
-                        });
-                    }
-                    catch (_err) {
-                        // Another daemon may have claimed it — skip
-                        continue;
-                    }
-                    try {
-                        await this.executeSandboxCommand(cmd);
-                        state.processed++;
-                        state.error = null;
-                        this.logInfo(`Sandbox command executed: ${commandType}`);
-                    }
-                    catch (err) {
-                        const errorMsg = err instanceof Error ? err.message : String(err);
-                        state.failed++;
-                        state.error = errorMsg;
-                        this.logWarn(`Sandbox command failed: ${commandType} - ${errorMsg}`);
-                        // Report failure
-                        try {
-                            await getHttpClient().mutation(api["functions/sandbox/desktop"].completeCommand, {
-                                commandId,
-                                status: "failed",
-                                stderr: errorMsg.slice(0, 2000),
-                            });
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                state.error = err instanceof Error ? err.message : String(err);
-                // Don't spam on persistent errors
-                await sleep(5000, signal);
-            }
-            await sleep(1000, signal);
-        }
-    }
-    /**
-     * Execute a single sandbox command locally.
-     * Handles startServer (spawn detached process), stopServer (kill by PID),
-     * and exec (run command and capture output).
-     */
-    async executeSandboxCommand(cmd) {
-        const c = cmd;
-        const commandId = c._id;
-        switch (c.commandType) {
-            case "startServer": {
-                if (!c.serverId) {
-                    throw new Error("startServer command missing serverId");
-                }
-                const [command, ...args] = c.cmd;
-                if (!command) {
-                    throw new Error("startServer command has empty cmd array");
-                }
-                const proc = spawnProcess(command, args, {
-                    cwd: c.workdir ?? process.cwd(),
-                    env: { ...process.env, ...(c.env ?? {}) },
-                    detached: true,
-                    stdio: ["ignore", "pipe", "pipe"],
-                });
-                // Track the process by serverId
-                this.sandboxServerProcesses.set(c.serverId, proc);
-                const pid = proc.pid;
-                let stdoutBuf = "";
-                let stderrBuf = "";
-                proc.stdout?.on("data", (chunk) => {
-                    stdoutBuf += chunk.toString();
-                    // Keep only last 4KB for reporting
-                    if (stdoutBuf.length > 4096) {
-                        stdoutBuf = stdoutBuf.slice(-4096);
-                    }
-                });
-                proc.stderr?.on("data", (chunk) => {
-                    stderrBuf += chunk.toString();
-                    if (stderrBuf.length > 4096) {
-                        stderrBuf = stderrBuf.slice(-4096);
-                    }
-                });
-                // Report running status to Convex
-                const publicUrl = c.serverOpts ? `http://localhost:${c.serverOpts.port}` : undefined;
-                await getHttpClient().mutation(api["functions/sandbox/desktop"].updateServerStatus, {
-                    serverId: c.serverId,
-                    status: "running",
-                    providerServerId: pid ? String(pid) : undefined,
-                    publicUrl,
-                });
-                // Complete the command
-                await getHttpClient().mutation(api["functions/sandbox/desktop"].completeCommand, {
-                    commandId,
-                    status: "completed",
-                    stdout: `Server started with PID ${pid}`,
-                });
-                // Monitor process exit
-                proc.on("exit", (code, sig) => {
-                    this.sandboxServerProcesses.delete(c.serverId);
-                    // Best-effort status update
-                    getHttpClient()
-                        .mutation(api["functions/sandbox/desktop"].updateServerStatus, {
-                        serverId: c.serverId,
-                        status: code === 0 || sig === "SIGTERM" ? "stopped" : "failed",
-                        error: code !== 0 && code !== null
-                            ? `Process exited with code ${code}${stderrBuf ? `: ${stderrBuf.slice(0, 500)}` : ""}`
-                            : undefined,
-                    })
-                        .catch(() => {
-                        // ignore
-                    });
-                });
-                proc.unref();
-                break;
-            }
-            case "stopServer": {
-                if (!c.serverId) {
-                    throw new Error("stopServer command missing serverId");
-                }
-                const existing = this.sandboxServerProcesses.get(c.serverId);
-                if (existing) {
-                    existing.kill("SIGTERM");
-                    this.sandboxServerProcesses.delete(c.serverId);
-                }
-                await getHttpClient().mutation(api["functions/sandbox/desktop"].updateServerStatus, {
-                    serverId: c.serverId,
-                    status: "stopped",
-                });
-                await getHttpClient().mutation(api["functions/sandbox/desktop"].completeCommand, {
-                    commandId,
-                    status: "completed",
-                    stdout: existing
-                        ? `Server stopped (PID ${existing.pid})`
-                        : "Server not found locally (may have already exited)",
-                });
-                break;
-            }
-            case "exec": {
-                const startTime = Date.now();
-                const [execCmd, ...execArgs] = c.cmd;
-                if (!execCmd) {
-                    throw new Error("exec command has empty cmd array");
-                }
-                const result = await new Promise((resolve) => {
-                    let stdout = "";
-                    let stderr = "";
-                    const proc = spawnProcess(execCmd, execArgs, {
-                        cwd: c.workdir ?? process.cwd(),
-                        env: { ...process.env, ...(c.env ?? {}) },
-                        stdio: ["ignore", "pipe", "pipe"],
-                        timeout: c.timeoutMs ?? 30_000,
-                    });
-                    proc.stdout?.on("data", (chunk) => {
-                        stdout += chunk.toString();
-                    });
-                    proc.stderr?.on("data", (chunk) => {
-                        stderr += chunk.toString();
-                    });
-                    proc.on("close", (code) => {
-                        resolve({
-                            exitCode: code ?? 1,
-                            stdout: stdout.slice(0, 8000),
-                            stderr: stderr.slice(0, 8000),
-                        });
-                    });
-                    proc.on("error", (err) => {
-                        resolve({
-                            exitCode: 1,
-                            stdout: "",
-                            stderr: err.message,
-                        });
-                    });
-                });
-                const durationMs = Date.now() - startTime;
-                await getHttpClient().mutation(api["functions/sandbox/desktop"].completeCommand, {
-                    commandId,
-                    status: result.exitCode === 0 ? "completed" : "failed",
-                    exitCode: result.exitCode,
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    durationMs,
-                });
-                break;
-            }
-            default:
-                throw new Error(`Unknown sandbox command type: ${c.commandType}`);
-        }
-    }
-    /**
-     * Execute a queued command from the chat agent.
-     * Currently supports "abbie session start" for spawning local agent sessions.
-     */
-    async executeQueuedCommand(command, args) {
-        switch (command) {
-            case "abbie session start": {
-                if (!args || typeof args !== "object") {
-                    return {
-                        success: false,
-                        error: 'Invalid args for "abbie session start": expected an object',
-                    };
-                }
-                const sessionArgs = args;
-                const allowedAgents = new Set(AGENTS);
-                if (!sessionArgs.agent || !allowedAgents.has(sessionArgs.agent)) {
-                    return {
-                        success: false,
-                        error: 'Invalid args for "abbie session start": missing or invalid `agent` (claude|codex|copilot|gemini)',
-                    };
-                }
-                if (typeof sessionArgs.project !== "string" || sessionArgs.project.trim().length === 0) {
-                    return {
-                        success: false,
-                        error: 'Invalid args for "abbie session start": missing `project`',
-                    };
-                }
-                if (typeof sessionArgs.goal !== "string" || sessionArgs.goal.trim().length === 0) {
-                    return {
-                        success: false,
-                        error: 'Invalid args for "abbie session start": missing `goal`',
-                    };
-                }
-                const manager = getActiveSessionManager();
-                const result = await manager.start({
-                    agent: sessionArgs.agent,
-                    project: sessionArgs.project,
-                    goal: sessionArgs.goal,
-                    issue: sessionArgs.issue,
-                    cwd: sessionArgs.cwd,
-                });
-                return {
-                    success: true,
-                    sessionId: result.session_id,
-                };
-            }
-            case "read-buffer": {
-                if (!args || typeof args !== "object") {
-                    return { success: false, error: 'Invalid args for "read-buffer": expected an object' };
-                }
-                const bufArgs = args;
-                if (!bufArgs.paneId) {
-                    return { success: false, error: 'Missing "paneId" for read-buffer' };
-                }
-                // Find nvim server for this pane from inventory
-                const inv = await windows.inventory({
-                    includeNvim: true,
-                    includeAgent: false,
-                    includeBuffers: false,
-                });
-                const paneState = inv.find((s) => s.window.paneId === bufArgs.paneId);
-                if (!paneState?.nvim?.serverAddr) {
-                    return { success: false, error: `No nvim server found for pane ${bufArgs.paneId}` };
-                }
-                const serverAddr = paneState.nvim.serverAddr;
-                // If no bufnr, list all buffers
-                if (bufArgs.bufnr === undefined) {
-                    const bufs = await nvim.listBuffers(serverAddr);
-                    if (!bufs)
-                        return { success: false, error: "Failed to list nvim buffers" };
-                    return {
-                        success: true,
-                        buffers: bufs.map((b) => ({
-                            bufnr: b.bufnr,
-                            name: b.name,
-                            isTerminal: b.name.startsWith("term://"),
-                        })),
-                    };
-                }
-                // Read specific buffer
-                const maxLines = bufArgs.lines ?? 200;
-                const allLines = await nvim.getBufferLines(serverAddr, bufArgs.bufnr, 1, "$");
-                if (!allLines) {
-                    return { success: false, error: `Failed to read buffer ${bufArgs.bufnr}` };
-                }
-                const tail = allLines.length > maxLines ? allLines.slice(-maxLines) : allLines;
-                return {
-                    success: true,
-                    bufnr: bufArgs.bufnr,
-                    totalLines: allLines.length,
-                    returnedLines: tail.length,
-                    content: tail.join("\n"),
-                };
-            }
-            case "terminal-input": {
-                if (!args || typeof args !== "object") {
-                    return { success: false, error: 'Invalid args for "terminal-input": expected an object' };
-                }
-                const inputArgs = args;
-                if (!inputArgs.paneId || !inputArgs.data) {
-                    return { success: false, error: 'Missing "paneId" or "data" for terminal-input' };
-                }
-                try {
-                    const { spawn: spawnProcess } = await import("node:child_process");
-                    // Split on newlines and send Enter for each boundary (same as sendToTmux)
-                    const parts = inputArgs.data.split(/\r\n|\r|\n/);
-                    for (let i = 0; i < parts.length; i++) {
-                        const part = parts[i];
-                        if (part.length > 0) {
-                            await new Promise((resolve, reject) => {
-                                const proc = spawnProcess("tmux", [
-                                    "send-keys",
-                                    "-t",
-                                    inputArgs.paneId,
-                                    "-l",
-                                    part,
-                                ]);
-                                proc.on("close", (code) => code === 0 ? resolve() : reject(new Error(`tmux exit ${code}`)));
-                                proc.on("error", reject);
-                            });
-                        }
-                        if (i < parts.length - 1) {
-                            await new Promise((resolve, reject) => {
-                                const proc = spawnProcess("tmux", ["send-keys", "-t", inputArgs.paneId, "Enter"]);
-                                proc.on("close", (code) => code === 0 ? resolve() : reject(new Error(`tmux exit ${code}`)));
-                                proc.on("error", reject);
-                            });
-                        }
-                    }
-                    return { success: true };
-                }
-                catch (err) {
-                    return { success: false, error: `terminal-input failed: ${err.message}` };
-                }
-            }
-            default:
-                return {
-                    success: false,
-                    error: `Unknown command: ${command}`,
-                };
-        }
-    }
-}