@supanadit/morse-web 0.13.0 → 0.14.1

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 = 21;
+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
     });
@@ -1378,7 +1409,29 @@ var PiRpcAgent = class {
       provider: model.provider,
       modelId: model.id
     });
-    this.patchState({ model: data ? toModelRef(data) : model });
+    const thinking = await this.readThinkingLevels();
+    this.patchState({
+      model: data ? toModelRef(data) : model,
+      ...thinking
+    });
+  }
+  /**
+   * The levels the current model supports, and the level pi settled on (a model
+   * without reasoning resets it to `off`). Returns a patch with nothing to say
+   * when pi did not answer, so the caller keeps the last known levels instead of
+   * inventing the full list — a failed refresh must not make the picker wrong.
+   */
+  async readThinkingLevels() {
+    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;
+    return {
+      ...available.length > 0 ? { availableThinkingLevels: available } : {},
+      ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
+    };
   }
   async setThinkingLevel(level) {
     await this.client.request({ type: "set_thinking_level", level });
@@ -1446,6 +1499,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 +1646,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 +1825,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 +1863,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 +1961,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 +1985,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 +2492,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 +2649,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,7 +2666,14 @@ function createPiRpcAdapter(config, logger) {
       noSession: config.noSession,
       extraArgs: config.extraArgs,
       env: config.env
-    })
+    }),
+    describeCli: () => {
+      try {
+        return resolvePiCli(cliOptions);
+      } catch {
+        return void 0;
+      }
+    }
   };
 }
 
@@ -2722,6 +3254,7 @@ var HostSessionController = class {
         void this.warmDraft();
       } else {
         await this.runSessionChange(() => this.options.services.registry.activate(existingKey));
+        void this.refreshModels();
       }
     }
     void this.publishLists();
