@bytespell/shella 0.1.11 → 0.1.14

package/dist/index.js

@@ -8,13 +8,12 @@ var __export = (target, all) => {
 import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
-import path2 from "path";
-import { fileURLToPath } from "url";
+import path10 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { createExpressMiddleware } from "@trpc/server/adapters/express";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
-import { agentManager as agentManager2 } from "@bytespell/amux/agents/manager";
+import { muxManager as muxManager3 } from "@bytespell/amux/streams/manager";
 import { setVerbose, debug } from "@bytespell/amux/lib/logger";
-import "@bytespell/amux/db";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -56,11 +55,37 @@ function ensureDir(dir) {
 var schema_exports = {};
 __export(schema_exports, {
   panes: () => panes,
+  streamConfigs: () => streamConfigs,
+  streams: () => streams,
   uiState: () => uiState,
   windows: () => windows
 });
 import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
 import { sql } from "drizzle-orm";
+var streamConfigs = sqliteTable("stream_configs", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  /** Driver type for routing (e.g., 'acp', 'pty', or custom plugin types) */
+  driverType: text("driver_type").notNull().default("acp"),
+  command: text("command").notNull(),
+  args: text("args", { mode: "json" }).$type().default([]),
+  env: text("env", { mode: "json" }).$type().default({}),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
+var streams = sqliteTable("streams", {
+  id: text("id").primaryKey(),
+  directory: text("directory").notNull(),
+  streamConfigId: text("stream_config_id").notNull().references(() => streamConfigs.id),
+  /** Stream type determined by the driver at creation time. Built-in: 'acp', 'pty' */
+  streamType: text("stream_type").notNull(),
+  /** Generic driver state (e.g., ACP's session ID for resumption) */
+  driverState: text("driver_state", { mode: "json" }).$type(),
+  /** Title from stream (via session_info_update for ACP) */
+  title: text("title"),
+  model: text("model"),
+  mode: text("mode"),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
+});
 var windows = sqliteTable("windows", {
   id: text("id").primaryKey(),
   title: text("title").notNull(),
@@ -74,8 +99,12 @@ var windows = sqliteTable("windows", {
 var panes = sqliteTable("panes", {
   id: text("id").primaryKey(),
   windowId: text("window_id").notNull().references(() => windows.id, { onDelete: "cascade" }),
-  /** Content configuration. Null when pane type not yet selected. */
+  /** Static content (browser URL, etc.). Null when no content. */
   content: text("content", { mode: "json" }).$type(),
+  /** Live event stream (amux stream). Null when no stream. */
+  eventStream: text("event_stream", { mode: "json" }).$type(),
+  /** Renderer ID (e.g., 'builtin:terminal', 'project:custom-viewer'). Null = use default. */
+  rendererId: text("renderer_id"),
   createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
 });
 var uiState = sqliteTable("ui_state", {
@@ -90,6 +119,30 @@ sqlite.pragma("journal_mode = WAL");
 sqlite.pragma("foreign_keys = ON");
 var db = drizzle(sqlite, { schema: schema_exports });
 sqlite.exec(`
+  -- Stream tables (from amux)
+  CREATE TABLE IF NOT EXISTS stream_configs (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    driver_type TEXT NOT NULL DEFAULT 'acp',
+    command TEXT NOT NULL,
+    args TEXT DEFAULT '[]',
+    env TEXT DEFAULT '{}',
+    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+  );
+
+  CREATE TABLE IF NOT EXISTS streams (
+    id TEXT PRIMARY KEY,
+    directory TEXT NOT NULL,
+    stream_config_id TEXT NOT NULL REFERENCES stream_configs(id),
+    stream_type TEXT NOT NULL,
+    driver_state TEXT,
+    title TEXT,
+    model TEXT,
+    mode TEXT,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+  );
+
+  -- UI tables
   CREATE TABLE IF NOT EXISTS windows (
     id TEXT PRIMARY KEY,
     title TEXT NOT NULL,
@@ -104,6 +157,8 @@ sqlite.exec(`
     id TEXT PRIMARY KEY,
     window_id TEXT NOT NULL REFERENCES windows(id) ON DELETE CASCADE,
     content TEXT,
+    event_stream TEXT,
+    renderer_id TEXT,
     created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
   );
 
@@ -113,157 +168,686 @@ sqlite.exec(`
   );
 `);
 try {
-  const tableInfo = sqlite.prepare("PRAGMA table_info(panes)").all();
-  const hasSessionId = tableInfo.some((col) => col.name === "session_id");
-  const hasContent = tableInfo.some((col) => col.name === "content");
-  if (hasSessionId && !hasContent) {
-    sqlite.exec(`
-      -- Disable foreign keys temporarily
-      PRAGMA foreign_keys = OFF;
+  const configInfo = sqlite.prepare(`PRAGMA table_info(stream_configs)`).all();
+  const hasDriverType = configInfo.some((col) => col.name === "driver_type");
+  if (!hasDriverType) {
+    console.log("[db] Adding driver_type column to stream_configs...");
+    sqlite.exec(`ALTER TABLE stream_configs ADD COLUMN driver_type TEXT NOT NULL DEFAULT 'acp'`);
+    sqlite.exec(`UPDATE stream_configs SET driver_type = 'pty' WHERE command = '__shell__'`);
+    sqlite.exec(`UPDATE stream_configs SET driver_type = 'mock' WHERE command = '__mock__'`);
+    console.log("[db] driver_type migration complete");
+  }
+} catch (e) {
+}
+try {
+  const tableInfo = sqlite.prepare(`PRAGMA table_info(panes)`).all();
+  const hasProcessColumn = tableInfo.some((col) => col.name === "process");
+  const hasEventStreamColumn = tableInfo.some((col) => col.name === "event_stream");
+  if (hasProcessColumn && !hasEventStreamColumn) {
+    console.log("[db] Migrating panes.process to panes.event_stream...");
+    sqlite.exec(`ALTER TABLE panes ADD COLUMN event_stream TEXT`);
+    const panesWithProcess = sqlite.prepare(`SELECT id, process FROM panes WHERE process IS NOT NULL`).all();
+    for (const pane of panesWithProcess) {
+      try {
+        const process2 = JSON.parse(pane.process);
+        if (process2.type === "session" && process2.sessionId) {
+          const eventStream = JSON.stringify({ type: "acp", streamId: process2.sessionId });
+          sqlite.prepare(`UPDATE panes SET event_stream = ? WHERE id = ?`).run(eventStream, pane.id);
+        }
+      } catch (e) {
+      }
+    }
+    console.log("[db] Migration complete, migrated", panesWithProcess.length, "panes");
+  }
+} catch (e) {
+}
 
-      -- Create new table with content column
-      CREATE TABLE panes_new (
-        id TEXT PRIMARY KEY,
-        window_id TEXT NOT NULL REFERENCES windows(id) ON DELETE CASCADE,
-        content TEXT,
-        created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-      );
+// src/lib/configDiscovery.ts
+import { execSync } from "child_process";
+import { randomUUID } from "crypto";
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var claudeDiscoverer = {
+  name: "claude",
+  discover() {
+    if (!commandExists("claude")) {
+      return null;
+    }
+    return {
+      id: randomUUID(),
+      name: "claude",
+      driverType: "acp",
+      command: "npx",
+      args: ["@zed-industries/claude-code-acp"],
+      env: {},
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+};
+var codexDiscoverer = {
+  name: "codex",
+  discover() {
+    if (!commandExists("codex")) {
+      return null;
+    }
+    return {
+      id: randomUUID(),
+      name: "codex",
+      driverType: "acp",
+      command: "npx",
+      args: ["@zed-industries/codex-acp"],
+      env: {},
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+};
+var geminiDiscoverer = {
+  name: "gemini",
+  discover() {
+    if (!commandExists("gemini")) {
+      return null;
+    }
+    return {
+      id: randomUUID(),
+      name: "gemini",
+      driverType: "acp",
+      command: "gemini",
+      args: ["--experimental-acp"],
+      env: {},
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+};
+var openCodeDiscoverer = {
+  name: "opencode",
+  discover() {
+    if (!commandExists("opencode")) {
+      return null;
+    }
+    return {
+      id: randomUUID(),
+      name: "opencode",
+      driverType: "acp",
+      command: "opencode",
+      args: ["acp"],
+      env: {},
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+};
+var shellDiscoverer = {
+  name: "Shell",
+  discover() {
+    return {
+      id: "shell",
+      name: "shell",
+      driverType: "pty",
+      command: "",
+      // PTY driver ignores command, spawns user's $SHELL
+      args: [],
+      env: {},
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+};
+var builtInDiscoverers = [
+  claudeDiscoverer,
+  codexDiscoverer,
+  geminiDiscoverer,
+  openCodeDiscoverer,
+  shellDiscoverer
+];
+function discoverAndRegisterConfigs(discoverers) {
+  const existing = db.select().from(streamConfigs).all();
+  let added = 0;
+  for (const discoverer of discoverers) {
+    const config = discoverer.discover();
+    if (!config) {
+      continue;
+    }
+    const alreadyExists = existing.some(
+      (e) => e.command === config.command && JSON.stringify(e.args) === JSON.stringify(config.args)
+    );
+    if (!alreadyExists) {
+      db.insert(streamConfigs).values({
+        id: config.id,
+        name: config.name,
+        driverType: config.driverType,
+        command: config.command,
+        args: config.args,
+        env: config.env,
+        createdAt: config.createdAt
+      }).run();
+      console.log(`[config] Discovered: ${config.name}`);
+      added++;
+    }
+  }
+  if (added > 0) {
+    console.log(`[config] ${added} new stream config(s) registered`);
+  }
+}
 
-      -- Copy data, converting session_id to content JSON
-      INSERT INTO panes_new (id, window_id, content, created_at)
-      SELECT
-        id,
-        window_id,
-        CASE
-          WHEN session_id IS NOT NULL THEN json_object('type', 'session', 'sessionId', session_id)
-          ELSE NULL
-        END,
-        created_at
-      FROM panes;
+// src/lib/driverWatcher.ts
+import chokidar from "chokidar";
+import * as path3 from "path";
+import * as os2 from "os";
+import * as fs3 from "fs/promises";
+import { EventEmitter } from "events";
+
+// src/lib/driverCompiler.ts
+import { build } from "esbuild";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+async function compileDriver(pluginDir) {
+  const serverPath = path2.join(pluginDir, "server.ts");
+  try {
+    await fs2.access(serverPath);
+  } catch {
+    return null;
+  }
+  const metaPath = path2.join(pluginDir, "meta.json");
+  let meta;
+  try {
+    const metaContent = await fs2.readFile(metaPath, "utf-8");
+    meta = JSON.parse(metaContent);
+  } catch (err) {
+    throw new Error(
+      `Failed to read meta.json for ${pluginDir}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!meta.id || typeof meta.id !== "string") {
+    throw new Error(`Plugin in ${pluginDir}: meta.json requires "id" field`);
+  }
+  if (!meta.name || typeof meta.name !== "string") {
+    throw new Error(`Plugin in ${pluginDir}: meta.json requires "name" field`);
+  }
+  const outDir = path2.join(pluginDir, ".shella");
+  const outFile = path2.join(outDir, "server.mjs");
+  await fs2.mkdir(outDir, { recursive: true });
+  const pkgPath = path2.join(pluginDir, "package.json");
+  let hasPackageJson = false;
+  try {
+    await fs2.access(pkgPath);
+    hasPackageJson = true;
+  } catch {
+  }
+  const shellaRoot = path2.resolve(__dirname, "../..");
+  const sdkPath = path2.resolve(shellaRoot, "../sdk/dist");
+  await build({
+    entryPoints: [serverPath],
+    bundle: true,
+    write: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    outfile: outFile,
+    alias: {
+      "@bytespell/shella-sdk": path2.join(sdkPath, "index.js"),
+      "@bytespell/shella-sdk/server": path2.join(sdkPath, "server.js")
+    },
+    // If plugin has package.json, look for node_modules
+    nodePaths: hasPackageJson ? [path2.join(pluginDir, "node_modules")] : [],
+    minify: false
+  });
+  return {
+    id: meta.id,
+    name: meta.name,
+    filePath: outFile,
+    pluginDir
+  };
+}
+
+// src/lib/driverWatcher.ts
+import { muxManager } from "@bytespell/amux/streams/manager";
+import { eq } from "drizzle-orm";
+var DriverEventEmitter = class extends EventEmitter {
+  emit(event, data) {
+    return super.emit(event, data);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+};
+var loadedDrivers = /* @__PURE__ */ new Map();
+async function loadDriver(compiled) {
+  const entry = loadedDrivers.get(compiled.pluginDir);
+  const version = (entry?.version ?? 0) + 1;
+  const url = `file://${compiled.filePath}?v=${version}`;
+  const module = await import(
+    /* @vite-ignore */
+    url
+  );
+  const driver = module.default;
+  if (!driver || typeof driver.start !== "function") {
+    throw new Error(`Plugin driver must export default with start() method`);
+  }
+  driver.type = compiled.id;
+  loadedDrivers.set(compiled.pluginDir, { id: compiled.id, version });
+  return driver;
+}
+function ensureStreamConfig(compiled) {
+  const existing = db.select().from(streamConfigs).where(eq(streamConfigs.id, compiled.id)).get();
+  if (!existing) {
+    db.insert(streamConfigs).values({
+      id: compiled.id,
+      name: compiled.name,
+      driverType: compiled.id,
+      // Driver type matches plugin id
+      command: "",
+      // Plugin drivers don't spawn processes
+      args: [],
+      env: {},
+      createdAt: /* @__PURE__ */ new Date()
+    }).run();
+  } else if (existing.name !== compiled.name) {
+    db.update(streamConfigs).set({ name: compiled.name }).where(eq(streamConfigs.id, compiled.id)).run();
+  }
+}
+function removeStreamConfig(id) {
+  db.delete(streamConfigs).where(eq(streamConfigs.id, id)).run();
+}
+function watchDrivers(emitter) {
+  const userPath = path3.join(os2.homedir(), ".shella", "renderers");
+  const pendingCompiles = /* @__PURE__ */ new Map();
+  const watcher = chokidar.watch(userPath, {
+    ignoreInitial: false,
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 150,
+      pollInterval: 50
+    },
+    depth: 3
+    // Watch inside plugin folders
+  });
+  const getPluginDir = (filePath) => {
+    const relative3 = path3.relative(userPath, filePath);
+    const parts = relative3.split(path3.sep);
+    if (parts.length >= 1 && parts[0]) {
+      return path3.join(userPath, parts[0]);
+    }
+    return null;
+  };
+  const isServerFile = (filePath) => {
+    const relative3 = path3.relative(userPath, filePath);
+    const parts = relative3.split(path3.sep);
+    return parts.length >= 2 && (parts[1] === "server.ts" || parts[1]?.startsWith("server/") || filePath.includes("/server/"));
+  };
+  const scheduleCompile = (pluginDir) => {
+    if (pendingCompiles.has(pluginDir)) {
+      clearTimeout(pendingCompiles.get(pluginDir));
+    }
+    pendingCompiles.set(
+      pluginDir,
+      setTimeout(async () => {
+        pendingCompiles.delete(pluginDir);
+        await handleDriverChange(pluginDir);
+      }, 150)
+    );
+  };
+  const handleDriverChange = async (pluginDir) => {
+    try {
+      const compiled = await compileDriver(pluginDir);
+      if (!compiled) return;
+      const existing = loadedDrivers.get(pluginDir);
+      if (existing) {
+        muxManager.unregisterDriver(existing.id);
+      }
+      const driver = await loadDriver(compiled);
+      muxManager.registerDriver(driver);
+      ensureStreamConfig(compiled);
+      if (!existing) {
+        console.log(`[drivers] Added: ${compiled.id} (${compiled.name})`);
+        emitter.emit("driver:added", { id: compiled.id, name: compiled.name });
+      } else {
+        console.log(`[drivers] Updated: ${compiled.id} (${compiled.name})`);
+        emitter.emit("driver:updated", { id: compiled.id, name: compiled.name });
+      }
+    } catch (err) {
+      console.error(`[drivers] Error compiling ${pluginDir}:`, err);
+      emitter.emit("driver:error", {
+        pluginDir,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  };
+  watcher.on("add", (filePath) => {
+    if (isServerFile(filePath)) {
+      const pluginDir = getPluginDir(filePath);
+      if (pluginDir) scheduleCompile(pluginDir);
+    }
+  });
+  watcher.on("change", (filePath) => {
+    if (isServerFile(filePath)) {
+      const pluginDir = getPluginDir(filePath);
+      if (pluginDir) scheduleCompile(pluginDir);
+    }
+  });
+  watcher.on("unlink", (filePath) => {
+    if (filePath.endsWith("server.ts")) {
+      const pluginDir = getPluginDir(filePath);
+      if (pluginDir) {
+        const entry = loadedDrivers.get(pluginDir);
+        if (entry) {
+          muxManager.unregisterDriver(entry.id);
+          removeStreamConfig(entry.id);
+          loadedDrivers.delete(pluginDir);
+          console.log(`[drivers] Removed: ${entry.id}`);
+          emitter.emit("driver:removed", { id: entry.id });
+        }
+      }
+    }
+  });
+  watcher.on("error", (err) => {
+    console.error("[drivers] Watcher error:", err);
+  });
+  return () => {
+    for (const timeout of pendingCompiles.values()) {
+      clearTimeout(timeout);
+    }
+    pendingCompiles.clear();
+    watcher.close();
+  };
+}
+async function scanDrivers() {
+  const userPath = path3.join(os2.homedir(), ".shella", "renderers");
+  try {
+    const entries = await fs3.readdir(userPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginDir = path3.join(userPath, entry.name);
+      try {
+        const compiled = await compileDriver(pluginDir);
+        if (compiled) {
+          const driver = await loadDriver(compiled);
+          muxManager.registerDriver(driver);
+          ensureStreamConfig(compiled);
+          console.log(`[drivers] Loaded: ${compiled.id} (${compiled.name})`);
+        }
+      } catch (err) {
+        console.error(`[drivers] Error loading ${pluginDir}:`, err);
+      }
+    }
+  } catch {
+  }
+}
 
-      -- Drop old table and rename new
-      DROP TABLE panes;
-      ALTER TABLE panes_new RENAME TO panes;
+// src/amuxBridge.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import path5 from "path";
+import fs5 from "fs";
+import { eq as eq2, inArray } from "drizzle-orm";
 
-      -- Re-enable foreign keys
-      PRAGMA foreign_keys = ON;
-    `);
-    console.log("[shella-db] Migrated panes from session_id to content column");
+// src/lib/files.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import { glob } from "glob";
+async function listFilesForAutocomplete(workingDir, partialPath, limit) {
+  const normalized = partialPath.startsWith("./") ? partialPath.slice(2) : partialPath;
+  if (normalized.includes("/")) {
+    return listFilesPrefix(workingDir, normalized, limit);
+  }
+  return listFilesFuzzy(workingDir, normalized, limit);
+}
+async function listFilesPrefix(workingDir, partialPath, limit) {
+  const lastSlash = partialPath.lastIndexOf("/");
+  const dirPart = lastSlash >= 0 ? partialPath.slice(0, lastSlash) : "";
+  const prefix = lastSlash >= 0 ? partialPath.slice(lastSlash + 1) : partialPath;
+  const targetDir = path4.resolve(workingDir, dirPart);
+  const normalizedWorkingDir = path4.resolve(workingDir);
+  const normalizedTargetDir = path4.resolve(targetDir);
+  if (!normalizedTargetDir.startsWith(normalizedWorkingDir)) {
+    return [];
+  }
+  try {
+    const entries = await fs4.readdir(targetDir, { withFileTypes: true });
+    const matching = entries.filter((e) => !e.name.startsWith(".")).filter((e) => prefix === "" || e.name.toLowerCase().startsWith(prefix.toLowerCase())).slice(0, limit * 2).map((e) => ({
+      name: e.name,
+      path: dirPart ? `${dirPart}/${e.name}` : e.name,
+      isDirectory: e.isDirectory()
+    }));
+    matching.sort((a, b) => {
+      if (a.isDirectory !== b.isDirectory) {
+        return a.isDirectory ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    return matching.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+async function listFilesFuzzy(workingDir, query, limit) {
+  if (!query.trim()) return [];
+  try {
+    const pattern = `{*${query}*,**/*${query}*}`;
+    const matches = await glob(pattern, {
+      cwd: workingDir,
+      nodir: false,
+      dot: false,
+      // Skip hidden files
+      ignore: ["**/node_modules/**", "**/.git/**"],
+      maxDepth: 10
+    });
+    const results = [];
+    for (const match of matches.slice(0, limit * 2)) {
+      try {
+        const fullPath = path4.join(workingDir, match);
+        const stat2 = await fs4.stat(fullPath);
+        results.push({
+          name: path4.basename(match),
+          path: match,
+          isDirectory: stat2.isDirectory()
+        });
+      } catch {
+      }
+    }
+    results.sort((a, b) => {
+      if (a.isDirectory !== b.isDirectory) {
+        return a.isDirectory ? -1 : 1;
+      }
+      const aDepth = a.path.split("/").length;
+      const bDepth = b.path.split("/").length;
+      if (aDepth !== bDepth) {
+        return aDepth - bDepth;
+      }
+      return a.path.localeCompare(b.path);
+    });
+    return results.slice(0, limit);
+  } catch {
+    return [];
   }
-} catch {
 }
 
 // src/amuxBridge.ts
-import { randomUUID } from "crypto";
-import { eq, inArray } from "drizzle-orm";
-import { db as db2, schema } from "@bytespell/amux/db";
-import { agentManager } from "@bytespell/amux/agents/manager";
-import { clearEventsForSession } from "@bytespell/amux/agents/eventStore";
-import { listFilesForAutocomplete } from "@bytespell/amux/trpc/files";
-var { sessions, agentConfigs, appState } = schema;
+import { muxManager as muxManager2 } from "@bytespell/amux/streams/manager";
+import { isAcpEvent } from "@bytespell/amux/types";
+function getStreamStorageDir(streamId) {
+  return path5.join(getDataDir(), "streams", streamId);
+}
+function generateTitleFromMessage(message) {
+  const cleaned = message.replace(/@[\w./~-]+/g, "").replace(/\s+/g, " ").trim();
+  const firstLine = cleaned.split("\n")[0] || cleaned;
+  if (firstLine.length <= 50) return firstLine;
+  const truncated = firstLine.slice(0, 50);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return lastSpace > 20 ? truncated.slice(0, lastSpace) + "..." : truncated + "...";
+}
 function createAmuxBridge() {
-  return {
-    async getSessions(ids) {
+  const bridge = {
+    async getStreams(ids) {
       if (ids.length === 0) return [];
-      return db2.select().from(sessions).where(inArray(sessions.id, ids)).all();
+      return db.select().from(streams).where(inArray(streams.id, ids)).all();
     },
-    async getSession(id) {
-      return db2.select().from(sessions).where(eq(sessions.id, id)).get() ?? null;
+    async getStream(id) {
+      return db.select().from(streams).where(eq2(streams.id, id)).get() ?? null;
     },
-    async createSession(params) {
-      let configId = params.agentConfigId;
+    async createStream(params) {
+      let configId = params.streamConfigId;
       if (!configId) {
-        const lastUsedRow = db2.select().from(appState).where(eq(appState.key, "last_used_agent_config_id")).get();
+        const lastUsedRow = db.select().from(uiState).where(eq2(uiState.key, "last_used_stream_config_id")).get();
         if (lastUsedRow?.value) {
-          const config2 = db2.select().from(agentConfigs).where(eq(agentConfigs.id, lastUsedRow.value)).get();
+          const config2 = db.select().from(streamConfigs).where(eq2(streamConfigs.id, lastUsedRow.value)).get();
           if (config2) configId = config2.id;
         }
         if (!configId) {
-          const firstConfig = db2.select().from(agentConfigs).get();
+          const firstConfig = db.select().from(streamConfigs).get();
           if (!firstConfig) {
-            throw new Error("No agent configs available");
+            throw new Error("No stream configs available");
           }
           configId = firstConfig.id;
         }
       } else {
-        db2.insert(appState).values({ key: "last_used_agent_config_id", value: configId }).onConflictDoUpdate({ target: appState.key, set: { value: configId } }).run();
+        db.insert(uiState).values({ key: "last_used_stream_config_id", value: configId }).onConflictDoUpdate({ target: uiState.key, set: { value: configId } }).run();
       }
-      const id = params.id ?? randomUUID();
+      const id = params.id ?? randomUUID2();
       const now = /* @__PURE__ */ new Date();
-      const config = db2.select().from(agentConfigs).where(eq(agentConfigs.id, configId)).get();
-      const initialTitle = config?.streamType === "pty" ? params.directory.split("/").pop() || null : null;
-      db2.insert(sessions).values({
+      const config = db.select().from(streamConfigs).where(eq2(streamConfigs.id, configId)).get();
+      const streamType = config?.driverType === "pty" ? "pty" : "acp";
+      const initialTitle = streamType === "pty" ? params.directory.split("/").pop() || null : null;
+      db.insert(streams).values({
         id,
         directory: params.directory,
-        agentConfigId: configId,
-        acpSessionId: null,
+        streamConfigId: configId,
+        streamType,
+        driverState: null,
         title: initialTitle,
         model: null,
         mode: null,
         createdAt: now
       }).run();
-      return db2.select().from(sessions).where(eq(sessions.id, id)).get();
+      return db.select().from(streams).where(eq2(streams.id, id)).get();
     },
-    async deleteSession(id) {
-      await agentManager.stopForSession(id);
-      clearEventsForSession(id);
-      db2.delete(sessions).where(eq(sessions.id, id)).run();
+    async deleteStream(id) {
+      await muxManager2.stopForStream(id);
+      const storageDir = getStreamStorageDir(id);
+      try {
+        if (fs5.existsSync(storageDir)) {
+          fs5.rmSync(storageDir, { recursive: true });
+        }
+      } catch {
+      }
+      db.delete(streams).where(eq2(streams.id, id)).run();
     },
-    async getAgentConfigs() {
-      return db2.select().from(agentConfigs).all();
+    async getStreamConfigs() {
+      return db.select().from(streamConfigs).all();
     },
-    async startAgent(sessionId) {
-      return agentManager.startForSession(sessionId);
+    async startStream(streamId) {
+      const dbStream = db.select().from(streams).where(eq2(streams.id, streamId)).get();
+      if (!dbStream) throw new Error(`Stream ${streamId} not found`);
+      const dbConfig = db.select().from(streamConfigs).where(eq2(streamConfigs.id, dbStream.streamConfigId)).get();
+      if (!dbConfig) throw new Error(`Stream config ${dbStream.streamConfigId} not found`);
+      const storageDir = getStreamStorageDir(streamId);
+      const emit = (event) => {
+        if (isAcpEvent(event) && event.sessionUpdate === "session_info_update") {
+          const title = event.title;
+          if (title !== void 0) {
+            db.update(streams).set({ title }).where(eq2(streams.id, streamId)).run();
+          }
+        }
+      };
+      const handle = await muxManager2.startStream({
+        streamId,
+        driverType: dbConfig.driverType,
+        config: {
+          id: dbConfig.id,
+          name: dbConfig.name,
+          command: dbConfig.command,
+          args: dbConfig.args ?? [],
+          env: dbConfig.env ?? {}
+        },
+        cwd: dbStream.directory,
+        restoredState: dbStream.driverState,
+        emit,
+        storageDir
+      });
+      const driverState = muxManager2.getDriverState(streamId);
+      if (driverState !== void 0) {
+        db.update(streams).set({ driverState }).where(eq2(streams.id, streamId)).run();
+      }
+      const replayData = muxManager2.getReplayData(streamId);
+      const replayEvents = Array.isArray(replayData) ? replayData : [];
+      const scrollback = typeof replayData === "string" ? replayData : muxManager2.getTerminalScrollback(streamId);
+      return {
+        acpSessionId: handle.stream.acpSessionId,
+        replayEvents,
+        scrollback,
+        models: handle.stream.models,
+        modes: handle.stream.modes
+      };
     },
-    async stopAgent(sessionId) {
-      await agentManager.stopForSession(sessionId);
+    async stopStream(streamId) {
+      const driverState = muxManager2.getDriverState(streamId);
+      if (driverState !== void 0) {
+        db.update(streams).set({ driverState }).where(eq2(streams.id, streamId)).run();
+      }
+      await muxManager2.stopForStream(streamId);
     },
-    async prompt(sessionId, message) {
-      await agentManager.prompt(sessionId, message);
+    async input(streamId, message) {
+      const stream = db.select().from(streams).where(eq2(streams.id, streamId)).get();
+      if (!stream) throw new Error(`Stream ${streamId} not found`);
+      if (!stream.title) {
+        const title = generateTitleFromMessage(message);
+        if (title) {
+          db.update(streams).set({ title }).where(eq2(streams.id, streamId)).run();
+        }
+      }
+      await muxManager2.input(streamId, message);
     },
-    async cancel(sessionId) {
-      await agentManager.cancel(sessionId);
+    async cancel(streamId) {
+      await muxManager2.cancel(streamId);
     },
-    async setMode(sessionId, modeId) {
-      await agentManager.setMode(sessionId, modeId);
+    async setMode(streamId, modeId) {
+      await muxManager2.setMode(streamId, modeId);
     },
-    async setModel(sessionId, modelId) {
-      await agentManager.setModel(sessionId, modelId);
+    async setModel(streamId, modelId) {
+      await muxManager2.setModel(streamId, modelId);
     },
-    respondPermission(sessionId, requestId, optionId) {
-      agentManager.respondPermission(sessionId, requestId, optionId);
+    respondPermission(streamId, requestId, optionId) {
+      muxManager2.respondPermission(streamId, requestId, optionId);
     },
-    subscribeToSession(sessionId, callback) {
+    subscribeToStream(streamId, callback) {
       const handler = (event) => {
-        if (event.sessionId === sessionId) {
-          callback(event.update);
+        if (event.streamId === streamId) {
+          callback(event);
         }
       };
-      agentManager.on("update", handler);
-      return () => agentManager.off("update", handler);
+      muxManager2.on("update", handler);
+      return () => muxManager2.off("update", handler);
     },
-    async listFilesForAutocomplete(sessionId, partialPath, limit) {
-      const session = db2.select().from(sessions).where(eq(sessions.id, sessionId)).get();
-      if (!session) throw new Error(`Session ${sessionId} not found`);
-      return listFilesForAutocomplete(session.directory, partialPath, limit);
+    async listFilesForAutocomplete(streamId, partialPath, limit) {
+      const stream = db.select().from(streams).where(eq2(streams.id, streamId)).get();
+      if (!stream) throw new Error(`Stream ${streamId} not found`);
+      return listFilesForAutocomplete(stream.directory, partialPath, limit);
     },
     // Terminal operations
-    terminalWrite(sessionId, data) {
-      agentManager.terminalWrite(sessionId, data);
+    terminalWrite(streamId, data) {
+      muxManager2.terminalWrite(streamId, data);
     },
-    terminalResize(sessionId, cols, rows) {
-      agentManager.terminalResize(sessionId, cols, rows);
+    terminalResize(streamId, cols, rows) {
+      muxManager2.terminalResize(streamId, cols, rows);
     },
-    getTerminalScrollback(sessionId) {
-      return agentManager.getTerminalScrollback(sessionId);
+    getTerminalScrollback(streamId) {
+      return muxManager2.getTerminalScrollback(streamId);
     },
-    isTerminalSession(sessionId) {
-      return agentManager.isTerminalSession(sessionId);
+    isTerminalStream(streamId) {
+      return muxManager2.isTerminalStream(streamId);
     },
-    updateSessionTitle(sessionId, title) {
-      db2.update(sessions).set({ title }).where(eq(sessions.id, sessionId)).run();
+    updateStreamTitle(streamId, title) {
+      db.update(streams).set({ title }).where(eq2(streams.id, streamId)).run();
     }
   };
+  return bridge;
 }
 
 // src/trpc/trpc.ts
@@ -274,8 +858,8 @@ var publicProcedure = t.procedure;
 
 // src/trpc/windows.ts
 import { z } from "zod";
-import { randomUUID as randomUUID2 } from "crypto";
-import { eq as eq2 } from "drizzle-orm";
+import { randomUUID as randomUUID3 } from "crypto";
+import { eq as eq3 } from "drizzle-orm";
 
 // client/lib/layout.ts
 function createLeaf(paneId) {
@@ -290,13 +874,13 @@ function getAllPaneIds(node) {
   }
   return [...getAllPaneIds(node.first), ...getAllPaneIds(node.second)];
 }
-function findPanePath(node, paneId, path3 = []) {
+function findPanePath(node, paneId, path11 = []) {
   if (node.type === "leaf") {
-    return node.paneId === paneId ? path3 : null;
+    return node.paneId === paneId ? path11 : null;
   }
-  const firstPath = findPanePath(node.first, paneId, [...path3, "first"]);
+  const firstPath = findPanePath(node.first, paneId, [...path11, "first"]);
   if (firstPath) return firstPath;
-  return findPanePath(node.second, paneId, [...path3, "second"]);
+  return findPanePath(node.second, paneId, [...path11, "second"]);
 }
 function replacePaneWithNode(root, paneId, newNode) {
   if (root.type === "leaf") {
@@ -333,15 +917,15 @@ function removePane(root, paneId) {
   }
   return root;
 }
-function updateRatio(root, path3, newRatio) {
-  if (path3.length === 0) {
+function updateRatio(root, path11, newRatio) {
+  if (path11.length === 0) {
     if (root.type === "branch") {
       return { ...root, ratio: Math.max(10, Math.min(90, newRatio)) };
     }
     return root;
   }
   if (root.type === "leaf") return root;
-  const [next, ...rest] = path3;
+  const [next, ...rest] = path11;
   if (next === "first") {
     return { ...root, first: updateRatio(root.first, rest, newRatio) };
   } else {
@@ -349,11 +933,11 @@ function updateRatio(root, path3, newRatio) {
   }
 }
 function getAdjacentPane(root, currentPaneId, direction) {
-  const path3 = findPanePath(root, currentPaneId);
-  if (!path3) return null;
+  const path11 = findPanePath(root, currentPaneId);
+  if (!path11) return null;
   let node = root;
   const pathNodes = [];
-  for (const step of path3) {
+  for (const step of path11) {
     if (node.type === "branch") {
       pathNodes.push({ node, childSide: step });
       node = step === "first" ? node.first : node.second;
@@ -399,71 +983,76 @@ function generateTitle(existingCount, directory) {
 }
 var windowsRouter = router({
   /**
-   * List all windows with their panes and sessions.
+   * List all windows with their panes and streams.
    */
   list: publicProcedure.query(async () => {
     const allWindows = db.select().from(windows).orderBy(windows.createdAt).all();
     const allPanes = db.select().from(panes).all();
-    const activeRow = db.select().from(uiState).where(eq2(uiState.key, "active_window_id")).get();
-    const sessionIds = [...new Set(
-      allPanes.map((p) => p.content?.type === "session" ? p.content.sessionId : null).filter((id) => id !== null)
+    const activeRow = db.select().from(uiState).where(eq3(uiState.key, "active_window_id")).get();
+    const streamIds = [...new Set(
+      allPanes.map((p) => p.eventStream?.streamId ?? null).filter((id) => id !== null)
     )];
-    const sessionsData = await amux.getSessions(sessionIds);
-    const sessionMap = new Map(sessionsData.map((s) => [s.id, s]));
-    const agentConfigs2 = await amux.getAgentConfigs();
+    const streamsData = await amux.getStreams(streamIds);
+    const streamMap = new Map(streamsData.map((s) => [s.id, s]));
+    const streamConfigs2 = await amux.getStreamConfigs();
     return {
       windows: allWindows.map((w) => ({
         ...w,
         panes: allPanes.filter((p) => p.windowId === w.id).map((p) => ({
           ...p,
-          // Enrich session-type content with full session data
-          session: p.content?.type === "session" ? sessionMap.get(p.content.sessionId) ?? null : null
+          // Enrich eventStream with full stream data
+          stream: p.eventStream ? streamMap.get(p.eventStream.streamId) ?? null : null
         }))
       })),
       activeWindowId: activeRow?.value ?? allWindows[allWindows.length - 1]?.id ?? null,
-      agentConfigs: agentConfigs2
+      streamConfigs: streamConfigs2,
+      // Legacy alias
+      agentConfigs: streamConfigs2
     };
   }),
   /**
    * Get a single window by ID.
    */
   get: publicProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {
-    const window = db.select().from(windows).where(eq2(windows.id, input.id)).get();
+    const window = db.select().from(windows).where(eq3(windows.id, input.id)).get();
     if (!window) {
       throw new Error(`Window ${input.id} not found`);
     }
-    const windowPanes = db.select().from(panes).where(eq2(panes.windowId, input.id)).all();
-    const sessionIds = windowPanes.map((p) => p.content?.type === "session" ? p.content.sessionId : null).filter((id) => id !== null);
-    const sessionsData = await amux.getSessions(sessionIds);
-    const sessionMap = new Map(sessionsData.map((s) => [s.id, s]));
+    const windowPanes = db.select().from(panes).where(eq3(panes.windowId, input.id)).all();
+    const streamIds = windowPanes.map((p) => p.eventStream?.streamId ?? null).filter((id) => id !== null);
+    const streamsData = await amux.getStreams(streamIds);
+    const streamMap = new Map(streamsData.map((s) => [s.id, s]));
     return {
       ...window,
       panes: windowPanes.map((p) => ({
         ...p,
-        session: p.content?.type === "session" ? sessionMap.get(p.content.sessionId) ?? null : null
+        stream: p.eventStream ? streamMap.get(p.eventStream.streamId) ?? null : null
       }))
     };
   }),
   /**
    * Create a new window with a single pane.
-   * If agentConfigId is not provided, pane is created with no content (shows picker).
+   * If streamConfigId is not provided, pane is created with no content (shows picker).
    */
   create: publicProcedure.input(z.object({
     id: z.string().optional(),
     title: z.string().optional(),
     directory: z.string().optional(),
+    streamConfigId: z.string().optional(),
+    // Legacy alias
     agentConfigId: z.string().optional()
   })).mutation(async ({ input }) => {
     const directory = input.directory ?? process.cwd();
-    let session = null;
-    if (input.agentConfigId) {
-      session = await amux.createSession({
+    const configId = input.streamConfigId ?? input.agentConfigId;
+    let stream = null;
+    if (configId) {
+      stream = await amux.createStream({
         directory,
-        agentConfigId: input.agentConfigId
+        streamConfigId: configId
       });
     }
-    const windowId = input.id ?? randomUUID2();
-    const paneId = randomUUID2();
+    const windowId = input.id ?? randomUUID3();
+    const paneId = randomUUID3();
     const existingCount = db.select().from(windows).all().length;
     const layout = createLeaf(paneId);
     db.insert(windows).values({
@@ -476,16 +1065,17 @@ var windowsRouter = router({
     db.insert(panes).values({
       id: paneId,
       windowId,
-      content: session ? { type: "session", sessionId: session.id } : null
+      content: null,
+      eventStream: stream ? { type: stream.streamType, streamId: stream.id } : null
     }).run();
     db.insert(uiState).values({ key: "active_window_id", value: windowId }).onConflictDoUpdate({ target: uiState.key, set: { value: windowId } }).run();
-    const newWindow = db.select().from(windows).where(eq2(windows.id, windowId)).get();
-    const newPanes = db.select().from(panes).where(eq2(panes.windowId, windowId)).all();
+    const newWindow = db.select().from(windows).where(eq3(windows.id, windowId)).get();
+    const newPanes = db.select().from(panes).where(eq3(panes.windowId, windowId)).all();
     return {
       ...newWindow,
       panes: newPanes.map((p) => ({
         ...p,
-        session: session && p.content?.type === "session" && p.content.sessionId === session.id ? session : null
+        stream: stream && p.eventStream?.streamId === stream.id ? stream : null
       }))
     };
   }),
@@ -502,28 +1092,28 @@ var windowsRouter = router({
       updates.hasCustomTitle = true;
     }
     updates.lastAccessedAt = /* @__PURE__ */ new Date();
-    db.update(windows).set(updates).where(eq2(windows.id, input.id)).run();
-    return db.select().from(windows).where(eq2(windows.id, input.id)).get();
+    db.update(windows).set(updates).where(eq3(windows.id, input.id)).run();
+    return db.select().from(windows).where(eq3(windows.id, input.id)).get();
   }),
   /**
-   * Delete a window and all its panes/sessions.
+   * Delete a window and all its panes/streams.
    */
   delete: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ input }) => {
-    const windowPanes = db.select().from(panes).where(eq2(panes.windowId, input.id)).all();
+    const windowPanes = db.select().from(panes).where(eq3(panes.windowId, input.id)).all();
     for (const pane of windowPanes) {
-      if (pane.content?.type === "session") {
-        await amux.deleteSession(pane.content.sessionId);
+      if (pane.eventStream) {
+        await amux.deleteStream(pane.eventStream.streamId);
       }
     }
-    db.delete(windows).where(eq2(windows.id, input.id)).run();
-    const activeRow = db.select().from(uiState).where(eq2(uiState.key, "active_window_id")).get();
+    db.delete(windows).where(eq3(windows.id, input.id)).run();
+    const activeRow = db.select().from(uiState).where(eq3(uiState.key, "active_window_id")).get();
     if (activeRow?.value === input.id) {
       const remaining = db.select().from(windows).orderBy(windows.createdAt).all();
       const newActiveId = remaining[remaining.length - 1]?.id ?? null;
       if (newActiveId) {
-        db.update(uiState).set({ value: newActiveId }).where(eq2(uiState.key, "active_window_id")).run();
+        db.update(uiState).set({ value: newActiveId }).where(eq3(uiState.key, "active_window_id")).run();
       } else {
-        db.delete(uiState).where(eq2(uiState.key, "active_window_id")).run();
+        db.delete(uiState).where(eq3(uiState.key, "active_window_id")).run();
       }
     }
     return { ok: true };
@@ -533,15 +1123,26 @@ var windowsRouter = router({
    */
   setActive: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ input }) => {
     db.insert(uiState).values({ key: "active_window_id", value: input.id }).onConflictDoUpdate({ target: uiState.key, set: { value: input.id } }).run();
-    db.update(windows).set({ lastAccessedAt: /* @__PURE__ */ new Date() }).where(eq2(windows.id, input.id)).run();
+    db.update(windows).set({ lastAccessedAt: /* @__PURE__ */ new Date() }).where(eq3(windows.id, input.id)).run();
     return { ok: true };
   })
 });
 
 // src/trpc/layout.ts
 import { z as z2 } from "zod";
-import { randomUUID as randomUUID3 } from "crypto";
-import { eq as eq3 } from "drizzle-orm";
+import { randomUUID as randomUUID4 } from "crypto";
+import * as path6 from "path";
+import * as os3 from "os";
+import { eq as eq4 } from "drizzle-orm";
+function expandTilde(p) {
+  if (p.startsWith("~/")) {
+    return path6.join(os3.homedir(), p.slice(2));
+  }
+  if (p === "~") {
+    return os3.homedir();
+  }
+  return p;
+}
 var amux2;
 function setAmuxBridge2(bridge) {
   amux2 = bridge;
@@ -559,20 +1160,20 @@ var layoutRouter = router({
     newPaneId: z2.string().optional(),
     newSessionId: z2.string().optional()
   })).mutation(async ({ input }) => {
-    const sourcePane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
+    const sourcePane = db.select().from(panes).where(eq4(panes.id, input.paneId)).get();
     if (!sourcePane) {
       throw new Error(`Pane ${input.paneId} not found`);
     }
-    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    const window = db.select().from(windows).where(eq4(windows.id, input.windowId)).get();
     if (!window) {
       throw new Error(`Window ${input.windowId} not found`);
     }
-    const newContent = null;
-    const newPaneId = input.newPaneId ?? randomUUID3();
+    const newPaneId = input.newPaneId ?? randomUUID4();
     db.insert(panes).values({
       id: newPaneId,
       windowId: input.windowId,
-      content: newContent
+      content: null,
+      eventStream: null
     }).run();
     const currentLayout = window.layout;
     const newLayout = splitPane(currentLayout, input.paneId, newPaneId, input.direction);
@@ -580,19 +1181,22 @@ var layoutRouter = router({
       layout: newLayout,
       activePaneId: newPaneId,
       lastAccessedAt: /* @__PURE__ */ new Date()
-    }).where(eq3(windows.id, input.windowId)).run();
+    }).where(eq4(windows.id, input.windowId)).run();
     const now = /* @__PURE__ */ new Date();
     return {
       newPaneId,
-      newSessionId: null,
+      newStreamId: null,
       layout: newLayout,
       newPane: {
         id: newPaneId,
         windowId: input.windowId,
-        content: newContent,
+        content: null,
+        eventStream: null,
         createdAt: now.toISOString(),
-        session: null
-      }
+        stream: null
+      },
+      // Legacy aliases
+      newSessionId: null
     };
   }),
   /**
@@ -602,27 +1206,27 @@ var layoutRouter = router({
     windowId: z2.string(),
     paneId: z2.string()
   })).mutation(async ({ input }) => {
-    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    const window = db.select().from(windows).where(eq4(windows.id, input.windowId)).get();
     if (!window) {
       throw new Error(`Window ${input.windowId} not found`);
     }
-    const pane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
+    const pane = db.select().from(panes).where(eq4(panes.id, input.paneId)).get();
     if (!pane) {
       throw new Error(`Pane ${input.paneId} not found`);
     }
     const currentLayout = window.layout;
     const allPaneIds = getAllPaneIds(currentLayout);
     if (allPaneIds.length === 1) {
-      if (pane.content?.type === "session") {
-        await amux2.deleteSession(pane.content.sessionId);
+      if (pane.eventStream) {
+        await amux2.deleteStream(pane.eventStream.streamId);
       }
-      db.delete(windows).where(eq3(windows.id, input.windowId)).run();
+      db.delete(windows).where(eq4(windows.id, input.windowId)).run();
       return { windowClosed: true, layout: null, activePaneId: null };
     }
-    if (pane.content?.type === "session") {
-      await amux2.deleteSession(pane.content.sessionId);
+    if (pane.eventStream) {
+      await amux2.deleteStream(pane.eventStream.streamId);
     }
-    db.delete(panes).where(eq3(panes.id, input.paneId)).run();
+    db.delete(panes).where(eq4(panes.id, input.paneId)).run();
     const newLayout = removePane(currentLayout, input.paneId);
     if (!newLayout) {
       throw new Error("Failed to remove pane from layout");
@@ -632,7 +1236,7 @@ var layoutRouter = router({
       layout: newLayout,
       activePaneId: newActivePaneId,
       lastAccessedAt: /* @__PURE__ */ new Date()
-    }).where(eq3(windows.id, input.windowId)).run();
+    }).where(eq4(windows.id, input.windowId)).run();
     return {
       windowClosed: false,
       layout: newLayout,
@@ -649,7 +1253,7 @@ var layoutRouter = router({
     db.update(windows).set({
       activePaneId: input.paneId,
       lastAccessedAt: /* @__PURE__ */ new Date()
-    }).where(eq3(windows.id, input.windowId)).run();
+    }).where(eq4(windows.id, input.windowId)).run();
     return { ok: true };
   }),
   /**
@@ -660,7 +1264,7 @@ var layoutRouter = router({
     currentPaneId: z2.string(),
     direction: z2.enum(["left", "right", "up", "down"])
   })).mutation(async ({ input }) => {
-    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    const window = db.select().from(windows).where(eq4(windows.id, input.windowId)).get();
     if (!window) {
       throw new Error(`Window ${input.windowId} not found`);
     }
@@ -670,7 +1274,7 @@ var layoutRouter = router({
       db.update(windows).set({
         activePaneId: adjacentPaneId,
         lastAccessedAt: /* @__PURE__ */ new Date()
-      }).where(eq3(windows.id, input.windowId)).run();
+      }).where(eq4(windows.id, input.windowId)).run();
       return { newActivePaneId: adjacentPaneId };
     }
     return { newActivePaneId: null };
@@ -683,93 +1287,110 @@ var layoutRouter = router({
     path: z2.array(z2.enum(["first", "second"])),
     ratio: z2.number().min(10).max(90)
   })).mutation(async ({ input }) => {
-    const window = db.select().from(windows).where(eq3(windows.id, input.windowId)).get();
+    const window = db.select().from(windows).where(eq4(windows.id, input.windowId)).get();
     if (!window) {
       throw new Error(`Window ${input.windowId} not found`);
     }
     const currentLayout = window.layout;
     const newLayout = updateRatio(currentLayout, input.path, input.ratio);
-    db.update(windows).set({ layout: newLayout }).where(eq3(windows.id, input.windowId)).run();
+    db.update(windows).set({ layout: newLayout }).where(eq4(windows.id, input.windowId)).run();
     return { layout: newLayout };
   }),
   /**
-   * Set the session for an empty pane (used when user picks agent/shell type).
-   * Creates a session in amux and updates the pane.
+   * Set static content for a pane (browser URL, etc.).
+   * Upsert behavior - works for both initial set and updates.
    */
-  setSession: publicProcedure.input(z2.object({
+  setPaneContent: publicProcedure.input(z2.object({
     paneId: z2.string(),
-    agentConfigId: z2.string(),
-    directory: z2.string().optional()
+    content: z2.record(z2.unknown()).nullable(),
+    rendererId: z2.string().optional()
   })).mutation(async ({ input }) => {
-    const pane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
+    const pane = db.select().from(panes).where(eq4(panes.id, input.paneId)).get();
     if (!pane) {
       throw new Error(`Pane ${input.paneId} not found`);
     }
-    if (pane.content) {
-      throw new Error(`Pane ${input.paneId} already has content`);
-    }
-    const session = await amux2.createSession({
-      directory: input.directory ?? process.cwd(),
-      agentConfigId: input.agentConfigId
-    });
-    db.update(panes).set({ content: { type: "session", sessionId: session.id } }).where(eq3(panes.id, input.paneId)).run();
-    await amux2.startAgent(session.id);
-    return {
-      sessionId: session.id,
-      content: { type: "session", sessionId: session.id },
-      session: {
-        id: session.id,
-        directory: session.directory,
-        agentConfigId: session.agentConfigId,
-        model: session.model,
-        mode: session.mode,
-        createdAt: session.createdAt.toISOString(),
-        acpSessionId: session.acpSessionId
-      }
-    };
+    db.update(panes).set({
+      content: input.content,
+      rendererId: input.rendererId ?? null
+    }).where(eq4(panes.id, input.paneId)).run();
+    return { content: input.content, rendererId: input.rendererId };
   }),
   /**
-   * Set browser content for an empty pane.
+   * Set an event stream for a pane (agent or shell).
+   * Creates stream in amux and starts the backend.
    */
-  setBrowserContent: publicProcedure.input(z2.object({
+  setPaneEventStream: publicProcedure.input(z2.object({
     paneId: z2.string(),
-    url: z2.string().url()
+    streamConfigId: z2.string(),
+    directory: z2.string().optional(),
+    rendererId: z2.string().optional(),
+    // Legacy alias
+    agentConfigId: z2.string().optional()
   })).mutation(async ({ input }) => {
-    const pane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
+    const pane = db.select().from(panes).where(eq4(panes.id, input.paneId)).get();
     if (!pane) {
       throw new Error(`Pane ${input.paneId} not found`);
     }
-    if (pane.content) {
-      throw new Error(`Pane ${input.paneId} already has content`);
+    if (pane.eventStream) {
+      throw new Error(`Pane ${input.paneId} already has an event stream`);
     }
-    const content = { type: "browser", url: input.url };
-    db.update(panes).set({ content }).where(eq3(panes.id, input.paneId)).run();
-    return { content };
-  }),
-  /**
-   * Update the URL of an existing browser pane.
-   */
-  updateBrowserUrl: publicProcedure.input(z2.object({
-    paneId: z2.string(),
-    url: z2.string().url()
-  })).mutation(async ({ input }) => {
-    const pane = db.select().from(panes).where(eq3(panes.id, input.paneId)).get();
-    if (!pane) {
-      throw new Error(`Pane ${input.paneId} not found`);
-    }
-    if (pane.content?.type !== "browser") {
-      throw new Error(`Pane ${input.paneId} is not a browser pane`);
-    }
-    const content = { type: "browser", url: input.url };
-    db.update(panes).set({ content }).where(eq3(panes.id, input.paneId)).run();
-    return { content };
+    const configId = input.streamConfigId ?? input.agentConfigId;
+    const directory = input.directory ? expandTilde(input.directory) : process.cwd();
+    const stream = await amux2.createStream({
+      directory,
+      streamConfigId: configId
+    });
+    const eventStream = { type: stream.streamType, streamId: stream.id };
+    db.update(panes).set({
+      eventStream,
+      rendererId: input.rendererId ?? null
+    }).where(eq4(panes.id, input.paneId)).run();
+    await amux2.startStream(stream.id);
+    return {
+      streamId: stream.id,
+      eventStream,
+      stream: {
+        id: stream.id,
+        directory: stream.directory,
+        streamConfigId: stream.streamConfigId,
+        streamType: stream.streamType,
+        model: stream.model,
+        mode: stream.mode,
+        createdAt: stream.createdAt.toISOString()
+      },
+      // Legacy aliases
+      sessionId: stream.id,
+      process: eventStream,
+      session: {
+        id: stream.id,
+        directory: stream.directory,
+        agentConfigId: stream.streamConfigId,
+        model: stream.model,
+        mode: stream.mode,
+        createdAt: stream.createdAt.toISOString()
+      }
+    };
   })
 });
 
 // src/trpc/agents.ts
 import { z as z3 } from "zod";
-import { eq as eq4 } from "drizzle-orm";
 import { observable } from "@trpc/server/observable";
+
+// src/lib/panes.ts
+import { eq as eq5 } from "drizzle-orm";
+function getStreamIdForPane(paneId) {
+  const pane = db.select().from(panes).where(eq5(panes.id, paneId)).get();
+  if (!pane) {
+    throw new Error(`Pane ${paneId} not found`);
+  }
+  if (!pane.eventStream) {
+    throw new Error(`Pane ${paneId} does not have an event stream`);
+  }
+  return pane.eventStream.streamId;
+}
+
+// src/trpc/agents.ts
 var amux3;
 function setAmuxBridge3(bridge) {
   amux3 = bridge;
@@ -777,71 +1398,61 @@ function setAmuxBridge3(bridge) {
 var paneInput = z3.object({
   paneId: z3.string()
 });
-function getSessionIdForPane(paneId) {
-  const pane = db.select().from(panes).where(eq4(panes.id, paneId)).get();
-  if (!pane) {
-    throw new Error(`Pane ${paneId} not found`);
-  }
-  if (pane.content?.type !== "session") {
-    throw new Error(`Pane ${paneId} is not a session pane`);
-  }
-  return pane.content.sessionId;
-}
-var agentsRouter = router({
+var streamsRouter = router({
   /**
-   * Start agent for a pane.
+   * Start stream for a pane.
    */
   start: publicProcedure.input(paneInput).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    return amux3.startAgent(sessionId);
+    const streamId = getStreamIdForPane(input.paneId);
+    return amux3.startStream(streamId);
   }),
   /**
-   * Stop agent for a pane.
+   * Stop stream for a pane.
    */
   stop: publicProcedure.input(paneInput).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    await amux3.stopAgent(sessionId);
+    const streamId = getStreamIdForPane(input.paneId);
+    await amux3.stopStream(streamId);
     return { ok: true };
   }),
   /**
-   * Send a prompt to a pane's agent.
+   * Send input to a pane's stream.
    */
-  prompt: publicProcedure.input(z3.object({
+  input: publicProcedure.input(z3.object({
     paneId: z3.string(),
     message: z3.string()
   })).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    await amux3.prompt(sessionId, input.message);
+    const streamId = getStreamIdForPane(input.paneId);
+    await amux3.input(streamId, input.message);
     return { ok: true };
   }),
   /**
    * Cancel the current prompt.
    */
   cancel: publicProcedure.input(paneInput).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    await amux3.cancel(sessionId);
+    const streamId = getStreamIdForPane(input.paneId);
+    await amux3.cancel(streamId);
     return { ok: true };
   }),
   /**
-   * Set agent mode.
+   * Set stream mode.
    */
   setMode: publicProcedure.input(z3.object({
     paneId: z3.string(),
     modeId: z3.string()
   })).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    await amux3.setMode(sessionId, input.modeId);
+    const streamId = getStreamIdForPane(input.paneId);
+    await amux3.setMode(streamId, input.modeId);
     return { ok: true };
   }),
   /**
-   * Set agent model.
+   * Set stream model.
    */
   setModel: publicProcedure.input(z3.object({
     paneId: z3.string(),
     modelId: z3.string()
   })).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    await amux3.setModel(sessionId, input.modelId);
+    const streamId = getStreamIdForPane(input.paneId);
+    await amux3.setModel(streamId, input.modelId);
     return { ok: true };
   }),
   /**
@@ -852,17 +1463,17 @@ var agentsRouter = router({
     requestId: z3.string(),
     optionId: z3.string()
   })).mutation(async ({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
-    amux3.respondPermission(sessionId, input.requestId, input.optionId);
+    const streamId = getStreamIdForPane(input.paneId);
+    amux3.respondPermission(streamId, input.requestId, input.optionId);
     return { ok: true };
   }),
   /**
-   * Subscribe to updates for a pane's agent session.
+   * Subscribe to updates for a pane's stream.
    */
   subscribe: publicProcedure.input(paneInput).subscription(({ input }) => {
-    const sessionId = getSessionIdForPane(input.paneId);
+    const streamId = getStreamIdForPane(input.paneId);
     return observable((emit) => {
-      return amux3.subscribeToSession(sessionId, (update) => {
+      return amux3.subscribeToStream(streamId, (update) => {
         emit.next(update);
       });
     });
@@ -871,22 +1482,42 @@ var agentsRouter = router({
 
 // src/trpc/files.ts
 import { z as z4 } from "zod";
-import { eq as eq5 } from "drizzle-orm";
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
+import * as os4 from "os";
+function expandTilde2(p) {
+  if (p.startsWith("~/")) {
+    return path7.join(os4.homedir(), p.slice(2));
+  }
+  if (p === "~") {
+    return os4.homedir();
+  }
+  return p;
+}
 var amux4;
 function setAmuxBridge4(bridge) {
   amux4 = bridge;
 }
-function getSessionIdForPane2(paneId) {
-  const pane = db.select().from(panes).where(eq5(panes.id, paneId)).get();
-  if (!pane) {
-    throw new Error(`Pane ${paneId} not found`);
-  }
-  if (pane.content?.type !== "session") {
-    throw new Error(`Pane ${paneId} is not a session pane`);
-  }
-  return pane.content.sessionId;
-}
 var filesRouter = router({
+  /**
+   * Get server's current working directory.
+   */
+  getCwd: publicProcedure.query(() => process.cwd()),
+  /**
+   * List directories in a given path.
+   * Used by DirectoryPicker for browsing.
+   */
+  listDirectory: publicProcedure.input(z4.object({
+    directory: z4.string()
+  })).query(async ({ input }) => {
+    try {
+      const absPath = path7.resolve(expandTilde2(input.directory));
+      const entries = await fs6.readdir(absPath, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, isDirectory: true })).sort((a, b) => a.name.localeCompare(b.name));
+    } catch {
+      return [];
+    }
+  }),
   /**
    * List files/directories matching a partial path for autocomplete.
    * Returns files in the session's working directory.
@@ -896,8 +1527,8 @@ var filesRouter = router({
     partialPath: z4.string(),
     limit: z4.number().default(20)
   })).query(async ({ input }) => {
-    const sessionId = getSessionIdForPane2(input.paneId);
-    return amux4.listFilesForAutocomplete(sessionId, input.partialPath, input.limit);
+    const streamId = getStreamIdForPane(input.paneId);
+    return amux4.listFilesForAutocomplete(streamId, input.partialPath, input.limit);
   })
 });
 
@@ -911,15 +1542,15 @@ function setAmuxBridge5(bridge) {
 var paneInput2 = z5.object({
   paneId: z5.string()
 });
-function getSessionIdForPane3(paneId) {
+function getStreamIdForPane2(paneId) {
   const pane = db.select().from(panes).where(eq6(panes.id, paneId)).get();
   if (!pane) {
     throw new Error(`Pane ${paneId} not found`);
   }
-  if (pane.content?.type !== "session") {
-    throw new Error(`Pane ${paneId} is not a session pane`);
+  if (!pane.eventStream) {
+    throw new Error(`Pane ${paneId} does not have an event stream`);
   }
-  return pane.content.sessionId;
+  return pane.eventStream.streamId;
 }
 var terminalsRouter = router({
   /**
@@ -931,8 +1562,8 @@ var terminalsRouter = router({
       data: z5.string()
     })
   ).mutation(({ input }) => {
-    const sessionId = getSessionIdForPane3(input.paneId);
-    amux5.terminalWrite(sessionId, input.data);
+    const streamId = getStreamIdForPane2(input.paneId);
+    amux5.terminalWrite(streamId, input.data);
     return { ok: true };
   }),
   /**
@@ -945,16 +1576,16 @@ var terminalsRouter = router({
       rows: z5.number().int().positive()
     })
   ).mutation(({ input }) => {
-    const sessionId = getSessionIdForPane3(input.paneId);
-    amux5.terminalResize(sessionId, input.cols, input.rows);
+    const streamId = getStreamIdForPane2(input.paneId);
+    amux5.terminalResize(streamId, input.cols, input.rows);
     return { ok: true };
   }),
   /**
-   * Check if a pane is a terminal session.
+   * Check if a pane is a terminal stream.
    */
   isTerminal: publicProcedure.input(paneInput2).query(({ input }) => {
-    const sessionId = getSessionIdForPane3(input.paneId);
-    return { isTerminal: amux5.isTerminalSession(sessionId) };
+    const streamId = getStreamIdForPane2(input.paneId);
+    return { isTerminal: amux5.isTerminalStream(streamId) };
   }),
   /**
    * Set terminal title (from OSC escape sequence).
@@ -963,12 +1594,264 @@ var terminalsRouter = router({
     paneId: z5.string(),
     title: z5.string()
   })).mutation(({ input }) => {
-    const sessionId = getSessionIdForPane3(input.paneId);
-    amux5.updateSessionTitle(sessionId, input.title);
+    const streamId = getStreamIdForPane2(input.paneId);
+    amux5.updateStreamTitle(streamId, input.title);
     return { ok: true };
   })
 });
 
+// src/trpc/renderers.ts
+import { observable as observable2 } from "@trpc/server/observable";
+
+// src/lib/rendererWatcher.ts
+import chokidar2 from "chokidar";
+import * as path9 from "path";
+import * as os5 from "os";
+import * as fs8 from "fs/promises";
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/lib/rendererCompiler.ts
+import { build as build2 } from "esbuild";
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
+async function compileRenderer(pluginDir) {
+  const metaPath = path8.join(pluginDir, "meta.json");
+  const entryPath = path8.join(pluginDir, "index.tsx");
+  const pkgPath = path8.join(pluginDir, "package.json");
+  let meta;
+  try {
+    const metaContent = await fs7.readFile(metaPath, "utf-8");
+    meta = JSON.parse(metaContent);
+  } catch (err) {
+    throw new Error(
+      `Failed to read meta file for ${pluginDir}. Expected ${metaPath} with { name, target } properties. Error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!meta.name || typeof meta.name !== "string") {
+    throw new Error(`Meta file ${metaPath} must have a 'name' string property`);
+  }
+  if (!meta.target || !meta.target.kind) {
+    throw new Error(`Meta file ${metaPath} must have a 'target' object with 'kind' property`);
+  }
+  let hasPackageJson = false;
+  try {
+    const pkgContent = await fs7.readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    hasPackageJson = true;
+    const deps = pkg.dependencies || {};
+    if (deps["react"] || deps["react-dom"]) {
+      throw new Error(
+        `Plugin "${meta.name}": react and react-dom must be in peerDependencies, not dependencies. This ensures plugins share the same React instance as the host app.`
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("peerDependencies")) {
+      throw err;
+    }
+  }
+  const result = await build2({
+    entryPoints: [entryPath],
+    bundle: true,
+    write: false,
+    format: "esm",
+    jsx: "automatic",
+    target: "es2020",
+    external: ["react", "react-dom", "react/jsx-runtime", "@bytespell/shella-sdk", "@bytespell/shella-sdk/components/ui"],
+    // If plugin has package.json, look for node_modules
+    nodePaths: hasPackageJson ? [path8.join(pluginDir, "node_modules")] : [],
+    minify: false
+  });
+  const code = result.outputFiles[0].text;
+  const id = `user:${path8.basename(pluginDir)}`;
+  return {
+    id,
+    name: meta.name,
+    description: meta.description,
+    target: meta.target,
+    code
+  };
+}
+async function isValidPlugin(dirPath) {
+  try {
+    await fs7.access(path8.join(dirPath, "meta.json"));
+    await fs7.access(path8.join(dirPath, "index.tsx"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/rendererWatcher.ts
+var RendererEventEmitter = class extends EventEmitter2 {
+  emit(event, data) {
+    return super.emit(event, data);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+};
+function watchRenderers(emitter) {
+  const userPath = path9.join(os5.homedir(), ".shella", "renderers");
+  ensureDir2(userPath);
+  const knownPlugins = /* @__PURE__ */ new Map();
+  const pendingCompiles = /* @__PURE__ */ new Map();
+  const watcher = chokidar2.watch(userPath, {
+    ignoreInitial: false,
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50
+    },
+    depth: 3
+    // Watch inside plugin folders for nested components
+  });
+  const getPluginDir = (filePath) => {
+    const relative3 = path9.relative(userPath, filePath);
+    const parts = relative3.split(path9.sep);
+    if (parts.length >= 1 && parts[0]) {
+      return path9.join(userPath, parts[0]);
+    }
+    return null;
+  };
+  const scheduleCompile = (pluginDir) => {
+    if (pendingCompiles.has(pluginDir)) {
+      clearTimeout(pendingCompiles.get(pluginDir));
+    }
+    pendingCompiles.set(
+      pluginDir,
+      setTimeout(async () => {
+        pendingCompiles.delete(pluginDir);
+        await handlePluginChange(pluginDir);
+      }, 100)
+    );
+  };
+  const handlePluginChange = async (pluginDir) => {
+    if (!await isValidPlugin(pluginDir)) return;
+    try {
+      const compiled = await compileRenderer(pluginDir);
+      if (!knownPlugins.has(pluginDir)) {
+        knownPlugins.set(pluginDir, true);
+        console.log(`[renderers] Added: ${compiled.id}`);
+        emitter.emit("renderer:added", compiled);
+      } else {
+        console.log(`[renderers] Updated: ${compiled.id}`);
+        emitter.emit("renderer:updated", { id: compiled.id, code: compiled.code });
+      }
+    } catch (err) {
+      console.error(`[renderers] Error compiling ${pluginDir}:`, err);
+      emitter.emit("renderer:error", {
+        filePath: pluginDir,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  };
+  watcher.on("add", (filePath) => {
+    const pluginDir = getPluginDir(filePath);
+    if (pluginDir) scheduleCompile(pluginDir);
+  });
+  watcher.on("change", (filePath) => {
+    const pluginDir = getPluginDir(filePath);
+    if (pluginDir) scheduleCompile(pluginDir);
+  });
+  watcher.on("unlinkDir", (dirPath) => {
+    if (knownPlugins.has(dirPath)) {
+      const id = `user:${path9.basename(dirPath)}`;
+      knownPlugins.delete(dirPath);
+      console.log(`[renderers] Removed: ${id}`);
+      emitter.emit("renderer:removed", { id });
+    }
+  });
+  watcher.on("error", (err) => {
+    console.error("[renderers] Watcher error:", err);
+  });
+  return () => {
+    for (const timeout of pendingCompiles.values()) {
+      clearTimeout(timeout);
+    }
+    pendingCompiles.clear();
+    watcher.close();
+  };
+}
+async function ensureDir2(dirPath) {
+  try {
+    await fs8.mkdir(dirPath, { recursive: true });
+  } catch {
+  }
+}
+async function scanRenderers() {
+  const userPath = path9.join(os5.homedir(), ".shella", "renderers");
+  const renderers = [];
+  try {
+    const entries = await fs8.readdir(userPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginDir = path9.join(userPath, entry.name);
+      if (await isValidPlugin(pluginDir)) {
+        try {
+          const compiled = await compileRenderer(pluginDir);
+          renderers.push(compiled);
+        } catch (err) {
+          console.error(`[renderers] Error compiling ${pluginDir}:`, err);
+        }
+      }
+    }
+  } catch {
+  }
+  return renderers;
+}
+
+// src/trpc/renderers.ts
+var rendererEmitter = new RendererEventEmitter();
+var stopWatcher = null;
+function initRendererWatcher() {
+  if (stopWatcher) {
+    stopWatcher();
+  }
+  stopWatcher = watchRenderers(rendererEmitter);
+}
+var renderersRouter = router({
+  /**
+   * List all currently available user renderers
+   * Used for initial hydration when client connects.
+   */
+  list: publicProcedure.query(async () => {
+    return scanRenderers();
+  }),
+  /**
+   * Subscribe to renderer additions
+   */
+  onAdded: publicProcedure.subscription(() => {
+    return observable2((emit) => {
+      const handler = (data) => emit.next(data);
+      rendererEmitter.on("renderer:added", handler);
+      return () => rendererEmitter.off("renderer:added", handler);
+    });
+  }),
+  /**
+   * Subscribe to renderer updates (code changes)
+   */
+  onUpdated: publicProcedure.subscription(() => {
+    return observable2((emit) => {
+      const handler = (data) => emit.next(data);
+      rendererEmitter.on("renderer:updated", handler);
+      return () => rendererEmitter.off("renderer:updated", handler);
+    });
+  }),
+  /**
+   * Subscribe to renderer removals
+   */
+  onRemoved: publicProcedure.subscription(() => {
+    return observable2((emit) => {
+      const handler = (data) => emit.next(data);
+      rendererEmitter.on("renderer:removed", handler);
+      return () => rendererEmitter.off("renderer:removed", handler);
+    });
+  })
+});
+
 // src/trpc/router.ts
 function initializeRouters(amux6) {
   setAmuxBridge(amux6);
@@ -976,39 +1859,60 @@ function initializeRouters(amux6) {
   setAmuxBridge3(amux6);
   setAmuxBridge4(amux6);
   setAmuxBridge5(amux6);
+  initRendererWatcher();
 }
 var shellaRouter = router({
   windows: windowsRouter,
   layout: layoutRouter,
-  agents: agentsRouter,
+  streams: streamsRouter,
   files: filesRouter,
-  terminals: terminalsRouter
+  terminals: terminalsRouter,
+  renderers: renderersRouter,
+  // Legacy alias
+  agents: streamsRouter
 });
 
 // src/index.ts
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+discoverAndRegisterConfigs(builtInDiscoverers);
+var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
 function createShellaServer(options = {}) {
   const port = options.port ?? 3067;
   if (options.verbose) {
     setVerbose(true);
   }
+  const driverEmitter = new DriverEventEmitter();
+  let stopDriverWatcher = null;
+  driverEmitter.on("driver:added", ({ id, name }) => {
+    debug("shella", `Driver registered: ${id} (${name})`);
+  });
+  driverEmitter.on("driver:updated", ({ id, name }) => {
+    debug("shella", `Driver updated: ${id} (${name})`);
+  });
+  driverEmitter.on("driver:removed", ({ id }) => {
+    debug("shella", `Driver removed: ${id}`);
+  });
+  driverEmitter.on("driver:error", ({ pluginDir, error }) => {
+    console.error(`Driver error in ${pluginDir}:`, error.message);
+  });
   const amuxBridge = createAmuxBridge();
   initializeRouters(amuxBridge);
   const app = express();
   app.use(express.json());
-  const publicPath = path2.join(__dirname, "..", "public");
+  const publicPath = path10.join(__dirname2, "..", "public");
   app.use(express.static(publicPath));
   app.use("/trpc", createExpressMiddleware({ router: shellaRouter }));
   app.get("/health", (_req, res) => res.json({ status: "ok" }));
   app.get("/{*splat}", (_req, res) => {
-    res.sendFile(path2.join(publicPath, "index.html"));
+    res.sendFile(path10.join(publicPath, "index.html"));
   });
   const server = createServer(app);
   const wss = new WebSocketServer({ server, path: "/trpc" });
   applyWSSHandler({ wss, router: shellaRouter });
   return {
-    start: () => {
-      return new Promise((resolve, reject) => {
+    start: async () => {
+      await scanDrivers();
+      stopDriverWatcher = watchDrivers(driverEmitter);
+      return new Promise((resolve4, reject) => {
         server.once("error", (err) => {
           if (err.code === "EADDRINUSE") {
             reject(new Error(`Port ${port} is already in use. Kill the other process or use a different port.`));
@@ -1020,14 +1924,15 @@ function createShellaServer(options = {}) {
           const url = `http://localhost:${port}`;
           debug("shella", `Running on ${url}`);
           options.onReady?.(url);
-          resolve();
+          resolve4();
         });
       });
     },
     stop: async () => {
       debug("shella", "Shutting down...");
+      stopDriverWatcher?.();
       wss.close();
-      await agentManager2.stopAll();
+      await muxManager3.stopAll();
       server.close();
     }
   };