@agentproto/runtime 0.1.0

package/dist/index.mjs

@@ -0,0 +1,4350 @@
+import { randomUUID, randomBytes, createHash } from 'crypto';
+import { existsSync, mkdirSync, writeFileSync, promises, readFileSync } from 'fs';
+import { unlink, readFile, stat, readdir, writeFile, mkdir, chmod, rm } from 'fs/promises';
+import { join, resolve, dirname, isAbsolute, normalize, relative, basename } from 'path';
+import { createMcpServer } from '@agentproto/mcp-server';
+import { execFile, spawn } from 'child_process';
+import { z } from 'zod';
+import { EventEmitter } from 'events';
+import { homedir } from 'os';
+import matter from 'gray-matter';
+import { createServer } from 'http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { WebSocketServer } from 'ws';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { promisify } from 'util';
+
+/**
+ * @agentproto/runtime v0.1.0-alpha
+ * Long-running gateway: MCP server + HTTP transport + HEARTBEAT autonomy + conversation persistence over a workspace dir.
+ */
+
+async function writeRuntimeMeta(workspace, meta) {
+  const dir = join(workspace, ".agentproto");
+  try {
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      join(dir, "runtime.json"),
+      JSON.stringify(meta, null, 2) + "\n",
+      { encoding: "utf8", mode: 384 }
+    );
+  } catch (err) {
+    console.error("[runtime] failed to write .agentproto/runtime.json:", err);
+  }
+}
+async function unlinkRuntimeMeta(workspace) {
+  try {
+    await unlink(join(workspace, ".agentproto", "runtime.json"));
+  } catch {
+  }
+}
+async function readRuntimeMeta(workspace) {
+  const path = join(workspace, ".agentproto", "runtime.json");
+  try {
+    const [raw, st] = await Promise.all([readFile(path, "utf8"), stat(path)]);
+    const meta = JSON.parse(raw);
+    return { meta, mtime: st.mtime };
+  } catch {
+    return null;
+  }
+}
+async function sweepStaleRuntimeMetas(workspaces, currentWorkspace) {
+  const cleaned = [];
+  for (const ws of workspaces) {
+    if (ws === currentWorkspace) continue;
+    const meta = await readRuntimeMeta(ws);
+    if (!meta) continue;
+    const pid = meta.meta.pid;
+    if (typeof pid === "number" && !isPidAlive(pid)) {
+      try {
+        await unlink(join(ws, ".agentproto", "runtime.json"));
+        cleaned.push(join(ws, ".agentproto", "runtime.json"));
+      } catch {
+      }
+    }
+  }
+  return cleaned;
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_TIMEOUT_MS = 6e5;
+var ALLOWLIST_REL = ".agentproto/allowed-commands.json";
+var allowlistCache = null;
+async function loadAllowlist(workspace) {
+  const path = resolve(workspace, ALLOWLIST_REL);
+  if (!existsSync(path)) {
+    allowlistCache = null;
+    return /* @__PURE__ */ new Set();
+  }
+  try {
+    const s = await stat(path);
+    if (allowlistCache && allowlistCache.path === path && allowlistCache.entry.mtimeMs === s.mtimeMs) {
+      return allowlistCache.entry.commands;
+    }
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    const list = Array.isArray(parsed.commands) ? parsed.commands : [];
+    const commands = new Set(
+      list.filter((x) => typeof x === "string" && x.length > 0).map((x) => x.trim())
+    );
+    allowlistCache = { path, entry: { mtimeMs: s.mtimeMs, commands } };
+    return commands;
+  } catch (err) {
+    console.error(
+      `[runtime] failed to load ${ALLOWLIST_REL} (will deny all):`,
+      err
+    );
+    allowlistCache = null;
+    return /* @__PURE__ */ new Set();
+  }
+}
+function makeCwdAnchor(workspace) {
+  const root = resolve(workspace);
+  return (input) => {
+    if (!input || input.length === 0) return root;
+    const candidate = isAbsolute(input) ? normalize(input) : normalize(join(root, input));
+    const rel = relative(root, candidate);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      throw new Error(
+        `cwd escapes the workspace: '${input}' (workspace=${root})`
+      );
+    }
+    return candidate;
+  };
+}
+function registerCommandTools(server, opts) {
+  const anchorCwd = makeCwdAnchor(opts.workspace);
+  server.tool(
+    "execute_command",
+    "Run a shell command on the host running the runtime. The command basename must be in `<workspace>/.agentproto/allowed-commands.json`; default-deny otherwise. Captures stdout / stderr / exit code and returns them as JSON. Use this to drive local CLIs (Claude Code, gh, pnpm, \u2026) from a remote agent.",
+    {
+      command: z.string().min(1).describe(
+        "Executable name or absolute path. Must be allowlisted by basename in the workspace's allowed-commands.json."
+      ),
+      args: z.array(z.string()).optional().describe(
+        "Argv array. Passed verbatim \u2014 no shell expansion (we spawn with shell:false so quoting doesn't bite)."
+      ),
+      cwd: z.string().optional().describe(
+        "Working directory, workspace-relative or an absolute path inside the workspace. Defaults to the workspace root."
+      ),
+      stdin: z.string().optional().describe("Optional input piped to the process's stdin."),
+      timeoutMs: z.number().int().positive().max(MAX_TIMEOUT_MS).optional().describe(
+        `Hard kill after this many ms. Defaults to ${DEFAULT_TIMEOUT_MS}; capped at ${MAX_TIMEOUT_MS}.`
+      )
+    },
+    async ({ command, args, cwd, stdin, timeoutMs }) => {
+      const allowlist = await loadAllowlist(opts.workspace);
+      const baseName = basename(command);
+      if (!allowlist.has(baseName)) {
+        const allowed = [...allowlist].sort().join(", ") || "(empty)";
+        throw new Error(
+          `command '${baseName}' is not in the allowlist. Add it to ${join(opts.workspace, ALLOWLIST_REL)} under "commands": [...]. Currently allowed: ${allowed}.`
+        );
+      }
+      const resolvedCwd = anchorCwd(cwd);
+      const limit = Math.min(timeoutMs ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+      const result = await runCommand({
+        command,
+        args: args ?? [],
+        cwd: resolvedCwd,
+        stdin,
+        timeoutMs: limit
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+}
+var STREAM_BUFFER_CAP = 1048576;
+async function runCommand(input) {
+  return new Promise((resolvePromise) => {
+    const startedAt = Date.now();
+    const child = spawn(input.command, input.args, {
+      cwd: input.cwd,
+      shell: false,
+      // Inherit user env so PATH lookups for `claude`, `gh`, etc. work.
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let truncated = false;
+    let timedOut = false;
+    function appendCapped(buf, chunk) {
+      if (buf.length >= STREAM_BUFFER_CAP) {
+        truncated = true;
+        return buf;
+      }
+      const room = STREAM_BUFFER_CAP - buf.length;
+      const text3 = chunk.toString("utf8");
+      if (text3.length > room) {
+        truncated = true;
+        return buf + text3.slice(0, room);
+      }
+      return buf + text3;
+    }
+    child.stdout?.on("data", (d) => {
+      stdout = appendCapped(stdout, d);
+    });
+    child.stderr?.on("data", (d) => {
+      stderr = appendCapped(stderr, d);
+    });
+    if (input.stdin) {
+      child.stdin?.write(input.stdin);
+    }
+    child.stdin?.end();
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3).unref();
+    }, input.timeoutMs);
+    timer.unref();
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolvePromise({
+        exitCode: -1,
+        signal: null,
+        stdout,
+        stderr: stderr + (stderr ? "\n" : "") + err.message,
+        truncated,
+        durationMs: Date.now() - startedAt
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      resolvePromise({
+        exitCode: typeof code === "number" ? code : -1,
+        signal: signal ?? (timedOut ? "SIGTERM-timeout" : null),
+        stdout,
+        stderr,
+        truncated,
+        durationMs: Date.now() - startedAt
+      });
+    });
+  });
+}
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n/;
+function fileConversationStore(opts) {
+  const dir = opts.dir ?? join(opts.workspace, "conversations");
+  const filePath = (id) => join(dir, `${id}.md`);
+  return {
+    pathFor: filePath,
+    async open(id, meta) {
+      await mkdir(dir, { recursive: true });
+      const path = filePath(id);
+      if (existsSync(path)) return;
+      const header = renderHeader({
+        id,
+        agent: meta.agent,
+        started: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "open"
+      });
+      await writeFile(path, header, "utf8");
+    },
+    async appendTurn(id, role, content, options) {
+      const path = filePath(id);
+      if (!existsSync(path)) {
+        await this.open(id, { agent: options?.attribution ?? "unknown" });
+      }
+      const block = renderTurn({
+        role,
+        at: options?.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        attribution: options?.attribution,
+        content
+      });
+      await writeFile(path, block, { encoding: "utf8", flag: "a" });
+    },
+    async read(id) {
+      const path = filePath(id);
+      const source = await readFile(path, "utf8");
+      return parseConversation(source, id);
+    },
+    async list() {
+      if (!existsSync(dir)) return [];
+      const entries = await readdir(dir, { withFileTypes: true });
+      const out = [];
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+        const id = entry.name.slice(0, -3);
+        try {
+          const source = await readFile(join(dir, entry.name), "utf8");
+          const { meta } = parseConversation(source, id);
+          out.push({ id, meta });
+        } catch {
+        }
+      }
+      return out;
+    }
+  };
+}
+function renderHeader(meta) {
+  return [
+    "---",
+    `schema: conversation/v1`,
+    `id: ${meta.id}`,
+    `agent: ${meta.agent}`,
+    `started: ${meta.started}`,
+    `status: ${meta.status}`,
+    "---",
+    "",
+    ""
+  ].join("\n");
+}
+function renderTurn(turn) {
+  const heading = turn.attribution ? `## ${turn.role} \u2014 ${turn.at} (${turn.attribution})` : `## ${turn.role} \u2014 ${turn.at}`;
+  return `${heading}
+
+${turn.content.trimEnd()}
+
+`;
+}
+function parseConversation(source, fallbackId) {
+  const match = source.match(FRONTMATTER_RE);
+  let meta = {
+    id: fallbackId,
+    agent: "unknown",
+    started: "",
+    status: "open"
+  };
+  let body = source;
+  if (match) {
+    meta = parseFrontmatter(match[1] ?? "", fallbackId);
+    body = source.slice(match[0].length);
+  }
+  const turns = [];
+  const lines = body.split("\n");
+  let current = null;
+  let buffer = [];
+  const flush = () => {
+    if (!current) return;
+    current.content = buffer.join("\n").trim();
+    turns.push(current);
+    current = null;
+    buffer = [];
+  };
+  const headingRe = /^##\s+(user|assistant|system)\s+—\s+(\S+)(?:\s+\(([^)]+)\))?\s*$/;
+  for (const line of lines) {
+    const m = line.match(headingRe);
+    if (m) {
+      flush();
+      current = {
+        role: m[1],
+        at: m[2] ?? "",
+        attribution: m[3],
+        content: ""
+      };
+      continue;
+    }
+    if (current) buffer.push(line);
+  }
+  flush();
+  return { meta, turns };
+}
+function parseFrontmatter(raw, fallbackId) {
+  const out = {};
+  for (const line of raw.split("\n")) {
+    const colon = line.indexOf(":");
+    if (colon < 1) continue;
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    out[key] = value;
+  }
+  return {
+    id: out.id ?? fallbackId,
+    agent: out.agent ?? "unknown",
+    started: out.started ?? "",
+    status: out.status === "closed" ? "closed" : "open"
+  };
+}
+function createRuntimeEvents() {
+  const ee = new EventEmitter();
+  ee.setMaxListeners(50);
+  return {
+    on(type, handler) {
+      const wrapped = (ev) => {
+        if (ev.type === type) handler(ev);
+      };
+      ee.on("event", wrapped);
+      return () => ee.off("event", wrapped);
+    },
+    onAny(handler) {
+      ee.on("event", handler);
+      return () => ee.off("event", handler);
+    },
+    emit(ev) {
+      ee.emit("event", ev);
+    }
+  };
+}
+var FsPathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FsPathError";
+  }
+};
+function makeAnchor(workspace) {
+  const root = resolve(workspace);
+  return (input) => {
+    if (typeof input !== "string" || input.length === 0) {
+      throw new FsPathError("path must be a non-empty string");
+    }
+    const candidate = isAbsolute(input) ? normalize(input) : normalize(join(root, input));
+    const rel = relative(root, candidate);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      throw new FsPathError(`path escapes the workspace: '${input}'`);
+    }
+    return candidate;
+  };
+}
+function text(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value)
+      }
+    ]
+  };
+}
+function registerFsTools(server, opts) {
+  const anchor = makeAnchor(opts.workspace);
+  server.tool(
+    "read_file",
+    "Read a UTF-8 file from the workspace.",
+    { path: z.string().describe("Workspace-relative path to the file.") },
+    async ({ path }) => {
+      const abs = anchor(path);
+      const buf = await readFile(abs);
+      return text(buf.toString("utf8"));
+    }
+  );
+  server.tool(
+    "write_file",
+    "Write a file to the workspace. Parent directories are created on demand.",
+    {
+      path: z.string().describe("Workspace-relative path to the file."),
+      content: z.string().describe("File body (UTF-8).")
+    },
+    async ({ path, content }) => {
+      const abs = anchor(path);
+      await mkdir(dirname(abs), { recursive: true });
+      await writeFile(abs, content, "utf8");
+      return text("ok");
+    }
+  );
+  server.tool(
+    "list_directory",
+    "List entries of a directory in the workspace. Returns one '[FILE]' or '[DIR]' line per entry, mirroring `@modelcontextprotocol/server-filesystem`.",
+    {
+      path: z.string().optional().describe("Workspace-relative directory (defaults to workspace root).")
+    },
+    async ({ path }) => {
+      const abs = anchor(path && path.length > 0 ? path : ".");
+      const entries = await readdir(abs, { withFileTypes: true });
+      const lines = entries.map(
+        (e) => e.isDirectory() ? `[DIR]  ${e.name}` : `[FILE] ${e.name}`
+      );
+      return text(lines.join("\n"));
+    }
+  );
+  server.tool(
+    "get_file_info",
+    "Stat a file or directory in the workspace.",
+    { path: z.string().describe("Workspace-relative path.") },
+    async ({ path }) => {
+      const abs = anchor(path);
+      const info = await stat(abs);
+      return text({
+        name: abs.split("/").pop() ?? path,
+        path,
+        type: info.isDirectory() ? "directory" : "file",
+        size: info.size,
+        modified: info.mtime.toISOString(),
+        created: info.birthtime.toISOString()
+      });
+    }
+  );
+  server.tool(
+    "create_directory",
+    "Create a directory (recursive) in the workspace.",
+    { path: z.string().describe("Workspace-relative directory path.") },
+    async ({ path }) => {
+      const abs = anchor(path);
+      await mkdir(abs, { recursive: true });
+      return text("ok");
+    }
+  );
+  server.tool(
+    "delete_file",
+    "Delete a file or empty directory in the workspace.",
+    { path: z.string().describe("Workspace-relative path.") },
+    async ({ path }) => {
+      const abs = anchor(path);
+      await rm(abs, { recursive: true, force: true });
+      return text("ok");
+    }
+  );
+}
+var WORKSPACES_CONFIG_VERSION = 1;
+var DEFAULT_CONFIG_DIR = () => resolve(homedir(), ".agentproto");
+var DEFAULT_CONFIG_PATH = () => resolve(DEFAULT_CONFIG_DIR(), "workspaces.json");
+function sanitizeSlug(input) {
+  const trimmed = input.trim().toLowerCase();
+  const cleaned = trimmed.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return cleaned || "workspace";
+}
+async function loadWorkspacesConfig(path = DEFAULT_CONFIG_PATH()) {
+  let raw;
+  try {
+    raw = await promises.readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { version: WORKSPACES_CONFIG_VERSION, workspaces: [] };
+    }
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `agentproto: ${path} is not valid JSON (${err instanceof Error ? err.message : String(err)}). Delete the file or fix it manually.`
+    );
+  }
+  return normalizeConfig(parsed);
+}
+function findWorkspace(config, slug) {
+  return config.workspaces.find((w) => w.slug === sanitizeSlug(slug));
+}
+function getActiveWorkspace(config) {
+  if (!config.active) return config.workspaces[0];
+  return findWorkspace(config, config.active) ?? config.workspaces[0];
+}
+function normalizeConfig(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return { version: WORKSPACES_CONFIG_VERSION, workspaces: [] };
+  }
+  const obj = parsed;
+  const workspaces = [];
+  if (Array.isArray(obj.workspaces)) {
+    for (const entry of obj.workspaces) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const slug = typeof e.slug === "string" ? sanitizeSlug(e.slug) : "";
+      const path = typeof e.path === "string" ? e.path : "";
+      if (!slug || !path) continue;
+      const addedAt = typeof e.addedAt === "string" ? e.addedAt : (/* @__PURE__ */ new Date()).toISOString();
+      const updatedAt = typeof e.updatedAt === "string" ? e.updatedAt : addedAt;
+      const we = { slug, path, addedAt, updatedAt };
+      if (typeof e.label === "string" && e.label.trim()) {
+        we.label = e.label.trim();
+      }
+      workspaces.push(we);
+    }
+  }
+  const dedup = /* @__PURE__ */ new Map();
+  for (const w of workspaces) dedup.set(w.slug, w);
+  const finalList = Array.from(dedup.values());
+  const active = typeof obj.active === "string" && finalList.some((w) => w.slug === obj.active) ? obj.active : finalList[0]?.slug;
+  const out = {
+    version: WORKSPACES_CONFIG_VERSION,
+    workspaces: finalList
+  };
+  if (active !== void 0) out.active = active;
+  return out;
+}
+async function discoverMcps(opts = {}) {
+  const home = opts.home ?? homedir();
+  const out = [];
+  const errors = [];
+  await Promise.all([
+    scanClaudeCode(home, out, errors),
+    scanCursor(home, out, errors),
+    scanGoose(home, out),
+    scanRegisteredWorkspaces(out, errors)
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const dedup = [];
+  for (const m of out) {
+    const key = `${m.source}:${m.scope}:${m.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    dedup.push(m);
+  }
+  if (errors.length > 0) {
+    for (const e of errors) console.warn(`[mcp-discovery] ${e}`);
+  }
+  return dedup.sort((a, b) => {
+    if (a.source !== b.source) return a.source.localeCompare(b.source);
+    if (a.scope !== b.scope) return a.scope.localeCompare(b.scope);
+    return a.name.localeCompare(b.name);
+  });
+}
+async function scanClaudeCode(home, out, errors) {
+  const path = resolve(home, ".claude.json");
+  let raw;
+  try {
+    raw = await promises.readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    errors.push(`claude-code: read ${path} \u2014 ${err.message}`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    errors.push(`claude-code: JSON parse ${path} \u2014 ${err.message}`);
+    return;
+  }
+  if (!parsed || typeof parsed !== "object") return;
+  const root = parsed;
+  const top = root.mcpServers;
+  if (top && typeof top === "object") {
+    pushMcpMap({
+      out,
+      source: "claude-code",
+      scope: "global",
+      map: top
+    });
+  }
+  const projects = root.projects;
+  if (projects && typeof projects === "object") {
+    for (const [projPath, proj] of Object.entries(
+      projects
+    )) {
+      if (!proj || typeof proj !== "object") continue;
+      const projMcps = proj.mcpServers;
+      if (!projMcps || typeof projMcps !== "object") continue;
+      pushMcpMap({
+        out,
+        source: "claude-code",
+        scope: `project:${projPath}`,
+        map: projMcps
+      });
+    }
+  }
+}
+async function scanCursor(home, out, errors) {
+  const path = resolve(home, ".cursor", "mcp.json");
+  let raw;
+  try {
+    raw = await promises.readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    errors.push(`cursor: read ${path} \u2014 ${err.message}`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    errors.push(`cursor: JSON parse ${path} \u2014 ${err.message}`);
+    return;
+  }
+  if (!parsed || typeof parsed !== "object") return;
+  const root = parsed;
+  const map = root.mcpServers;
+  if (map && typeof map === "object") {
+    pushMcpMap({
+      out,
+      source: "cursor",
+      scope: "global",
+      map
+    });
+  }
+}
+async function scanGoose(home, out, errors) {
+  const path = resolve(home, ".config", "goose", "config.yaml");
+  try {
+    await promises.access(path);
+  } catch {
+    return;
+  }
+  out.push({
+    id: "goose:global:_detected",
+    source: "goose",
+    scope: "global",
+    name: "(goose config detected)",
+    type: "unknown",
+    parseNote: "Goose config found but YAML parsing is not yet implemented. Open ~/.config/goose/config.yaml to inspect MCP entries."
+  });
+}
+async function scanRegisteredWorkspaces(out, errors) {
+  let workspaces = [];
+  try {
+    const cfg = await loadWorkspacesConfig();
+    workspaces = cfg.workspaces;
+  } catch (err) {
+    errors.push(`workspaces: load failed \u2014 ${err.message}`);
+    return;
+  }
+  await Promise.all(
+    workspaces.map(async (ws) => {
+      const candidates = [
+        resolve(ws.path, ".mcp.json"),
+        resolve(ws.path, ".cursor", "mcp.json"),
+        resolve(ws.path, ".vscode", "mcp.json")
+      ];
+      for (const path of candidates) {
+        let raw;
+        try {
+          raw = await promises.readFile(path, "utf8");
+        } catch (err) {
+          if (err.code === "ENOENT") continue;
+          errors.push(
+            `workspace ${ws.slug}: read ${path} \u2014 ${err.message}`
+          );
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(raw);
+        } catch (err) {
+          errors.push(
+            `workspace ${ws.slug}: JSON parse ${path} \u2014 ${err.message}`
+          );
+          continue;
+        }
+        if (!parsed || typeof parsed !== "object") continue;
+        const map = parsed.mcpServers;
+        if (!map || typeof map !== "object") continue;
+        pushMcpMap({
+          out,
+          source: "workspace",
+          scope: `workspace:${ws.slug}`,
+          map
+        });
+      }
+    })
+  );
+}
+function pushMcpMap(args) {
+  for (const [name, raw] of Object.entries(args.map)) {
+    if (!raw || typeof raw !== "object") continue;
+    const entry = raw;
+    const id = `${args.source}:${args.scope}:${name}`;
+    const declared = typeof entry.type === "string" ? entry.type : null;
+    const url = typeof entry.url === "string" ? entry.url : void 0;
+    const command = typeof entry.command === "string" ? entry.command : void 0;
+    let type;
+    if (declared === "http" || declared === "sse" || declared === "stdio") {
+      type = declared;
+    } else if (url) {
+      type = "http";
+    } else if (command) {
+      type = "stdio";
+    } else {
+      type = "unknown";
+    }
+    const m = {
+      id,
+      source: args.source,
+      scope: args.scope,
+      name,
+      type
+    };
+    if (command !== void 0) m.command = command;
+    if (Array.isArray(entry.args)) {
+      m.args = entry.args.filter((a) => typeof a === "string");
+    }
+    if (entry.env && typeof entry.env === "object") {
+      m.env = stringifyValues(entry.env);
+    }
+    if (url !== void 0) m.url = url;
+    if (entry.headers && typeof entry.headers === "object") {
+      m.headers = stringifyValues(entry.headers);
+    }
+    if (type === "unknown") {
+      m.parseNote = "Entry has neither `command` nor `url` \u2014 couldn't classify transport.";
+    }
+    args.out.push(m);
+  }
+}
+function stringifyValues(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (typeof v === "string") out[k] = v;
+    else if (v != null) out[k] = String(v);
+  }
+  return out;
+}
+var IMPORTED_MCPS_PATH = () => resolve(homedir(), ".agentproto", "imported-mcps.json");
+var IMPORTED_MCPS_VERSION = 1;
+var EMPTY = {
+  version: IMPORTED_MCPS_VERSION,
+  imports: []
+};
+async function loadImportedMcps(path = IMPORTED_MCPS_PATH()) {
+  let raw;
+  try {
+    raw = await promises.readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return EMPTY;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `agentproto: ${path} is not valid JSON (${err instanceof Error ? err.message : String(err)}). Delete or fix manually.`
+    );
+  }
+  return normalize3(parsed);
+}
+async function saveImportedMcps(config, path = IMPORTED_MCPS_PATH()) {
+  await promises.mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp.${process.pid}`;
+  await promises.writeFile(tmp, JSON.stringify(config, null, 2) + "\n", "utf8");
+  await promises.rename(tmp, path);
+}
+function addImport(config, input) {
+  const alias = (input.alias ?? input.snapshot.name).trim();
+  if (!alias) {
+    throw new Error("addImport: alias resolves to empty string");
+  }
+  const addedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const next = {
+    id: input.snapshot.id,
+    alias,
+    addedAt,
+    snapshot: input.snapshot
+  };
+  const others = config.imports.filter((e) => e.id !== input.snapshot.id);
+  return { ...config, imports: [...others, next] };
+}
+function removeImport(config, id) {
+  return { ...config, imports: config.imports.filter((e) => e.id !== id) };
+}
+function normalize3(parsed) {
+  if (!parsed || typeof parsed !== "object") return EMPTY;
+  const obj = parsed;
+  const imports = [];
+  if (Array.isArray(obj.imports)) {
+    for (const entry of obj.imports) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const id = typeof e.id === "string" ? e.id : "";
+      const alias = typeof e.alias === "string" ? e.alias : id;
+      const addedAt = typeof e.addedAt === "string" ? e.addedAt : (/* @__PURE__ */ new Date()).toISOString();
+      const snapshot = e.snapshot;
+      if (!id || !snapshot) continue;
+      imports.push({ id, alias, addedAt, snapshot });
+    }
+  }
+  return { version: IMPORTED_MCPS_VERSION, imports };
+}
+
+// src/session-tools.ts
+function registerSessionTools(server, opts) {
+  const { registry, resolveAgentAdapter, listAgentAdapters, mcpProxy } = opts;
+  const ptyEnabled = opts.ptyEnabled === true;
+  server.tool(
+    "start_agent_session",
+    "Spawn a long-running agent CLI (claude-code, hermes, \u2026) on the host. The session stays alive across multiple turns \u2014 call `prompt_agent_session` to continue the conversation. Returns the session id + initial descriptor. When `workspaceSlug` is set, resolves the cwd via `~/.agentproto/workspaces.json`; otherwise pass `cwd` explicitly or fall back to the active workspace.",
+    {
+      adapter: z.string().min(1).describe(
+        "Adapter slug \u2014 one of the installed `@agentproto/adapter-*` packages (e.g. 'claude-code', 'hermes', 'aider')."
+      ),
+      workspaceSlug: z.string().optional().describe(
+        "Workspace slug from `agentproto workspace list`. The daemon resolves it to an absolute path. Omit to use the `cwd` field or the active workspace."
+      ),
+      cwd: z.string().optional().describe(
+        "Absolute path to spawn the agent in. Wins over `workspaceSlug` when both are set."
+      ),
+      prompt: z.string().optional().describe(
+        "Optional initial prompt. The session is spawned and the prompt dispatched in one shot \u2014 equivalent to `start` then `prompt` back-to-back. Skip to spawn idle."
+      ),
+      label: z.string().optional().describe(
+        "Free-text label that surfaces in `list_agent_sessions` and the UI \u2014 useful for tagging sessions with a conversation id or operator name."
+      )
+    },
+    async (input) => {
+      if (!resolveAgentAdapter) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "start_agent_session is not enabled \u2014 the daemon was started without an adapter resolver. Re-run the daemon with the `@agentproto/cli` shim wired (see playground/scripts/gateway.ts)."
+            }
+          ],
+          isError: true
+        };
+      }
+      let cwd = input.cwd;
+      let resolvedSlug = input.workspaceSlug ?? "default";
+      if (!cwd) {
+        try {
+          const config = await loadWorkspacesConfig();
+          const ws = input.workspaceSlug ? findWorkspace(config, input.workspaceSlug) : getActiveWorkspace(config);
+          if (ws) {
+            cwd = ws.path;
+            resolvedSlug = ws.slug;
+          }
+        } catch {
+        }
+      }
+      if (!cwd) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "start_agent_session: no cwd resolvable. Pass `cwd` explicitly, or pass `workspaceSlug` matching `agentproto workspace list`, or set an active workspace via `agentproto workspace use <slug>`."
+            }
+          ],
+          isError: true
+        };
+      }
+      const resolved = await resolveAgentAdapter(input.adapter);
+      if (!resolved) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `start_agent_session: adapter "${input.adapter}" not found. Try \`agentproto install <slug>\` first.`
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const agentSession = await resolved.startSession({ cwd });
+        const desc = registry.spawnAgent({
+          workspaceSlug: resolvedSlug,
+          cwd,
+          agentSession,
+          adapterSlug: input.adapter,
+          ...input.prompt ? { initialPrompt: input.prompt } : {},
+          ...input.label ? { label: input.label } : {},
+          ...resolved.commandPreview ? { commandPreview: resolved.commandPreview } : {}
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(desc, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `start_agent_session: spawn failed \u2014 ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "prompt_agent_session",
+    "Send a follow-up prompt to a live agent session \u2014 multi-turn continuity without re-spawning. The session id comes from `start_agent_session` (or `list_agent_sessions`). Returns immediately; tail output via `get_agent_session_output` or the SSE /sessions/:id/stream endpoint.",
+    {
+      sessionId: z.string().describe("Session id returned by start_agent_session."),
+      prompt: z.string().min(1).describe("The next user turn (plain text).")
+    },
+    async (input) => {
+      try {
+        void registry.sendPrompt(input.sessionId, input.prompt).catch(() => {
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { ok: true, sessionId: input.sessionId, queued: true },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `prompt_agent_session: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_sessions",
+    "List sessions tracked by the daemon \u2014 agent-CLI sessions (claude-code, hermes, \u2026), terminal/PTY sessions (claude TUI, bash, \u2026), and raw commands. Each entry includes `kind`, `pty` (true for real PTYs), `name` (when set at spawn), `status`, `command`, age + exit code. Use this when you need to know what's already running before spawning anything new, or to discover a session id by name.",
+    {
+      kind: z.enum(["terminal", "agent-cli", "command", "all"]).optional().describe(
+        "Filter by session kind. `all` (default) returns every kind. Use `terminal` to list only PTY sessions, `agent-cli` for structured ACP agents."
+      ),
+      onlyAlive: z.boolean().optional().describe("When true, only running/starting sessions. Default false."),
+      status: z.enum(["starting", "running", "exited", "killed", "error"]).optional().describe("Filter by exact status (overrides onlyAlive).")
+    },
+    async (input) => {
+      let rows = registry.list();
+      if (input.kind && input.kind !== "all") {
+        rows = rows.filter((s) => s.kind === input.kind);
+      }
+      if (input.status) {
+        rows = rows.filter((s) => s.status === input.status);
+      } else if (input.onlyAlive) {
+        rows = rows.filter(
+          (s) => s.status === "running" || s.status === "starting"
+        );
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ sessions: rows }, null, 2) }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_agent_sessions",
+    "DEPRECATED \u2014 prefer `list_sessions` which returns ALL kinds + filters. Despite the name this tool already returns every kind, not just agent-cli sessions; the new tool's name reflects the actual surface.",
+    {
+      onlyAlive: z.boolean().optional().describe("Filter to status running/starting only. Default false.")
+    },
+    async (input) => {
+      const all = registry.list();
+      const filtered = input.onlyAlive ? all.filter((s) => s.status === "running" || s.status === "starting") : all;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ sessions: filtered }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_agent_session_output",
+    "Tail the recent output of a session. Returns the last N lines of the ring buffer (stdout + stderr inter-leaved, newest last). Use this to read an agent's reply after `prompt_agent_session`.",
+    {
+      sessionId: z.string().describe("Session id."),
+      lastN: z.number().int().min(1).max(500).optional().describe("Max lines to return. Default 80, max 500.")
+    },
+    async (input) => {
+      const desc = registry.get(input.sessionId);
+      if (!desc) {
+        return {
+          content: [
+            { type: "text", text: `get_agent_session_output: no session "${input.sessionId}"` }
+          ],
+          isError: true
+        };
+      }
+      const limit = input.lastN ?? 80;
+      const lines = [];
+      const unsub = registry.attach(input.sessionId, (line, _stream) => {
+        lines.push(line);
+      });
+      if (unsub) unsub();
+      const tail = lines.slice(-limit);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                sessionId: input.sessionId,
+                status: desc.status,
+                lastOutputAt: desc.lastOutputAt,
+                lines: tail
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_adapters",
+    "Enumerate every agent CLI adapter installed on the host (claude-code, hermes, aider, \u2026). Returns slug + display name + version + protocol so callers can let users pick from the installed set instead of guessing. Use before `start_agent_session` when the model doesn't already know what's available.",
+    {},
+    async () => {
+      if (!listAgentAdapters) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "list_adapters is not enabled \u2014 the daemon was started without an adapter lister. Wire `@agentproto/cli`'s `listInstalledAdapters` via `createGateway({ listAgentAdapters })`."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const adapters = await listAgentAdapters();
+        return {
+          content: [{ type: "text", text: JSON.stringify({ adapters }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `list_adapters failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_discovered_mcps",
+    "Discover MCP servers already configured in the user's other agent tooling (claude-code, cursor, goose). Returns the union with source attribution so the operator can suggest 'I see you have a chrome-devtools MCP set up in claude \u2014 want me to use it?' instead of asking the user to re-configure. Read-only \u2014 does not modify any host's config.",
+    {},
+    async () => {
+      try {
+        const mcps = await discoverMcps();
+        return {
+          content: [{ type: "text", text: JSON.stringify({ mcps }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `list_discovered_mcps failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_imported_mcps",
+    "Return the user's curated set of MCP servers \u2014 the ones they've imported from claude / cursor / workspace configs into the daemon. Use to know which MCPs the operator may freely call vs. ones still showing up in `list_discovered_mcps` waiting on the user's blessing.",
+    {},
+    async () => {
+      try {
+        const config = await loadImportedMcps();
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(config, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `list_imported_mcps failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "import_mcp",
+    "Import a discovered MCP into the daemon's curated set. The agent calls `list_discovered_mcps` first, asks the user, then commits the choice via this tool. The snapshot is captured at import time so the entry stays usable if the source config (claude/cursor) is later removed.",
+    {
+      sourceMcpId: z.string().min(1).describe(
+        "The discovered MCP id from `list_discovered_mcps` (e.g. 'claude-code:project:/path:chrome-devtools')."
+      ),
+      alias: z.string().optional().describe(
+        "Optional friendly name to display. Defaults to the source MCP's name."
+      )
+    },
+    async (input) => {
+      try {
+        const discovered = await discoverMcps();
+        const snapshot = discovered.find((d) => d.id === input.sourceMcpId);
+        if (!snapshot) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `import_mcp: discovered MCP "${input.sourceMcpId}" not found. Re-run list_discovered_mcps to get current ids.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const cfg = await loadImportedMcps();
+        const next = addImport(cfg, {
+          snapshot,
+          ...input.alias ? { alias: input.alias } : {}
+        });
+        await saveImportedMcps(next);
+        const entry = next.imports.find((e) => e.id === snapshot.id);
+        return {
+          content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `import_mcp failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "remove_imported_mcp",
+    "Remove a previously-imported MCP from the daemon's curated set. Use when the user no longer wants the operator referencing it.",
+    {
+      id: z.string().min(1).describe(
+        "The imported MCP id (matches the discovered MCP id at import time)."
+      )
+    },
+    async (input) => {
+      try {
+        const cfg = await loadImportedMcps();
+        if (!cfg.imports.some((e) => e.id === input.id)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `remove_imported_mcp: id "${input.id}" not in imports. Use list_imported_mcps to see current entries.`
+              }
+            ],
+            isError: true
+          };
+        }
+        await saveImportedMcps(removeImport(cfg, input.id));
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ ok: true, id: input.id }, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `remove_imported_mcp failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "mcp_imported_status",
+    "Snapshot every imported MCP server with its connection status, transport type, and tool count. Use this first when an operator wonders 'what MCPs do I actually have access to right now?' \u2014 the answer covers both 'imported but not yet connected' and 'connected with N tools'. Errors during connect surface in `lastError`.",
+    {},
+    async () => {
+      if (!mcpProxy) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "mcp_imported_status is not enabled \u2014 daemon was started without an MCP proxy. The host must wire `mcpProxy` in createGateway."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const aliases = await mcpProxy.listAliases();
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ imports: aliases }, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `mcp_imported_status failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "mcp_imported_list_tools",
+    "List the tools exposed by one imported MCP server. The proxy lazily connects on first call \u2014 first-use latency includes the transport handshake (stdio: ~1-2s for npx-spawned servers; http/sse: <100ms). Returns the upstream `inputSchema` (JSON Schema) verbatim so the operator can build a valid `arguments` object for the follow-up `mcp_imported_call` invocation.",
+    {
+      alias: z.string().min(1).describe(
+        "Alias from `list_imported_mcps` / `mcp_imported_status` (typically the original MCP name, e.g. 'chrome-devtools')."
+      )
+    },
+    async (input) => {
+      if (!mcpProxy) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "mcp_imported_list_tools is not enabled \u2014 see mcp_imported_status."
+            }
+          ],
+          isError: true
+        };
+      }
+      const out = await mcpProxy.listTools(input.alias);
+      if (!out.ok) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `mcp_imported_list_tools "${input.alias}": ${out.error}`
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ alias: input.alias, tools: out.tools }, null, 2) }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "mcp_imported_call",
+    "Invoke a tool on an imported MCP server. The daemon proxies the call through the live client connection \u2014 the upstream server validates `arguments` against its own input schema (which you can fetch via `mcp_imported_list_tools`). The full upstream result is returned verbatim, including `isError` flags so the operator sees the original failure shape.",
+    {
+      alias: z.string().min(1).describe("Imported MCP alias."),
+      toolName: z.string().min(1).describe(
+        "Tool name as it appears in `mcp_imported_list_tools` (NOT a namespaced version \u2014 pass the upstream's own name)."
+      ),
+      args: z.record(z.string(), z.unknown()).optional().describe(
+        "Tool arguments as a JSON object. Schema is the upstream's \u2014 the proxy doesn't validate, only forwards. Default: empty object."
+      )
+    },
+    async (input) => {
+      if (!mcpProxy) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "mcp_imported_call is not enabled \u2014 see mcp_imported_status."
+            }
+          ],
+          isError: true
+        };
+      }
+      const out = await mcpProxy.callTool(
+        input.alias,
+        input.toolName,
+        input.args ?? {}
+      );
+      if (!out.ok) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `mcp_imported_call "${input.alias}".${input.toolName}: ${out.error}`
+            }
+          ],
+          isError: true
+        };
+      }
+      return out.result;
+    }
+  );
+  server.tool(
+    "kill_agent_session",
+    "Stop a session \u2014 SIGTERM the underlying child + close the agent protocol session. Use to free resources after the operator is done, or when a session is wedged.",
+    {
+      sessionId: z.string().describe("Session id.")
+    },
+    async (input) => {
+      const ok = registry.kill(input.sessionId);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ ok, sessionId: input.sessionId }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  const ptyNotConfigured = (toolName) => ({
+    content: [
+      {
+        type: "text",
+        text: `${toolName}: PTY support not enabled \u2014 the daemon was started without a node-pty factory. Re-run \`agentproto serve\` from a build that ships node-pty (the optional dep ships with @agentproto/cli).`
+      }
+    ],
+    isError: true
+  });
+  server.tool(
+    "start_terminal_session",
+    "Spawn a process under a real PTY (node-pty) on the host. Bytes (including ANSI escapes, alt-screen sequences) flow through the daemon's byte ring buffer; subscribers attach via the WS at /sessions/:id/pty. Use for interactive TUIs (claude, vim, htop) or to orchestrate shells from another agent. Returns the session descriptor.",
+    {
+      argv: z.array(z.string()).min(1).describe(
+        "Argv array. First element is the binary, rest are arguments. e.g. ['claude'] or ['bash', '-l']."
+      ),
+      workspaceSlug: z.string().optional().describe(
+        "Workspace slug from `agentproto workspace list`. Resolves cwd. Omit to use `cwd` explicitly or the active workspace."
+      ),
+      cwd: z.string().optional().describe("Absolute cwd. Wins over workspaceSlug when both set."),
+      cols: z.number().int().min(1).max(500).optional().describe("Initial cols. Default 80."),
+      rows: z.number().int().min(1).max(200).optional().describe("Initial rows. Default 24."),
+      name: z.string().optional().describe(
+        "User-friendly slug. Becomes an alias for the session id in subsequent tool calls (read/write/kill accept either)."
+      ),
+      label: z.string().optional().describe(
+        "Free-text label surfaced in list_agent_sessions and the UI."
+      )
+    },
+    async (input) => {
+      if (!ptyEnabled) return ptyNotConfigured("start_terminal_session");
+      let cwd = input.cwd;
+      let resolvedSlug = input.workspaceSlug ?? "default";
+      if (!cwd) {
+        try {
+          const config = await loadWorkspacesConfig();
+          const ws = input.workspaceSlug ? findWorkspace(config, input.workspaceSlug) : getActiveWorkspace(config);
+          if (ws) {
+            cwd = ws.path;
+            resolvedSlug = ws.slug;
+          }
+        } catch {
+        }
+      }
+      if (!cwd) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "start_terminal_session: no cwd resolvable. Pass `cwd` explicitly or `workspaceSlug` matching `agentproto workspace list`."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const desc = registry.spawnPty({
+          argv: input.argv,
+          cwd,
+          workspaceSlug: resolvedSlug,
+          cols: input.cols ?? 80,
+          rows: input.rows ?? 24,
+          ...input.name ? { name: input.name } : {},
+          ...input.label ? { label: input.label } : {}
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(desc, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `start_terminal_session: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "write_terminal_input",
+    "Send keystrokes to a PTY session's stdin. The text is forwarded verbatim \u2014 include trailing newlines if the target needs them (e.g. shell commands). Use after `start_terminal_session` to drive an interactive CLI.",
+    {
+      sessionId: z.string().describe("Session id OR name from start_terminal_session."),
+      text: z.string().describe("Text to write. Sent as-is to the PTY's stdin.")
+    },
+    async (input) => {
+      if (!ptyEnabled) return ptyNotConfigured("write_terminal_input");
+      const desc = registry.findByIdOrName(input.sessionId);
+      if (!desc) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `write_terminal_input: no session "${input.sessionId}"`
+            }
+          ],
+          isError: true
+        };
+      }
+      const ok = registry.writeTerminalInput(desc.id, input.text);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ ok, sessionId: desc.id }, null, 2)
+          }
+        ],
+        ...ok ? {} : { isError: true }
+      };
+    }
+  );
+  server.tool(
+    "read_terminal_output",
+    "Snapshot the recent byte buffer of a PTY session. Returns base64-encoded bytes (the buffer is RAW including ANSI escapes \u2014 strip with a regex if you want plain text). `lastBytes` caps the read from the tail.",
+    {
+      sessionId: z.string().describe("Session id OR name from start_terminal_session."),
+      lastBytes: z.number().int().min(1).max(64 * 1024).optional().describe("Max bytes from the tail. Default: full ring buffer (~64 KiB).")
+    },
+    async (input) => {
+      if (!ptyEnabled) return ptyNotConfigured("read_terminal_output");
+      const desc = registry.findByIdOrName(input.sessionId);
+      if (!desc) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `read_terminal_output: no session "${input.sessionId}"`
+            }
+          ],
+          isError: true
+        };
+      }
+      const buf = registry.readTerminalOutput(
+        desc.id,
+        input.lastBytes
+      );
+      if (!buf) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `read_terminal_output: session "${desc.id}" is not a PTY`
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                sessionId: desc.id,
+                status: desc.status,
+                bytes: buf.byteLength,
+                b64: buf.toString("base64")
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "kill_terminal_session",
+    "SIGTERM a PTY session and drop it from the alive set. Same effect as `kill_agent_session` for the PTY family \u2014 separate name so it's obvious what's being stopped.",
+    {
+      sessionId: z.string().describe("Session id OR name from start_terminal_session.")
+    },
+    async (input) => {
+      if (!ptyEnabled) return ptyNotConfigured("kill_terminal_session");
+      const desc = registry.findByIdOrName(input.sessionId);
+      if (!desc) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `kill_terminal_session: no session "${input.sessionId}"`
+            }
+          ],
+          isError: true
+        };
+      }
+      const ok = registry.kill(desc.id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ ok, sessionId: desc.id }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+function startHeartbeat(opts) {
+  const filename = opts.filename ?? "HEARTBEAT.md";
+  const path = join(opts.workspace, filename);
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  let timer = null;
+  let currentEveryMs = null;
+  let firing = false;
+  async function load() {
+    if (!existsSync(path)) return null;
+    let source;
+    try {
+      source = await readFile(path, "utf8");
+    } catch {
+      return null;
+    }
+    const parsed = matter(source);
+    const fm = parsed.data;
+    const agent = typeof fm.agent === "string" ? fm.agent : null;
+    if (!agent) return null;
+    const enabled = fm.enabled === void 0 ? true : Boolean(fm.enabled);
+    const everyRaw = typeof fm.every === "string" ? fm.every : "60s";
+    const everyMs = parseDuration(everyRaw);
+    if (!everyMs) return null;
+    const conversationTemplate = typeof fm.conversation === "string" ? fm.conversation : "heartbeat-{date}";
+    return {
+      agent,
+      everyMs,
+      enabled,
+      conversationTemplate,
+      body: parsed.content.trim()
+    };
+  }
+  async function tick() {
+    if (firing) return;
+    if (opts.shouldFire && !opts.shouldFire()) return;
+    firing = true;
+    let agentId;
+    try {
+      const hb = await load();
+      if (!hb || !hb.enabled) return;
+      agentId = hb.agent;
+      const agent = await opts.buildAgent(hb.agent);
+      if (!agent) {
+        opts.events.emit({
+          type: "heartbeat-error",
+          at: now().toISOString(),
+          agent: hb.agent,
+          error: `buildAgent('${hb.agent}') returned null`
+        });
+        return;
+      }
+      if (!hb.body) {
+        opts.events.emit({
+          type: "heartbeat-error",
+          at: now().toISOString(),
+          agent: hb.agent,
+          error: "HEARTBEAT.md body is empty"
+        });
+        return;
+      }
+      const conversationId = expandTemplate(hb.conversationTemplate, now());
+      await opts.conversations.open(conversationId, { agent: hb.agent });
+      const startedAt = now();
+      await opts.conversations.appendTurn(
+        conversationId,
+        "user",
+        hb.body,
+        { at: startedAt.toISOString(), attribution: "heartbeat" }
+      );
+      opts.events.emit({
+        type: "conv-turn-appended",
+        at: startedAt.toISOString(),
+        conversationId,
+        role: "user",
+        contentPreview: preview(hb.body)
+      });
+      const t0 = Date.now();
+      const reply = await agent.generate(hb.body);
+      const durationMs = Date.now() - t0;
+      const finishedAt = now();
+      await opts.conversations.appendTurn(
+        conversationId,
+        "assistant",
+        reply.text,
+        { at: finishedAt.toISOString(), attribution: hb.agent }
+      );
+      opts.events.emit({
+        type: "conv-turn-appended",
+        at: finishedAt.toISOString(),
+        conversationId,
+        role: "assistant",
+        contentPreview: preview(reply.text)
+      });
+      opts.events.emit({
+        type: "heartbeat-fired",
+        at: finishedAt.toISOString(),
+        agent: hb.agent,
+        conversationId,
+        prompt: hb.body,
+        reply: reply.text,
+        durationMs
+      });
+      if (currentEveryMs !== null && currentEveryMs !== hb.everyMs) {
+        reschedule(hb.everyMs);
+      }
+    } catch (err) {
+      opts.events.emit({
+        type: "heartbeat-error",
+        at: now().toISOString(),
+        agent: agentId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    } finally {
+      firing = false;
+    }
+  }
+  function reschedule(everyMs) {
+    if (timer) clearInterval(timer);
+    currentEveryMs = everyMs;
+    timer = setInterval(() => {
+      void tick();
+    }, everyMs);
+  }
+  return {
+    start() {
+      if (timer) return;
+      void load().then((hb) => {
+        const everyMs = hb?.everyMs ?? 6e4;
+        reschedule(everyMs);
+      });
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+        currentEveryMs = null;
+      }
+    },
+    async fireNow() {
+      await tick();
+    }
+  };
+}
+var DURATION_RE = /^(\d+)\s*(s|m|h|d)$/;
+function parseDuration(input) {
+  const trimmed = input.trim();
+  const match = trimmed.match(DURATION_RE);
+  if (!match) return null;
+  const n = Number(match[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  switch (match[2]) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 36e5;
+    case "d":
+      return n * 864e5;
+    default:
+      return null;
+  }
+}
+function expandTemplate(template, when) {
+  const date = when.toISOString().slice(0, 10);
+  return template.replace(/\{date\}/g, date);
+}
+function preview(text3, max = 120) {
+  const flat = text3.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+var DEFAULT_ALLOWED_ORIGINS = [
+  "http://localhost:*",
+  "http://127.0.0.1:*",
+  "https://localhost:*"
+];
+async function startHttpServer(opts) {
+  const startedAt = Date.now();
+  const authSource = opts.auth ?? { mode: "none" };
+  const readAuth = () => typeof authSource === "function" ? authSource() : authSource;
+  function isLoopback(req) {
+    const addr = req.socket.remoteAddress ?? "";
+    const isLocalAddr = addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+    if (!isLocalAddr) return false;
+    if (req.headers["x-forwarded-for"]) return false;
+    return true;
+  }
+  function authorize(req, res) {
+    const auth = readAuth();
+    if (auth.mode === "none") return true;
+    if (isLoopback(req)) return true;
+    const header = req.headers.authorization;
+    const expected = `Bearer ${auth.token}`;
+    if (header !== expected) {
+      res.writeHead(401, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "unauthorized" }));
+      return false;
+    }
+    return true;
+  }
+  function checkSessionsToken(req) {
+    if (!opts.token) return "ok";
+    const header = req.headers.authorization;
+    const expected = `Bearer ${opts.token}`;
+    if (header === expected) return "ok";
+    const urlStr = req.url ?? "";
+    if (urlStr.includes("?")) {
+      const qs = new URLSearchParams(urlStr.slice(urlStr.indexOf("?") + 1));
+      const qsToken = qs.get("token");
+      if (qsToken && qsToken === opts.token) return "ok";
+    }
+    const origin = req.headers.origin;
+    if (typeof origin === "string" && originAllowed(origin)) return "ok";
+    return header ? "bad" : "missing";
+  }
+  function originAllowed(origin) {
+    const list = opts.strictOrigins ? opts.allowedOrigins ?? [] : [...DEFAULT_ALLOWED_ORIGINS, ...opts.allowedOrigins ?? []];
+    for (const pattern of list) {
+      if (pattern === origin) return true;
+      if (pattern.endsWith(":*")) {
+        const prefix = pattern.slice(0, -2);
+        if (origin === prefix || origin.startsWith(prefix + ":")) return true;
+      }
+    }
+    return false;
+  }
+  function rejectUnauthorizedSession(req, res, kind) {
+    const origin = req.headers.origin ?? null;
+    const allowList = opts.strictOrigins ? opts.allowedOrigins ?? [] : [...DEFAULT_ALLOWED_ORIGINS, ...opts.allowedOrigins ?? []];
+    res.writeHead(401, { "content-type": "application/json" });
+    const message = kind === "missing" ? origin ? `Origin "${origin}" not in the daemon's allowlist, and no Bearer token sent. Either add it (\`agentproto config set daemon.allowedOrigins ${origin}\` then restart the daemon), or send Authorization: Bearer <token> read from <workspace>/.agentproto/runtime.json.` : `Authorization: Bearer <token> required on mutating /sessions/* routes. Read the token from <workspace>/.agentproto/runtime.json. (Browser callers can use an Origin in the allowlist instead.)` : `Invalid bearer token. The daemon regenerated its token on its last boot \u2014 re-read <workspace>/.agentproto/runtime.json.`;
+    res.end(
+      JSON.stringify({
+        error: "sessions_unauthorized",
+        message,
+        // Debug data so a UI / network-tab inspection points the user
+        // straight at the fix without needing the daemon's stderr.
+        rejectedOrigin: origin,
+        allowedOrigins: allowList,
+        // We never echo the token; only the absence-or-presence flag.
+        receivedAuthHeader: typeof req.headers.authorization === "string"
+      })
+    );
+  }
+  function isMutatingSessionsRoute(method, path) {
+    if (!path.startsWith("/sessions")) return false;
+    if (method === "POST" || method === "DELETE" || method === "PUT" || method === "PATCH") {
+      return true;
+    }
+    return false;
+  }
+  async function handleMcp(req, res) {
+    if (!authorize(req, res)) return;
+    const server2 = await opts.mcpServerFactory();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    const transportInternal = transport;
+    if ("onerror" in transport) {
+      transportInternal["onerror"] = (err) => {
+        console.error("[mcp transport.onerror]", err);
+      };
+    }
+    res.on("close", () => {
+      void transport.close();
+      void server2.close();
+    });
+    try {
+      await server2.connect(transport);
+      await transport.handleRequest(req, res);
+    } catch (err) {
+      console.error("[mcp] handleRequest threw:", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "content-type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "mcp_transport_failed",
+            message: err instanceof Error ? err.message : String(err)
+          })
+        );
+      }
+    }
+  }
+  function handleHealth(_req, res) {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(
+      JSON.stringify({
+        status: "ok",
+        workspace: opts.meta.workspace,
+        registered: opts.meta.registered,
+        uptimeMs: Date.now() - startedAt
+      })
+    );
+  }
+  function handleEvents(req, res) {
+    if (!authorize(req, res)) return;
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive"
+    });
+    res.write(`: connected
+
+`);
+    const off = opts.events.onAny((ev) => {
+      res.write(`data: ${JSON.stringify(ev)}
+
+`);
+    });
+    req.on("close", off);
+  }
+  async function handleListConversations(req, res) {
+    if (!authorize(req, res)) return;
+    const list = await opts.conversations.list();
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify(list));
+  }
+  async function handleGetConversation(req, res, id) {
+    if (!authorize(req, res)) return;
+    try {
+      const data = await opts.conversations.read(id);
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify(data));
+    } catch (err) {
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "not_found",
+          message: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  async function handleHeartbeatTick(req, res) {
+    if (!authorize(req, res)) return;
+    await opts.heartbeat.fireNow();
+    res.writeHead(202, { "content-type": "application/json" });
+    res.end(JSON.stringify({ status: "fired" }));
+  }
+  async function handleFileUpload(req, res, url) {
+    const reply = (status, body) => {
+      res.writeHead(status, { "content-type": "application/json" });
+      res.end(JSON.stringify(body));
+    };
+    const qs = new URLSearchParams(url.includes("?") ? url.slice(url.indexOf("?") + 1) : "");
+    const cwd = qs.get("cwd");
+    const rawName = qs.get("name");
+    if (!cwd || !rawName) {
+      reply(400, { error: "missing_cwd_or_name" });
+      return;
+    }
+    if (!isAbsolute(cwd)) {
+      reply(400, { error: "cwd_not_absolute" });
+      return;
+    }
+    const safeName = rawName.replace(/[/\\]/g, "_").replace(/\.\.+/g, ".").replace(/^\.+/, "").slice(0, 200);
+    if (safeName.length === 0) {
+      reply(400, { error: "invalid_name" });
+      return;
+    }
+    try {
+      const st = await stat(cwd);
+      if (!st.isDirectory()) {
+        reply(400, { error: "cwd_not_a_directory" });
+        return;
+      }
+    } catch {
+      reply(400, { error: "cwd_not_found" });
+      return;
+    }
+    const dir = join(cwd, ".agentproto-attachments");
+    const target = resolve(dir, safeName);
+    if (!target.startsWith(resolve(dir) + (dir.endsWith("/") ? "" : "/"))) {
+      reply(400, { error: "path_traversal_blocked" });
+      return;
+    }
+    const MAX_BYTES = 32 * 1024 * 1024;
+    const chunks = [];
+    let total = 0;
+    let aborted = false;
+    await new Promise((resolveBody, rejectBody) => {
+      req.on("data", (chunk) => {
+        if (aborted) return;
+        const buf = chunk;
+        total += buf.length;
+        if (total > MAX_BYTES) {
+          aborted = true;
+          reply(413, { error: "file_too_large", maxBytes: MAX_BYTES });
+          rejectBody(new Error("too_large"));
+          return;
+        }
+        chunks.push(buf);
+      });
+      req.on("end", () => {
+        if (!aborted) resolveBody();
+      });
+      req.on("error", (err) => rejectBody(err));
+    }).catch(() => void 0);
+    if (aborted) return;
+    try {
+      await mkdir(dir, { recursive: true });
+      await writeFile(target, Buffer.concat(chunks));
+      reply(200, { path: target, bytes: total });
+    } catch (err) {
+      reply(500, {
+        error: "write_failed",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  function applyCors(req, res) {
+    const origin = req.headers.origin ?? "*";
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Credentials", "true");
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      req.headers["access-control-request-headers"] ?? "authorization,content-type,mcp-session-id"
+    );
+    res.setHeader(
+      "Access-Control-Allow-Methods",
+      "GET,POST,PUT,PATCH,DELETE,OPTIONS"
+    );
+    if (req.headers["access-control-request-private-network"] === "true") {
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+    }
+  }
+  const server = createServer((req, res) => {
+    void (async () => {
+      try {
+        const url = req.url ?? "/";
+        const path = url.split("?")[0] ?? "/";
+        if (req.headers["x-forwarded-for"]) {
+          opts.events.emit({
+            type: "remote-log",
+            at: (/* @__PURE__ */ new Date()).toISOString(),
+            line: `[http-in] ${req.method} ${url} host=${req.headers.host ?? "?"} xff=${String(req.headers["x-forwarded-for"])}`
+          });
+        }
+        applyCors(req, res);
+        if (req.method === "OPTIONS") {
+          res.writeHead(204);
+          res.end();
+          return;
+        }
+        if (path === "/health" && req.method === "GET") {
+          handleHealth(req, res);
+          return;
+        }
+        if (path === "/events" && req.method === "GET") {
+          handleEvents(req, res);
+          return;
+        }
+        if (path === "/mcp") {
+          await handleMcp(req, res);
+          return;
+        }
+        if (path === "/conversations" && req.method === "GET") {
+          await handleListConversations(req, res);
+          return;
+        }
+        if (path.startsWith("/conversations/") && req.method === "GET") {
+          const id = path.slice("/conversations/".length);
+          await handleGetConversation(req, res, id);
+          return;
+        }
+        if (path === "/heartbeat/tick" && req.method === "POST") {
+          await handleHeartbeatTick(req, res);
+          return;
+        }
+        if (path === "/files/upload" && req.method === "POST") {
+          const gate = checkSessionsToken(req);
+          if (gate !== "ok") {
+            rejectUnauthorizedSession(req, res, gate);
+            return;
+          }
+          await handleFileUpload(req, res, url);
+          return;
+        }
+        if (opts.sessions && path.startsWith("/sessions")) {
+          if (isMutatingSessionsRoute(req.method ?? "GET", path)) {
+            const gate = checkSessionsToken(req);
+            if (gate !== "ok") {
+              rejectUnauthorizedSession(req, res, gate);
+              return;
+            }
+          }
+          const handled = await handleSessions(
+            req,
+            res,
+            path,
+            opts.sessions,
+            opts.resolveAgentAdapter,
+            opts.ptyEnabled === true
+          );
+          if (handled) return;
+        }
+        if (path === "/workspaces" && req.method === "GET") {
+          try {
+            const config = await loadWorkspacesConfig();
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify(config));
+          } catch (err) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "workspaces_load_failed",
+                message: err instanceof Error ? err.message : String(err)
+              })
+            );
+          }
+          return;
+        }
+        if (path === "/mcps/imports" && req.method === "GET") {
+          const config = await loadImportedMcps();
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify(config));
+          return;
+        }
+        if (path === "/mcps/imports" && req.method === "POST") {
+          const body = await readJsonBody(req);
+          if (!body || typeof body.sourceMcpId !== "string") {
+            res.writeHead(400, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "missing_sourceMcpId" }));
+            return;
+          }
+          const discovered = await discoverMcps();
+          const snapshot = discovered.find((d) => d.id === body.sourceMcpId);
+          if (!snapshot) {
+            res.writeHead(404, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "discovered_mcp_not_found",
+                sourceMcpId: body.sourceMcpId
+              })
+            );
+            return;
+          }
+          const cfg = await loadImportedMcps();
+          const next = addImport(cfg, {
+            snapshot,
+            ...body.alias ? { alias: body.alias } : {}
+          });
+          await saveImportedMcps(next);
+          res.writeHead(201, { "content-type": "application/json" });
+          res.end(JSON.stringify(next.imports.find((e) => e.id === snapshot.id)));
+          return;
+        }
+        const importMatch = path.match(/^\/mcps\/imports\/(.+)$/);
+        if (importMatch && req.method === "DELETE") {
+          const id = decodeURIComponent(importMatch[1] ?? "");
+          const cfg = await loadImportedMcps();
+          if (!cfg.imports.some((e) => e.id === id)) {
+            res.writeHead(404, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "import_not_found", id }));
+            return;
+          }
+          await saveImportedMcps(removeImport(cfg, id));
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ ok: true, id }));
+          return;
+        }
+        if (path === "/mcps/discovered" && req.method === "GET") {
+          try {
+            const mcps = await discoverMcps();
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ mcps }));
+          } catch (err) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "discovery_failed",
+                message: err instanceof Error ? err.message : String(err)
+              })
+            );
+          }
+          return;
+        }
+        if (path === "/mcps/proxy/status" && req.method === "GET") {
+          if (!opts.mcpProxy) {
+            res.writeHead(501, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "mcp_proxy_not_configured" }));
+            return;
+          }
+          try {
+            const imports = await opts.mcpProxy.listAliases();
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ imports }));
+          } catch (err) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "proxy_status_failed",
+                message: err instanceof Error ? err.message : String(err)
+              })
+            );
+          }
+          return;
+        }
+        const proxyToolsMatch = path.match(/^\/mcps\/proxy\/tools\/(.+)$/);
+        if (proxyToolsMatch && req.method === "GET") {
+          if (!opts.mcpProxy) {
+            res.writeHead(501, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "mcp_proxy_not_configured" }));
+            return;
+          }
+          const alias = decodeURIComponent(proxyToolsMatch[1] ?? "");
+          const out = await opts.mcpProxy.listTools(alias);
+          res.writeHead(out.ok ? 200 : 502, {
+            "content-type": "application/json"
+          });
+          res.end(JSON.stringify(out));
+          return;
+        }
+        if (path === "/mcps/proxy/call" && req.method === "POST") {
+          if (!opts.mcpProxy) {
+            res.writeHead(501, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "mcp_proxy_not_configured" }));
+            return;
+          }
+          const body = await readJsonBody(req);
+          if (!body || typeof body.alias !== "string" || typeof body.toolName !== "string") {
+            res.writeHead(400, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "invalid_body",
+                message: "expected { alias, toolName, args? }"
+              })
+            );
+            return;
+          }
+          const result = await opts.mcpProxy.callTool(
+            body.alias,
+            body.toolName,
+            body.args ?? {}
+          );
+          res.writeHead(result.ok ? 200 : 502, {
+            "content-type": "application/json"
+          });
+          res.end(JSON.stringify(result));
+          return;
+        }
+        if (path === "/adapters" && req.method === "GET") {
+          if (!opts.listAgentAdapters) {
+            res.writeHead(501, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "lister_not_configured",
+                message: "Daemon was started without `listAgentAdapters` \u2014 see @agentproto/cli's `listInstalledAdapters` for the canonical impl."
+              })
+            );
+            return;
+          }
+          try {
+            const adapters = await opts.listAgentAdapters();
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ adapters }));
+          } catch (err) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(
+              JSON.stringify({
+                error: "list_failed",
+                message: err instanceof Error ? err.message : String(err)
+              })
+            );
+          }
+          return;
+        }
+        res.writeHead(404, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "not_found", path }));
+      } catch (err) {
+        if (!res.headersSent) {
+          res.writeHead(500, { "content-type": "application/json" });
+          res.end(
+            JSON.stringify({
+              error: "internal_error",
+              message: err instanceof Error ? err.message : String(err)
+            })
+          );
+        }
+      }
+    })();
+  });
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (req, socket, head) => {
+    const url = req.url ?? "/";
+    const path = url.split("?")[0] ?? "/";
+    const ptyMatch = path.match(/^\/sessions\/([^/]+)\/pty$/);
+    if (!ptyMatch) {
+      socket.destroy();
+      return;
+    }
+    if (!opts.sessions || opts.ptyEnabled !== true) {
+      rejectUpgrade(socket, 501, "pty_not_configured");
+      return;
+    }
+    const gate = checkSessionsToken(req);
+    if (gate !== "ok") {
+      rejectUpgrade(socket, 401, gate === "missing" ? "missing_token" : "bad_token");
+      return;
+    }
+    const id = ptyMatch[1];
+    if (!id) {
+      rejectUpgrade(socket, 400, "missing_id");
+      return;
+    }
+    const desc = opts.sessions.findByIdOrName(id);
+    if (!desc) {
+      rejectUpgrade(socket, 404, "session_not_found");
+      return;
+    }
+    if (desc.pty !== true) {
+      rejectUpgrade(socket, 400, "session_not_pty");
+      return;
+    }
+    if (desc.status === "exited" || desc.status === "killed" || desc.status === "error") {
+      rejectUpgrade(
+        socket,
+        410,
+        `session_${desc.status}`,
+        `Session ${desc.id}${desc.name ? ` (${desc.name})` : ""} has ${desc.status}. Spawn a fresh one with: agentproto sessions restart ${desc.name ?? desc.id}`
+      );
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      handlePtyWebSocket(ws, req, desc.id, opts.sessions);
+    });
+  });
+  const bind = opts.bind ?? "127.0.0.1";
+  await new Promise((resolve8, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port, bind, () => resolve8());
+  });
+  return {
+    url: `http://${bind}:${opts.port}`,
+    async stop() {
+      wss.close();
+      await new Promise((resolve8) => server.close(() => resolve8()));
+    }
+  };
+}
+function rejectUpgrade(socket, status, reason, message) {
+  const reasonText = `${status} ${reason}`;
+  const body = { error: reason };
+  if (message) body.message = message;
+  try {
+    socket.write(
+      `HTTP/1.1 ${reasonText}\r
+Content-Type: application/json\r
+Connection: close\r
+\r
+` + JSON.stringify(body) + `
+`
+    );
+  } catch {
+  }
+  socket.destroy();
+}
+function handlePtyWebSocket(ws, req, sessionId, registry) {
+  const query = new URLSearchParams(
+    (req.url ?? "").includes("?") ? (req.url ?? "").split("?")[1] : ""
+  );
+  const cols = clampPositiveInt(query.get("cols"), 80);
+  const rows = clampPositiveInt(query.get("rows"), 24);
+  const BACKPRESSURE_BYTES = 256 * 1024;
+  const handle = registry.attachPty(
+    sessionId,
+    { cols, rows },
+    (chunk) => {
+      if (ws.readyState !== ws.OPEN) return;
+      if (ws.bufferedAmount > BACKPRESSURE_BYTES) return;
+      ws.send(
+        JSON.stringify({ kind: "data", b64: chunk.toString("base64") })
+      );
+    },
+    (evt) => {
+      if (ws.readyState !== ws.OPEN) return;
+      ws.send(
+        JSON.stringify({
+          kind: "exit",
+          exitCode: evt.exitCode,
+          ...evt.signal != null ? { signal: evt.signal } : {}
+        })
+      );
+      try {
+        ws.close(1e3, "session exited");
+      } catch {
+      }
+    }
+  );
+  if (!handle) {
+    try {
+      ws.close(1011, "session not attachable");
+    } catch {
+    }
+    return;
+  }
+  ws.on("message", (raw, isBinary) => {
+    if (isBinary) {
+      return;
+    }
+    let frame;
+    try {
+      frame = JSON.parse(raw.toString("utf8"));
+    } catch {
+      return;
+    }
+    if (!frame || typeof frame !== "object") return;
+    const f = frame;
+    switch (f.kind) {
+      case "input": {
+        if (typeof f.text === "string") {
+          handle.write(f.text);
+        } else if (typeof f.b64 === "string") {
+          try {
+            handle.write(Buffer.from(f.b64, "base64").toString("utf8"));
+          } catch {
+          }
+        }
+        break;
+      }
+      case "resize": {
+        const c = typeof f.cols === "number" && f.cols > 0 ? Math.floor(f.cols) : null;
+        const r = typeof f.rows === "number" && f.rows > 0 ? Math.floor(f.rows) : null;
+        if (c && r) handle.resize(c, r);
+        break;
+      }
+      case "ping":
+        try {
+          ws.send(JSON.stringify({ kind: "pong" }));
+        } catch {
+        }
+        break;
+    }
+  });
+  ws.on("close", () => {
+    handle.detach();
+  });
+  ws.on("error", () => {
+    handle.detach();
+  });
+}
+function clampPositiveInt(raw, fallback) {
+  if (!raw) return fallback;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function clampInt(raw, fallback, min, max) {
+  if (!raw) return fallback;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n)) return fallback;
+  if (n < min) return min;
+  if (n > max) return max;
+  return n;
+}
+async function handleSessions(req, res, path, registry, resolveAgentAdapter, ptyEnabled = false) {
+  const json = (status, body) => {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+  };
+  if (path === "/sessions" && req.method === "GET") {
+    json(200, { sessions: registry.list() });
+    return true;
+  }
+  if (path === "/sessions/agent" && req.method === "POST") {
+    if (!resolveAgentAdapter) {
+      json(501, {
+        error: "agent_resolver_not_configured",
+        message: "POST /sessions/agent needs the host to inject `resolveAgentAdapter` (e.g. via @agentproto/cli's resolveAdapter shim)."
+      });
+      return true;
+    }
+    const body = await readJsonBody(req);
+    if (!body || typeof body !== "object") {
+      json(400, { error: "invalid_body" });
+      return true;
+    }
+    const b = body;
+    const adapter = typeof b.adapter === "string" ? b.adapter : "";
+    if (!adapter) {
+      json(400, { error: "missing_adapter" });
+      return true;
+    }
+    let cwd = typeof b.cwd === "string" && b.cwd.length > 0 ? b.cwd : null;
+    let workspaceSlug = typeof b.workspaceSlug === "string" ? b.workspaceSlug : "";
+    if (!cwd) {
+      try {
+        const config = await loadWorkspacesConfig();
+        const ws = workspaceSlug ? findWorkspace(config, workspaceSlug) : getActiveWorkspace(config);
+        if (ws) {
+          cwd = ws.path;
+          workspaceSlug = ws.slug;
+        }
+      } catch {
+      }
+    }
+    if (!cwd) {
+      cwd = process.cwd();
+      console.warn(
+        `[/sessions/agent] no cwd resolvable for adapter=${adapter} (no body.cwd, no workspaceSlug match in ~/.agentproto/workspaces.json, no active workspace) \u2014 falling back to daemon's cwd ${cwd}`
+      );
+    }
+    if (!workspaceSlug) workspaceSlug = "default";
+    const resolved = await resolveAgentAdapter(adapter);
+    if (!resolved) {
+      json(404, { error: "adapter_not_found", adapter });
+      return true;
+    }
+    try {
+      const resumeSessionId = typeof b.resumeSessionId === "string" && b.resumeSessionId.length > 0 ? b.resumeSessionId : void 0;
+      const agentSession = await resolved.startSession({
+        cwd,
+        ...resumeSessionId ? { resumeSessionId } : {}
+      });
+      const desc = registry.spawnAgent({
+        workspaceSlug,
+        cwd,
+        agentSession,
+        adapterSlug: adapter,
+        ...typeof b.prompt === "string" ? { initialPrompt: b.prompt } : {},
+        ...typeof b.label === "string" ? { label: b.label } : {},
+        ...resolved.commandPreview ? { commandPreview: resolved.commandPreview } : {}
+      });
+      json(201, desc);
+    } catch (err) {
+      json(500, {
+        error: "agent_spawn_failed",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return true;
+  }
+  if (path === "/sessions/terminal" && req.method === "POST") {
+    if (!ptyEnabled) {
+      json(501, {
+        error: "pty_not_configured",
+        message: "POST /sessions/terminal needs the host to inject `spawnPty` into createGateway (node-pty optional dep \u2014 install in @agentproto/cli)."
+      });
+      return true;
+    }
+    const body = await readJsonBody(req);
+    if (!body || typeof body !== "object") {
+      json(400, { error: "invalid_body" });
+      return true;
+    }
+    const b = body;
+    const argv = Array.isArray(b.argv) ? b.argv.filter((v) => typeof v === "string") : [];
+    if (argv.length === 0) {
+      json(400, { error: "missing_argv" });
+      return true;
+    }
+    const cols = typeof b.cols === "number" && b.cols > 0 ? Math.floor(b.cols) : 80;
+    const rows = typeof b.rows === "number" && b.rows > 0 ? Math.floor(b.rows) : 24;
+    let cwd = typeof b.cwd === "string" && b.cwd.length > 0 ? b.cwd : null;
+    let workspaceSlug = typeof b.workspaceSlug === "string" ? b.workspaceSlug : "";
+    if (!cwd) {
+      try {
+        const config = await loadWorkspacesConfig();
+        const ws = workspaceSlug ? findWorkspace(config, workspaceSlug) : getActiveWorkspace(config);
+        if (ws) {
+          cwd = ws.path;
+          workspaceSlug = ws.slug;
+        }
+      } catch {
+      }
+    }
+    if (!cwd) {
+      cwd = process.cwd();
+      console.warn(
+        `[/sessions/terminal] no cwd resolvable for argv=${argv.join(" ")} \u2014 falling back to daemon's cwd ${cwd}`
+      );
+    }
+    if (!workspaceSlug) workspaceSlug = "default";
+    try {
+      const desc = registry.spawnPty({
+        argv,
+        cwd,
+        workspaceSlug,
+        cols,
+        rows,
+        ...b.env && typeof b.env === "object" ? { env: b.env } : {},
+        ...typeof b.name === "string" ? { name: b.name } : {},
+        ...typeof b.label === "string" ? { label: b.label } : {}
+      });
+      json(201, desc);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const status = msg.includes("already in use") ? 409 : msg.includes("no PTY factory") ? 501 : 500;
+      json(status, { error: "pty_spawn_failed", message: msg });
+    }
+    return true;
+  }
+  const promptMatch = path.match(/^\/sessions\/([^/]+)\/prompt$/);
+  if (promptMatch && req.method === "POST") {
+    const id2 = promptMatch[1];
+    if (!id2) return false;
+    const body = await readJsonBody(req);
+    const prompt = body?.prompt;
+    const validPrompt = typeof prompt === "string" && prompt.length > 0 || Array.isArray(prompt) && prompt.length > 0 && prompt.every((b) => b !== null && typeof b === "object") || prompt !== null && typeof prompt === "object" && !Array.isArray(prompt);
+    if (!validPrompt) {
+      json(400, {
+        error: "missing_prompt",
+        message: "Body `prompt` must be a non-empty string, a content block object, or an array of content blocks."
+      });
+      return true;
+    }
+    const reqUrl = req.url ?? "";
+    const queryString = reqUrl.includes("?") ? reqUrl.slice(reqUrl.indexOf("?") + 1) : "";
+    const wait = new URLSearchParams(queryString).get("wait");
+    const fireAndForget = wait === "false" || wait === "0";
+    try {
+      if (fireAndForget) {
+        registry.enqueuePrompt(id2, prompt);
+        json(202, { ok: true, id: id2, queued: true });
+      } else {
+        await registry.sendPrompt(id2, prompt);
+        json(200, { ok: true, id: id2 });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const status = msg.includes("no session") ? 404 : msg.includes("not an agent") ? 400 : msg.includes("mid-turn") ? 409 : 500;
+      json(status, { error: "send_prompt_failed", message: msg });
+    }
+    return true;
+  }
+  if (path === "/sessions" && req.method === "POST") {
+    const body = await readJsonBody(req);
+    if (!body || typeof body !== "object") {
+      json(400, { error: "invalid_body" });
+      return true;
+    }
+    const b = body;
+    const argv = Array.isArray(b.argv) ? b.argv.filter((v) => typeof v === "string") : [];
+    if (argv.length === 0) {
+      json(400, { error: "missing_argv" });
+      return true;
+    }
+    try {
+      const desc = registry.spawn({
+        kind: b.kind === "terminal" || b.kind === "agent-cli" || b.kind === "command" ? b.kind : "command",
+        workspaceSlug: typeof b.workspaceSlug === "string" ? b.workspaceSlug : "default",
+        cwd: typeof b.cwd === "string" ? b.cwd : process.cwd(),
+        argv,
+        env: b.env && typeof b.env === "object" ? b.env : void 0,
+        label: typeof b.label === "string" ? b.label : void 0
+      });
+      json(201, desc);
+    } catch (err) {
+      json(500, {
+        error: "spawn_failed",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return true;
+  }
+  const idMatch = path.match(
+    /^\/sessions\/([^/]+)(\/stream|\/kill|\/preview)?$/
+  );
+  if (!idMatch) return false;
+  const [, rawIdOrName, suffix] = idMatch;
+  if (!rawIdOrName) return false;
+  const resolvedDesc = registry.findByIdOrName(rawIdOrName);
+  const id = resolvedDesc?.id ?? rawIdOrName;
+  if (suffix === "/preview" && req.method === "GET") {
+    if (!resolvedDesc) {
+      json(404, { error: "session_not_found", id: rawIdOrName });
+      return true;
+    }
+    const reqUrl = req.url ?? "";
+    const qs = new URLSearchParams(
+      reqUrl.includes("?") ? reqUrl.slice(reqUrl.indexOf("?") + 1) : ""
+    );
+    const lineCap = clampInt(qs.get("lines"), 10, 1, 200);
+    const byteCap = clampInt(qs.get("bytes"), 16 * 1024, 256, 64 * 1024);
+    const lines = [];
+    if (resolvedDesc.pty !== true) {
+      const unsub = registry.attach(id, (line) => {
+        lines.push(line);
+      });
+      if (unsub) unsub();
+    }
+    const bufBytes = registry.readTerminalOutput(id, byteCap);
+    json(200, {
+      id: resolvedDesc.id,
+      lines: lines.slice(-lineCap),
+      bytes: bufBytes ? bufBytes.toString("base64") : null
+    });
+    return true;
+  }
+  if (suffix === "/stream" && req.method === "GET") {
+    if (!resolvedDesc) {
+      json(404, { error: "session_not_found", id: rawIdOrName });
+      return true;
+    }
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
+    });
+    const ping = setInterval(() => {
+      try {
+        res.write(`: keep-alive
+
+`);
+      } catch {
+        clearInterval(ping);
+      }
+    }, 25e3);
+    const unsub = registry.attach(id, (line, stream) => {
+      try {
+        res.write(
+          `data: ${JSON.stringify({ line, stream })}
+
+`
+        );
+      } catch {
+      }
+    });
+    if (!unsub) {
+      clearInterval(ping);
+      res.end();
+      return true;
+    }
+    req.once("close", () => {
+      unsub();
+      clearInterval(ping);
+    });
+    return true;
+  }
+  if (suffix === "/kill" && req.method === "POST") {
+    const ok = registry.kill(id);
+    json(ok ? 200 : 404, { ok, id });
+    return true;
+  }
+  if (!suffix && req.method === "GET") {
+    if (!resolvedDesc) {
+      json(404, { error: "session_not_found", id: rawIdOrName });
+      return true;
+    }
+    json(200, resolvedDesc);
+    return true;
+  }
+  if (!suffix && req.method === "DELETE") {
+    const ok = registry.forget(id);
+    json(ok ? 200 : 404, { ok, id });
+    return true;
+  }
+  return false;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) return null;
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+var RESUME_STRATEGIES = {
+  "claude-code": {
+    // Printed by claude on graceful exit when session persistence
+    // is on (default). Example: `claude --resume 0e483f81-1a44-4bec-9667-b37158450296`
+    outputHint: /claude\s+--resume\s+([0-9a-f-]{8,})/i,
+    storeAs: "claudeResumeId",
+    fsProbe: probeMtimeLatestJsonl(".claude/projects"),
+    spawnArgs: (id) => ["claude", "--resume", id]
+  }
+  // Stubs for other shipped adapters — fill in as we learn each
+  // provider's resume mechanism. Today they fall back to ACP-level
+  // resume (whatever the agent-cli runtime supports) or fresh spawn.
+  //
+  //   hermes: { storeAs: "hermesResumeId", ... }
+  //   codex: { storeAs: "codexResumeId", ... }
+  //   openclaw: { storeAs: "openClawResumeId", ... }
+  //   opencode: { storeAs: "openCodeResumeId", ... }
+};
+function probeMtimeLatestJsonl(storeRel) {
+  return async (cwd, prevStartedAt) => {
+    const encoded = cwd.replace(/\//g, "-");
+    const dir = resolve(homedir(), storeRel, encoded);
+    let entries;
+    try {
+      entries = await promises.readdir(dir);
+    } catch {
+      return null;
+    }
+    const jsonl = entries.filter((e) => e.endsWith(".jsonl"));
+    if (jsonl.length === 0) return null;
+    const startedAtMs = Date.parse(prevStartedAt);
+    const candidates = [];
+    for (const f of jsonl) {
+      try {
+        const st = await promises.stat(join(dir, f));
+        if (!Number.isFinite(startedAtMs) || st.mtimeMs >= startedAtMs - 1e3) {
+          candidates.push({ name: f, mtime: st.mtimeMs });
+        }
+      } catch {
+      }
+    }
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => b.mtime - a.mtime);
+    return candidates[0].name.replace(/\.jsonl$/, "");
+  };
+}
+var SESSIONS_FILE_PATH = () => resolve(homedir(), ".agentproto", "sessions.json");
+var RECENT_LINES_CAP = 500;
+var RECENT_BYTES_CAP = 64 * 1024;
+var PERSIST_DEBOUNCE_MS = 1500;
+var HISTORY_CAP = 200;
+function stripAnsiCodes(s) {
+  return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
+function createSessionsRegistry(opts) {
+  const persistPath = opts?.persistPath ?? SESSIONS_FILE_PATH();
+  const persist = opts?.persist ?? true;
+  const ptyFactory = opts?.spawnPty;
+  const resumeAgent = opts?.resumeAgent;
+  const sessions = /* @__PURE__ */ new Map();
+  let persistTimer = null;
+  let nextSubId = 1;
+  let shutdownDone = false;
+  if (persist) {
+    loadHistorySnapshot(persistPath, sessions);
+  }
+  const onProcessExit = () => {
+    shutdownImpl();
+  };
+  if (persist) {
+    process.on("exit", onProcessExit);
+  }
+  const schedulePersist = () => {
+    if (!persist) return;
+    if (persistTimer) clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+      void persistSnapshot();
+    }, PERSIST_DEBOUNCE_MS);
+  };
+  const persistSnapshot = async () => {
+    try {
+      const snapshot = {
+        savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessions: Array.from(sessions.values()).map((s) => s.desc)
+      };
+      await promises.mkdir(dirname(persistPath), { recursive: true });
+      await promises.writeFile(persistPath, JSON.stringify(snapshot, null, 2) + "\n");
+    } catch (err) {
+      console.warn(
+        `[sessions] persist failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  };
+  const appendLine = (rt, line, stream) => {
+    rt.recentLines.push(line);
+    if (rt.recentLines.length > RECENT_LINES_CAP) {
+      rt.recentLines.splice(0, rt.recentLines.length - RECENT_LINES_CAP);
+    }
+    rt.desc.lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
+    sniffResumeHints(rt, line);
+    rt.emitter.emit("line", { line, stream });
+  };
+  const sniffResumeHints = (rt, line) => {
+    if (rt.desc.kind !== "agent-cli") return;
+    const strategy = rt.desc.adapterSlug ? RESUME_STRATEGIES[rt.desc.adapterSlug] : void 0;
+    if (!strategy?.outputHint) return;
+    const plain = stripAnsiCodes(line);
+    const m = plain.match(strategy.outputHint);
+    if (m && m[1]) {
+      rt.desc.resumeMetadata = {
+        ...rt.desc.resumeMetadata ?? {},
+        [strategy.storeAs]: m[1]
+      };
+      schedulePersist();
+    }
+  };
+  const appendBytes = (rt, chunk) => {
+    rt.recentBytes.push(chunk);
+    rt.recentBytesSize += chunk.byteLength;
+    while (rt.recentBytesSize > RECENT_BYTES_CAP && rt.recentBytes.length > 1) {
+      const dropped = rt.recentBytes.shift();
+      if (dropped) rt.recentBytesSize -= dropped.byteLength;
+    }
+    rt.desc.lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
+    rt.emitter.emit("data", chunk);
+  };
+  const reconcilePtySize = (rt) => {
+    if (!rt.pty || !rt.ptySubscribers || rt.ptySubscribers.size === 0) return;
+    let cols = Infinity;
+    let rows = Infinity;
+    for (const dim of rt.ptySubscribers.values()) {
+      if (dim.cols < cols) cols = dim.cols;
+      if (dim.rows < rows) rows = dim.rows;
+    }
+    if (!Number.isFinite(cols) || !Number.isFinite(rows)) return;
+    try {
+      rt.pty.resize(cols, rows);
+    } catch {
+    }
+  };
+  const projectEvent = (rt, evt) => {
+    switch (evt.kind) {
+      case "text-delta":
+        if (evt.text) {
+          const combined = rt.textBuf + evt.text;
+          const lines = combined.split(/\r?\n/);
+          rt.textBuf = lines.pop() ?? "";
+          for (const line of lines) appendLine(rt, line, "stdout");
+        }
+        break;
+      case "thought":
+        if (evt.text) {
+          const combined = rt.thoughtBuf + evt.text;
+          const lines = combined.split(/\r?\n/);
+          rt.thoughtBuf = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.trim()) {
+              appendLine(rt, `\x1B[2m[thought] ${line}\x1B[0m`, "stdout");
+            }
+          }
+        }
+        break;
+      case "tool-call":
+        appendLine(
+          rt,
+          `\x1B[36m[tool] ${evt.toolName ?? "?"}\x1B[0m`,
+          "stdout"
+        );
+        break;
+      case "tool-result":
+        if (evt.isError)
+          appendLine(rt, `\x1B[31m[tool-error]\x1B[0m`, "stderr");
+        break;
+      case "agent-prompt":
+        appendLine(rt, `\x1B[33m[awaiting input]\x1B[0m`, "stdout");
+        break;
+      case "turn-end": {
+        if (rt.thoughtBuf.trim()) {
+          appendLine(
+            rt,
+            `\x1B[2m[thought] ${rt.thoughtBuf}\x1B[0m`,
+            "stdout"
+          );
+        }
+        rt.thoughtBuf = "";
+        if (rt.textBuf) {
+          appendLine(rt, rt.textBuf, "stdout");
+          rt.textBuf = "";
+        }
+        appendLine(
+          rt,
+          `\x1B[2m\u2500\u2500 turn-end (${evt.reason ?? "completed"}) \u2500\u2500\x1B[0m`,
+          "stdout"
+        );
+        break;
+      }
+      case "error": {
+        const code = typeof evt.error?.code === "number" ? ` (code ${evt.error.code})` : "";
+        appendLine(
+          rt,
+          `\x1B[31m[error]${code} ${evt.error?.message ?? "unknown"}\x1B[0m`,
+          "stderr"
+        );
+        const data = evt.error?.data;
+        if (data && typeof data === "object" && typeof data.stderr === "string") {
+          for (const line of data.stderr.split(/\r?\n/)) {
+            if (line) appendLine(rt, `\x1B[2m  ${line}\x1B[0m`, "stderr");
+          }
+        }
+        break;
+      }
+    }
+  };
+  const validateAgentTurn = (id, caller) => {
+    const rt = sessions.get(id);
+    if (!rt) throw new Error(`${caller}: no session "${id}"`);
+    if (!rt.agentSession) {
+      throw new Error(
+        `${caller}: session "${id}" is not an agent session (kind=${rt.desc.kind})`
+      );
+    }
+    if (rt.busy) {
+      throw new Error(
+        `${caller}: session "${id}" is mid-turn \u2014 wait for it to finish or cancel`
+      );
+    }
+    return rt;
+  };
+  const maybeResumeAgent = async (rt) => {
+    if (rt.agentSession) return;
+    if (!resumeAgent) return;
+    if (rt.desc.kind !== "agent-cli") return;
+    const adapterSlug = rt.desc.adapterSlug ?? rt.adapterSlug;
+    const adapterSessionId = rt.desc.adapterSessionId;
+    const cwd = rt.desc.cwd;
+    if (!adapterSlug || !adapterSessionId || !cwd) return;
+    if (rt.resumePromise) {
+      await rt.resumePromise;
+      return;
+    }
+    rt.resumePromise = (async () => {
+      appendLine(
+        rt,
+        `\u2500\u2500 resuming ${adapterSlug} session ${adapterSessionId} \u2500\u2500`,
+        "stdout"
+      );
+      try {
+        const fresh = await resumeAgent({
+          adapterSlug,
+          cwd,
+          resumeSessionId: adapterSessionId
+        });
+        if (!fresh) {
+          appendLine(
+            rt,
+            `[error] resume failed: adapter '${adapterSlug}' returned null`,
+            "stderr"
+          );
+          return;
+        }
+        rt.agentSession = fresh;
+        rt.adapterSlug = adapterSlug;
+        rt.desc.adapterSessionId = fresh.sessionId;
+        if (rt.desc.status !== "running") {
+          rt.desc.status = "running";
+          delete rt.desc.endedAt;
+          delete rt.desc.exitCode;
+          rt.emitter.emit("status", rt.desc.status);
+        }
+        schedulePersist();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        appendLine(rt, `[error] resume failed: ${msg}`, "stderr");
+      }
+    })();
+    try {
+      await rt.resumePromise;
+    } finally {
+      rt.resumePromise = void 0;
+    }
+  };
+  const runAgentTurn = async (rt, message) => {
+    if (!rt.agentSession) {
+      throw new Error("runAgentTurn: session has no agentSession");
+    }
+    rt.busy = true;
+    try {
+      appendLine(
+        rt,
+        `\x1B[2m\u2500\u2500 \u25B6 ${typeof message === "string" ? message : JSON.stringify(message)} \u2500\u2500\x1B[0m`,
+        "stdout"
+      );
+      const wrapped = typeof message === "string" ? { type: "text", text: message } : message;
+      for await (const evt of rt.agentSession.send(wrapped)) {
+        projectEvent(rt, evt);
+      }
+    } catch (err) {
+      rt.desc.status = "error";
+      rt.desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      appendLine(
+        rt,
+        `[turn error] ${err instanceof Error ? err.message : String(err)}`,
+        "stderr"
+      );
+      schedulePersist();
+    } finally {
+      rt.busy = false;
+    }
+  };
+  const wireOutputStreams = (rt) => {
+    const onChunk = (stream) => (chunk) => {
+      const text3 = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      for (const line of text3.split(/\r?\n/)) {
+        if (line.length > 0) appendLine(rt, line, stream);
+      }
+    };
+    if (!rt.child) return;
+    rt.child.stdout?.on("data", onChunk("stdout"));
+    rt.child.stderr?.on("data", onChunk("stderr"));
+  };
+  return {
+    spawn(input) {
+      const id = input.id ?? `sess_${randomUUID().slice(0, 8)}`;
+      if (sessions.has(id)) {
+        throw new Error(`sessions.spawn: id "${id}" already in use`);
+      }
+      const env = { ...process.env, ...input.env ?? {} };
+      delete env.NODE_OPTIONS;
+      const [bin, ...args] = input.argv;
+      if (!bin) throw new Error("sessions.spawn: argv must include a binary");
+      const stdinMode = input.keepStdin ? "pipe" : "ignore";
+      const child = spawn(bin, args, {
+        cwd: input.cwd,
+        env,
+        stdio: [stdinMode, "pipe", "pipe"]
+      });
+      const desc = {
+        id,
+        kind: input.kind,
+        workspaceSlug: input.workspaceSlug,
+        command: [bin, ...args].map(quoteArg).join(" "),
+        pid: child.pid ?? null,
+        status: "starting",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        argv: input.argv,
+        cwd: input.cwd,
+        ...input.label ? { label: input.label } : {}
+      };
+      const rt = {
+        desc,
+        child,
+        recentLines: [],
+        recentBytes: [],
+        recentBytesSize: 0,
+        emitter: new EventEmitter(),
+        busy: false,
+        textBuf: "",
+        thoughtBuf: ""
+      };
+      rt.emitter.setMaxListeners(50);
+      sessions.set(id, rt);
+      wireOutputStreams(rt);
+      child.once("spawn", () => {
+        desc.status = "running";
+        rt.emitter.emit("status", desc.status);
+        schedulePersist();
+      });
+      child.once("error", (err) => {
+        desc.status = "error";
+        desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+        appendLine(rt, `[spawn error] ${err.message}`, "stderr");
+        rt.emitter.emit("status", desc.status);
+        schedulePersist();
+      });
+      child.once("exit", (code, signal) => {
+        if (signal && desc.status !== "killed") desc.status = "killed";
+        else if (desc.status === "running" || desc.status === "starting") {
+          desc.status = "exited";
+        }
+        desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (typeof code === "number") desc.exitCode = code;
+        rt.emitter.emit("status", desc.status);
+        schedulePersist();
+      });
+      schedulePersist();
+      return desc;
+    },
+    register(input) {
+      if (sessions.has(input.id)) {
+        const existing = sessions.get(input.id);
+        if (existing) return existing.desc;
+      }
+      const desc = {
+        id: input.id,
+        kind: input.kind ?? "command",
+        workspaceSlug: input.workspaceSlug,
+        command: input.command,
+        pid: input.child.pid ?? null,
+        status: input.child.killed ? "killed" : "running",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...input.label ? { label: input.label } : {}
+      };
+      const rt = {
+        desc,
+        child: input.child,
+        recentLines: [],
+        recentBytes: [],
+        recentBytesSize: 0,
+        emitter: new EventEmitter(),
+        busy: false,
+        textBuf: "",
+        thoughtBuf: ""
+      };
+      rt.emitter.setMaxListeners(50);
+      sessions.set(input.id, rt);
+      wireOutputStreams(rt);
+      input.child.once("exit", (code, signal) => {
+        if (signal && desc.status !== "killed") desc.status = "killed";
+        else if (desc.status === "running") desc.status = "exited";
+        desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (typeof code === "number") desc.exitCode = code;
+        rt.emitter.emit("status", desc.status);
+        schedulePersist();
+      });
+      input.child.once("error", (err) => {
+        desc.status = "error";
+        desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+        appendLine(rt, `[child error] ${err.message}`, "stderr");
+        rt.emitter.emit("status", desc.status);
+        schedulePersist();
+      });
+      schedulePersist();
+      return desc;
+    },
+    spawnAgent(input) {
+      const id = `sess_${randomUUID().slice(0, 8)}`;
+      const desc = {
+        id,
+        kind: "agent-cli",
+        workspaceSlug: input.workspaceSlug,
+        command: input.commandPreview ?? `${input.adapterSlug} (agent)`,
+        pid: null,
+        status: "running",
+        // driver already started the session
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cwd: input.cwd,
+        adapterSlug: input.adapterSlug,
+        // ACP-level session id — sticks across daemon restart so
+        // `agentproto sessions restart <id>` can pass it as
+        // `resumeSessionId` and the adapter reattaches to the prior
+        // conversation rather than starting blank.
+        adapterSessionId: input.agentSession.sessionId,
+        ...input.label ? { label: input.label } : {}
+      };
+      const rt = {
+        desc,
+        agentSession: input.agentSession,
+        adapterSlug: input.adapterSlug,
+        recentLines: [],
+        recentBytes: [],
+        recentBytesSize: 0,
+        emitter: new EventEmitter(),
+        busy: false,
+        textBuf: "",
+        thoughtBuf: ""
+      };
+      rt.emitter.setMaxListeners(50);
+      sessions.set(id, rt);
+      appendLine(
+        rt,
+        `\u2500\u2500 ${input.adapterSlug} agent session ${input.agentSession.sessionId} (cwd ${input.cwd}) \u2500\u2500`,
+        "stdout"
+      );
+      schedulePersist();
+      if (input.initialPrompt) {
+        void runAgentTurn(rt, input.initialPrompt).catch((err) => {
+          appendLine(
+            rt,
+            `[turn error] ${err instanceof Error ? err.message : String(err)}`,
+            "stderr"
+          );
+        });
+      }
+      return desc;
+    },
+    spawnPty(input) {
+      if (!ptyFactory) {
+        throw new Error(
+          "sessions.spawnPty: no PTY factory configured (node-pty optional dep missing in the daemon)"
+        );
+      }
+      const id = `sess_${randomUUID().slice(0, 8)}`;
+      if (input.name) {
+        for (const rt2 of sessions.values()) {
+          if (rt2.desc.name !== input.name) continue;
+          const status = rt2.desc.status;
+          if (status === "running" || status === "starting") {
+            throw new Error(
+              `sessions.spawnPty: name "${input.name}" already in use by ${rt2.desc.id} (status=${status})`
+            );
+          }
+          rt2.desc.name = void 0;
+        }
+      }
+      const [bin, ...args] = input.argv;
+      if (!bin) {
+        throw new Error("sessions.spawnPty: argv must include a binary");
+      }
+      const env = { ...process.env, ...input.env ?? {} };
+      delete env.NODE_OPTIONS;
+      const pty = ptyFactory({
+        command: bin,
+        args,
+        cwd: input.cwd,
+        env,
+        cols: input.cols,
+        rows: input.rows
+      });
+      const desc = {
+        id,
+        kind: "terminal",
+        workspaceSlug: input.workspaceSlug,
+        command: [bin, ...args].map(quoteArg).join(" "),
+        pid: pty.pid,
+        status: "running",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        pty: true,
+        argv: input.argv,
+        cwd: input.cwd,
+        ...input.name ? { name: input.name } : {},
+        ...input.label ? { label: input.label } : {}
+      };
+      const rt = {
+        desc,
+        pty,
+        ptySubscribers: /* @__PURE__ */ new Map(),
+        recentLines: [],
+        recentBytes: [],
+        recentBytesSize: 0,
+        emitter: new EventEmitter(),
+        busy: false,
+        textBuf: "",
+        thoughtBuf: ""
+      };
+      rt.emitter.setMaxListeners(50);
+      sessions.set(id, rt);
+      pty.onData((chunk) => {
+        appendBytes(rt, Buffer.from(chunk, "utf8"));
+      });
+      pty.onExit((evt) => {
+        if (rt.desc.status !== "killed") {
+          rt.desc.status = "exited";
+        }
+        rt.desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (typeof evt.exitCode === "number") rt.desc.exitCode = evt.exitCode;
+        rt.emitter.emit("exit", evt);
+        rt.emitter.emit("status", rt.desc.status);
+        schedulePersist();
+      });
+      schedulePersist();
+      return desc;
+    },
+    async sendPrompt(id, message) {
+      const rtPre = sessions.get(id);
+      if (rtPre) await maybeResumeAgent(rtPre);
+      const rt = validateAgentTurn(id, "sendPrompt");
+      await runAgentTurn(rt, message);
+    },
+    enqueuePrompt(id, message) {
+      const rtPre = sessions.get(id);
+      if (!rtPre) {
+        throw new Error(`enqueuePrompt: no session "${id}"`);
+      }
+      if (rtPre.desc.kind !== "agent-cli") {
+        throw new Error(
+          `enqueuePrompt: session "${id}" is not an agent session (kind=${rtPre.desc.kind})`
+        );
+      }
+      if (rtPre.busy) {
+        throw new Error(
+          `enqueuePrompt: session "${id}" is mid-turn \u2014 wait for it to finish or cancel`
+        );
+      }
+      void (async () => {
+        try {
+          await maybeResumeAgent(rtPre);
+          const rt = validateAgentTurn(id, "enqueuePrompt");
+          await runAgentTurn(rt, message);
+        } catch (err) {
+          appendLine(
+            rtPre,
+            `[error] ${err instanceof Error ? err.message : String(err)}`,
+            "stderr"
+          );
+        }
+      })();
+    },
+    list() {
+      return Array.from(sessions.values()).map((s) => s.desc).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    },
+    get(id) {
+      return sessions.get(id)?.desc;
+    },
+    attach(id, onLine) {
+      const rt = sessions.get(id);
+      if (!rt) return null;
+      for (const line of rt.recentLines) onLine(line, "stdout");
+      const handler = (evt) => onLine(evt.line, evt.stream);
+      rt.emitter.on("line", handler);
+      return () => rt.emitter.off("line", handler);
+    },
+    attachPty(id, initial, onData, onExit) {
+      const rt = sessions.get(id);
+      if (!rt || !rt.pty || !rt.ptySubscribers) return null;
+      for (const chunk of rt.recentBytes) onData(chunk);
+      const subId = nextSubId++;
+      rt.ptySubscribers.set(subId, { cols: initial.cols, rows: initial.rows });
+      reconcilePtySize(rt);
+      const dataHandler = (chunk) => onData(chunk);
+      const exitHandler = (evt) => onExit(evt);
+      rt.emitter.on("data", dataHandler);
+      rt.emitter.once("exit", exitHandler);
+      return {
+        write(data) {
+          if (!rt.pty) return;
+          try {
+            rt.pty.write(data);
+          } catch {
+          }
+        },
+        resize(cols, rows) {
+          if (!rt.ptySubscribers) return;
+          rt.ptySubscribers.set(subId, { cols, rows });
+          reconcilePtySize(rt);
+        },
+        detach() {
+          rt.emitter.off("data", dataHandler);
+          rt.emitter.off("exit", exitHandler);
+          rt.ptySubscribers?.delete(subId);
+          reconcilePtySize(rt);
+        }
+      };
+    },
+    findByIdOrName(query) {
+      const direct = sessions.get(query);
+      if (direct) return direct.desc;
+      for (const rt of sessions.values()) {
+        if (rt.desc.name === query) return rt.desc;
+      }
+      return void 0;
+    },
+    writeTerminalInput(id, data) {
+      const rt = sessions.get(id);
+      if (!rt || !rt.pty) return false;
+      try {
+        rt.pty.write(data);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    readTerminalOutput(id, lastBytes) {
+      const rt = sessions.get(id);
+      if (!rt || !rt.pty) return null;
+      const joined = Buffer.concat(rt.recentBytes, rt.recentBytesSize);
+      if (typeof lastBytes === "number" && lastBytes > 0 && joined.byteLength > lastBytes) {
+        return joined.subarray(joined.byteLength - lastBytes);
+      }
+      return joined;
+    },
+    kill(id, signal = "SIGTERM") {
+      const rt = sessions.get(id);
+      if (!rt) return false;
+      if (rt.desc.status === "exited" || rt.desc.status === "killed" || rt.desc.status === "error") {
+        return false;
+      }
+      rt.desc.status = "killed";
+      rt.desc.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (rt.agentSession) {
+        void rt.agentSession.close().catch(() => void 0);
+      }
+      if (rt.pty) {
+        try {
+          rt.pty.kill(signal);
+        } catch {
+        }
+      }
+      rt.child?.kill(signal);
+      schedulePersist();
+      return true;
+    },
+    forget(id) {
+      const rt = sessions.get(id);
+      if (!rt) return false;
+      rt.emitter.removeAllListeners();
+      sessions.delete(id);
+      schedulePersist();
+      return true;
+    },
+    shutdown() {
+      shutdownImpl();
+    }
+  };
+  function shutdownImpl() {
+    if (shutdownDone) return;
+    shutdownDone = true;
+    if (persistTimer) clearTimeout(persistTimer);
+    if (persist) {
+      try {
+        process.off("exit", onProcessExit);
+      } catch {
+      }
+    }
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    for (const rt of sessions.values()) {
+      rt.emitter.removeAllListeners();
+      if (rt.desc.status === "running" || rt.desc.status === "starting") {
+        rt.desc.status = "killed";
+        rt.desc.endedAt = nowIso;
+        if (rt.agentSession) {
+          void rt.agentSession.close().catch(() => void 0);
+        }
+        if (rt.pty) {
+          try {
+            rt.pty.kill("SIGTERM");
+          } catch {
+          }
+        }
+        rt.child?.kill("SIGTERM");
+      }
+    }
+    if (persist) {
+      try {
+        const snapshot = {
+          savedAt: nowIso,
+          sessions: Array.from(sessions.values()).map((s) => s.desc)
+        };
+        mkdirSync(dirname(persistPath), { recursive: true });
+        writeFileSync(persistPath, JSON.stringify(snapshot, null, 2) + "\n");
+      } catch {
+      }
+    }
+    sessions.clear();
+  }
+}
+function loadHistorySnapshot(persistPath, sessions) {
+  let raw;
+  try {
+    raw = readFileSync(persistPath, "utf8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.warn(
+      `[sessions] history file ${persistPath} is malformed \u2014 ignoring`
+    );
+    return;
+  }
+  if (!Array.isArray(parsed.sessions)) return;
+  const sorted = parsed.sessions.filter((s) => !!s && typeof s.id === "string").sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, HISTORY_CAP);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const desc of sorted) {
+    if (sessions.has(desc.id)) continue;
+    const wasAlive = desc.status === "running" || desc.status === "starting";
+    const reclassified = wasAlive ? {
+      ...desc,
+      status: "killed",
+      endedAt: desc.endedAt ?? now
+    } : desc;
+    const rt = {
+      desc: reclassified,
+      recentLines: [],
+      recentBytes: [],
+      recentBytesSize: 0,
+      emitter: new EventEmitter(),
+      busy: false,
+      textBuf: "",
+      thoughtBuf: ""
+    };
+    rt.emitter.setMaxListeners(50);
+    sessions.set(desc.id, rt);
+  }
+}
+function quoteArg(arg) {
+  if (arg === "") return '""';
+  if (/^[a-zA-Z0-9._/=:@,+-]+$/.test(arg)) return arg;
+  return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+var McpProxyRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  lastMtimeMs = 0;
+  /** Sentinel so we know whether the file has *ever* been read.
+   *  Distinguishes "file missing on first call" (legit empty state)
+   *  from "we've read it before and it's gone" (treat as empty too,
+   *  but only after closing live clients). */
+  hasReadOnce = false;
+  /**
+   * Reload the imports file when its mtime has advanced. Avoids
+   * repeated parsing when nothing changed — most calls are no-ops.
+   * Disconnects clients whose import was removed; connects the new
+   * set lazily (the first call that touches them).
+   */
+  async ensureCurrent() {
+    let mtimeMs = 0;
+    try {
+      const st = await promises.stat(IMPORTED_MCPS_PATH());
+      mtimeMs = st.mtimeMs;
+    } catch {
+      mtimeMs = 0;
+    }
+    if (this.hasReadOnce && mtimeMs === this.lastMtimeMs) return;
+    const config = await loadImportedMcps().catch(() => ({
+      version: 1,
+      imports: []
+    }));
+    const wantedIds = new Set(config.imports.map((e) => e.id));
+    for (const [id, c] of this.clients.entries()) {
+      if (!wantedIds.has(id)) {
+        await safeClose(c.client);
+        this.clients.delete(id);
+      }
+    }
+    for (const entry of config.imports) {
+      const existing = this.clients.get(entry.id);
+      if (existing) {
+        if (JSON.stringify(existing.entry.snapshot) !== JSON.stringify(entry.snapshot)) {
+          await safeClose(existing.client);
+          this.clients.set(entry.id, freshPlaceholder(entry));
+        } else {
+          existing.entry = entry;
+        }
+      } else {
+        this.clients.set(entry.id, freshPlaceholder(entry));
+      }
+    }
+    this.lastMtimeMs = mtimeMs;
+    this.hasReadOnce = true;
+  }
+  /**
+   * Lazy connect: the first call to `connectIfNeeded(alias)`
+   * actually opens the transport + handshakes. Subsequent calls
+   * reuse the live client.
+   */
+  async connectIfNeeded(alias) {
+    await this.ensureCurrent();
+    const handle = this.findByAlias(alias);
+    if (!handle) return null;
+    if (handle.client) return handle;
+    try {
+      const client = await openClient(handle.entry);
+      handle.client = client;
+      handle.lastError = null;
+      const t = await client.listTools();
+      handle.tools = t.tools.map(toDescriptor);
+      return handle;
+    } catch (err) {
+      handle.client = null;
+      handle.tools = null;
+      handle.lastError = err instanceof Error ? err.message : String(err);
+      return handle;
+    }
+  }
+  /** Find a client handle by alias *or* import id (defensive — agents
+   *  sometimes pass the id from `list_imported_mcps`). */
+  findByAlias(aliasOrId) {
+    for (const c of this.clients.values()) {
+      if (c.entry.alias === aliasOrId) return c;
+      if (c.entry.id === aliasOrId) return c;
+    }
+    return void 0;
+  }
+  async listAliases() {
+    await this.ensureCurrent();
+    return Array.from(this.clients.values()).map((c) => ({
+      alias: c.entry.alias,
+      importId: c.entry.id,
+      source: c.entry.snapshot.source,
+      type: c.entry.snapshot.type,
+      status: c.client ? "connected" : c.lastError ? "error" : "pending",
+      toolCount: c.tools?.length ?? 0,
+      ...c.lastError ? { lastError: c.lastError } : {}
+    }));
+  }
+  async listTools(alias) {
+    const handle = await this.connectIfNeeded(alias);
+    if (!handle) return { ok: false, error: `unknown alias "${alias}"` };
+    if (!handle.client || !handle.tools) {
+      return {
+        ok: false,
+        error: handle.lastError ?? "client not connected"
+      };
+    }
+    return { ok: true, tools: handle.tools };
+  }
+  async callTool(alias, toolName, args) {
+    const handle = await this.connectIfNeeded(alias);
+    if (!handle) return { ok: false, error: `unknown alias "${alias}"` };
+    if (!handle.client) {
+      return {
+        ok: false,
+        error: handle.lastError ?? "client not connected"
+      };
+    }
+    try {
+      const result = await handle.client.callTool({
+        name: toolName,
+        arguments: args && typeof args === "object" ? args : {}
+      });
+      return { ok: true, result };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (/closed|disconnect|EPIPE|ECONNRESET/i.test(msg)) {
+        await safeClose(handle.client);
+        handle.client = null;
+        handle.tools = null;
+        handle.lastError = msg;
+      }
+      return { ok: false, error: msg };
+    }
+  }
+  async closeAll() {
+    await Promise.all(
+      Array.from(this.clients.values()).map((c) => safeClose(c.client))
+    );
+    this.clients.clear();
+  }
+};
+function freshPlaceholder(entry) {
+  return { entry, client: null, tools: null, lastError: null };
+}
+function toDescriptor(tool) {
+  return {
+    name: tool.name,
+    ...tool.description ? { description: tool.description } : {},
+    ...tool.inputSchema ? { inputSchema: tool.inputSchema } : {}
+  };
+}
+function expandEnvPlaceholders(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const expanded = v.replace(
+      /\$\{([A-Z_][A-Z0-9_]*)(?::-([^}]*))?\}/gi,
+      (_match, name, fallback) => {
+        const fromEnv = process.env[name];
+        if (fromEnv !== void 0) return fromEnv;
+        if (fallback !== void 0) return fallback;
+        return "";
+      }
+    );
+    if (expanded.length === 0) continue;
+    out[k] = expanded;
+  }
+  return out;
+}
+async function safeClose(client) {
+  if (!client) return;
+  try {
+    await client.close();
+  } catch {
+  }
+}
+async function openClient(entry) {
+  const snap = entry.snapshot;
+  const client = new Client(
+    { name: "agentproto-daemon-proxy", version: "0.1.0" },
+    { capabilities: {} }
+  );
+  if (snap.type === "stdio") {
+    if (!snap.command) {
+      throw new Error(
+        `import "${entry.alias}" is stdio but has no command field`
+      );
+    }
+    const expandedEnv = expandEnvPlaceholders(snap.env ?? {});
+    const transport = new StdioClientTransport({
+      command: snap.command,
+      args: snap.args ?? [],
+      env: { ...process.env, ...expandedEnv },
+      // Pipe stderr so we can include it in the error message instead of
+      // surfacing the opaque "Connection closed" MCP error code.
+      stderr: "pipe"
+    });
+    const stderrBuf = [];
+    transport.stderr?.on("data", (chunk) => {
+      stderrBuf.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+      if (stderrBuf.length > 40) stderrBuf.shift();
+    });
+    try {
+      await client.connect(transport);
+    } catch (err) {
+      const stderrText = stderrBuf.join("").trim();
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(stderrText ? `${msg}
+stderr: ${stderrText.slice(-600)}` : msg);
+    }
+    return client;
+  }
+  if (snap.type === "http") {
+    if (!snap.url) throw new Error(`import "${entry.alias}" has no url`);
+    const transport = new StreamableHTTPClientTransport(new URL(snap.url), {
+      requestInit: {
+        headers: snap.headers ?? {}
+      }
+    });
+    await client.connect(transport);
+    return client;
+  }
+  if (snap.type === "sse") {
+    if (!snap.url) throw new Error(`import "${entry.alias}" has no url`);
+    const transport = new SSEClientTransport(new URL(snap.url), {
+      requestInit: {
+        headers: snap.headers ?? {}
+      }
+    });
+    await client.connect(transport);
+    return client;
+  }
+  throw new Error(
+    `import "${entry.alias}" has unsupported transport type "${snap.type}"`
+  );
+}
+var execFileAsync = promisify(execFile);
+var URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+var STARTUP_TIMEOUT_MS = 3e4;
+function quickTunnelProvider() {
+  let child = null;
+  let configPath = null;
+  return {
+    id: "quick",
+    async start(opts) {
+      await assertCloudflaredOnPath();
+      const targetUrl = `http://${opts.target.host}:${opts.target.port}`;
+      const id = randomBytes(4).toString("hex");
+      const dir = join(opts.workspace, ".agentproto");
+      await mkdir(dir, { recursive: true });
+      configPath = join(dir, `cloudflared-${id}.yml`);
+      const configBody = [
+        `# generated by agentproto-runtime \u2014 sentinel only`,
+        `# overrides ~/.cloudflared/config.yml so its ingress rules`,
+        `# don't shadow the inline --url rule. Safe to delete when the`,
+        `# tunnel is down.`,
+        `no-autoupdate: true`,
+        `loglevel: debug`,
+        ``
+      ].join("\n");
+      await writeFile(configPath, configBody, "utf8");
+      const proc = spawn(
+        "cloudflared",
+        ["tunnel", "--config", configPath, "--url", targetUrl],
+        { stdio: ["ignore", "pipe", "pipe"], shell: false }
+      );
+      child = proc;
+      const url = await new Promise((resolve8, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          try {
+            proc.kill("SIGTERM");
+          } catch {
+          }
+          reject(
+            new Error(
+              `cloudflared did not emit a public URL within ${STARTUP_TIMEOUT_MS / 1e3}s`
+            )
+          );
+        }, STARTUP_TIMEOUT_MS);
+        const onData = (chunk) => {
+          const text3 = chunk.toString("utf8");
+          for (const line of text3.split(/\r?\n/)) {
+            if (line.length > 0) opts.onLog?.(`[cloudflared] ${line}`);
+          }
+          if (settled) return;
+          const match = text3.match(URL_REGEX);
+          if (match) {
+            settled = true;
+            clearTimeout(timer);
+            resolve8(match[0]);
+          }
+        };
+        proc.stderr?.on("data", onData);
+        proc.stdout?.on("data", onData);
+        proc.once("error", (err) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          reject(err);
+        });
+        proc.once("exit", (code, signal) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          reject(
+            new Error(
+              `cloudflared exited before emitting a URL (code=${code}, signal=${signal})`
+            )
+          );
+        });
+      });
+      proc.once("exit", (code, signal) => {
+        opts.onLog?.(
+          `[cloudflared] exited (code=${code ?? "?"} signal=${signal ?? "-"})`
+        );
+      });
+      return { publicUrl: url, pid: proc.pid ?? null };
+    },
+    async stop() {
+      const proc = child;
+      const cfg = configPath;
+      child = null;
+      configPath = null;
+      if (cfg) {
+        try {
+          await rm(cfg, { force: true });
+        } catch {
+        }
+      }
+      if (!proc || proc.exitCode !== null) return;
+      proc.kill("SIGTERM");
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }, 3e3);
+      timer.unref();
+      await new Promise((resolve8) => {
+        if (proc.exitCode !== null) {
+          clearTimeout(timer);
+          resolve8();
+          return;
+        }
+        proc.once("exit", () => {
+          clearTimeout(timer);
+          resolve8();
+        });
+      });
+    }
+  };
+}
+async function assertCloudflaredOnPath() {
+  try {
+    await execFileAsync("cloudflared", ["--version"], { timeout: 3e3 });
+  } catch {
+    throw new Error(
+      "cloudflared not found on PATH. Install it first:\n  macOS:    brew install cloudflared\n  Linux:    https://pkg.cloudflare.com/index.html\n  Windows:  winget install --id Cloudflare.cloudflared\nOr download a prebuilt binary from https://github.com/cloudflare/cloudflared/releases."
+    );
+  }
+}
+
+// src/remote-controller.ts
+var RemoteController = class {
+  state = null;
+  bearerToken = null;
+  provider = null;
+  lastError;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Auth getter handed to startHttpServer. The HTTP server calls this
+   * on every request so flipping enable/disable is effective without
+   * a restart.
+   */
+  readAuth = () => {
+    if (this.bearerToken === null) return { mode: "none" };
+    return { mode: "bearer", token: this.bearerToken };
+  };
+  status() {
+    if (!this.state) {
+      return { enabled: false, lastError: this.lastError };
+    }
+    return {
+      enabled: true,
+      provider: this.state.provider,
+      publicUrl: this.state.publicUrl,
+      pid: this.state.pid,
+      createdAt: this.state.createdAt,
+      target: this.state.target,
+      exposesGateway: this.state.exposesGateway,
+      lastError: this.lastError
+    };
+  }
+  async enable(input) {
+    if (this.state) {
+      throw new Error(
+        "remote tunnel already active \u2014 call remote_disable first to rotate"
+      );
+    }
+    const providerId = input.provider ?? "quick";
+    const provider = pickProvider(providerId);
+    this.lastError = void 0;
+    const target = {
+      host: input.targetHost ?? "127.0.0.1",
+      port: input.targetPort ?? this.opts.port
+    };
+    const exposesGateway = target.host === "127.0.0.1" && target.port === this.opts.port;
+    let started;
+    try {
+      started = await provider.start({
+        target,
+        workspace: this.opts.workspace,
+        onLog: (line) => {
+          this.opts.onLog?.(line);
+        }
+      });
+    } catch (err) {
+      this.lastError = errToMessage(err);
+      throw err;
+    }
+    let bearerToken = null;
+    let bearerTokenHash = "";
+    if (exposesGateway) {
+      bearerToken = randomBytes(32).toString("base64url");
+      bearerTokenHash = sha256(bearerToken);
+    }
+    const state = {
+      provider: providerId,
+      publicUrl: started.publicUrl,
+      bearerTokenHash,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: started.pid,
+      target,
+      exposesGateway
+    };
+    this.state = state;
+    this.bearerToken = bearerToken;
+    this.provider = provider;
+    await persistState(this.opts.workspace, state);
+    const result = {
+      provider: providerId,
+      publicUrl: started.publicUrl,
+      target,
+      exposesGateway
+    };
+    if (exposesGateway && bearerToken) {
+      const mcpEndpoint = `${started.publicUrl}/mcp`;
+      result.bearerToken = bearerToken;
+      result.mcpEndpoint = mcpEndpoint;
+      result.mcpConfigSnippet = buildMcpConfigSnippet(mcpEndpoint, bearerToken);
+    }
+    return result;
+  }
+  async disable() {
+    if (!this.state) return { disabled: false };
+    const provider = this.provider;
+    this.state = null;
+    this.bearerToken = null;
+    this.provider = null;
+    if (provider) {
+      try {
+        await provider.stop();
+      } catch (err) {
+        this.lastError = errToMessage(err);
+      }
+    }
+    await clearState(this.opts.workspace);
+    return { disabled: true };
+  }
+  /**
+   * Stop the provider on gateway shutdown. Does NOT clear persisted
+   * state — that survives across restarts so the user can `remote_status`
+   * after rebooting and see "stale state, run remote_enable to refresh".
+   * (Stale-recovery semantics land in v2; today we just leave the file.)
+   */
+  async shutdown() {
+    if (this.provider) {
+      try {
+        await this.provider.stop();
+      } catch {
+      }
+    }
+  }
+};
+function pickProvider(id) {
+  if (id === "quick") return quickTunnelProvider();
+  const _exhaustive = id;
+  throw new Error(`unknown remote provider: ${String(_exhaustive)}`);
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function errToMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function persistState(workspace, state) {
+  const dir = join(workspace, ".agentproto");
+  await mkdir(dir, { recursive: true });
+  const file = join(dir, "remote.json");
+  await writeFile(file, JSON.stringify(state, null, 2) + "\n", "utf8");
+  try {
+    await chmod(file, 384);
+  } catch {
+  }
+}
+async function clearState(workspace) {
+  const file = join(workspace, ".agentproto/remote.json");
+  if (!existsSync(file)) return;
+  await rm(file, { force: true });
+}
+function buildMcpConfigSnippet(endpoint, token) {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        "agentproto-remote": {
+          transport: "http",
+          url: endpoint,
+          headers: { Authorization: `Bearer ${token}` }
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+function text2(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+function registerRemoteTools(server, opts) {
+  const { controller } = opts;
+  server.tool(
+    "remote_enable",
+    "Publish a local port to the internet via Cloudflare. By default exposes this gateway and gates it with a bearer token (returned ONCE in the response \u2014 store it; only its hash is persisted). Pass `targetPort` to tunnel a different local service (Supabase, dev server, \u2026); in that mode the daemon does not gate the proxied traffic \u2014 the upstream service handles its own auth. Returns the public URL plus a paste-ready `.mcp.json` snippet (gateway mode only). Re-running while a tunnel is already up errors; call `remote_disable` first to rotate.",
+    {
+      provider: z.enum(["quick"]).optional().describe(
+        "Tunnel backend. `quick` = Cloudflare Quick Tunnel (no API key, ephemeral *.trycloudflare.com URL). Defaults to `quick`. Named-CF / Tailscale providers TBD."
+      ),
+      targetPort: z.number().int().min(1).max(65535).optional().describe(
+        "Local port to expose. Defaults to this gateway's own port (= publish the MCP server). Pass another port to tunnel a different local service (e.g. 54371 for Supabase) \u2014 in that mode bearer auth is OFF since the upstream handles its own gating."
+      ),
+      targetHost: z.string().optional().describe(
+        "Host the tunnel forwards to. Defaults to `127.0.0.1`. Use `localhost` only if the target is explicitly IPv6-bound; cloudflared resolves DNS and IPv6-first lookups can break IPv4-only origins."
+      )
+    },
+    async ({ provider, targetPort, targetHost }) => {
+      const result = await controller.enable({ provider, targetPort, targetHost });
+      return text2(result);
+    }
+  );
+  server.tool(
+    "remote_disable",
+    "Tear down the active remote tunnel and drop bearer auth back to loopback-only. Idempotent \u2014 calling when no tunnel is active is a no-op.",
+    {},
+    async () => {
+      const result = await controller.disable();
+      return text2(result);
+    }
+  );
+  server.tool(
+    "remote_status",
+    "Report whether a remote tunnel is active. When active: provider, public URL, supervised PID, createdAt. The bearer token itself is never returned by status \u2014 it was shown once at enable.",
+    {},
+    async () => {
+      return text2(controller.status());
+    }
+  );
+}
+var WorkspacePathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkspacePathError";
+  }
+};
+function createWorkspaceFs(opts) {
+  const root = resolve(opts.workspace);
+  function resolvePath4(path) {
+    if (typeof path !== "string" || path.length === 0) {
+      throw new WorkspacePathError("path must be a non-empty string");
+    }
+    if (isAbsolute(path)) {
+      throw new WorkspacePathError(
+        "absolute paths are not allowed; use a workspace-relative path"
+      );
+    }
+    const joined = normalize(join(root, path));
+    const rel = relative(root, joined);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      throw new WorkspacePathError(
+        `path escapes the workspace: '${path}'`
+      );
+    }
+    return joined;
+  }
+  return {
+    async readFile(path) {
+      const abs = resolvePath4(path);
+      const buf = await readFile(abs);
+      return buf.toString("utf8");
+    },
+    async writeFile(path, content) {
+      const abs = resolvePath4(path);
+      await mkdir(dirname(abs), { recursive: true });
+      await writeFile(abs, content);
+    },
+    async exists(path) {
+      try {
+        const abs = resolvePath4(path);
+        return existsSync(abs);
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+// src/index.ts
+async function createGateway(opts) {
+  const workspace = resolve(opts.workspace);
+  if (!existsSync(workspace)) {
+    throw new Error(`runtime: workspace dir does not exist: ${workspace}`);
+  }
+  const port = opts.port ?? 18790;
+  const events = createRuntimeEvents();
+  const conversations = fileConversationStore({ workspace });
+  const workspaceFs = createWorkspaceFs({ workspace });
+  const remote = new RemoteController({
+    workspace,
+    port,
+    onLog: (line) => events.emit({
+      type: "remote-log",
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      line
+    })
+  });
+  const { registered } = await createMcpServer({
+    specs: opts.specs,
+    workspace,
+    name: opts.name ?? "agentproto-runtime",
+    version: opts.version ?? "0.1.0-alpha"
+  });
+  const sessions = createSessionsRegistry({
+    ...opts.spawnPty ? { spawnPty: opts.spawnPty } : {},
+    // Resume hook: when a prompt arrives for a dead agent-cli row
+    // (typical after daemon restart), the registry calls back into
+    // the adapter resolver to re-create the AgentSession with
+    // `resumeSessionId = adapterSessionId`. ACP semantics: the
+    // upstream provider reattaches to the prior conversation.
+    // Unwired (no resolveAgentAdapter) → legacy "not an agent
+    // session" error, user must spawn fresh.
+    ...opts.resolveAgentAdapter ? {
+      resumeAgent: async ({ adapterSlug, cwd, resumeSessionId }) => {
+        const adapter = await opts.resolveAgentAdapter(adapterSlug);
+        if (!adapter) return null;
+        try {
+          return await adapter.startSession({ cwd, resumeSessionId });
+        } catch (err) {
+          console.warn(
+            `[agentproto] resumeAgent('${adapterSlug}', ${resumeSessionId}) failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+          return null;
+        }
+      }
+    } : {}
+  });
+  const token = opts.token ?? randomUUID();
+  const mcpProxy = new McpProxyRegistry();
+  const mcpServerFactory = async () => {
+    const { server } = await createMcpServer({
+      specs: opts.specs,
+      workspace,
+      name: opts.name ?? "agentproto-runtime",
+      version: opts.version ?? "0.1.0-alpha"
+    });
+    registerFsTools(server, { workspace });
+    registerCommandTools(server, { workspace });
+    registerRemoteTools(server, { controller: remote });
+    registerSessionTools(server, {
+      registry: sessions,
+      mcpProxy,
+      ptyEnabled: opts.spawnPty != null,
+      ...opts.resolveAgentAdapter ? { resolveAgentAdapter: opts.resolveAgentAdapter } : {},
+      ...opts.listAgentAdapters ? { listAgentAdapters: opts.listAgentAdapters } : {}
+    });
+    return server;
+  };
+  if (opts.boot !== false) {
+    await runBoot(workspace, opts, conversations, events).catch((err) => {
+      events.emit({
+        type: "heartbeat-error",
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        agent: opts.defaultBootAgent,
+        error: `BOOT.md failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    });
+  }
+  const heartbeat = startHeartbeat({
+    workspace,
+    conversations,
+    events,
+    buildAgent: opts.buildAgent ?? noopBuildAgent
+  });
+  const http = await startHttpServer({
+    port,
+    bind: opts.bind,
+    // Auth is read on every request via this getter. `opts.auth`
+    // (when provided) is the startup default and represents the
+    // operator's intent — bearer-only deployments stay bearer-only
+    // even when no remote tunnel is up. The controller's auth wins
+    // once a tunnel is enabled (it issues a fresh token); on disable
+    // we fall back to `opts.auth` if set, otherwise `mode: "none"`.
+    auth: () => {
+      const remoteAuth = remote.readAuth();
+      if (remoteAuth.mode === "bearer") return remoteAuth;
+      return opts.auth ?? { mode: "none" };
+    },
+    mcpServerFactory,
+    conversations,
+    events,
+    heartbeat,
+    sessions,
+    mcpProxy,
+    token,
+    ptyEnabled: opts.spawnPty != null,
+    ...opts.allowedOrigins ? { allowedOrigins: opts.allowedOrigins } : {},
+    ...opts.strictOrigins ? { strictOrigins: true } : {},
+    ...opts.resolveAgentAdapter ? { resolveAgentAdapter: opts.resolveAgentAdapter } : {},
+    ...opts.listAgentAdapters ? { listAgentAdapters: opts.listAgentAdapters } : {},
+    meta: { workspace, registered }
+  });
+  heartbeat.start();
+  events.emit({
+    type: "boot",
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace,
+    registered
+  });
+  void writeRuntimeMeta(workspace, {
+    workspace,
+    port,
+    bind: opts.bind ?? "127.0.0.1",
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    name: opts.name ?? "agentproto-runtime",
+    registered,
+    token
+  });
+  return {
+    url: http.url,
+    workspace,
+    workspaceFs,
+    registered,
+    sessions,
+    token,
+    async stop() {
+      heartbeat.stop();
+      sessions.shutdown();
+      await mcpProxy.closeAll();
+      await remote.shutdown();
+      await http.stop();
+    }
+  };
+}
+var noopBuildAgent = async () => null;
+async function runBoot(workspace, opts, conversations, events) {
+  const path = join(workspace, "BOOT.md");
+  if (!existsSync(path)) return;
+  const body = (await readFile(path, "utf8")).trim();
+  if (!body) return;
+  if (!opts.buildAgent || !opts.defaultBootAgent) return;
+  const agent = await opts.buildAgent(opts.defaultBootAgent);
+  if (!agent) return;
+  const conversationId = `boot-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:.]/g, "-")}`;
+  await conversations.open(conversationId, { agent: opts.defaultBootAgent });
+  await conversations.appendTurn(conversationId, "user", body, {
+    attribution: "boot"
+  });
+  const reply = await agent.generate(body);
+  await conversations.appendTurn(conversationId, "assistant", reply.text, {
+    attribution: opts.defaultBootAgent
+  });
+  events.emit({
+    type: "heartbeat-fired",
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    agent: opts.defaultBootAgent,
+    conversationId,
+    prompt: body,
+    reply: reply.text,
+    durationMs: 0
+  });
+}
+
+export { createGateway, createWorkspaceFs, fileConversationStore, parseDuration, readRuntimeMeta, sweepStaleRuntimeMetas, unlinkRuntimeMeta };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map