@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/daemon.ts

@@ -1,1809 +0,0 @@
-import { type ChildProcess, 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 type { FunctionReturnType } from "convex/server";
-import { type ActiveSession, 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,
-  type RedactMode,
-  redactContent,
-  sendKeys,
-} from "../../lib/tmux/index.js";
-import { AGENTS } from "../../lib/types.js";
-import * as windows from "../../lib/windows/index.js";
-import { ConfigSyncRunner, type SyncTickResult } from "../../lib/config-sync/index.js";
-import { ContentSyncRunner, type ContentSyncRunnerOptions } from "../../lib/content-sync/index.js";
-import type { ContentSyncTickResult } from "../../lib/content-sync/types.js";
-import { BaseCommand } from "../base-command.js";
-
-type DaemonTick = {
-  at: string;
-  tmuxRunning: boolean;
-  windows: { synced: boolean; count: number; error?: string };
-  panes: { enabled: boolean; synced: boolean; count: number; redacted: number; error?: string };
-  input: { enabled: boolean; received: number; sent: number; skipped: number; error?: string };
-  commandQueue: {
-    enabled: boolean;
-    processed: number;
-    failed: number;
-    pending: number;
-    error?: string;
-  };
-  bufferContent: { enabled: boolean; synced: boolean; count: number; error?: string };
-  sessions: { enabled: boolean; created: number; updated: number; error?: string };
-  projects: { enabled: boolean; synced: boolean; count: number; error?: string };
-  heartbeat: { ok: boolean; error?: string };
-  desktopHeartbeat: { ok: boolean; error?: string };
-  sandboxCommands: {
-    enabled: boolean;
-    processed: number;
-    failed: number;
-    activeServers: number;
-    error?: string;
-  };
-  configSync?: {
-    ok: boolean;
-    reason: string;
-    agents: SyncTickResult["changes"];
-    error?: string;
-  };
-  contentSync?: {
-    ok: boolean;
-    reason: string;
-    changes: ContentSyncTickResult["changes"];
-    error?: string;
-  };
-};
-
-type SessionSyncState = {
-  status: ActiveSession["status"];
-  endedAt?: number;
-  startCommitSha?: string;
-  cwd?: string;
-  traceId?: string;
-  sessionId?: string;
-  project?: string;
-};
-
-type TerminalInputPayload = {
-  deviceId: string;
-  paneId: string;
-  data: string;
-  token?: string;
-};
-
-function sleep(ms: number, signal: AbortSignal): Promise<void> {
-  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: string, max: number): string {
-  if (value.length <= max) return value;
-  return `${value.slice(0, max - 1)}…`;
-}
-
-function isSessionNotFoundError(err: unknown, sessionId: string): boolean {
-  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: string): string | undefined {
-  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: string,
-  fromSha: string,
-  toSha?: string,
-): Array<{ status: string; file: string }> {
-  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 override description = "Run daemon to sync local state to Convex";
-  static override hidden = false;
-
-  static override 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)",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    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<string, SessionSyncState>();
-    let lastWindowsHash: string | null = null;
-    const paneHashByPaneId = new Map<string, string>();
-    const bufferContentHashByKey = new Map<string, string>(); // "paneId:bufnr" -> hash
-    const inventoryByPaneId = new Map<string, windows.WindowInfo>();
-
-    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 as string | null,
-    };
-
-    const inputUnsubscribers: Array<() => void> = [];
-    const seenInputEventIds = new Set<string>();
-    let processingInput = false;
-    const pendingInputEvents: Array<{ id: string; payload: TerminalInputPayload }> = [];
-
-    const enqueueInput = (id: string, payload: TerminalInputPayload) => {
-      if (seenInputEventIds.has(id)) return;
-      seenInputEventIds.add(id);
-      // Bound memory.
-      if (seenInputEventIds.size > 500) {
-        const first = seenInputEventIds.values().next().value as string | undefined;
-        if (first) seenInputEventIds.delete(first);
-      }
-      pendingInputEvents.push({ id, payload });
-      inputState.received++;
-    };
-
-    const sendToTmux = async (payload: TerminalInputPayload): Promise<void> => {
-      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 (): Promise<void> => {
-      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: NodeJS.Signals) => {
-      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: Promise<void> | null = null;
-    let sandboxCmdWorker: Promise<void> | null = null;
-
-    // Sync subscription state (declared outside try for finally cleanup)
-    let configSyncUnsub: (() => void) | null = null;
-    let contentSyncUnsub: (() => void) | null = 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 as { _id?: unknown })._id;
-              const eventId = typeof id === "string" ? id : null;
-              if (!eventId) continue;
-
-              const payload = (evt as { payload?: unknown }).payload;
-              if (!payload || typeof payload !== "object") continue;
-              const p = payload as Partial<TerminalInputPayload>;
-              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 as string | 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 as string | null,
-      };
-
-      // Config sync — subscribes to Convex for MCP connections, writes agent config files.
-      // Fires instantly on change via Convex reactive subscription.
-      let configSyncRunner: ConfigSyncRunner | null = null;
-      let configSyncInFlight = false;
-      let lastConfigSyncResult: DaemonTick["configSync"] = undefined;
-
-      // Content sync — subscribes to Convex for rules/skills/hooks, writes to ~/.abbie/.
-      // Fires instantly on change via Convex reactive subscription.
-      let contentSyncRunner: ContentSyncRunner | null = null;
-      let contentSyncInFlight = false;
-      let lastContentSyncResult: DaemonTick["contentSync"] = undefined;
-
-      // Set up decrypt function for apiKey values (best-effort)
-      let configSyncDecrypt: ((v: string) => Promise<string>) | undefined;
-      try {
-        const { decryptIfEncrypted } = await import("@lnittman/convex-encryption");
-        configSyncDecrypt = async (v: string) => {
-          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: DaemonTick = {
-          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 as "none" | RedactMode,
-              );
-              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;
-  }
-
-  private async syncWindows(
-    deviceId: string,
-    options?: {
-      clear?: boolean;
-      lastHash?: string | null;
-      inventory?: Awaited<ReturnType<typeof windows.inventory>>;
-    },
-  ): Promise<{ synced: boolean; count: number; hash: string }> {
-    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<number, string>();
-    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 };
-  }
-
-  private async syncPanes(
-    deviceId: string,
-    inventory: Awaited<ReturnType<typeof windows.inventory>>,
-    lastHashByPaneId: Map<string, string>,
-    redactMode: "none" | RedactMode,
-  ): Promise<{ synced: boolean; count: number; redacted: number }> {
-    const updates: { paneId: string; paneIndex: number; content: string }[] = [];
-    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 };
-  }
-
-  private async syncNvimBufferContent(
-    deviceId: string,
-    inventory: Awaited<ReturnType<typeof windows.inventory>>,
-    hashByKey: Map<string, string>,
-  ): Promise<{ synced: boolean; count: number }> {
-    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: {
-        bufnr: number;
-        name: string;
-        content: string;
-        lineCount: number;
-        isTerminal: boolean;
-      }[] = [];
-
-      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 };
-  }
-
-  private async syncDeviceHeartbeat(deviceId: string): Promise<void> {
-    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,
-      },
-    });
-  }
-
-  private async syncDesktopHeartbeat(deviceId: string): Promise<void> {
-    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;
-    }
-  }
-
-  private async syncSessions(
-    deviceId: string,
-    stateBySessionId: Map<string, SessionSyncState>,
-  ): Promise<{ created: number; updated: number }> {
-    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: SessionSyncState = {
-        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 as { updated?: boolean }).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 };
-  }
-
-  private lastProjectsHash: string | null = null;
-  private desktopProviderRegistered = false;
-  private clerkId: string | null = null;
-  private desktopProviderId: string | null = null;
-  private desktopConnectionId: string | null = null;
-  private sandboxServerProcesses = new Map<string, ChildProcess>();
-
-  private async syncProjects(deviceId: string): Promise<{ synced: boolean; count: number }> {
-    // 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 as "darwin" | "linux" | "win32",
-          },
-        );
-        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: Record<
-      string,
-      {
-        name: string;
-        emoji: string;
-        linearTeam: string | null;
-        color: string;
-      }
-    > = {};
-
-    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 };
-  }
-
-  private lastProjectsPushHash: string | null = null;
-
-  /**
-   * Push local project configs (.abbie/config.json) UP to Convex projects table.
-   * Idempotent — uses hash dedup to avoid redundant mutations.
-   */
-  private async pushLocalProjects(clerkId: string): Promise<{ pushed: number }> {
-    const discovered = discoverProjects().filter((p) => p.hasConfig && p.configPath);
-
-    // Build normalized config data for hashing
-    const configData: Array<{
-      name: string;
-      emoji: string;
-      color: string;
-      team?: string;
-      path: string;
-    }> = [];
-    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 };
-  }
-
-  private async runCommandQueueWorker(
-    deviceId: string,
-    state: { processed: number; failed: number; error: string | null; inFlight: boolean },
-    signal: AbortSignal,
-  ): Promise<void> {
-    type ClaimResult = FunctionReturnType<typeof api.commandQueue.claim>;
-    type Claimed = Exclude<ClaimResult, null>;
-
-    while (!signal.aborted) {
-      if (state.inFlight) {
-        await sleep(250, signal);
-        continue;
-      }
-
-      let claimed: Claimed | null = 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.
-   */
-  private async runSandboxCommandWorker(
-    connectionId: string,
-    state: { processed: number; failed: number; error: string | null },
-    signal: AbortSignal,
-  ): Promise<void> {
-    type PendingCommand = {
-      _id: string;
-      commandType: "exec" | "startServer" | "stopServer";
-      cmd: string[];
-      serverId?: string;
-      runId?: string;
-    };
-
-    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 as PendingCommand[]) {
-          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" as const,
-                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).
-   */
-  private async executeSandboxCommand(cmd: { _id: string; commandType: "exec" | "startServer" | "stopServer"; cmd: string[]; serverId?: string; runId?: string }): Promise<void> {
-    const c = cmd as {
-      _id: string;
-      commandType: "exec" | "startServer" | "stopServer";
-      cmd: string[];
-      serverId?: string;
-      workdir?: string;
-      env?: Record<string, string>;
-      timeoutMs?: number;
-      serverOpts?: {
-        port: number;
-        name?: string;
-        healthCheck?: { path?: string; timeoutMs?: number; intervalMs?: number };
-      };
-    };
-
-    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: Buffer) => {
-          stdoutBuf += chunk.toString();
-          // Keep only last 4KB for reporting
-          if (stdoutBuf.length > 4096) {
-            stdoutBuf = stdoutBuf.slice(-4096);
-          }
-        });
-
-        proc.stderr?.on("data", (chunk: Buffer) => {
-          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" as const,
-          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" as const,
-          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<{
-          exitCode: number;
-          stdout: string;
-          stderr: string;
-        }>((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: Buffer) => {
-            stdout += chunk.toString();
-          });
-          proc.stderr?.on("data", (chunk: Buffer) => {
-            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" as const) : ("failed" as const),
-          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.
-   */
-  private async executeQueuedCommand(
-    command: string,
-    args: unknown,
-  ): Promise<
-    | ({ success: true; error?: undefined } & Record<string, unknown>)
-    | { success: false; error: string }
-  > {
-    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 as Partial<{
-          agent: "claude" | "codex" | "copilot" | "gemini";
-          project: string;
-          goal: string;
-          issue?: string;
-          cwd?: string;
-        }>;
-
-        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 as Partial<{
-          paneId: string;
-          bufnr: number;
-          lines: number;
-        }>;
-
-        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 as Partial<{ paneId: string; data: string }>;
-        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<void>((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<void>((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 as Error).message}` };
-        }
-      }
-
-      default:
-        return {
-          success: false,
-          error: `Unknown command: ${command}`,
-        };
-    }
-  }
-}