@supanadit/morse-web 0.12.0 → 0.14.0

package/dist/server.mjs

@@ -33,6 +33,7 @@ var CLIENT_MESSAGE_TYPES = [
   "history/load",
   "session/list",
   "commands/refresh",
+  "models/refresh",
   "project/list",
   "project/open",
   "model/set",
@@ -79,7 +80,7 @@ function hasKnownType(value, allowed) {
 }
 
 // ../protocol/dist/version.js
-var PROTOCOL_VERSION = 20;
+var PROTOCOL_VERSION = 22;
 var FRONTEND_MANIFEST_FILE = "webview.manifest.json";
 var DEFAULT_WS_PATH = "/ws";
 
@@ -169,9 +170,9 @@ var SessionRegistry = class {
   hotLimit;
   activeKey;
   syntheticKeys = 0;
-  /** Cached snapshot of a never-recording spawn (see `draftDefaults`). */
-  draftCache;
-  draftProbe;
+  /** Cached snapshots of never-recording spawns, keyed by model (`''` = the default). */
+  draftCache = /* @__PURE__ */ new Map();
+  draftProbes = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
     this.hotLimit = Math.max(1, deps.hotLimit ?? DEFAULT_HOT_LIMIT);
@@ -204,24 +205,43 @@ var SessionRegistry = class {
   hotKeys() {
     return [...this.recency];
   }
+  /**
+   * Forgets the session-less probe caches, so the next `draftDefaults()` runs pi
+   * again. The model picker calls it while the panel is still on a draft, where
+   * spawning nothing would otherwise freeze the catalog for the host's lifetime.
+   */
+  refreshDraftDefaults() {
+    this.draftCache.clear();
+    this.draftProbes.clear();
+  }
   /**
    * What the backend offers before any session exists: the model catalog,
-   * thinking levels and commands of an untouched spawn. Probed once per
-   * registry — never per client — from a gateway that never records itself
-   * (pi `--no-session`), so the empty state can ship a real model picker
-   * without creating a session.
+   * thinking levels and commands of an untouched spawn. Probed once per model —
+   * never per client — from a gateway that never records itself (pi
+   * `--no-session`), so the empty state can ship a real model picker without
+   * creating a session. Passing `model` asks for that model's thinking levels,
+   * which pi reports per current model.
    */
-  async draftDefaults() {
-    if (this.draftCache) {
-      return this.draftCache;
-    }
-    if (!this.draftProbe) {
-      this.draftProbe = this.probeDraft().catch((error) => {
-        this.draftProbe = void 0;
+  async draftDefaults(model) {
+    const key = model ? `${model.provider}/${model.id}` : "";
+    const cached = this.draftCache.get(key);
+    if (cached) {
+      return cached;
+    }
+    let probe = this.draftProbes.get(key);
+    if (!probe) {
+      probe = this.probeDraft(model).then((state) => {
+        if (state) {
+          this.draftCache.set(key, state);
+        }
+        return state;
+      }).catch((error) => {
+        this.draftProbes.delete(key);
         throw error;
       });
+      this.draftProbes.set(key, probe);
     }
-    return this.draftProbe;
+    return probe;
   }
   /** Opens a new (or resumes an existing) session and makes it active. */
   async open(options = {}) {
@@ -372,8 +392,8 @@ var SessionRegistry = class {
     this.recency.length = 0;
     this.listeners.clear();
     this.activeKey = void 0;
-    this.draftCache = void 0;
-    this.draftProbe = void 0;
+    this.draftCache.clear();
+    this.draftProbes.clear();
     await Promise.all(sessions.map((session) => {
       session.detach();
       return session.gateway.dispose().catch((error) => {
@@ -439,13 +459,16 @@ var SessionRegistry = class {
     return `${workspace.cwd}#ephemeral-${this.syntheticKeys}`;
   }
   /** Asks the factory for a never-recording gateway and snapshots its state. */
-  async probeDraft() {
+  async probeDraft(model) {
     const factory = this.deps.factory.probeDefaults;
     if (!factory) {
       return void 0;
     }
     try {
-      const gateway = await factory.call(this.deps.factory, { workspace: this.deps.defaultWorkspace });
+      const gateway = await factory.call(this.deps.factory, {
+        workspace: this.deps.defaultWorkspace,
+        ...model ? { model } : {}
+      });
       const state = await gateway.state();
       await gateway.dispose();
       return state;
@@ -1036,6 +1059,14 @@ function isDefined(value) {
 // ../adapter-pi-rpc/dist/internal/rpc-client.js
 import { spawn } from "node:child_process";
 
+// ../adapter-pi-rpc/dist/internal/spawn-env.js
+function cleanSpawnEnv(env = process.env) {
+  const copy = { ...env };
+  delete copy.NODE_CHANNEL_FD;
+  delete copy.NODE_CHANNEL_SERIALIZATION_MODE;
+  return copy;
+}
+
 // ../adapter-pi-rpc/dist/internal/jsonl-framer.js
 import { StringDecoder } from "node:string_decoder";
 var JsonlFramer = class {
@@ -1089,7 +1120,7 @@ var PiRpcClient = class {
     this.failed = void 0;
     const child = spawn(this.options.command, this.options.args, {
       cwd: this.options.cwd,
-      env: this.options.env ?? process.env,
+      env: cleanSpawnEnv(this.options.env),
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
@@ -1379,6 +1410,23 @@ var PiRpcAgent = class {
       modelId: model.id
     });
     this.patchState({ model: data ? toModelRef(data) : model });
+    await this.refreshThinkingLevels();
+  }
+  /**
+   * Re-read the levels the current model supports, and the level pi actually
+   * settled the session on (a model without reasoning resets it to `off`).
+   */
+  async refreshThinkingLevels() {
+    const [levels, state] = await Promise.all([
+      this.client.request({ type: "get_available_thinking_levels" }).catch(() => void 0),
+      this.client.request({ type: "get_state" }).catch(() => void 0)
+    ]);
+    const available = dedupeThinkingLevels((levels?.levels ?? []).map(toThinkingLevel).filter(isDefined2));
+    const thinkingLevel = state ? toThinkingLevel(state.thinkingLevel) : void 0;
+    this.patchState({
+      availableThinkingLevels: available.length > 0 ? available : [...THINKING_LEVELS],
+      ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
+    });
   }
   async setThinkingLevel(level) {
     await this.client.request({ type: "set_thinking_level", level });
@@ -1446,6 +1494,22 @@ var PiRpcAgent = class {
   commandContext() {
     return { cwd: this.options.workspace.cwd, env: this.options.env };
   }
+  /**
+   * Re-reads `get_available_models` and reports it the same way a fresh spawn
+   * would. The model picker calls it the moment it opens, so a model added to
+   * `models.json` while this session is warm is there without reopening the
+   * session or restarting the host.
+   */
+  async refreshModels() {
+    if (this.disposed || !this.ready) {
+      return;
+    }
+    const models = await this.client.request({ type: "get_available_models" }).catch(() => void 0);
+    if (models === void 0) {
+      return;
+    }
+    this.patchState({ availableModels: (models.models ?? []).map(toModelRef) });
+  }
   /**
    * Pulls the cumulative token/cost/context totals pi keeps for the session, so
    * the footer can show the same numbers the TUI does. Best-effort: an older pi
@@ -1577,7 +1641,7 @@ function toThinkingLevel(value) {
   if (!value) {
     return void 0;
   }
-  return THINKING_LEVELS.find((level) => level === value);
+  return THINKING_LEVELS.find((level) => level === value) ?? value.trim();
 }
 function dedupeThinkingLevels(levels) {
   return [...new Set(levels)];
@@ -1756,7 +1820,7 @@ ${mentions}` : mentions;
 // ../adapter-pi-rpc/dist/internal/resolve-pi.js
 import { accessSync, constants } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { delimiter, isAbsolute, join as join2 } from "node:path";
+import { delimiter, dirname, isAbsolute, join as join2 } from "node:path";
 var PI_INSTALL_COMMAND = "npm install -g @earendil-works/pi-coding-agent";
 function buildRpcArgs(options) {
   const args = ["--mode", "rpc"];
@@ -1794,6 +1858,33 @@ function resolvePi(options = {}) {
     "- NestJS host: env MORSE_PI_PATH (or MORSE_PI_ENTRY for a bundled rpc-entry.js)"
   ].join("\n"), { remedy: { install: PI_INSTALL_COMMAND } });
 }
+function resolvePiCli(options = {}) {
+  const env = options.env ?? process.env;
+  const configured = options.piPath ?? env.MORSE_PI_PATH;
+  if (configured) {
+    return { command: configured, baseArgs: [], source: "configured" };
+  }
+  const onPath = findOnPath("pi", env);
+  if (onPath) {
+    return { command: onPath, baseArgs: [], source: "path" };
+  }
+  const entry = options.nodeEntryPath ?? env.MORSE_PI_ENTRY;
+  const cli = entry ? siblingCliEntry(entry) : void 0;
+  if (cli) {
+    return { command: process.execPath, baseArgs: [cli], source: "node-entry" };
+  }
+  throw new AgentUnavailableError([
+    "The pi CLI was not found, so Morse cannot run `pi mcp`.",
+    `Install it (\`${PI_INSTALL_COMMAND}\`) or point Morse at it:`,
+    '- VS Code: setting "morse.pi.path"',
+    "- NestJS host: env MORSE_PI_PATH"
+  ].join("\n"), { remedy: { install: PI_INSTALL_COMMAND } });
+}
+function siblingCliEntry(entry) {
+  const directory = dirname(entry);
+  const cli = join2(directory, "cli.js");
+  return entry.endsWith("rpc-entry.js") && isExecutableEntry(cli) ? cli : void 0;
+}
 function findOnPath(binary, env = process.env) {
   const pathValue = env.PATH ?? env.Path ?? "";
   if (pathValue.length === 0) {
@@ -1865,7 +1956,13 @@ var PiRpcAgentFactory = class {
       extraArgs: this.options.extraArgs,
       env: this.options.env
     };
-    return this.spawnAgent(resolveOptions, input.workspace);
+    const agent = await this.spawnAgent(resolveOptions, input.workspace);
+    if (input.model) {
+      await agent.setModel(input.model).catch((error) => {
+        this.logger.warn("Could not select the model on the draft probe", error);
+      });
+    }
+    return agent;
   }
   async spawnAgent(resolveOptions, workspace, sessionPath) {
     const spawn2 = resolvePi(resolveOptions);
@@ -1883,9 +1980,425 @@ var PiRpcAgentFactory = class {
   }
 };
 
+// ../adapter-pi-rpc/dist/pi-mcp.js
+import { execFile } from "node:child_process";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+
+// ../adapter-pi-rpc/dist/internal/mcp-config.js
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+function isValidMcpServerName(name) {
+  return SERVER_NAME.test(name);
+}
+function readMcpFile(path) {
+  if (!existsSync(path)) {
+    return { mcpServers: {} };
+  }
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${path} is not a JSON object.`);
+  }
+  const servers = parsed.mcpServers;
+  if (servers !== void 0 && (typeof servers !== "object" || servers === null || Array.isArray(servers))) {
+    throw new Error(`${path}: "mcpServers" must be an object.`);
+  }
+  return {
+    ...parsed,
+    mcpServers: servers ?? {}
+  };
+}
+function writeMcpFile(path, file) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+function findMcpServer(path, name) {
+  return readMcpFile(path).mcpServers[name];
+}
+function definesMcpServer(entry) {
+  return entry !== void 0 && (entry.command !== void 0 || entry.url !== void 0 || entry.type !== void 0);
+}
+function setMcpServerOverrideEnabled(path, name, enabled) {
+  const file = readMcpFile(path);
+  const existing = file.mcpServers[name];
+  if (enabled) {
+    if (!existing) {
+      return;
+    }
+    delete existing.enabled;
+    if (Object.keys(existing).length === 0) {
+      delete file.mcpServers[name];
+    }
+  } else {
+    const entry = definesMcpServer(existing) ? {} : existing ?? {};
+    entry.enabled = false;
+    file.mcpServers[name] = entry;
+  }
+  writeMcpFile(path, file);
+}
+function upsertMcpServer(path, name, config) {
+  if (!isValidMcpServerName(name)) {
+    throw new Error(`"${name}" is not a valid MCP server name (letters, digits, "_" and "-").`);
+  }
+  const file = readMcpFile(path);
+  file.mcpServers[name] = config;
+  writeMcpFile(path, file);
+}
+function removeMcpServer(path, name) {
+  const file = readMcpFile(path);
+  if (!(name in file.mcpServers)) {
+    return false;
+  }
+  delete file.mcpServers[name];
+  writeMcpFile(path, file);
+  return true;
+}
+function setMcpServerEnabled(path, name, enabled) {
+  const file = readMcpFile(path);
+  const server = file.mcpServers[name];
+  if (!server) {
+    return false;
+  }
+  if (enabled) {
+    delete server.enabled;
+  } else {
+    server.enabled = false;
+  }
+  writeMcpFile(path, file);
+  return true;
+}
+
+// ../adapter-pi-rpc/dist/pi-mcp.js
+function parseMcpServerInput(raw) {
+  const args = isRecord(raw) ? raw : {};
+  const input = { name: asString2(args.name) };
+  if (args.scope === "global" || args.scope === "project") {
+    input.scope = args.scope;
+  }
+  if (args.type === "stdio" || args.type === "http") {
+    input.type = args.type;
+  }
+  for (const key of ["command", "cwd", "url", "description"]) {
+    const value = asString2(args[key]);
+    if (value.length > 0) {
+      input[key] = value;
+    }
+  }
+  if (args.exposure === "codemode" || args.exposure === "deferred" || args.exposure === "direct" || args.exposure === "hidden") {
+    input.exposure = args.exposure;
+  }
+  if (Array.isArray(args.args)) {
+    input.args = args.args.filter(isString);
+  }
+  input.env = stringRecord(args.env);
+  input.headers = stringRecord(args.headers);
+  return input;
+}
+var DEFAULT_TIMEOUT_MS = 2e4;
+var PiMcp = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Connect every enabled server and report what happened. */
+  async status(cwd) {
+    const spawn2 = resolvePiCli(this.options);
+    const { stdout, stderr, failed, timedOut } = await run(spawn2.command, [...spawn2.baseArgs, "mcp", "list", "--json"], cwd, cleanSpawnEnv(this.env()), this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const parsed = parseStatus(stdout);
+    if (!parsed) {
+      const seconds = Math.round((this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS) / 1e3);
+      const detail = timedOut ? `\`pi mcp list\` did not finish within ${seconds}s \u2014 a server is likely hanging (try \`pi mcp list\` in a terminal)` : stderr.trim() || (failed ? `\`pi mcp list\` exited with an error` : "no output");
+      throw new Error(`Could not read the MCP server list: ${detail}`);
+    }
+    return parsed;
+  }
+  async add(input, cwd) {
+    if (!isValidMcpServerName(input.name)) {
+      return {
+        ok: false,
+        message: `"${input.name}" is not a valid server name (letters, digits, "_" and "-").`
+      };
+    }
+    const isHttp = input.type === "http" || input.url !== void 0 && input.command === void 0;
+    const config = this.toConfig(input, isHttp);
+    if (typeof config === "string") {
+      return { ok: false, message: config };
+    }
+    const path = this.configPath(cwd, input.scope);
+    try {
+      upsertMcpServer(path, input.name, config);
+    } catch (error) {
+      return { ok: false, message: describe(error) };
+    }
+    return { ok: true, path };
+  }
+  async remove(name, cwd, scope) {
+    if (scope === "global") {
+      return this.removeFrom(this.globalPath(), name, "global");
+    }
+    if (scope === "project") {
+      return this.removeFrom(this.projectPath(cwd), name, "project");
+    }
+    for (const path of this.configPaths(cwd)) {
+      try {
+        if (removeMcpServer(path, name)) {
+          return { ok: true, path };
+        }
+      } catch (error) {
+        return { ok: false, message: describe(error) };
+      }
+    }
+    return { ok: false, message: `No server named "${name}" is configured.` };
+  }
+  removeFrom(path, name, scope) {
+    try {
+      if (!removeMcpServer(path, name)) {
+        return {
+          ok: false,
+          message: scope === "project" ? `"${name}" is not defined in this project's .pi/mcp.json.` : `"${name}" is not defined in the user mcp.json.`
+        };
+      }
+    } catch (error) {
+      return { ok: false, message: describe(error) };
+    }
+    return { ok: true, path, scope };
+  }
+  /**
+   * Enable or disable a server in one scope.
+   *
+   * Global edits the user file. Project edits the project entry when the project
+   * defines the server, and otherwise writes a project **override** — the way
+   * pi's `/mcp` does "Disable in this project" — so a user-level server can be
+   * turned off in one directory without touching every other project.
+   */
+  async setEnabled(name, enabled, cwd, scope) {
+    if (scope === "global") {
+      return this.setEnabledIn(this.globalPath(), name, enabled, "global");
+    }
+    if (scope === "project") {
+      const projectPath = this.projectPath(cwd);
+      if (definesMcpServer(findMcpServer(projectPath, name))) {
+        return this.setEnabledIn(projectPath, name, enabled, "project");
+      }
+      const known = findMcpServer(projectPath, name) !== void 0 || findMcpServer(this.globalPath(), name) !== void 0;
+      if (!known) {
+        return {
+          ok: false,
+          message: `No server named "${name}" is configured.`
+        };
+      }
+      try {
+        setMcpServerOverrideEnabled(projectPath, name, enabled);
+      } catch (error) {
+        return { ok: false, message: describe(error) };
+      }
+      return { ok: true, path: projectPath, scope: "project", override: true };
+    }
+    for (const path of this.configPaths(cwd)) {
+      try {
+        if (findMcpServer(path, name) === void 0) {
+          continue;
+        }
+        setMcpServerEnabled(path, name, enabled);
+        return { ok: true, path };
+      } catch (error) {
+        return { ok: false, message: describe(error) };
+      }
+    }
+    return { ok: false, message: `No server named "${name}" is configured.` };
+  }
+  setEnabledIn(path, name, enabled, scope) {
+    try {
+      if (findMcpServer(path, name) === void 0) {
+        return {
+          ok: false,
+          message: scope === "project" ? `"${name}" is not defined in this project's .pi/mcp.json.` : `"${name}" is not defined in the user mcp.json.`
+        };
+      }
+      setMcpServerEnabled(path, name, enabled);
+    } catch (error) {
+      return { ok: false, message: describe(error) };
+    }
+    return { ok: true, path, scope };
+  }
+  /** The user-level file first, then the project's — so a project definition wins. */
+  configPaths(cwd) {
+    return [this.projectPath(cwd), this.globalPath()];
+  }
+  configPath(cwd, scope) {
+    return scope === "project" ? this.projectPath(cwd) : this.globalPath();
+  }
+  globalPath() {
+    return join3(this.agentDir(), "mcp.json");
+  }
+  projectPath(cwd) {
+    return join3(cwd, ".pi", "mcp.json");
+  }
+  agentDir() {
+    if (this.options.agentDir) {
+      return this.options.agentDir;
+    }
+    const fromEnv = this.env().PI_CODING_AGENT_DIR;
+    return fromEnv && fromEnv.length > 0 ? fromEnv : join3(homedir3(), ".pi", "agent");
+  }
+  env() {
+    return this.options.env ?? process.env;
+  }
+  /** The stored entry, or an error message when the input is incomplete. */
+  toConfig(input, isHttp) {
+    const config = {};
+    if (isHttp) {
+      const url = input.url?.trim();
+      if (!url) {
+        return 'An HTTP server needs a "url".';
+      }
+      config.type = "http";
+      config.url = url;
+      if (input.headers && Object.keys(input.headers).length > 0) {
+        config.headers = input.headers;
+      }
+    } else {
+      const command = input.command?.trim();
+      if (!command) {
+        return 'A stdio server needs a "command".';
+      }
+      config.type = "stdio";
+      config.command = command;
+      if (input.args && input.args.length > 0) {
+        config.args = input.args;
+      }
+      if (input.cwd?.trim()) {
+        config.cwd = input.cwd.trim();
+      }
+      if (input.env && Object.keys(input.env).length > 0) {
+        config.env = input.env;
+      }
+    }
+    if (input.exposure && input.exposure !== "codemode") {
+      config.exposure = input.exposure;
+    }
+    if (input.description?.trim()) {
+      config.description = input.description.trim();
+    }
+    if (input.enabled === false) {
+      config.enabled = false;
+    }
+    return config;
+  }
+};
+function run(command, args, cwd, env, timeoutMs) {
+  return new Promise((resolve6, reject) => {
+    execFile(command, args, { cwd, env, timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
+      const err = error;
+      const code = err?.code;
+      if (typeof code === "string") {
+        reject(new Error(`Could not run "${command}": ${stderr.trim() || code}`));
+        return;
+      }
+      resolve6({ stdout, stderr, failed: error !== null, timedOut: err?.killed === true });
+    });
+  });
+}
+function parseStatus(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed.servers)) {
+      return void 0;
+    }
+    return {
+      servers: parsed.servers.map(toServerStatus),
+      errors: Array.isArray(parsed.errors) ? parsed.errors.filter(isString) : [],
+      ...typeof parsed.note === "string" ? { note: parsed.note } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function toServerStatus(raw) {
+  const row = typeof raw === "object" && raw !== null ? raw : {};
+  const scope = row.scope;
+  return {
+    name: isString(row.name) ? row.name : "unknown",
+    scope: scope === "project" || scope === "extension" ? scope : "global",
+    source: isString(row.source) ? row.source : "",
+    ...isString(row.override) ? { override: row.override } : {},
+    enabled: row.enabled !== false,
+    exposure: toExposure(row.exposure),
+    transport: isString(row.transport) ? row.transport : "",
+    state: toState(row.state),
+    tools: Array.isArray(row.tools) ? row.tools.filter(isString) : [],
+    ...isRecord(row.toolExposure) ? { toolExposure: toExposureMap(row.toolExposure) } : {},
+    ...typeof row.resources === "number" ? { resources: row.resources } : {},
+    ...typeof row.resourceTemplates === "number" ? { resourceTemplates: row.resourceTemplates } : {},
+    ...isString(row.error) ? { error: row.error } : {}
+  };
+}
+function toState(value) {
+  switch (value) {
+    case "connecting":
+    case "connected":
+    case "disconnected":
+    case "needs-auth":
+    case "failed":
+    case "closed":
+    case "disabled":
+      return value;
+    default:
+      return "failed";
+  }
+}
+function toExposure(value) {
+  switch (value) {
+    case "codemode":
+    case "deferred":
+    case "direct":
+    case "hidden":
+      return value;
+    default:
+      return "codemode";
+  }
+}
+function toExposureMap(value) {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = toExposure(entry);
+  }
+  return result;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function asString2(value) {
+  return typeof value === "string" ? value : "";
+}
+function stringRecord(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") {
+      result[key] = entry;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // ../adapter-pi-rpc/dist/pi-rpc-session-catalog.js
 import { open, readdir as readdir2, readFile as readFile2, stat as stat2, unlink } from "node:fs/promises";
-import { join as join3, resolve as resolve2, sep } from "node:path";
+import { join as join4, resolve as resolve2, sep } from "node:path";
 var TYPE_PREFIX = '{"type":"';
 function typeAt(raw, start, end) {
   if (!raw.startsWith(TYPE_PREFIX, start)) {
@@ -1974,12 +2487,12 @@ var PiRpcSessionCatalog = class {
       if (!bucket.isDirectory()) {
         continue;
       }
-      const bucketPath = join3(this.directory, bucket.name);
+      const bucketPath = join4(this.directory, bucket.name);
       for (const entry of await safeReadDir(bucketPath)) {
         if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
           continue;
         }
-        const path = join3(bucketPath, entry.name);
+        const path = join4(bucketPath, entry.name);
         const info = await stat2(path).catch(() => void 0);
         files.push({ path, size: info?.size ?? 0, updatedAt: info?.mtimeMs ?? 0 });
       }
@@ -2131,9 +2644,16 @@ function createPiRpcAdapter(config, logger) {
     env: config.env,
     removeFile: config.removeSessionFile
   });
+  const cliOptions = {
+    piPath: config.piPath,
+    nodeEntryPath: config.nodeEntryPath,
+    env: config.env
+  };
+  const mcp = new PiMcp(cliOptions);
   return {
     factory,
     catalog,
+    mcp,
     describe: () => resolvePi({
       piPath: config.piPath,
       nodeEntryPath: config.nodeEntryPath,
@@ -2141,10 +2661,28 @@ function createPiRpcAdapter(config, logger) {
       noSession: config.noSession,
       extraArgs: config.extraArgs,
       env: config.env
-    })
+    }),
+    describeCli: () => {
+      try {
+        return resolvePiCli(cliOptions);
+      } catch {
+        return void 0;
+      }
+    }
   };
 }
 
+// ../host-runtime/dist/terminal-buffer.js
+var TERMINAL_BUFFER_CHARS = 256 * 1024;
+function trimTail(text, maxChars = TERMINAL_BUFFER_CHARS) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const tail = text.slice(-maxChars);
+  const newline = tail.indexOf("\n");
+  return newline === -1 ? tail : tail.slice(newline + 1);
+}
+
 // ../host-runtime/dist/transcript-projector.js
 var TranscriptProjector = class {
   options;
@@ -2671,8 +3209,15 @@ var HostSessionController = class {
   loadingOlderHistory = false;
   /** Discriminates history item ids across pages (see `historyItems`). */
   historyPageSeq = 0;
-  /** The shells this client has open, keyed by the terminal id it named. */
+  /** This client's live attachments to shells, keyed by the terminal id it named. */
   terminals = /* @__PURE__ */ new Map();
+  /**
+   * The ids this connection has already opened. It separates a *first* open — a
+   * page reattaching to a shell the host still runs — from a repeat open (the
+   * Restart button), which must replace the shell and clear its scrollback
+   * instead of replaying it into the emulator that already shows it.
+   */
+  openedTerminals = /* @__PURE__ */ new Set();
   /**
    * Bumped whenever a terminal id is opened or closed. A shell's late `exit`
    * (a replaced one, a killed one) compares its generation and stays silent, so
@@ -2704,6 +3249,7 @@ var HostSessionController = class {
         void this.warmDraft();
       } else {
         await this.runSessionChange(() => this.options.services.registry.activate(existingKey));
+        void this.refreshModels();
       }
     }
     void this.publishLists();
@@ -2721,11 +3267,12 @@ var HostSessionController = class {
       return;
     }
     this.disposed = true;
-    for (const process2 of this.terminals.values()) {
-      process2.kill();
+    for (const session of this.terminals.values()) {
+      session.detach();
     }
     this.terminals.clear();
     this.terminalGenerations.clear();
+    this.openedTerminals.clear();
     this.detachRegistry?.();
     this.detachRegistry = void 0;
     this.detachTranscripts?.();
@@ -2795,6 +3342,9 @@ var HostSessionController = class {
       case "commands/refresh":
         await this.refreshCommands();
         return;
+      case "models/refresh":
+        await this.refreshModels();
+        return;
       case "project/list":
         await this.publishProjects();
         return;
@@ -2830,23 +3380,38 @@ var HostSessionController = class {
     }
   }
   /**
-   * Starts a shell for the bottom panel. The directory is the viewing session's
-   * (or the draft's), never an arbitrary path the client names — the backend
-   * still re-checks it against the host policy before spawning.
+   * Attaches this client to a shell for the bottom panel. The directory is the
+   * viewing session's (or the draft's), never an arbitrary path the client
+   * names — the backend still re-checks it against the host policy before
+   * spawning.
+   *
+   * A *first* open on this connection may land on a shell that is already running
+   * (a reloaded page reattaching); a repeat open (the Restart button) replaces
+   * it, scrollback and all, so the fresh shell does not replay the old one.
    */
   async openTerminal(payload) {
-    if (this.options.terminal === void 0) {
+    const backend = this.options.terminal;
+    if (backend === void 0) {
       this.emitTerminalExit(payload.terminalId, void 0, "This host has no terminal.");
       return;
     }
-    this.closeTerminal(payload.terminalId);
-    const generation = this.terminalGenerations.get(payload.terminalId) ?? 0;
+    const previous = this.terminals.get(payload.terminalId);
+    if (previous !== void 0) {
+      previous.detach();
+      this.terminals.delete(payload.terminalId);
+      backend.close(payload.terminalId);
+    } else if (this.openedTerminals.has(payload.terminalId)) {
+      backend.close(payload.terminalId);
+    }
+    this.openedTerminals.add(payload.terminalId);
+    const generation = (this.terminalGenerations.get(payload.terminalId) ?? 0) + 1;
+    this.terminalGenerations.set(payload.terminalId, generation);
     const cwd = payload.cwd ?? this.currentState().workspace.cwd;
     const cols = clampGeometry(payload.cols, 80);
     const rows = clampGeometry(payload.rows, 24);
-    let process2;
+    let session;
     try {
-      process2 = await this.options.terminal.open({ cwd, cols, rows }, {
+      session = await backend.attach(payload.terminalId, { cwd, cols, rows }, {
         output: (data) => {
           if (this.terminalGenerations.get(payload.terminalId) === generation) {
             this.emitTerminalOutput(payload.terminalId, data);
@@ -2866,19 +3431,25 @@ var HostSessionController = class {
       return;
     }
     if (!this.disposed && this.terminalGenerations.get(payload.terminalId) === generation) {
-      this.terminals.set(payload.terminalId, process2);
+      this.terminals.set(payload.terminalId, session);
+      if (session.replay.length > 0) {
+        this.emitTerminalOutput(payload.terminalId, session.replay);
+      }
     } else {
-      process2.kill();
+      session.detach();
     }
   }
+  /**
+   * Ends a shell for good: the reader closed the pane. Bumps the generation first,
+   * so a late `exit` for the shell being replaced is not reported as news.
+   */
   closeTerminal(terminalId) {
     this.terminalGenerations.set(terminalId, (this.terminalGenerations.get(terminalId) ?? 0) + 1);
-    const process2 = this.terminals.get(terminalId);
-    if (process2 === void 0) {
-      return;
-    }
+    const session = this.terminals.get(terminalId);
     this.terminals.delete(terminalId);
-    process2.kill();
+    this.openedTerminals.delete(terminalId);
+    session?.detach();
+    this.options.terminal?.close(terminalId);
   }
   emitTerminalOutput(terminalId, data) {
     if (data.length > 0 && !this.disposed) {
@@ -2938,7 +3509,7 @@ var HostSessionController = class {
   /** Fills the draft pickers from the registry's session-less probe. */
   async warmDraft() {
     try {
-      this.draftCatalog = await this.options.services.registry.draftDefaults();
+      this.draftCatalog = await this.options.services.registry.draftDefaults(this.draftModel);
     } catch (error) {
       this.agentError = describeError(error);
       this.agentFailure = describeAgentFailure(error, this.options.agentHint);
@@ -3271,6 +3842,7 @@ var HostSessionController = class {
       const match = this.draftCatalog?.availableModels.find((model) => model.provider === provider && model.id === id);
       this.draftModel = match ?? { provider, id, name: id };
       this.emitState();
+      void this.refreshDraftCatalog(this.draftModel);
       return;
     }
     const result = await this.guard(() => this.options.services.chat.setModel({ provider, id, name: id }));
@@ -3278,6 +3850,23 @@ var HostSessionController = class {
       this.emitState();
     }
   }
+  /**
+   * Re-reads the draft catalog for a model picked before any session exists, so
+   * the thinking picker mirrors that model's levels instead of the default
+   * model's. The request is dropped when the reader picks again or a session
+   * opens while the probe is in flight.
+   */
+  async refreshDraftCatalog(model) {
+    try {
+      const catalog = await this.options.services.registry.draftDefaults(model);
+      if (catalog && this.activeKey === void 0 && !this.disposed && this.draftModel === model) {
+        this.draftCatalog = catalog;
+        this.emitState();
+      }
+    } catch (error) {
+      this.options.logger.warn("Could not probe the draft catalog for the picked model", error);
+    }
+  }
   async setThinkingLevel(level) {
     if (this.activeKey === void 0) {
       this.draftThinking = level;
@@ -3310,6 +3899,24 @@ var HostSessionController = class {
     }
     await this.guard(() => gateway.refreshCommands());
   }
+  /**
+   * Re-reads the model catalog on request. A warm session re-asks pi over RPC
+   * (cheap); a draft re-runs the session-less probe, since that is where its
+   * picker's catalog came from and it would otherwise be frozen for the host's
+   * lifetime.
+   */
+  async refreshModels() {
+    if (this.activeKey === void 0) {
+      this.options.services.registry.refreshDraftDefaults();
+      await this.warmDraft();
+      return;
+    }
+    const gateway = this.options.services.registry.active();
+    if (gateway?.refreshModels === void 0) {
+      return;
+    }
+    await this.guard(() => gateway.refreshModels());
+  }
   async runHostCommand(command, args, requestId) {
     const handler = this.options.onHostCommand;
     if (!handler) {
@@ -3665,7 +4272,7 @@ function hintOnly(hint) {
 // ../server/src/internal/http/health.controller.ts
 import { Controller, Get } from "@nestjs/common";
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { Inject } from "@nestjs/common";
 
 // ../server/src/app/tokens.ts
@@ -3693,7 +4300,7 @@ var HealthController = class {
     };
   }
   async manifest() {
-    const raw = await readFile3(join4(this.config.uiDir, "webview.manifest.json"), "utf8").catch(
+    const raw = await readFile3(join5(this.config.uiDir, "webview.manifest.json"), "utf8").catch(
       () => void 0
     );
     return parseFrontendManifest(raw) ?? { name: "unknown", protocolVersion: PROTOCOL_VERSION };
@@ -3769,7 +4376,50 @@ var ServerProjectPolicy = class {
 // ../server/src/internal/terminal/terminal.service.ts
 import { spawn as spawnPty } from "node-pty";
 import { Inject as Inject2, Injectable } from "@nestjs/common";
+
+// ../server/src/internal/terminal/terminal-log.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join6 } from "node:path";
+var LOG_DIR = "terminals";
+var LOG_MAX_CHARS = TERMINAL_BUFFER_CHARS * 4;
+function readTerminalLog(dataDir, terminalId) {
+  try {
+    const raw = readFileSync2(logPath(dataDir, terminalId), "utf8");
+    return trimTail(raw, LOG_MAX_CHARS);
+  } catch {
+    return "";
+  }
+}
+function writeTerminalLog(dataDir, terminalId, text) {
+  const trimmed = trimTail(text, LOG_MAX_CHARS);
+  const target = logPath(dataDir, terminalId);
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    mkdirSync2(join6(dataDir, LOG_DIR), { recursive: true });
+    writeFileSync2(temp, trimmed);
+    renameSync(temp, target);
+  } catch {
+    try {
+      writeFileSync2(target, trimmed);
+    } catch {
+      rmSync(temp, { force: true });
+    }
+  }
+}
+function removeTerminalLog(dataDir, terminalId) {
+  rmSync(logPath(dataDir, terminalId), { force: true });
+}
+function safeTerminalName(terminalId) {
+  const safe = terminalId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 100);
+  return safe.length > 0 ? safe : "terminal";
+}
+function logPath(dataDir, terminalId) {
+  return join6(dataDir, LOG_DIR, `${safeTerminalName(terminalId)}.log`);
+}
+
+// ../server/src/internal/terminal/terminal.service.ts
 var SIGKILL_AFTER_MS = 1500;
+var FLUSH_DEBOUNCE_MS = 2e3;
 function defaultShell() {
   const configured = process.env.SHELL?.trim();
   if (configured !== void 0 && configured.length > 0) {
@@ -3778,17 +4428,95 @@ function defaultShell() {
   return process.platform === "win32" ? "powershell.exe" : "/bin/bash";
 }
 var ServerTerminalBackend = class {
-  constructor(policy, logger) {
+  constructor(policy, logger, config) {
     this.policy = policy;
     this.logger = logger;
+    this.config = config;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  attach(terminalId, options, sink) {
+    const entry = this.entryFor(terminalId);
+    if (entry.pty === void 0) {
+      this.spawn(terminalId, entry, options);
+    } else {
+      this.resize(entry, options.cols, options.rows);
+    }
+    entry.sinks.add(sink);
+    this.cancelIdle(entry);
+    return {
+      replay: entry.output,
+      write: (data) => entry.pty?.write(data),
+      resize: (cols, rows) => this.resize(entry, cols, rows),
+      detach: () => this.detach(terminalId, entry, sink)
+    };
+  }
+  /** Ends a shell for good, drops its scrollback, and tells any other viewer. */
+  close(terminalId) {
+    const entry = this.entries.get(terminalId);
+    this.entries.delete(terminalId);
+    if (entry !== void 0) {
+      this.stopFlush(entry);
+      this.cancelIdle(entry);
+      entry.generation += 1;
+      const sinks = [...entry.sinks];
+      entry.sinks.clear();
+      this.killPty(entry.pty);
+      entry.pty = void 0;
+      for (const sink of sinks) {
+        sink.exit();
+      }
+    }
+    removeTerminalLog(this.config.dataDir, terminalId);
+  }
+  onModuleDestroy() {
+    for (const [terminalId, entry] of this.entries) {
+      entry.generation += 1;
+      this.persist(terminalId, entry);
+      this.killPty(entry.pty);
+      entry.pty = void 0;
+      this.stopFlush(entry);
+      this.cancelIdle(entry);
+    }
+    this.entries.clear();
   }
-  open(options, sink) {
+  /** SIGTERM, then SIGKILL for a shell that ignores it (a hung process group). */
+  killPty(pty) {
+    if (pty === void 0) {
+      return;
+    }
+    try {
+      pty.kill();
+    } catch {
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        pty.kill("SIGKILL");
+      } catch {
+      }
+    }, SIGKILL_AFTER_MS);
+    timer.unref?.();
+  }
+  entryFor(terminalId) {
+    const existing = this.entries.get(terminalId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const entry = {
+      sinks: /* @__PURE__ */ new Set(),
+      output: readTerminalLog(this.config.dataDir, terminalId),
+      dirty: false,
+      generation: 0
+    };
+    this.entries.set(terminalId, entry);
+    return entry;
+  }
+  spawn(terminalId, entry, options) {
     if (!this.policy.canOpen(options.cwd)) {
-      throw new UnsupportedByHostError(
-        `Morse is not allowed to run a terminal in ${options.cwd}.`
-      );
+      throw new UnsupportedByHostError(`Morse is not allowed to run a terminal in ${options.cwd}.`);
     }
     const shell = defaultShell();
+    const generation = ++entry.generation;
     const pty = spawnPty(shell, [], {
       name: "xterm-256color",
       cols: options.cols,
@@ -3796,41 +4524,105 @@ var ServerTerminalBackend = class {
       cwd: options.cwd,
       env: { ...process.env, TERM: "xterm-256color", MORSE_TERMINAL: "1" }
     });
+    entry.pty = pty;
     this.logger.info(`Terminal opened in ${options.cwd} (${shell}, pid ${pty.pid})`);
-    let exited = false;
-    const data = pty.onData((chunk) => sink.output(chunk));
+    pty.onData((chunk) => {
+      if (entry.generation !== generation) {
+        return;
+      }
+      entry.output += chunk;
+      if (entry.output.length > TERMINAL_BUFFER_CHARS * 1.5) {
+        entry.output = trimTail(entry.output, TERMINAL_BUFFER_CHARS);
+      }
+      entry.dirty = true;
+      this.scheduleFlush(terminalId, entry);
+      for (const sink of entry.sinks) {
+        sink.output(chunk);
+      }
+    });
     pty.onExit(({ exitCode }) => {
-      exited = true;
-      data.dispose();
-      sink.exit(exitCode);
+      if (entry.generation !== generation) {
+        return;
+      }
+      entry.pty = void 0;
+      this.persist(terminalId, entry);
+      for (const sink of [...entry.sinks]) {
+        sink.exit(exitCode);
+      }
     });
-    return {
-      write: (input) => {
-        if (!exited) {
-          pty.write(input);
-        }
-      },
-      resize: (cols, rows) => {
-        if (!exited) {
-          pty.resize(cols, rows);
-        }
-      },
-      kill: () => {
-        if (exited) {
-          return;
-        }
-        exited = true;
-        pty.kill();
-        const timer = setTimeout(() => pty.kill("SIGKILL"), SIGKILL_AFTER_MS);
-        timer.unref?.();
+  }
+  resize(entry, cols, rows) {
+    try {
+      entry.pty?.resize(cols, rows);
+    } catch {
+    }
+  }
+  detach(terminalId, entry, sink) {
+    entry.sinks.delete(sink);
+    if (entry.sinks.size > 0) {
+      return;
+    }
+    this.persist(terminalId, entry);
+    this.scheduleIdle(terminalId, entry);
+  }
+  /**
+   * Reclaims a shell nobody has reattached to. The log stays (the output should
+   * still be there next time); only the process goes.
+   */
+  scheduleIdle(terminalId, entry) {
+    if (this.config.terminalIdleMs <= 0) {
+      return;
+    }
+    this.cancelIdle(entry);
+    entry.idleTimer = setTimeout(() => {
+      entry.idleTimer = void 0;
+      if (entry.sinks.size > 0) {
+        return;
       }
-    };
+      entry.generation += 1;
+      this.killPty(entry.pty);
+      entry.pty = void 0;
+      this.persist(terminalId, entry);
+      this.entries.delete(terminalId);
+    }, this.config.terminalIdleMs);
+    entry.idleTimer.unref?.();
+  }
+  cancelIdle(entry) {
+    if (entry.idleTimer !== void 0) {
+      clearTimeout(entry.idleTimer);
+      entry.idleTimer = void 0;
+    }
+  }
+  scheduleFlush(terminalId, entry) {
+    if (entry.flushTimer !== void 0) {
+      return;
+    }
+    entry.flushTimer = setTimeout(() => {
+      entry.flushTimer = void 0;
+      this.persist(terminalId, entry);
+    }, FLUSH_DEBOUNCE_MS);
+    entry.flushTimer.unref?.();
+  }
+  stopFlush(entry) {
+    if (entry.flushTimer !== void 0) {
+      clearTimeout(entry.flushTimer);
+      entry.flushTimer = void 0;
+    }
+  }
+  persist(terminalId, entry) {
+    this.stopFlush(entry);
+    if (!entry.dirty) {
+      return;
+    }
+    entry.dirty = false;
+    writeTerminalLog(this.config.dataDir, terminalId, entry.output);
   }
 };
 ServerTerminalBackend = __decorateClass([
   Injectable(),
   __decorateParam(0, Inject2(MORSE_PROJECT_POLICY)),
-  __decorateParam(1, Inject2(MORSE_LOGGER))
+  __decorateParam(1, Inject2(MORSE_LOGGER)),
+  __decorateParam(2, Inject2(MORSE_CONFIG))
 ], ServerTerminalBackend);
 
 // ../server/src/internal/registry.ts
@@ -3870,9 +4662,9 @@ import { Inject as Inject5 } from "@nestjs/common";
 import { Inject as Inject4, Injectable as Injectable3 } from "@nestjs/common";
 
 // ../server/src/internal/uploads/upload-store.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute3, join as join5, relative, sep as sep3 } from "node:path";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join7, relative, sep as sep3 } from "node:path";
 var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
 var DEFAULT_UPLOAD_DIR = ".morse/uploads";
 var UploadError = class extends Error {
@@ -3892,7 +4684,7 @@ async function saveUpload(cwd, request, uploadDir = DEFAULT_UPLOAD_DIR) {
       `That file is ${formatMb(bytes.length)} MB; the limit is ${formatMb(MAX_UPLOAD_BYTES)} MB.`
     );
   }
-  const directory = isAbsolute3(uploadDir) ? uploadDir : join5(cwd, uploadDir);
+  const directory = isAbsolute3(uploadDir) ? uploadDir : join7(cwd, uploadDir);
   await mkdir(directory, { recursive: true });
   const target = uniquePath(directory, name);
   await writeFile(target, bytes);
@@ -3911,10 +4703,10 @@ function uniquePath(directory, name) {
   const dot = name.lastIndexOf(".");
   const stem = dot > 0 ? name.slice(0, dot) : name;
   const extension = dot > 0 ? name.slice(dot) : "";
-  let candidate = join5(directory, name);
+  let candidate = join7(directory, name);
   let suffix = 1;
-  while (existsSync(candidate)) {
-    candidate = join5(directory, `${stem}-${suffix}${extension}`);
+  while (existsSync2(candidate)) {
+    candidate = join7(directory, `${stem}-${suffix}${extension}`);
     suffix += 1;
   }
   return candidate;
@@ -3930,8 +4722,8 @@ function formatMb(bytes) {
 
 // ../server/src/internal/workspace/directory-browser.ts
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname, isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename3, dirname as dirname3, isAbsolute as isAbsolute4, join as join8, resolve as resolve4 } from "node:path";
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -3955,8 +4747,8 @@ async function browseDirectory(path, options) {
     throw new Error(`A folder path must be absolute: ${requested}`);
   }
   const entries = await readdir3(start, { withFileTypes: true });
-  const directories = entries.filter((entry) => entry.isDirectory()).filter((entry) => !shouldSkip(entry.name)).map((entry) => ({ name: entry.name, path: join6(start, entry.name) })).sort((left, right) => left.name.localeCompare(right.name));
-  const parent = dirname(start);
+  const directories = entries.filter((entry) => entry.isDirectory()).filter((entry) => !shouldSkip(entry.name)).map((entry) => ({ name: entry.name, path: join8(start, entry.name) })).sort((left, right) => left.name.localeCompare(right.name));
+  const parent = dirname3(start);
   return {
     path: start,
     parent: parent === start ? void 0 : parent,
@@ -3970,7 +4762,7 @@ function shouldSkip(name) {
 }
 async function isGitRepo(path) {
   try {
-    await stat3(join6(path, ".git"));
+    await stat3(join8(path, ".git"));
     return true;
   } catch {
     return false;
@@ -3979,7 +4771,7 @@ async function isGitRepo(path) {
 function shortcutRoots(options) {
   const seen = /* @__PURE__ */ new Set();
   const roots = [];
-  for (const candidate of [...options.roots ?? [], homedir3(), options.defaultPath]) {
+  for (const candidate of [...options.roots ?? [], homedir4(), options.defaultPath]) {
     if (!candidate || !isAbsolute4(candidate)) {
       continue;
     }
@@ -4041,7 +4833,7 @@ function toPosix(path) {
 }
 
 // ../server/src/internal/workspace/git-log.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { relative as relative3 } from "node:path";
 var DEFAULT_MAX_COMMITS = 250;
 var HARD_MAX_COMMITS = 500;
@@ -4092,9 +4884,9 @@ async function readGitStatus(cwd) {
     gitText(["rev-parse", "--show-prefix"], cwd),
     gitText(["status", "--porcelain=v1", "-z", "--untracked-files=all"], cwd)
   ]);
-  return { isRepo: true, files: parseStatus(raw ?? "", prefix?.trim() ?? "") };
+  return { isRepo: true, files: parseStatus2(raw ?? "", prefix?.trim() ?? "") };
 }
-function parseStatus(raw, root) {
+function parseStatus2(raw, root) {
   const records = raw.split("\0");
   const files = [];
   for (let index = 0; index < records.length; index += 1) {
@@ -4338,7 +5130,7 @@ function parseRefs(raw) {
 }
 function gitText(args, cwd) {
   return new Promise((resolve6) => {
-    execFile(
+    execFile2(
       "git",
       args,
       { cwd, timeout: 5e3, maxBuffer: 16 * 1024 * 1024, windowsHide: true },
@@ -4354,7 +5146,7 @@ async function gitRun(args, cwd, timeout = 5e3) {
 }
 function gitExec(args, cwd, timeout = 5e3) {
   return new Promise((resolve6) => {
-    execFile(
+    execFile2(
       "git",
       args,
       {
@@ -4382,9 +5174,9 @@ function gitExec(args, cwd, timeout = 5e3) {
 }
 
 // ../server/src/internal/workspace/workspace-index.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { readdir as readdir4 } from "node:fs/promises";
-import { join as join7, relative as relative4 } from "node:path";
+import { join as join9, relative as relative4 } from "node:path";
 var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -4469,7 +5261,7 @@ async function gitFileList(cwd) {
 }
 function runGit(args, cwd) {
   return new Promise((resolve6) => {
-    execFile2(
+    execFile3(
       "git",
       args,
       { cwd, timeout: 5e3, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
@@ -4495,7 +5287,7 @@ async function walk(root, directory, files) {
     if (files.length >= MAX_INDEXED_FILES) {
       return;
     }
-    const full = join7(directory, entry.name);
+    const full = join9(directory, entry.name);
     if (entry.isDirectory()) {
       if (SKIPPED_DIRECTORIES2.has(entry.name) || entry.name.startsWith(".")) {
         continue;
@@ -4513,20 +5305,20 @@ function toPosix3(path) {
 }
 
 // ../server/src/internal/workspace/workbench-store.ts
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join10 } from "node:path";
 var LAYOUT_FILE = "workbench.json";
 var DRAFTS_FILE = "drafts.json";
 var LAYOUT_MAX_BYTES = 256 * 1024;
 var DRAFTS_MAX_BYTES = 32 * 1024 * 1024;
 function readWorkbench(dataDir) {
-  return readSlot(join8(dataDir, LAYOUT_FILE), LAYOUT_MAX_BYTES);
+  return readSlot(join10(dataDir, LAYOUT_FILE), LAYOUT_MAX_BYTES);
 }
 function saveWorkbench(dataDir, snapshot) {
   return saveSlot(dataDir, LAYOUT_FILE, snapshot, LAYOUT_MAX_BYTES);
 }
 function readDrafts(dataDir) {
-  return readSlot(join8(dataDir, DRAFTS_FILE), DRAFTS_MAX_BYTES);
+  return readSlot(join10(dataDir, DRAFTS_FILE), DRAFTS_MAX_BYTES);
 }
 function saveDrafts(dataDir, snapshot) {
   return saveSlot(dataDir, DRAFTS_FILE, snapshot, DRAFTS_MAX_BYTES);
@@ -4534,7 +5326,7 @@ function saveDrafts(dataDir, snapshot) {
 function readSlot(path, maxBytes) {
   let raw;
   try {
-    raw = readFileSync(path, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return void 0;
   }
@@ -4558,19 +5350,19 @@ function saveSlot(dataDir, file, snapshot, maxBytes) {
   if (Buffer.byteLength(serialized, "utf8") > maxBytes) {
     throw new UnsupportedByHostError(`That ${file} snapshot is too large to save.`);
   }
-  const target = join8(dataDir, file);
+  const target = join10(dataDir, file);
   const temp = `${target}.${process.pid}.tmp`;
   try {
-    mkdirSync(dataDir, { recursive: true });
-    writeFileSync(temp, serialized);
-    renameSync(temp, target);
+    mkdirSync3(dataDir, { recursive: true });
+    writeFileSync3(temp, serialized);
+    renameSync2(temp, target);
     return true;
   } catch {
     try {
-      writeFileSync(target, serialized);
+      writeFileSync3(target, serialized);
       return true;
     } catch {
-      rmSync(temp, { force: true });
+      rmSync2(temp, { force: true });
       return false;
     }
   }
@@ -4589,13 +5381,14 @@ function asSnapshot(value) {
 
 // ../server/src/internal/ws/session-factory.service.ts
 var MorseSessionFactory = class {
-  constructor(registry, transcripts, policy, logger, config, terminal) {
+  constructor(registry, transcripts, policy, logger, config, terminal, pi) {
     this.registry = registry;
     this.transcripts = transcripts;
     this.policy = policy;
     this.logger = logger;
     this.config = config;
     this.terminal = terminal;
+    this.pi = pi;
   }
   capabilities() {
     return {
@@ -4640,7 +5433,10 @@ var MorseSessionFactory = class {
       // A page served by this host may ask the registry for the latest release, so
       // the sidebar can say when a newer Morse is out. A host without it stays
       // quiet; this one is on unless `MORSE_UPDATE_CHECK=0` says otherwise.
-      updateCheck: this.config.updateCheck
+      updateCheck: this.config.updateCheck,
+      // Managing MCP servers runs the `pi` CLI, so this host offers it only when
+      // it found one. A host without it hides the affordance.
+      mcp: this.pi.describeCli() !== void 0
     };
   }
   createFor(emit) {
@@ -4785,6 +5581,31 @@ var MorseSessionFactory = class {
         const branch = typeof args?.branch === "string" ? args.branch : "";
         return checkoutGit(cwd, branch, args?.create === true);
       }
+      case "mcpStatus": {
+        const cwd = this.requireWritableCwd(context);
+        try {
+          return await this.pi.mcp.status(cwd);
+        } catch (error) {
+          return { servers: [], errors: [describeError2(error)] };
+        }
+      }
+      case "mcpAdd": {
+        const cwd = this.requireWritableCwd(context);
+        return this.pi.mcp.add(parseMcpServerInput(args), cwd);
+      }
+      case "mcpRemove": {
+        const cwd = this.requireWritableCwd(context);
+        return this.pi.mcp.remove(stringArg(args, "name"), cwd, mcpScope(args));
+      }
+      case "mcpSetEnabled": {
+        const cwd = this.requireWritableCwd(context);
+        return this.pi.mcp.setEnabled(
+          stringArg(args, "name"),
+          args?.enabled === true,
+          cwd,
+          mcpScope(args)
+        );
+      }
       default:
         throw new UnsupportedByHostError(`This host does not support "${command}".`);
     }
@@ -4834,7 +5655,8 @@ MorseSessionFactory = __decorateClass([
   __decorateParam(2, Inject4(MORSE_PROJECT_POLICY)),
   __decorateParam(3, Inject4(MORSE_LOGGER)),
   __decorateParam(4, Inject4(MORSE_CONFIG)),
-  __decorateParam(5, Inject4(ServerTerminalBackend))
+  __decorateParam(5, Inject4(ServerTerminalBackend)),
+  __decorateParam(6, Inject4(MORSE_PI_ADAPTER))
 ], MorseSessionFactory);
 function gitPaths(args) {
   const paths = args?.paths;
@@ -4843,6 +5665,16 @@ function gitPaths(args) {
   }
   return paths.filter((path) => typeof path === "string" && path.length > 0);
 }
+function stringArg(args, key) {
+  const value = args?.[key];
+  return typeof value === "string" ? value : "";
+}
+function mcpScope(args) {
+  return args?.scope === "global" || args?.scope === "project" ? args.scope : void 0;
+}
+function describeError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // ../server/src/internal/ws/morse.gateway.ts
 var MorseGateway = class {
@@ -4892,19 +5724,19 @@ MorseGateway = __decorateClass([
 ], MorseGateway);
 
 // ../server/src/app/config.ts
-import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute6, join as join9 } from "node:path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute6, join as join11 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 import { fileURLToPath } from "node:url";
 function loadConfig(env = process.env) {
   const workspacePath = resolveWorkspacePath(env);
   const configuredUiDir = env.MORSE_UI_DIR;
-  const moduleDir = dirname2(fileURLToPath(import.meta.url));
-  const bundledUiDir = join9(moduleDir, "ui");
-  const monorepoUiDir = join9(moduleDir, "..", "..", "..", "ui-angular", "dist");
-  const defaultUiDir = existsSync2(join9(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
+  const moduleDir = dirname4(fileURLToPath(import.meta.url));
+  const bundledUiDir = join11(moduleDir, "ui");
+  const monorepoUiDir = join11(moduleDir, "..", "..", "..", "ui-angular", "dist");
+  const defaultUiDir = existsSync3(join11(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
   const defaultHost = "127.0.0.1";
-  const uiDir = configuredUiDir ? isAbsolute6(configuredUiDir) ? configuredUiDir : join9(process.cwd(), configuredUiDir) : defaultUiDir;
+  const uiDir = configuredUiDir ? isAbsolute6(configuredUiDir) ? configuredUiDir : join11(process.cwd(), configuredUiDir) : defaultUiDir;
   return {
     host: env.MORSE_HOST ?? defaultHost,
     port: parsePositiveInt(env.MORSE_PORT, 4399),
@@ -4920,6 +5752,7 @@ function loadConfig(env = process.env) {
     projects: parseList(env.MORSE_PROJECTS),
     uploadDir: env.MORSE_UPLOAD_DIR?.trim() || DEFAULT_UPLOAD_DIR,
     dataDir: resolveDataDir(env),
+    terminalIdleMs: parsePositiveInt(env.MORSE_TERMINAL_IDLE_MS, 30 * 6e4),
     updateCheck: !isOff(env.MORSE_UPDATE_CHECK),
     instance: env.MORSE_INSTANCE?.trim() || void 0
   };
@@ -4927,7 +5760,7 @@ function loadConfig(env = process.env) {
 function readFrontendIdentity(uiDir) {
   try {
     return frontendIdentity(
-      parseFrontendManifest(readFileSync2(join9(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
+      parseFrontendManifest(readFileSync4(join11(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
     );
   } catch {
     return void 0;
@@ -4935,7 +5768,7 @@ function readFrontendIdentity(uiDir) {
 }
 function resolveDataDir(env) {
   const explicit = env.MORSE_HOME?.trim();
-  return explicit && explicit.length > 0 ? explicit : join9(homedir4(), ".morse");
+  return explicit && explicit.length > 0 ? explicit : join11(homedir5(), ".morse");
 }
 function parsePositiveInt(value, fallback) {
   if (!value) {
@@ -4962,11 +5795,11 @@ function resolveWorkspacePath(env) {
   const start = process.cwd();
   let directory = start;
   for (; ; ) {
-    const manifest = join9(directory, "package.json");
-    if (existsSync2(manifest) && declaresWorkspaces(manifest)) {
+    const manifest = join11(directory, "package.json");
+    if (existsSync3(manifest) && declaresWorkspaces(manifest)) {
       return directory;
     }
-    const parent = dirname2(directory);
+    const parent = dirname4(directory);
     if (parent === directory) {
       return start;
     }
@@ -4975,7 +5808,7 @@ function resolveWorkspacePath(env) {
 }
 function declaresWorkspaces(manifestPath) {
   try {
-    const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync4(manifestPath, "utf8"));
     return manifest.workspaces !== void 0;
   } catch {
     return false;