volute 0.48.0 → 0.50.0

package/dist/chunk-ALIVXDM4.js

@@ -0,0 +1,1014 @@
+#!/usr/bin/env node
+import {
+  clearMind,
+  summarizeOrphanedTurns
+} from "./chunk-7DXLIYPY.js";
+import {
+  deliverEvent,
+  recordNotice
+} from "./chunk-7OZWKHA3.js";
+import {
+  getPrompt
+} from "./chunk-5TPC4KCV.js";
+import {
+  isSandboxEnabled,
+  wrapForSandbox
+} from "./chunk-ZUG76D3P.js";
+import {
+  chownMindDir,
+  isIsolationEnabled,
+  wrapForIsolation
+} from "./chunk-AJWFDIEY.js";
+import {
+  loadMergedEnv
+} from "./chunk-7UWXAJMK.js";
+import {
+  getAiConfig,
+  resolveApiKey,
+  resolveOAuthCredentials
+} from "./chunk-632FJ23O.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  getSystemName,
+  mindDir,
+  mindTmpDir,
+  mindTmpEnv,
+  readGlobalConfig,
+  setMindRunning,
+  stateDir,
+  voluteSystemDir
+} from "./chunk-CAIYV33P.js";
+
+// packages/daemon/src/lib/util/json-state.ts
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { writeFile } from "fs/promises";
+function loadJsonMap(path) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    if (existsSync(path)) {
+      const raw = readFileSync(path, "utf-8").trim();
+      if (!raw) return map;
+      const data = JSON.parse(raw);
+      for (const [key, value] of Object.entries(data)) {
+        if (typeof value === "number") map.set(key, value);
+      }
+    }
+  } catch (err) {
+    console.warn(`[state] failed to load ${path}:`, err);
+  }
+  return map;
+}
+function saveJsonMap(path, map) {
+  const data = {};
+  for (const [key, value] of map) {
+    data[key] = value;
+  }
+  try {
+    writeFileSync(path, `${JSON.stringify(data)}
+`);
+  } catch (err) {
+    console.warn(`[state] failed to save ${path}:`, err);
+  }
+}
+async function saveJsonMapAsync(path, map) {
+  const data = {};
+  for (const [key, value] of map) {
+    data[key] = value;
+  }
+  try {
+    await writeFile(path, `${JSON.stringify(data)}
+`);
+  } catch (err) {
+    console.warn(`[state] failed to save ${path}:`, err);
+  }
+}
+function clearJsonMap(path, map) {
+  map.clear();
+  try {
+    if (existsSync(path)) unlinkSync(path);
+  } catch (err) {
+    console.warn(`[state] failed to clear ${path}:`, err);
+  }
+}
+
+// packages/daemon/src/lib/util/rotating-log.ts
+import { createWriteStream, existsSync as existsSync2, statSync } from "fs";
+import { access, rename, rm } from "fs/promises";
+import { Writable } from "stream";
+var MAX_SIZE = 10 * 1024 * 1024;
+var RotatingLog = class extends Writable {
+  constructor(path, maxSize = MAX_SIZE, maxFiles = 5) {
+    super();
+    this.path = path;
+    this.maxSize = maxSize;
+    this.maxFiles = maxFiles;
+    this.on("error", () => {
+    });
+    try {
+      this.size = existsSync2(path) ? statSync(path).size : 0;
+    } catch {
+      this.size = 0;
+    }
+    this.stream = createWriteStream(path, { flags: "a" });
+  }
+  stream;
+  size;
+  async rotateAsync() {
+    const oldest = `${this.path}.${this.maxFiles}`;
+    await access(oldest).then(() => rm(oldest)).catch(() => {
+    });
+    for (let i = this.maxFiles - 1; i >= 1; i--) {
+      const from = `${this.path}.${i}`;
+      const to = `${this.path}.${i + 1}`;
+      await access(from).then(() => rename(from, to)).catch(() => {
+      });
+    }
+    await rename(this.path, `${this.path}.1`);
+    const oldStream = this.stream;
+    this.stream = createWriteStream(this.path);
+    oldStream.end();
+  }
+  _write(chunk, _encoding, callback) {
+    this.size += chunk.length;
+    if (this.size > this.maxSize) {
+      this.rotateAsync().then(() => {
+        this.size = chunk.length;
+        this.stream.write(chunk, callback);
+      }).catch(() => {
+        this.size = chunk.length;
+        this.stream.write(chunk, callback);
+      });
+      return;
+    }
+    this.stream.write(chunk, callback);
+  }
+  _final(callback) {
+    this.stream.end(callback);
+  }
+};
+
+// packages/daemon/src/lib/daemon/credential-sync.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+var slog = logger_default.child("cred-sync");
+async function writeClaudeCredentials(homeDir, baseName, oauth) {
+  const claudeDir = resolve(homeDir, ".claude");
+  mkdirSync(claudeDir, { recursive: true });
+  writeFileSync2(
+    resolve(claudeDir, ".credentials.json"),
+    JSON.stringify({
+      claudeAiOauth: {
+        accessToken: oauth.access,
+        refreshToken: oauth.refresh,
+        expiresAt: oauth.expires ? new Date(oauth.expires).toISOString() : null,
+        scopes: ["user:inference", "user:profile"]
+      }
+    }),
+    { mode: 384 }
+  );
+  if (isIsolationEnabled()) {
+    await chownMindDir(claudeDir, baseName);
+  }
+  return claudeDir;
+}
+async function writePiProviderKey(piAgentDir, baseName, provider, key) {
+  mkdirSync(piAgentDir, { recursive: true });
+  const authPath = resolve(piAgentDir, "auth.json");
+  const authData = existsSync3(authPath) ? JSON.parse(readFileSync2(authPath, "utf-8")) : {};
+  authData[provider] = { type: "api_key", key };
+  writeFileSync2(authPath, JSON.stringify(authData, null, 2), { mode: 384 });
+  if (isIsolationEnabled()) {
+    await chownMindDir(piAgentDir, baseName);
+  }
+}
+async function writePiProviderOAuth(piAgentDir, baseName, provider, oauth) {
+  mkdirSync(piAgentDir, { recursive: true });
+  const authPath = resolve(piAgentDir, "auth.json");
+  const authData = existsSync3(authPath) ? JSON.parse(readFileSync2(authPath, "utf-8")) : {};
+  authData[provider] = { type: "oauth", ...oauth };
+  writeFileSync2(authPath, JSON.stringify(authData, null, 2), { mode: 384 });
+  if (isIsolationEnabled()) {
+    await chownMindDir(piAgentDir, baseName);
+  }
+}
+function piUsesProvider(piAgentDir, provider) {
+  try {
+    const authPath = resolve(piAgentDir, "auth.json");
+    if (!existsSync3(authPath)) return false;
+    const data = JSON.parse(readFileSync2(authPath, "utf-8"));
+    return data[provider] != null;
+  } catch {
+    return false;
+  }
+}
+async function syncProviderToMinds(provider, deps = {}) {
+  if (provider !== "anthropic" && provider !== "xai") return;
+  const getOauth = deps.getOauth ?? (() => getAiConfig()?.providers[provider]?.oauth);
+  const oauth = getOauth();
+  if (!oauth?.access) return;
+  const listRunning = deps.listRunning ?? (() => []);
+  const lookup = deps.lookup ?? findMind;
+  for (const name of listRunning()) {
+    try {
+      const entry = await lookup(name);
+      if (!entry) continue;
+      const dir = entry.dir ?? mindDir(name);
+      const baseName = entry.parent ?? name;
+      const template = entry.template;
+      if (template === "pi") {
+        const piAgentDir = resolve(dir, ".mind", "pi-agent");
+        if (piUsesProvider(piAgentDir, provider)) {
+          await writePiProviderKey(piAgentDir, baseName, provider, oauth.access);
+        }
+      } else if (provider === "anthropic" && (template === "claude" || !template)) {
+        await writeClaudeCredentials(resolve(dir, "home"), baseName, oauth);
+      }
+    } catch (err) {
+      slog.error(`failed to sync ${provider} credentials to mind ${name}`, logger_default.errorData(err));
+    }
+  }
+}
+
+// packages/daemon/src/lib/daemon/mind-tokens.ts
+import { randomUUID } from "crypto";
+var tokenToMind = /* @__PURE__ */ new Map();
+var mindToToken = /* @__PURE__ */ new Map();
+function generateMindToken(mindName) {
+  revokeMindToken(mindName);
+  const token = randomUUID();
+  tokenToMind.set(token, mindName);
+  mindToToken.set(mindName, token);
+  return token;
+}
+function revokeMindToken(mindName) {
+  const token = mindToToken.get(mindName);
+  if (token) {
+    tokenToMind.delete(token);
+    mindToToken.delete(mindName);
+  }
+}
+function resolveMindToken(token) {
+  return tokenToMind.get(token) ?? null;
+}
+function getMindToken(mindName) {
+  return mindToToken.get(mindName) ?? null;
+}
+
+// packages/daemon/src/lib/daemon/mind-manager.ts
+import { execFile, spawn } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+import { promisify } from "util";
+
+// packages/daemon/src/lib/util/health.ts
+async function checkHealth(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return { ok: false };
+    const data = await res.json();
+    return { ok: true, name: data.name };
+  } catch {
+    return { ok: false };
+  }
+}
+
+// packages/daemon/src/lib/daemon/restart-tracker.ts
+var DEFAULT_MAX_ATTEMPTS = 5;
+var DEFAULT_BASE_DELAY = 3e3;
+var DEFAULT_MAX_DELAY = 6e4;
+var RestartTracker = class {
+  attempts = /* @__PURE__ */ new Map();
+  maxAttempts;
+  baseDelay;
+  maxDelay;
+  constructor(opts) {
+    this.maxAttempts = opts?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    this.baseDelay = opts?.baseDelay ?? DEFAULT_BASE_DELAY;
+    this.maxDelay = opts?.maxDelay ?? DEFAULT_MAX_DELAY;
+  }
+  recordCrash(key) {
+    const attempts = this.attempts.get(key) ?? 0;
+    if (attempts >= this.maxAttempts) {
+      return { shouldRestart: false, delay: 0, attempt: attempts };
+    }
+    const delay = Math.min(this.baseDelay * 2 ** attempts, this.maxDelay);
+    this.attempts.set(key, attempts + 1);
+    return { shouldRestart: true, delay, attempt: attempts + 1 };
+  }
+  reset(key) {
+    return this.attempts.delete(key);
+  }
+  getAttempts(key) {
+    return this.attempts.get(key) ?? 0;
+  }
+  get maxRestartAttempts() {
+    return this.maxAttempts;
+  }
+  /** Bulk-load attempts from a Map (for persistence). */
+  load(data) {
+    this.attempts = new Map(data);
+  }
+  /** Export current attempts as a Map (for persistence). */
+  save() {
+    return new Map(this.attempts);
+  }
+  clear() {
+    this.attempts.clear();
+  }
+};
+
+// packages/daemon/src/lib/daemon/mind-manager.ts
+var mlog = logger_default.child("minds");
+var execFileAsync = promisify(execFile);
+var DAEMON_ONLY_OAUTH = /* @__PURE__ */ new Set(["xai"]);
+var MIND_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LANGUAGE",
+  "LC_ALL",
+  "LC_CTYPE",
+  "LC_MESSAGES",
+  "TERM",
+  "TERMINFO",
+  "COLORTERM",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "TZ",
+  "NODE_ENV",
+  "__CF_USER_TEXT_ENCODING",
+  // Outbound proxy / custom-CA config — required for minds' HTTPS calls (incl.
+  // the Anthropic API) to succeed on hosts that reach the internet only via a
+  // corporate proxy or custom CA bundle. Previously inherited via ...process.env.
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR"
+];
+function buildMindBaseEnv(source = process.env) {
+  const base = {};
+  for (const key of MIND_ENV_ALLOWLIST) {
+    if (source[key] !== void 0) base[key] = source[key];
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "VOLUTE_DAEMON_TOKEN") continue;
+    if (key.startsWith("VOLUTE_")) base[key] = value;
+  }
+  return base;
+}
+var MindStartupError = class extends Error {
+  constructor(message, stderr) {
+    super(message);
+    this.stderr = stderr;
+    this.name = "MindStartupError";
+  }
+};
+function mindPidPath(name) {
+  return resolve2(stateDir(name), "mind.pid");
+}
+function lifecycleSubtype(type) {
+  switch (type) {
+    case "merge":
+    case "merged":
+      return "merge";
+    case "split":
+      return "split";
+    case "sprouted":
+      return "sprout";
+    case "upgraded":
+      return "upgrade";
+    default:
+      return "restart";
+  }
+}
+async function buildPendingContextMessage(name, context) {
+  const parts = [];
+  if (context.type === "merge" || context.type === "merged") {
+    parts.push(await getPrompt("merge_message", { name: String(context.name ?? "") }));
+  } else if (context.type === "split") {
+    parts.push(await getPrompt("split_message", { name, parent: String(context.parent ?? "") }));
+    if (context.purpose) parts.push(`Why you were split off: ${String(context.purpose)}`);
+  } else if (context.type === "sprouted") {
+    parts.push(await getPrompt("sprout_message", { system: getSystemName() }));
+  } else if (context.type === "upgraded") {
+    parts.push(await getPrompt("upgrade_message"));
+  } else {
+    parts.push(await getPrompt("restart_message"));
+  }
+  if (context.summary) parts.push(`Changes: ${context.summary}`);
+  if (context.justification) parts.push(`Why: ${context.justification}`);
+  if (context.memory) parts.push(`Context: ${context.memory}`);
+  if (context.memoryDelta) {
+    parts.push(
+      `
+Your variant's memory & journal (not merged \u2014 integrate into your own memory what you want to keep):
+${context.memoryDelta}`
+    );
+  }
+  if (context.farewell)
+    parts.push(`Your variant's parting note (this was you, winding down):
+${context.farewell}`);
+  return parts.join("\n");
+}
+var MindManager = class {
+  minds = /* @__PURE__ */ new Map();
+  stopping = /* @__PURE__ */ new Set();
+  shuttingDown = false;
+  restartTracker = new RestartTracker();
+  pendingContext = /* @__PURE__ */ new Map();
+  // Per-name lifecycle mutex: start/stop/restart for a given mind serialize so
+  // concurrent callers can't double-spawn or have a loser's cleanup delete the
+  // winner's tracked child.
+  locks = /* @__PURE__ */ new Map();
+  /** Run `fn` after any in-flight lifecycle op for `name` settles, serializing per name. */
+  withLock(name, fn) {
+    const prev = this.locks.get(name) ?? Promise.resolve();
+    const result = prev.then(fn, fn);
+    const tail = result.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.locks.set(name, tail);
+    tail.finally(() => {
+      if (this.locks.get(name) === tail) this.locks.delete(name);
+    });
+    return result;
+  }
+  async resolveTarget(name) {
+    const entry = await findMind(name);
+    if (!entry) throw new Error(`Unknown mind: ${name}`);
+    if (entry.parent) {
+      if (!entry.dir) throw new Error(`Variant ${name} has no directory`);
+      return { dir: entry.dir, port: entry.port, baseName: entry.parent, template: entry.template };
+    }
+    const dir = entry.dir ?? mindDir(name);
+    if (!existsSync4(dir)) throw new Error(`Mind directory missing: ${dir}`);
+    return { dir, port: entry.port, baseName: name, template: entry.template };
+  }
+  async startMind(name) {
+    return this.withLock(name, () => this._startMind(name));
+  }
+  async _startMind(name) {
+    if (this.minds.has(name)) {
+      throw new Error(`Mind ${name} is already running`);
+    }
+    const target = await this.resolveTarget(name);
+    const { dir, baseName } = target;
+    const port = target.port;
+    const pidFile = mindPidPath(name);
+    try {
+      if (existsSync4(pidFile)) {
+        const stalePid = parseInt(readFileSync3(pidFile, "utf-8").trim(), 10);
+        if (stalePid > 0) {
+          try {
+            process.kill(stalePid, 0);
+            const { stdout } = await execFileAsync("ps", ["-p", String(stalePid), "-o", "args="]);
+            if (stdout.includes("server.ts")) {
+              mlog.warn(`killing stale mind process ${stalePid} for ${name}`);
+              process.kill(-stalePid, "SIGTERM");
+              await new Promise((r) => setTimeout(r, 500));
+            } else {
+              mlog.debug(`stale PID ${stalePid} for ${name} is not a mind process, skipping`);
+            }
+          } catch (err) {
+            if (err.code !== "ESRCH") {
+              mlog.warn(`failed to check/kill stale process for ${name}`, logger_default.errorData(err));
+            }
+          }
+        }
+        rmSync(pidFile, { force: true });
+      }
+    } catch (err) {
+      mlog.warn(`failed to read PID file for ${name}`, logger_default.errorData(err));
+    }
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (res.ok) {
+        mlog.warn(`killing orphan process on port ${port}`);
+        await killProcessOnPort(port);
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    } catch {
+    }
+    const mindStateDir = stateDir(name);
+    const logsDir = resolve2(mindStateDir, "logs");
+    mkdirSync2(logsDir, { recursive: true });
+    const mindTmp = mindTmpDir(dir);
+    mkdirSync2(mindTmp, { recursive: true });
+    if (isIsolationEnabled()) {
+      try {
+        await chownMindDir(mindStateDir, baseName);
+        await chownMindDir(resolve2(dir, ".mind"), baseName);
+      } catch (err) {
+        throw new Error(
+          `Cannot start mind ${name}: failed to set ownership on state directory ${mindStateDir}: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+    const logStream = new RotatingLog(resolve2(logsDir, "mind.log"));
+    const mindToken = generateMindToken(name);
+    const mindEnv = loadMergedEnv(name);
+    const mindLocalBin = resolve2(dir, "home", ".local", "bin");
+    const currentPath = process.env.PATH ?? "";
+    const env = {
+      ...buildMindBaseEnv(),
+      ...mindEnv,
+      VOLUTE_MIND: name,
+      VOLUTE_STATE_DIR: stateDir(name),
+      VOLUTE_MIND_DIR: dir,
+      VOLUTE_MIND_PORT: String(port),
+      VOLUTE_MIND_TOKEN: mindToken,
+      // Left unset when the system has no configured name — the startup-context
+      // hook then skips its "This system is named X" line rather than asserting
+      // a fabricated one.
+      VOLUTE_SYSTEM_NAME: readGlobalConfig().name,
+      ...mindTmpEnv(dir),
+      PATH: `${mindLocalBin}:${currentPath}`,
+      // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
+      CLAUDECODE: void 0
+    };
+    if (target.template === "pi") {
+      try {
+        const configPath = resolve2(dir, "home/.config/config.json");
+        if (existsSync4(configPath)) {
+          const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+          const modelStr = config.model;
+          if (modelStr?.includes(":")) {
+            const provider = modelStr.split(":")[0];
+            const piAgentDir = resolve2(dir, ".mind", "pi-agent");
+            const oauthCreds = await resolveOAuthCredentials(provider);
+            if (oauthCreds && !DAEMON_ONLY_OAUTH.has(provider)) {
+              await writePiProviderOAuth(piAgentDir, baseName, provider, oauthCreds);
+              env.PI_CODING_AGENT_DIR = piAgentDir;
+            } else {
+              const apiKey = oauthCreds?.access ?? await resolveApiKey(provider);
+              if (apiKey) {
+                await writePiProviderKey(piAgentDir, baseName, provider, apiKey);
+                env.PI_CODING_AGENT_DIR = piAgentDir;
+                const providerEnvVars = {
+                  openrouter: "OPENROUTER_API_KEY",
+                  openai: "OPENAI_API_KEY",
+                  anthropic: "ANTHROPIC_API_KEY",
+                  google: "GEMINI_API_KEY",
+                  groq: "GROQ_API_KEY",
+                  cerebras: "CEREBRAS_API_KEY",
+                  xai: "XAI_API_KEY",
+                  mistral: "MISTRAL_API_KEY",
+                  zai: "ZAI_API_KEY"
+                };
+                const providerEnv = providerEnvVars[provider];
+                if (providerEnv) env[providerEnv] = apiKey;
+              } else {
+                mlog.warn(
+                  `no API key found for provider "${provider}" \u2014 mind ${name} may fail to start`
+                );
+              }
+            }
+          }
+        }
+      } catch (err) {
+        mlog.error(`failed to inject AI provider key for ${name}`, logger_default.errorData(err));
+      }
+    }
+    if (target.template === "codex") {
+      try {
+        const ai = getAiConfig();
+        const codexConfig = ai?.providers["openai-codex"];
+        if (codexConfig?.oauth) {
+          const codexDir = resolve2(dir, ".mind", "codex");
+          mkdirSync2(codexDir, { recursive: true });
+          env.CODEX_HOME = codexDir;
+          const authPath = resolve2(codexDir, "auth.json");
+          writeFileSync3(
+            authPath,
+            JSON.stringify({
+              auth_mode: "chatgpt",
+              tokens: {
+                access_token: codexConfig.oauth.access,
+                refresh_token: codexConfig.oauth.refresh,
+                id_token: codexConfig.oauth.access
+              },
+              last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+            }),
+            { mode: 384 }
+          );
+          const configTomlPath = resolve2(codexDir, "config.toml");
+          if (!existsSync4(configTomlPath)) {
+            writeFileSync3(configTomlPath, 'cli_auth_credentials_store = "file"\n');
+          }
+          if (isIsolationEnabled()) {
+            await chownMindDir(codexDir, baseName);
+          }
+        } else {
+          const apiKey = await resolveApiKey("openai-codex");
+          if (apiKey) {
+            env.OPENAI_API_KEY = apiKey;
+          } else if (process.env.OPENAI_API_KEY) {
+            env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+          }
+        }
+      } catch (err) {
+        mlog.error(`failed to resolve OpenAI API key for ${name}`, logger_default.errorData(err));
+        if (process.env.OPENAI_API_KEY) {
+          env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+        }
+      }
+      const homeDir = resolve2(dir, "home");
+      const zshenvLines = Object.entries(env).filter(([k, v]) => k.startsWith("VOLUTE_") && v != null).map(([k, v]) => `export ${k}=${JSON.stringify(v)}`);
+      zshenvLines.push(`export PATH=${JSON.stringify(env.PATH ?? "")}`);
+      writeFileSync3(resolve2(homeDir, ".zshenv"), `${zshenvLines.join("\n")}
+`, { mode: 384 });
+    }
+    if (target.template === "claude" || !target.template) {
+      try {
+        const ai = getAiConfig();
+        const anthropicConfig = ai?.providers.anthropic;
+        if (anthropicConfig?.oauth) {
+          const key = await resolveApiKey("anthropic");
+          const oauth = getAiConfig()?.providers.anthropic?.oauth;
+          if (key && oauth) {
+            const claudeDir = await writeClaudeCredentials(resolve2(dir, "home"), baseName, oauth);
+            env.CLAUDE_CONFIG_DIR = claudeDir;
+          }
+        } else {
+          const apiKey = await resolveApiKey("anthropic");
+          if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+        }
+      } catch (err) {
+        mlog.error(`failed to inject Anthropic credentials for ${name}`, logger_default.errorData(err));
+      }
+    }
+    if (isIsolationEnabled()) {
+      env.HOME = resolve2(dir, "home");
+    }
+    const baseBin = process.env.VOLUTE_NODE_PATH ?? process.execPath;
+    const baseArgs = ["--import", "tsx", "src/server.ts", "--port", String(port)];
+    let spawnCmd;
+    let spawnArgs;
+    if (isIsolationEnabled()) {
+      [spawnCmd, spawnArgs] = await wrapForIsolation(baseBin, baseArgs, name);
+    } else if (isSandboxEnabled() && target.template !== "codex") {
+      [spawnCmd, spawnArgs] = await wrapForSandbox(baseBin, baseArgs, dir, name, [
+        dir,
+        mindStateDir,
+        mindTmp
+      ]);
+    } else {
+      spawnCmd = baseBin;
+      spawnArgs = baseArgs;
+    }
+    const spawnOpts = {
+      cwd: dir,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      env
+    };
+    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
+    this.minds.set(name, { child, port });
+    child.stdout?.pipe(logStream);
+    child.stderr?.pipe(logStream);
+    const recentStderr = [];
+    child.stderr?.on("data", (data) => {
+      const lines = data.toString().split("\n").filter(Boolean);
+      recentStderr.push(...lines);
+      while (recentStderr.length > 20) recentStderr.shift();
+    });
+    try {
+      await new Promise((resolve3, reject) => {
+        let settled = false;
+        const deadline = Date.now() + 3e4;
+        const onExit = (code) => {
+          const errorLine = recentStderr.find((l) => l.includes("Error:"));
+          const detail = errorLine ? `: ${errorLine.trim()}` : "";
+          finish(
+            () => reject(
+              new MindStartupError(
+                `Mind ${name} exited with code ${code} during startup${detail}`,
+                recentStderr.join("\n")
+              )
+            )
+          );
+        };
+        const onError = (err) => finish(() => reject(err));
+        function finish(action) {
+          if (settled) return;
+          settled = true;
+          child.off("exit", onExit);
+          child.off("error", onError);
+          action();
+        }
+        child.on("exit", onExit);
+        child.on("error", onError);
+        const poll = async () => {
+          if (settled) return;
+          const { ok } = await checkHealth(port);
+          if (settled) return;
+          if (ok) {
+            finish(() => resolve3());
+            return;
+          }
+          if (Date.now() >= deadline) {
+            finish(
+              () => reject(
+                new MindStartupError(
+                  `Mind ${name} did not become healthy within 30s`,
+                  recentStderr.join("\n")
+                )
+              )
+            );
+            return;
+          }
+          setTimeout(poll, 250);
+        };
+        void poll();
+      });
+    } catch (err) {
+      this.minds.delete(name);
+      try {
+        child.kill();
+      } catch {
+      }
+      throw err;
+    }
+    if (child.pid) {
+      try {
+        writeFileSync3(pidFile, String(child.pid));
+      } catch (err) {
+        mlog.warn(`failed to write PID file for ${name}`, logger_default.errorData(err));
+      }
+    }
+    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
+    this.setupCrashRecovery(name, child);
+    await setMindRunning(name, true);
+    mlog.info(`started mind ${name} on port ${port}`);
+    await this.deliverPendingContext(name);
+    try {
+      const { getSleepManagerIfReady } = await import("./sleep-manager-LIEPO6WG.js");
+      if (!getSleepManagerIfReady()?.isSleeping(name)) {
+        const { flushQueuedEvents } = await import("./system-events-A6IGCEC3.js");
+        const flushed = await flushQueuedEvents(name);
+        if (flushed > 0) mlog.info(`redelivered ${flushed} pending event(s) to ${name}`);
+      }
+    } catch (err) {
+      mlog.warn(`failed to flush pending events for ${name} on start`, logger_default.errorData(err));
+    }
+  }
+  setPendingContext(name, context) {
+    this.pendingContext.set(name, context);
+  }
+  /** Deliver pending context (merge info, sprout, restart) directly to the mind via HTTP.
+   *  Intentionally bypasses DeliveryManager — these are system messages that should not be
+   *  routed, gated, or batched. */
+  async deliverPendingContext(name) {
+    const context = this.pendingContext.get(name);
+    if (!context) return;
+    const tracked = this.minds.get(name);
+    if (!tracked) return;
+    this.pendingContext.delete(name);
+    const content = await buildPendingContextMessage(name, context);
+    const subtype = lifecycleSubtype(context.type);
+    await deliverEvent(name, {
+      type: "lifecycle",
+      body: content,
+      meta: { subtype, ...context.type ? { rawType: String(context.type) } : {} },
+      force: true
+    });
+  }
+  setupCrashRecovery(name, child) {
+    child.on("exit", async (code) => {
+      if (this.minds.get(name)?.child !== child) return;
+      this.minds.delete(name);
+      if (this.shuttingDown || this.stopping.has(name)) return;
+      mlog.error(`mind ${name} exited with code ${code}`);
+      try {
+        const { getSleepManagerIfReady } = await import("./sleep-manager-LIEPO6WG.js");
+        const sleepMgr = getSleepManagerIfReady();
+        const sleepState = sleepMgr?.getState(name);
+        if (sleepState?.sleeping) {
+          if (sleepState.wokenByTrigger && sleepMgr) {
+            mlog.info(`${name} crashed during trigger wake \u2014 returning to sleep`);
+            void sleepMgr.returnToSleepAfterCrash(name);
+          } else {
+            mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
+          }
+          return;
+        }
+      } catch (err) {
+        mlog.warn(`failed to check sleep state for ${name}`, logger_default.errorData(err));
+      }
+      clearMind(name).then((orphaned) => {
+        summarizeOrphanedTurns(orphaned);
+        for (const { session } of orphaned) {
+          void recordNotice({
+            mind: name,
+            thread: session ?? "main",
+            kind: "crash",
+            reason: "process_crash",
+            detail: "Your process crashed mid-turn and was automatically restarted. That turn was interrupted before it finished \u2014 check whether you left anything incomplete."
+          });
+        }
+      }).catch(
+        (err) => mlog.warn(`failed to clear turn state for ${name} after crash`, logger_default.errorData(err))
+      );
+      try {
+        const { getDeliveryManager } = await import("./delivery-manager-B4OKWD2P.js");
+        getDeliveryManager().clearMindSessions(name);
+      } catch (err) {
+        if (!(err instanceof Error && err.message.includes("not initialized"))) {
+          mlog.warn(`failed to clear delivery state for ${name} after crash`, logger_default.errorData(err));
+        }
+      }
+      import("./mind-activity-tracker-L7GCYXQR.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-H7YI3BTF.js").then(
+        ({ publish }) => publish({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
+      ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));
+      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
+      this.saveCrashAttempts();
+      if (!shouldRestart) {
+        mlog.error(`${name} crashed ${attempt} times \u2014 giving up on restart`);
+        await setMindRunning(name, false);
+        return;
+      }
+      mlog.info(
+        `crash recovery for ${name} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, restarting in ${delay}ms`
+      );
+      setTimeout(() => {
+        if (this.shuttingDown) return;
+        this.startMind(name).catch((err) => {
+          mlog.error(`failed to restart ${name}`, logger_default.errorData(err));
+        });
+      }, delay);
+    });
+  }
+  async stopMind(name) {
+    return this.withLock(name, () => this._stopMind(name));
+  }
+  async _stopMind(name) {
+    const tracked = this.minds.get(name);
+    if (!tracked) return;
+    this.stopping.add(name);
+    const { child } = tracked;
+    this.minds.delete(name);
+    await new Promise((resolve3) => {
+      const killTimer = setTimeout(() => {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+        resolve3();
+      }, 5e3);
+      child.on("exit", () => {
+        clearTimeout(killTimer);
+        resolve3();
+      });
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        clearTimeout(killTimer);
+        resolve3();
+      }
+    });
+    this.stopping.delete(name);
+    revokeMindToken(name);
+    try {
+      const orphanedTurns = await clearMind(name);
+      summarizeOrphanedTurns(orphanedTurns);
+    } catch (err) {
+      mlog.warn(`failed to clear turn state for ${name} on stop`, logger_default.errorData(err));
+    }
+    try {
+      const { getDeliveryManager } = await import("./delivery-manager-B4OKWD2P.js");
+      getDeliveryManager().clearMindSessions(name);
+    } catch (err) {
+      if (!(err instanceof Error && err.message.includes("not initialized"))) {
+        mlog.warn(`failed to clear delivery state for ${name} on stop`, logger_default.errorData(err));
+      }
+    }
+    try {
+      const { clearEchoTextCache } = await import("./echo-text-WYAAODBV.js");
+      clearEchoTextCache(name);
+    } catch (err) {
+      mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
+    }
+    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
+    rmSync(mindPidPath(name), { force: true });
+    if (!this.shuttingDown) {
+      await setMindRunning(name, false);
+    }
+    mlog.info(`stopped mind ${name}`);
+  }
+  async restartMind(name) {
+    return this.withLock(name, async () => {
+      await this._stopMind(name);
+      await this._startMind(name);
+    });
+  }
+  async stopAll() {
+    this.shuttingDown = true;
+    const names = [...this.minds.keys()];
+    await Promise.all(names.map((name) => this.stopMind(name)));
+  }
+  isRunning(name) {
+    return this.minds.has(name);
+  }
+  /**
+   * True when crash recovery for this mind has used up all restart attempts (the
+   * "giving up on restart" state). Cleared by the tracker reset on the next
+   * successful start or explicit stop.
+   */
+  hasExhaustedRestarts(name) {
+    return this.restartTracker.getAttempts(name) >= this.restartTracker.maxRestartAttempts;
+  }
+  getRunningMinds() {
+    return [...this.minds.keys()];
+  }
+  get crashAttemptsPath() {
+    return resolve2(voluteSystemDir(), "crash-attempts.json");
+  }
+  loadCrashAttempts() {
+    this.restartTracker.load(loadJsonMap(this.crashAttemptsPath));
+  }
+  saveCrashAttempts() {
+    saveJsonMap(this.crashAttemptsPath, this.restartTracker.save());
+  }
+  clearCrashAttempts() {
+    this.restartTracker.clear();
+    clearJsonMap(this.crashAttemptsPath, /* @__PURE__ */ new Map());
+  }
+};
+async function killProcessOnPort(port) {
+  try {
+    const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
+    const pids = /* @__PURE__ */ new Set();
+    for (const line of stdout.trim().split("\n").filter(Boolean)) {
+      const pid = parseInt(line, 10);
+      pids.add(pid);
+      try {
+        const { stdout: psOut } = await execFileAsync("ps", ["-p", String(pid), "-o", "pgid="]);
+        const pgid = parseInt(psOut.trim(), 10);
+        if (pgid > 1) pids.add(pgid);
+      } catch {
+      }
+    }
+    for (const pid of pids) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var instance = null;
+function initMindManager() {
+  if (instance) throw new Error("MindManager already initialized");
+  instance = new MindManager();
+  return instance;
+}
+function getMindManager() {
+  if (!instance) throw new Error("MindManager not initialized \u2014 call initMindManager() first");
+  return instance;
+}
+function tryGetMindManager() {
+  return instance;
+}
+
+export {
+  checkHealth,
+  loadJsonMap,
+  saveJsonMapAsync,
+  clearJsonMap,
+  RotatingLog,
+  syncProviderToMinds,
+  generateMindToken,
+  resolveMindToken,
+  getMindToken,
+  RestartTracker,
+  buildMindBaseEnv,
+  MindStartupError,
+  initMindManager,
+  getMindManager,
+  tryGetMindManager
+};