@@ -2814,6 +3347,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;
@@ -2978,7 +3514,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);
@@ -3311,6 +3847,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 }));
@@ -3318,6 +3855,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;
@@ -3350,6 +3904,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) {
@@ -3705,7 +4277,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
@@ -3733,7 +4305,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 };
@@ -3811,13 +4383,13 @@ import { spawn as spawnPty } from "node-pty";
 import { Inject as Inject2, Injectable } from "@nestjs/common";
 
 // ../server/src/internal/terminal/terminal-log.ts
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join as join5 } from "node:path";
+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 = readFileSync(logPath(dataDir, terminalId), "utf8");
+    const raw = readFileSync2(logPath(dataDir, terminalId), "utf8");
     return trimTail(raw, LOG_MAX_CHARS);
   } catch {
     return "";
@@ -3828,12 +4400,12 @@ function writeTerminalLog(dataDir, terminalId, text) {
   const target = logPath(dataDir, terminalId);
   const temp = `${target}.${process.pid}.tmp`;
   try {
-    mkdirSync(join5(dataDir, LOG_DIR), { recursive: true });
-    writeFileSync(temp, trimmed);
+    mkdirSync2(join6(dataDir, LOG_DIR), { recursive: true });
+    writeFileSync2(temp, trimmed);
     renameSync(temp, target);
   } catch {
     try {
-      writeFileSync(target, trimmed);
+      writeFileSync2(target, trimmed);
     } catch {
       rmSync(temp, { force: true });
     }
@@ -3847,7 +4419,7 @@ function safeTerminalName(terminalId) {
   return safe.length > 0 ? safe : "terminal";
 }
 function logPath(dataDir, terminalId) {
-  return join5(dataDir, LOG_DIR, `${safeTerminalName(terminalId)}.log`);
+  return join6(dataDir, LOG_DIR, `${safeTerminalName(terminalId)}.log`);
 }
 
 // ../server/src/internal/terminal/terminal.service.ts
@@ -4095,9 +4667,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 join6, 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 {
@@ -4117,7 +4689,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 : join6(cwd, uploadDir);
+  const directory = isAbsolute3(uploadDir) ? uploadDir : join7(cwd, uploadDir);
   await mkdir(directory, { recursive: true });
   const target = uniquePath(directory, name);
   await writeFile(target, bytes);
@@ -4136,10 +4708,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 = join6(directory, name);
+  let candidate = join7(directory, name);
   let suffix = 1;
-  while (existsSync(candidate)) {
-    candidate = join6(directory, `${stem}-${suffix}${extension}`);
+  while (existsSync2(candidate)) {
+    candidate = join7(directory, `${stem}-${suffix}${extension}`);
     suffix += 1;
   }
   return candidate;
@@ -4155,8 +4727,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 join7, 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",
@@ -4180,8 +4752,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: join7(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,
@@ -4195,7 +4767,7 @@ function shouldSkip(name) {
 }
 async function isGitRepo(path) {
   try {
-    await stat3(join7(path, ".git"));
+    await stat3(join8(path, ".git"));
     return true;
   } catch {
     return false;
@@ -4204,7 +4776,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;
     }
@@ -4266,7 +4838,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;
@@ -4317,9 +4889,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) {
@@ -4563,7 +5135,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 },
@@ -4579,7 +5151,7 @@ async function gitRun(args, cwd, timeout = 5e3) {
 }
 function gitExec(args, cwd, timeout = 5e3) {
   return new Promise((resolve6) => {
-    execFile(
+    execFile2(
       "git",
       args,
       {
@@ -4607,9 +5179,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 join8, 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",
@@ -4694,7 +5266,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 },
@@ -4720,7 +5292,7 @@ async function walk(root, directory, files) {
     if (files.length >= MAX_INDEXED_FILES) {
       return;
     }
-    const full = join8(directory, entry.name);
+    const full = join9(directory, entry.name);
     if (entry.isDirectory()) {
       if (SKIPPED_DIRECTORIES2.has(entry.name) || entry.name.startsWith(".")) {
         continue;
@@ -4738,20 +5310,20 @@ function toPosix3(path) {
 }
 
 // ../server/src/internal/workspace/workbench-store.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join9 } 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(join9(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(join9(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);
@@ -4759,7 +5331,7 @@ function saveDrafts(dataDir, snapshot) {
 function readSlot(path, maxBytes) {
   let raw;
   try {
-    raw = readFileSync2(path, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return void 0;
   }
@@ -4783,16 +5355,16 @@ 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 = join9(dataDir, file);
+  const target = join10(dataDir, file);
   const temp = `${target}.${process.pid}.tmp`;
   try {
-    mkdirSync2(dataDir, { recursive: true });
-    writeFileSync2(temp, serialized);
+    mkdirSync3(dataDir, { recursive: true });
+    writeFileSync3(temp, serialized);
     renameSync2(temp, target);
     return true;
   } catch {
     try {
-      writeFileSync2(target, serialized);
+      writeFileSync3(target, serialized);
       return true;
     } catch {
       rmSync2(temp, { force: true });
@@ -4814,13 +5386,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 {
@@ -4865,7 +5438,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) {
@@ -5010,6 +5586,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}".`);
     }
@@ -5059,7 +5660,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;
@@ -5068,6 +5670,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 {
@@ -5117,19 +5729,19 @@ MorseGateway = __decorateClass([
 ], MorseGateway);
 
 // ../server/src/app/config.ts
-import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute6, join as join10 } from "node:path";
-import { existsSync as existsSync2, readFileSync as readFileSync3 } 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 = join10(moduleDir, "ui");
-  const monorepoUiDir = join10(moduleDir, "..", "..", "..", "ui-angular", "dist");
-  const defaultUiDir = existsSync2(join10(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 : join10(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),
@@ -5153,7 +5765,7 @@ function loadConfig(env = process.env) {
 function readFrontendIdentity(uiDir) {
   try {
     return frontendIdentity(
-      parseFrontendManifest(readFileSync3(join10(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
+      parseFrontendManifest(readFileSync4(join11(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
     );
   } catch {
     return void 0;
@@ -5161,7 +5773,7 @@ function readFrontendIdentity(uiDir) {
 }
 function resolveDataDir(env) {
   const explicit = env.MORSE_HOME?.trim();
-  return explicit && explicit.length > 0 ? explicit : join10(homedir4(), ".morse");
+  return explicit && explicit.length > 0 ? explicit : join11(homedir5(), ".morse");
 }
 function parsePositiveInt(value, fallback) {
   if (!value) {
@@ -5188,11 +5800,11 @@ function resolveWorkspacePath(env) {
   const start = process.cwd();
   let directory = start;
   for (; ; ) {
-    const manifest = join10(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;
     }
@@ -5201,7 +5813,7 @@ function resolveWorkspacePath(env) {
 }
 function declaresWorkspaces(manifestPath) {
   try {
-    const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync4(manifestPath, "utf8"));
     return manifest.workspaces !== void 0;
   } catch {
     return false;