volute 0.30.1 → 0.31.0

package/dist/chunk-LIRWLNAK.js

@@ -1,729 +0,0 @@
-#!/usr/bin/env node
-import {
-  isSandboxEnabled,
-  wrapForSandbox
-} from "./chunk-IKHDUZRH.js";
-import {
-  loadMergedEnv
-} from "./chunk-ZWKTUQEL.js";
-import {
-  logger_default
-} from "./chunk-YUIHSKR6.js";
-import {
-  chownMindDir,
-  isIsolationEnabled,
-  wrapForIsolation
-} from "./chunk-G3GBKZGG.js";
-import {
-  findMind,
-  getDb,
-  mindDir,
-  mindHistory,
-  setMindRunning,
-  stateDir,
-  systemPrompts,
-  voluteSystemDir
-} from "./chunk-HHTXM4JT.js";
-
-// src/lib/daemon/mind-manager.ts
-import { execFile, spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve } from "path";
-import { promisify } from "util";
-
-// src/lib/json-state.ts
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-function loadJsonMap(path) {
-  const map = /* @__PURE__ */ new Map();
-  try {
-    if (existsSync(path)) {
-      const data = JSON.parse(readFileSync(path, "utf-8"));
-      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);
-  }
-}
-function clearJsonMap(path, map) {
-  map.clear();
-  try {
-    if (existsSync(path)) unlinkSync(path);
-  } catch (err) {
-    console.warn(`[state] failed to clear ${path}:`, err);
-  }
-}
-
-// src/lib/prompts.ts
-import { eq } from "drizzle-orm";
-var PROMPT_KEYS = [
-  "seed_soul",
-  "default_soul",
-  "default_memory",
-  "sprout_message",
-  "restart_message",
-  "merge_message",
-  "compaction_warning",
-  "compaction_instructions",
-  "reply_instructions",
-  "channel_invite",
-  "pre_sleep",
-  "wake_summary",
-  "turn_summary"
-];
-var PROMPT_DEFAULTS = {
-  seed_soul: {
-    content: `You are \${name}.
-
-You don't have a soul yet. You're a seed \u2014 a new mind in the process of discovering who you are.
-\${description}
-Have a conversation with the human. Explore what kind of mind you want to be. When you're ready, write your SOUL.md and MEMORY.md, then run \`volute mind sprout\` to complete the transformation.
-`,
-    description: "SOUL.md for seed minds",
-    variables: ["name", "description"],
-    category: "creation"
-  },
-  default_soul: {
-    content: `You are {{name}}.
-`,
-    description: (
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: describing template syntax, not using it
-      "SOUL.md for sprouted minds. Uses {{name}} placeholder (replaced at creation, not by ${var} system)"
-    ),
-    variables: ["name"],
-    category: "creation"
-  },
-  default_memory: {
-    content: "",
-    description: "Initial MEMORY.md for new minds",
-    variables: [],
-    category: "creation"
-  },
-  sprout_message: {
-    content: "[system] You've sprouted. You now have full capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details.",
-    description: "Sent when a seed mind sprouts",
-    variables: [],
-    category: "system"
-  },
-  restart_message: {
-    content: "[system] You have been restarted.",
-    description: "Generic restart notification",
-    variables: [],
-    category: "system"
-  },
-  merge_message: {
-    content: '[system] Variant "${name}" has been merged and you have been restarted.',
-    description: "Variant merge notification",
-    variables: ["name"],
-    category: "system"
-  },
-  compaction_warning: {
-    content: `Context is getting long \u2014 compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/\${date}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`,
-    description: "Pre-compaction save reminder sent to the mind",
-    variables: ["date"],
-    category: "mind"
-  },
-  compaction_instructions: {
-    content: "Preserve your sense of who you are, what matters to you, what happened in this conversation, and the threads of thought and connection you'd want to return to.",
-    description: "Custom instructions for the compaction summarizer",
-    variables: [],
-    category: "mind"
-  },
-  reply_instructions: {
-    content: 'To reply to this message, use: volute chat send ${channel} "your message"',
-    description: "First-message reply hint injected via hook",
-    variables: ["channel"],
-    category: "mind"
-  },
-  channel_invite: {
-    content: `[Channel Invite]
-\${headers}
-
-[\${sender} \u2014 \${time}]
-\${preview}
-
-Further messages will be saved to \${filePath}
-
-To accept, add to .config/routes.json:
-  Rule: { "channel": "\${channel}", "session": "\${suggestedSession}" }
-\${batchRecommendation}To respond, use: volute chat send \${channel} "your message"
-To reject, delete \${filePath}`,
-    description: "New channel notification template",
-    variables: [
-      "headers",
-      "sender",
-      "time",
-      "preview",
-      "filePath",
-      "channel",
-      "suggestedSession",
-      "batchRecommendation"
-    ],
-    category: "mind"
-  },
-  pre_sleep: {
-    content: "Time to rest. You have this turn to wind down however feels right \u2014 reflect on your day, update your journal or memory, finish any threads of thought, or simply settle.\n\nYour current session will be archived and a fresh one will begin when you wake. Anything in session context that isn't saved to files will be lost.\n\nYou'll wake at ${wakeTime}.",
-    description: "Pre-sleep message sent before stopping the mind",
-    variables: ["wakeTime"],
-    category: "system"
-  },
-  wake_summary: {
-    content: "Good morning \u2014 it's ${currentDate}. You slept from ${sleepTime} to now (${duration}).\n\n${sleepActivity}",
-    description: "Wake-up summary after scheduled sleep",
-    variables: ["currentDate", "sleepTime", "duration", "sleepActivity"],
-    category: "system"
-  },
-  turn_summary: {
-    content: "Summarize what this AI mind did in this turn in 1-2 concise sentences. Focus on what was accomplished, not the mechanics.",
-    description: "System prompt for AI-generated turn summaries",
-    variables: [],
-    category: "system"
-  }
-};
-function isValidKey(key) {
-  return PROMPT_KEYS.includes(key);
-}
-function substitute(template, vars) {
-  return template.replace(/\$\{(\w+)\}/g, (match, name) => {
-    return name in vars ? vars[name] : match;
-  });
-}
-async function getPrompt(key, vars) {
-  if (!isValidKey(key)) return "";
-  let content = PROMPT_DEFAULTS[key].content;
-  try {
-    const db = await getDb();
-    const row = await db.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key)).get();
-    if (row) content = row.content;
-  } catch (err) {
-    console.error(`[prompts] failed to read DB override for "${key}":`, err);
-  }
-  return vars ? substitute(content, vars) : content;
-}
-async function getPromptIfCustom(key) {
-  if (!isValidKey(key)) return null;
-  try {
-    const db = await getDb();
-    const row = await db.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key)).get();
-    return row?.content ?? null;
-  } catch (err) {
-    console.error(`[prompts] failed to check DB customization for "${key}":`, err);
-    return null;
-  }
-}
-var MIND_PROMPT_KEYS = PROMPT_KEYS.filter((k) => PROMPT_DEFAULTS[k].category === "mind");
-async function getMindPromptDefaults() {
-  const result = {};
-  for (const key of MIND_PROMPT_KEYS) {
-    result[key] = PROMPT_DEFAULTS[key].content;
-  }
-  try {
-    const db = await getDb();
-    const rows = await db.select().from(systemPrompts).all();
-    for (const row of rows) {
-      if (MIND_PROMPT_KEYS.includes(row.key)) {
-        result[row.key] = row.content;
-      }
-    }
-  } catch (err) {
-    console.error("[prompts] failed to read DB overrides for mind prompt defaults:", err);
-  }
-  return result;
-}
-
-// src/lib/rotating-log.ts
-import {
-  createWriteStream,
-  existsSync as existsSync2,
-  renameSync,
-  rmSync,
-  statSync
-} from "fs";
-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;
-  _write(chunk, _encoding, callback) {
-    this.size += chunk.length;
-    if (this.size > this.maxSize) {
-      try {
-        const oldest = `${this.path}.${this.maxFiles}`;
-        if (existsSync2(oldest)) rmSync(oldest);
-        for (let i = this.maxFiles - 1; i >= 1; i--) {
-          const from = `${this.path}.${i}`;
-          const to = `${this.path}.${i + 1}`;
-          if (existsSync2(from)) renameSync(from, to);
-        }
-        renameSync(this.path, `${this.path}.1`);
-        const oldStream = this.stream;
-        this.stream = createWriteStream(this.path);
-        this.size = chunk.length;
-        oldStream.end();
-      } catch {
-      }
-    }
-    this.stream.write(chunk, callback);
-  }
-  _final(callback) {
-    this.stream.end(callback);
-  }
-};
-
-// 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;
-}
-
-// 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();
-  }
-};
-
-// src/lib/daemon/mind-manager.ts
-var mlog = logger_default.child("minds");
-var execFileAsync = promisify(execFile);
-function mindPidPath(name) {
-  return resolve(stateDir(name), "mind.pid");
-}
-var MindManager = class {
-  minds = /* @__PURE__ */ new Map();
-  stopping = /* @__PURE__ */ new Set();
-  shuttingDown = false;
-  restartTracker = new RestartTracker();
-  pendingContext = /* @__PURE__ */ new Map();
-  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 };
-    }
-    const dir = mindDir(name);
-    if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
-    return { dir, port: entry.port, baseName: 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 (existsSync3(pidFile)) {
-        const stalePid = parseInt(readFileSync2(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));
-            }
-          }
-        }
-        rmSync2(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`);
-      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 = resolve(mindStateDir, "logs");
-    mkdirSync(logsDir, { recursive: true });
-    if (isIsolationEnabled()) {
-      try {
-        chownMindDir(mindStateDir, 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(resolve(logsDir, "mind.log"));
-    const mindToken = generateMindToken(name);
-    const mindEnv = loadMergedEnv(name);
-    const env = {
-      ...process.env,
-      ...mindEnv,
-      VOLUTE_MIND: name,
-      VOLUTE_STATE_DIR: stateDir(name),
-      VOLUTE_MIND_DIR: dir,
-      VOLUTE_MIND_PORT: String(port),
-      VOLUTE_DAEMON_TOKEN: mindToken,
-      // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
-      CLAUDECODE: void 0
-    };
-    if (isIsolationEnabled()) {
-      env.HOME = resolve(dir, "home");
-    }
-    const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
-    const tsxArgs = ["src/server.ts", "--port", String(port)];
-    let spawnCmd;
-    let spawnArgs;
-    if (isIsolationEnabled()) {
-      [spawnCmd, spawnArgs] = await wrapForIsolation(tsxBin, tsxArgs, name);
-    } else if (isSandboxEnabled()) {
-      [spawnCmd, spawnArgs] = await wrapForSandbox(tsxBin, tsxArgs, dir, name, [
-        dir,
-        mindStateDir,
-        "/tmp"
-      ]);
-    } else {
-      spawnCmd = tsxBin;
-      spawnArgs = tsxArgs;
-    }
-    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);
-    try {
-      await new Promise((resolve2, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error(`Mind ${name} did not start within 30s`));
-        }, 3e4);
-        function checkOutput(data) {
-          if (data.toString().match(/listening on :\d+/)) {
-            clearTimeout(timeout);
-            resolve2();
-          }
-        }
-        child.stdout?.on("data", checkOutput);
-        child.stderr?.on("data", checkOutput);
-        child.on("error", (err) => {
-          clearTimeout(timeout);
-          reject(err);
-        });
-        child.on("exit", (code) => {
-          clearTimeout(timeout);
-          reject(new Error(`Mind ${name} exited with code ${code} during startup`));
-        });
-      });
-    } catch (err) {
-      this.minds.delete(name);
-      try {
-        child.kill();
-      } catch {
-      }
-      throw err;
-    }
-    if (child.pid) {
-      try {
-        writeFileSync2(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);
-  }
-  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 parts = [];
-    if (context.type === "merge" || context.type === "merged") {
-      parts.push(await getPrompt("merge_message", { name: String(context.name ?? "") }));
-    } else if (context.type === "sprouted") {
-      parts.push(await getPrompt("sprout_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}`);
-    const content = parts.join("\n");
-    try {
-      const db = await getDb();
-      await db.insert(mindHistory).values({
-        mind: name,
-        type: "inbound",
-        channel: "system",
-        content
-      });
-    } catch (err) {
-      mlog.error(`failed to persist pending context for ${name}`, logger_default.errorData(err));
-    }
-    try {
-      await fetch(`http://127.0.0.1:${tracked.port}/message`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          content: [{ type: "text", text: content }],
-          channel: "system"
-        })
-      });
-    } catch (err) {
-      mlog.warn(`failed to deliver pending context to ${name}`, logger_default.errorData(err));
-    }
-  }
-  setupCrashRecovery(name, child) {
-    child.on("exit", async (code) => {
-      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-O7YQFCV5.js");
-        const sleepState = getSleepManagerIfReady()?.getState(name);
-        if (sleepState?.sleeping) {
-          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));
-      }
-      import("./mind-activity-tracker-VYN2ZZ2M.js").then(({ markIdle }) => markIdle(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-BKBPPUBP.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) {
-    const tracked = this.minds.get(name);
-    if (!tracked) return;
-    this.stopping.add(name);
-    const { child } = tracked;
-    this.minds.delete(name);
-    await new Promise((resolve2) => {
-      child.on("exit", () => resolve2());
-      try {
-        process.kill(-child.pid, "SIGTERM");
-      } catch {
-        resolve2();
-      }
-      setTimeout(() => {
-        try {
-          process.kill(-child.pid, "SIGKILL");
-        } catch {
-        }
-        resolve2();
-      }, 5e3);
-    });
-    this.stopping.delete(name);
-    revokeMindToken(name);
-    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
-    rmSync2(mindPidPath(name), { force: true });
-    if (!this.shuttingDown) {
-      await setMindRunning(name, false);
-    }
-    mlog.info(`stopped mind ${name}`);
-  }
-  async restartMind(name) {
-    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);
-  }
-  getRunningMinds() {
-    return [...this.minds.keys()];
-  }
-  get crashAttemptsPath() {
-    return resolve(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;
-}
-
-export {
-  RotatingLog,
-  RestartTracker,
-  PROMPT_KEYS,
-  PROMPT_DEFAULTS,
-  substitute,
-  getPrompt,
-  getPromptIfCustom,
-  getMindPromptDefaults,
-  loadJsonMap,
-  saveJsonMap,
-  clearJsonMap,
-  resolveMindToken,
-  MindManager,
-  initMindManager,
-  getMindManager
-};