volute 0.13.1 → 0.14.0

package/dist/{chunk-K2ZT3YQ3.js → chunk-J52CJCVI.js}

@@ -1,25 +1,25 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-O4BN3ZIY.js";
+} from "./chunk-OYSZNX5I.js";
 import {
-  chownAgentDir,
+  chownMindDir,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-NXT67PPK.js";
+} from "./chunk-ZCEYUUID.js";
 import {
-  agentDir,
-  findAgent,
+  findMind,
   findVariant,
-  setAgentRunning,
+  mindDir,
+  setMindRunning,
   setVariantRunning,
   stateDir,
   voluteHome
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
-// src/lib/agent-manager.ts
+// src/lib/mind-manager.ts
 import { execFile, spawn } from "child_process";
-import { chmodSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 import { promisify } from "util";
 
@@ -113,41 +113,41 @@ var RotatingLog = class extends Writable {
   }
 };
 
-// src/lib/agent-manager.ts
+// src/lib/mind-manager.ts
 var execFileAsync = promisify(execFile);
-function agentPidPath(name) {
-  return resolve(stateDir(name), "agent.pid");
+function mindPidPath(name) {
+  return resolve(stateDir(name), "mind.pid");
 }
 var MAX_RESTART_ATTEMPTS = 5;
 var BASE_RESTART_DELAY = 3e3;
 var MAX_RESTART_DELAY = 6e4;
-var AgentManager = class {
-  agents = /* @__PURE__ */ new Map();
+var MindManager = class {
+  minds = /* @__PURE__ */ new Map();
   stopping = /* @__PURE__ */ new Set();
   shuttingDown = false;
   restartAttempts = /* @__PURE__ */ new Map();
   pendingContext = /* @__PURE__ */ new Map();
   resolveTarget(name) {
     const [baseName, variantName] = name.split("@", 2);
-    const entry = findAgent(baseName);
-    if (!entry) throw new Error(`Unknown agent: ${baseName}`);
+    const entry = findMind(baseName);
+    if (!entry) throw new Error(`Unknown mind: ${baseName}`);
     if (variantName) {
       const variant = findVariant(baseName, variantName);
-      if (!variant) throw new Error(`Unknown variant: ${variantName} (agent: ${baseName})`);
+      if (!variant) throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
       return { dir: variant.path, port: variant.port, isVariant: true, baseName, variantName };
     }
-    const dir = agentDir(baseName);
-    if (!existsSync3(dir)) throw new Error(`Agent directory missing: ${dir}`);
+    const dir = mindDir(baseName);
+    if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
     return { dir, port: entry.port, isVariant: false, baseName };
   }
-  async startAgent(name) {
-    if (this.agents.has(name)) {
-      throw new Error(`Agent ${name} is already running`);
+  async startMind(name) {
+    if (this.minds.has(name)) {
+      throw new Error(`Mind ${name} is already running`);
     }
     const target = this.resolveTarget(name);
     const { dir, isVariant, baseName, variantName } = target;
     const port = target.port;
-    const pidFile = agentPidPath(name);
+    const pidFile = mindPidPath(name);
     try {
       if (existsSync3(pidFile)) {
         const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
@@ -156,12 +156,12 @@ var AgentManager = class {
             process.kill(stalePid, 0);
             const { stdout } = await execFileAsync("ps", ["-p", String(stalePid), "-o", "args="]);
             if (stdout.includes("server.ts")) {
-              console.error(`[daemon] killing stale agent process ${stalePid} for ${name}`);
+              console.error(`[daemon] killing stale mind process ${stalePid} for ${name}`);
               process.kill(-stalePid, "SIGTERM");
               await new Promise((r) => setTimeout(r, 500));
             } else {
               console.error(
-                `[daemon] stale PID ${stalePid} for ${name} is not an agent process, skipping`
+                `[daemon] stale PID ${stalePid} for ${name} is not a mind process, skipping`
               );
             }
           } catch (err) {
@@ -184,35 +184,32 @@ var AgentManager = class {
       }
     } catch {
     }
-    const agentStateDir = stateDir(name);
-    const logsDir = resolve(agentStateDir, "logs");
+    const mindStateDir = stateDir(name);
+    const logsDir = resolve(mindStateDir, "logs");
     mkdirSync(logsDir, { recursive: true });
     if (isIsolationEnabled()) {
       try {
-        chownAgentDir(agentStateDir, baseName);
+        chownMindDir(mindStateDir, baseName);
       } catch (err) {
         throw new Error(
-          `Cannot start agent ${name}: failed to set ownership on state directory ${agentStateDir}: ${err instanceof Error ? err.message : err}`
+          `Cannot start mind ${name}: failed to set ownership on state directory ${mindStateDir}: ${err instanceof Error ? err.message : err}`
         );
       }
     }
-    const logStream = new RotatingLog(resolve(logsDir, "agent.log"));
-    const agentEnv = loadMergedEnv(name);
+    const logStream = new RotatingLog(resolve(logsDir, "mind.log"));
+    const mindEnv = loadMergedEnv(name);
     const env = {
       ...process.env,
-      ...agentEnv,
-      VOLUTE_AGENT: name,
+      ...mindEnv,
+      VOLUTE_MIND: name,
       VOLUTE_STATE_DIR: stateDir(name),
-      VOLUTE_AGENT_DIR: dir,
-      VOLUTE_AGENT_PORT: String(port)
+      VOLUTE_MIND_DIR: dir,
+      VOLUTE_MIND_PORT: String(port),
+      // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
+      CLAUDECODE: void 0
     };
     if (isIsolationEnabled()) {
       env.HOME = resolve(dir, "home");
-      if (process.env.CLAUDE_CONFIG_DIR) {
-        const projectsDir = resolve(process.env.CLAUDE_CONFIG_DIR, "projects");
-        mkdirSync(projectsDir, { recursive: true });
-        chmodSync(projectsDir, 1528);
-      }
     }
     const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
     const tsxArgs = ["src/server.ts", "--port", String(port)];
@@ -224,13 +221,13 @@ var AgentManager = class {
       env
     };
     const child = spawn(spawnCmd, spawnArgs, spawnOpts);
-    this.agents.set(name, { child, port });
+    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(`Agent ${name} did not start within 30s`));
+          reject(new Error(`Mind ${name} did not start within 30s`));
         }, 3e4);
         function checkOutput(data) {
           if (data.toString().match(/listening on :\d+/)) {
@@ -246,11 +243,11 @@ var AgentManager = class {
         });
         child.on("exit", (code) => {
           clearTimeout(timeout);
-          reject(new Error(`Agent ${name} exited with code ${code} during startup`));
+          reject(new Error(`Mind ${name} exited with code ${code} during startup`));
         });
       });
     } catch (err) {
-      this.agents.delete(name);
+      this.minds.delete(name);
       try {
         child.kill();
       } catch {
@@ -269,9 +266,9 @@ var AgentManager = class {
     if (isVariant) {
       setVariantRunning(baseName, variantName, true);
     } else {
-      setAgentRunning(name, true);
+      setMindRunning(name, true);
     }
-    console.error(`[daemon] started agent ${name} on port ${port}`);
+    console.error(`[daemon] started mind ${name} on port ${port}`);
     await this.deliverPendingContext(name);
   }
   setPendingContext(name, context) {
@@ -280,7 +277,7 @@ var AgentManager = class {
   async deliverPendingContext(name) {
     const context = this.pendingContext.get(name);
     if (!context) return;
-    const tracked = this.agents.get(name);
+    const tracked = this.minds.get(name);
     if (!tracked) return;
     this.pendingContext.delete(name);
     const parts = [];
@@ -288,7 +285,7 @@ var AgentManager = class {
       parts.push(`[system] Variant "${context.name}" has been merged and you have been restarted.`);
     } else if (context.type === "sprouted") {
       parts.push(
-        "[system] You've sprouted. You now have full agent capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details."
+        "[system] You've sprouted. You now have full capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details."
       );
     } else {
       parts.push("[system] You have been restarted.");
@@ -311,9 +308,9 @@ var AgentManager = class {
   }
   setupCrashRecovery(name, child) {
     child.on("exit", async (code) => {
-      this.agents.delete(name);
+      this.minds.delete(name);
       if (this.shuttingDown || this.stopping.has(name)) return;
-      console.error(`[daemon] agent ${name} exited with code ${code}`);
+      console.error(`[daemon] mind ${name} exited with code ${code}`);
       const attempts = this.restartAttempts.get(name) ?? 0;
       if (attempts >= MAX_RESTART_ATTEMPTS) {
         console.error(`[daemon] ${name} crashed ${attempts} times \u2014 giving up on restart`);
@@ -321,7 +318,7 @@ var AgentManager = class {
         if (variant) {
           setVariantRunning(base, variant, false);
         } else {
-          setAgentRunning(name, false);
+          setMindRunning(name, false);
         }
         return;
       }
@@ -333,18 +330,18 @@ var AgentManager = class {
       );
       setTimeout(() => {
         if (this.shuttingDown) return;
-        this.startAgent(name).catch((err) => {
+        this.startMind(name).catch((err) => {
           console.error(`[daemon] failed to restart ${name}:`, err);
         });
       }, delay);
     });
   }
-  async stopAgent(name) {
-    const tracked = this.agents.get(name);
+  async stopMind(name) {
+    const tracked = this.minds.get(name);
     if (!tracked) return;
     this.stopping.add(name);
     const { child } = tracked;
-    this.agents.delete(name);
+    this.minds.delete(name);
     await new Promise((resolve2) => {
       child.on("exit", () => resolve2());
       try {
@@ -362,31 +359,31 @@ var AgentManager = class {
     });
     this.stopping.delete(name);
     if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    rmSync2(agentPidPath(name), { force: true });
+    rmSync2(mindPidPath(name), { force: true });
     if (!this.shuttingDown) {
       const [baseName, variantName] = name.split("@", 2);
       if (variantName) {
         setVariantRunning(baseName, variantName, false);
       } else {
-        setAgentRunning(name, false);
+        setMindRunning(name, false);
       }
     }
-    console.error(`[daemon] stopped agent ${name}`);
+    console.error(`[daemon] stopped mind ${name}`);
   }
-  async restartAgent(name) {
-    await this.stopAgent(name);
-    await this.startAgent(name);
+  async restartMind(name) {
+    await this.stopMind(name);
+    await this.startMind(name);
   }
   async stopAll() {
     this.shuttingDown = true;
-    const names = [...this.agents.keys()];
-    await Promise.all(names.map((name) => this.stopAgent(name)));
+    const names = [...this.minds.keys()];
+    await Promise.all(names.map((name) => this.stopMind(name)));
   }
   isRunning(name) {
-    return this.agents.has(name);
+    return this.minds.has(name);
   }
-  getRunningAgents() {
-    return [...this.agents.keys()];
+  getRunningMinds() {
+    return [...this.minds.keys()];
   }
   get crashAttemptsPath() {
     return resolve(voluteHome(), "crash-attempts.json");
@@ -429,22 +426,22 @@ async function killProcessOnPort(port) {
   }
 }
 var instance = null;
-function initAgentManager() {
-  if (instance) throw new Error("AgentManager already initialized");
-  instance = new AgentManager();
+function initMindManager() {
+  if (instance) throw new Error("MindManager already initialized");
+  instance = new MindManager();
   return instance;
 }
-function getAgentManager() {
-  if (!instance) instance = new AgentManager();
+function getMindManager() {
+  if (!instance) instance = new MindManager();
   return instance;
 }
 
 export {
+  RotatingLog,
   loadJsonMap,
   saveJsonMap,
   clearJsonMap,
-  RotatingLog,
-  AgentManager,
-  initAgentManager,
-  getAgentManager
+  MindManager,
+  initMindManager,
+  getMindManager
 };

package/dist/{chunk-LGSW7T7K.js → chunk-M77QBTEH.js}

@@ -20,51 +20,54 @@ function voluteHome() {
   return resolve(homedir(), ".volute");
 }
 function ensureVoluteHome() {
-  const agentsBase = process.env.VOLUTE_AGENTS_DIR ?? resolve(voluteHome(), "agents");
-  mkdirSync(agentsBase, { recursive: true });
+  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve(voluteHome(), "minds");
+  mkdirSync(mindsBase, { recursive: true });
 }
 function readRegistry() {
-  const registryPath = resolve(voluteHome(), "agents.json");
+  const registryPath = resolve(voluteHome(), "minds.json");
   if (!existsSync(registryPath)) return [];
   try {
     const entries = JSON.parse(readFileSync(registryPath, "utf-8"));
-    return entries.map((e) => ({ ...e, running: e.running ?? false, stage: e.stage ?? "mind" }));
+    return entries.map((e) => ({
+      ...e,
+      running: e.running ?? false,
+      stage: e.stage ?? "sprouted"
+    }));
   } catch {
     return [];
   }
 }
 function writeRegistry(entries) {
   ensureVoluteHome();
-  const registryPath = resolve(voluteHome(), "agents.json");
+  const registryPath = resolve(voluteHome(), "minds.json");
   const tmpPath = `${registryPath}.tmp`;
   writeFileSync(tmpPath, `${JSON.stringify(entries, null, 2)}
 `);
   renameSync(tmpPath, registryPath);
 }
-var AGENT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var AGENT_NAME_MAX = 64;
-function validateAgentName(name) {
-  if (!name) return "Agent name is required";
-  if (name.length > AGENT_NAME_MAX)
-    return `Agent name must be at most ${AGENT_NAME_MAX} characters`;
-  if (!AGENT_NAME_RE.test(name)) {
-    return "Agent name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
+var MIND_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var MIND_NAME_MAX = 64;
+function validateMindName(name) {
+  if (!name) return "Mind name is required";
+  if (name.length > MIND_NAME_MAX) return `Mind name must be at most ${MIND_NAME_MAX} characters`;
+  if (!MIND_NAME_RE.test(name)) {
+    return "Mind name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
   }
   return null;
 }
-function addAgent(name, port, stage) {
-  const err = validateAgentName(name);
+function addMind(name, port, stage) {
+  const err = validateMindName(name);
   if (err) throw new Error(err);
   const entries = readRegistry();
   const filtered = entries.filter((e) => e.name !== name);
   filtered.push({ name, port, created: (/* @__PURE__ */ new Date()).toISOString(), running: false, stage });
   writeRegistry(filtered);
 }
-function removeAgent(name) {
+function removeMind(name) {
   const entries = readRegistry();
   writeRegistry(entries.filter((e) => e.name !== name));
 }
-function setAgentRunning(name, running) {
+function setMindRunning(name, running) {
   const entries = readRegistry();
   const entry = entries.find((e) => e.name === name);
   if (entry) {
@@ -72,7 +75,7 @@ function setAgentRunning(name, running) {
     writeRegistry(entries);
   }
 }
-function setAgentStage(name, stage) {
+function setMindStage(name, stage) {
   const entries = readRegistry();
   const entry = entries.find((e) => e.name === name);
   if (entry) {
@@ -80,14 +83,14 @@ function setAgentStage(name, stage) {
     writeRegistry(entries);
   }
 }
-function findAgent(name) {
+function findMind(name) {
   return readRegistry().find((e) => e.name === name);
 }
-function agentDir(name) {
-  if (process.env.VOLUTE_AGENTS_DIR) {
-    return resolve(process.env.VOLUTE_AGENTS_DIR, name);
+function mindDir(name) {
+  if (process.env.VOLUTE_MINDS_DIR) {
+    return resolve(process.env.VOLUTE_MINDS_DIR, name);
   }
-  return resolve(voluteHome(), "agents", name);
+  return resolve(voluteHome(), "minds", name);
 }
 function stateDir(name) {
   return resolve(voluteHome(), "state", name);
@@ -112,20 +115,20 @@ function daemonLoopback() {
   if (host === "::") return "[::1]";
   return host;
 }
-function resolveAgent(name) {
+function resolveMind(name) {
   const [baseName, variantName] = name.split("@", 2);
-  const entry = findAgent(baseName);
+  const entry = findMind(baseName);
   if (!entry) {
-    throw new Error(`Unknown agent: ${baseName}`);
+    throw new Error(`Unknown mind: ${baseName}`);
   }
-  const dir = agentDir(baseName);
+  const dir = mindDir(baseName);
   if (!existsSync(dir)) {
-    throw new Error(`Agent directory missing: ${dir}`);
+    throw new Error(`Mind directory missing: ${dir}`);
   }
   if (variantName) {
     const variant = findVariant(baseName, variantName);
     if (!variant) {
-      throw new Error(`Unknown variant: ${variantName} (agent: ${baseName})`);
+      throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
     }
     return { entry: { ...entry, port: variant.port }, dir: variant.path };
   }
@@ -150,59 +153,59 @@ function writeAllVariants(all) {
   writeFileSync2(variantsPath(), `${JSON.stringify(all, null, 2)}
 `);
 }
-function readVariants(agentName) {
-  return readAllVariants()[agentName] ?? [];
+function readVariants(mindName) {
+  return readAllVariants()[mindName] ?? [];
 }
-function writeVariants(agentName, variants) {
+function writeVariants(mindName, variants) {
   const all = readAllVariants();
   if (variants.length === 0) {
-    delete all[agentName];
+    delete all[mindName];
   } else {
-    all[agentName] = variants;
+    all[mindName] = variants;
   }
   writeAllVariants(all);
 }
-function addVariant(agentName, variant) {
-  const variants = readVariants(agentName);
+function addVariant(mindName, variant) {
+  const variants = readVariants(mindName);
   const filtered = variants.filter((v) => v.name !== variant.name);
   filtered.push(variant);
-  writeVariants(agentName, filtered);
+  writeVariants(mindName, filtered);
 }
-function removeVariant(agentName, name) {
-  const variants = readVariants(agentName);
+function removeVariant(mindName, name) {
+  const variants = readVariants(mindName);
   writeVariants(
-    agentName,
+    mindName,
     variants.filter((v) => v.name !== name)
   );
 }
-function findVariant(agentName, name) {
-  return readVariants(agentName).find((v) => v.name === name);
+function findVariant(mindName, name) {
+  return readVariants(mindName).find((v) => v.name === name);
 }
-function setVariantRunning(agentName, variantName, running) {
+function setVariantRunning(mindName, variantName, running) {
   const all = readAllVariants();
-  const variants = all[agentName] ?? [];
+  const variants = all[mindName] ?? [];
   const variant = variants.find((v) => v.name === variantName);
   if (variant) {
     variant.running = running;
-    all[agentName] = variants;
+    all[mindName] = variants;
     writeAllVariants(all);
   }
 }
 function getAllRunningVariants() {
   const all = readAllVariants();
   const result = [];
-  for (const [agentName, variants] of Object.entries(all)) {
+  for (const [mindName, variants] of Object.entries(all)) {
     for (const variant of variants) {
       if (variant.running) {
-        result.push({ agentName, variant });
+        result.push({ mindName, variant });
       }
     }
   }
   return result;
 }
-function removeAllVariants(agentName) {
+function removeAllVariants(mindName) {
   const all = readAllVariants();
-  delete all[agentName];
+  delete all[mindName];
   writeAllVariants(all);
 }
 async function checkHealth(port) {
@@ -242,15 +245,15 @@ export {
   voluteHome,
   ensureVoluteHome,
   readRegistry,
-  validateAgentName,
-  addAgent,
-  removeAgent,
-  setAgentRunning,
-  setAgentStage,
-  findAgent,
-  agentDir,
+  validateMindName,
+  addMind,
+  removeMind,
+  setMindRunning,
+  setMindStage,
+  findMind,
+  mindDir,
   stateDir,
   nextPort,
   daemonLoopback,
-  resolveAgent
+  resolveMind
 };

package/dist/{chunk-KXOFPDO6.js → chunk-MVSXRMJJ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/chunk-NAOW2CLO.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+// src/lib/resolve-mind-name.ts
+function resolveMindName(flags) {
+  const name = flags.mind || process.env.VOLUTE_MIND;
+  if (!name) {
+    console.error("No mind specified. Provide a name or set VOLUTE_MIND.");
+    process.exit(1);
+  }
+  return name;
+}
+
+export {
+  resolveMindName
+};

package/dist/{chunk-VQIJUR43.js → chunk-OJQ47SCA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-O4BN3ZIY.js → chunk-OYSZNX5I.js}

@@ -2,7 +2,7 @@
 import {
   stateDir,
   voluteHome
-} from "./chunk-LGSW7T7K.js";
+} from "./chunk-M77QBTEH.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -10,8 +10,8 @@ import { dirname, resolve } from "path";
 function sharedEnvPath() {
   return resolve(voluteHome(), "env.json");
 }
-function agentEnvPath(agentName) {
-  return resolve(stateDir(agentName), "env.json");
+function mindEnvPath(mindName) {
+  return resolve(stateDir(mindName), "env.json");
 }
 function readEnv(path) {
   if (!existsSync(path)) return {};
@@ -26,15 +26,15 @@ function writeEnv(path, env) {
   writeFileSync(path, `${JSON.stringify(env, null, 2)}
 `, { mode: 384 });
 }
-function loadMergedEnv(agentName) {
+function loadMergedEnv(mindName) {
   const shared = readEnv(sharedEnvPath());
-  const agent = readEnv(agentEnvPath(agentName));
-  return { ...shared, ...agent };
+  const mind = readEnv(mindEnvPath(mindName));
+  return { ...shared, ...mind };
 }
 
 export {
   sharedEnvPath,
-  agentEnvPath,
+  mindEnvPath,
   readEnv,
   writeEnv,
   loadMergedEnv