volute 0.17.0 → 0.19.0

package/README.md

@@ -74,7 +74,7 @@ The agent knows which channel each message came from — CLI, web, Discord, or s
 │   ├── VOLUTE.md          # channel routing docs
 │   └── memory/            # daily logs (YYYY-MM-DD.md)
 ├── src/                   # agent server code
-└── .volute/               # runtime state, session, logs
+└── .mind/                 # runtime state, session, logs
 ```
 
 **`SOUL.md`** is the identity. This is the core of the system prompt. Edit it to change how the agent thinks and speaks.

package/dist/archive-ZCFOSTKB.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  addHistoryToArchive,
+  createExportArchive,
+  extractArchive,
+  readManifest
+} from "./chunk-AW7P4EVV.js";
+import "./chunk-EBGCNDMM.js";
+import "./chunk-K3NQKI34.js";
+export {
+  addHistoryToArchive,
+  createExportArchive,
+  extractArchive,
+  readManifest
+};

package/dist/{channel-SLURLIRV.js → channel-PUQKGSQM.js}

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 import {
   resolveMindName
 } from "./chunk-NAOW2CLO.js";
@@ -7,12 +11,8 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-OJQ47SCA.js";
-import "./chunk-M77QBTEH.js";
-import {
-  getClient,
-  urlOf
-} from "./chunk-4RQBJWQX.js";
+} from "./chunk-WC6ZHVRL.js";
+import "./chunk-EBGCNDMM.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/channel.ts
@@ -34,6 +34,12 @@ async function run(args) {
     case "typing":
       await typingChannel(args.slice(1));
       break;
+    case "invite":
+      await inviteChannel(args.slice(1));
+      break;
+    case "pending":
+      await pendingChannel(args.slice(1));
+      break;
     case "--help":
     case "-h":
     case void 0:
@@ -50,7 +56,9 @@ function printUsage() {
   volute channel list [<platform>] [--mind <name>]
   volute channel users <platform> [--mind <name>]
   volute channel create <platform> --participants user1,user2 [--name "..."] [--mind <name>]
-  volute channel typing <channel-uri> [--mind <name>]`);
+  volute channel typing <channel-uri> [--mind <name>]
+  volute channel invite <channel-name> <username>
+  volute channel pending [--mind <name>]`);
 }
 async function readChannel(args) {
   const { positional, flags } = parseArgs(args, {
@@ -194,6 +202,51 @@ async function typingChannel(args) {
     process.exit(1);
   }
 }
+async function inviteChannel(args) {
+  const { positional } = parseArgs(args, {});
+  const channelName = positional[0];
+  const username = positional[1];
+  if (!channelName || !username) {
+    console.error("Usage: volute channel invite <channel-name> <username>");
+    process.exit(1);
+  }
+  const res = await daemonFetch(`/api/volute/channels/${encodeURIComponent(channelName)}/invite`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ username })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
+    process.exit(1);
+  }
+  console.log(`Invited ${username} to #${channelName}`);
+}
+async function pendingChannel(args) {
+  const { flags } = parseArgs(args, {
+    mind: { type: "string" }
+  });
+  const mindName = resolveMindName(flags);
+  const res = await daemonFetch(`/api/minds/${encodeURIComponent(mindName)}/delivery/pending`);
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
+    process.exit(1);
+  }
+  const pending = await res.json();
+  if (pending.length === 0) {
+    console.log("No pending messages.");
+    return;
+  }
+  for (const entry of pending) {
+    console.log(
+      `${(entry.channel ?? "unknown").padEnd(30)}  ${String(entry.count).padEnd(6)}  ${entry.sender ?? "unknown"}`
+    );
+    console.log(`  First seen: ${entry.firstSeen}`);
+    console.log(`  Preview: ${entry.preview}`);
+    console.log();
+  }
+}
 function parseUri(uri) {
   const colonIdx = uri.indexOf(":");
   if (colonIdx === -1) {

package/dist/{chunk-CE7WMOVW.js → chunk-2TJGRJ4O.js}

@@ -1,12 +1,21 @@
 #!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
 import {
   loadMergedEnv
-} from "./chunk-OYSZNX5I.js";
+} from "./chunk-VDWCHYTS.js";
+import {
+  getDb
+} from "./chunk-Z524RFCJ.js";
+import {
+  systemPrompts
+} from "./chunk-VQWDC6UK.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-ZCEYUUID.js";
+} from "./chunk-OGXOMR65.js";
 import {
   findMind,
   findVariant,
@@ -15,7 +24,7 @@ import {
   setVariantRunning,
   stateDir,
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/mind-manager.ts
 import { execFile, spawn } from "child_process";
@@ -60,71 +69,196 @@ function clearJsonMap(path, map) {
   }
 }
 
-// src/lib/log-buffer.ts
-var LogBuffer = class {
-  entries = [];
-  maxSize = 1e3;
-  subscribers = /* @__PURE__ */ new Set();
-  append(entry) {
-    this.entries.push(entry);
-    if (this.entries.length > this.maxSize) {
-      this.entries.shift();
-    }
-    for (const sub of this.subscribers) {
-      sub(entry);
-    }
-  }
-  getEntries() {
-    return [...this.entries];
-  }
-  subscribe(fn) {
-    this.subscribers.add(fn);
-    return () => this.subscribers.delete(fn);
+// 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",
+  "reply_instructions",
+  "channel_invite"
+];
+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 sprout\` to complete the transformation.
+`,
+    description: "SOUL.md for seed minds",
+    variables: ["name", "description"],
+    category: "creation"
+  },
+  default_soul: {
+    content: `You are {{name}}.
+`,
+    description: "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"
+  },
+  reply_instructions: {
+    content: 'To reply to this message, use: volute 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 send \${channel} "your message"
+To reject, delete \${filePath}`,
+    description: "New channel notification template",
+    variables: [
+      "headers",
+      "sender",
+      "time",
+      "preview",
+      "filePath",
+      "channel",
+      "suggestedSession",
+      "batchRecommendation"
+    ],
+    category: "mind"
   }
 };
-var logBuffer = new LogBuffer();
-
-// src/lib/logger.ts
-var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
-var minLevel = LEVELS[process.env.VOLUTE_LOG_LEVEL || "info"] ?? LEVELS.info;
-var output = (line) => process.stderr.write(`${line}
-`);
-function write(level, cat, msg, data) {
-  if (LEVELS[level] < minLevel) return;
-  const entry = {
-    level,
-    cat,
-    msg,
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    ...data ? { data } : {}
-  };
-  output(JSON.stringify(entry));
-  logBuffer.append(entry);
+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;
 }
-function child(cat) {
-  return {
-    debug: (msg, data) => write("debug", cat, msg, data),
-    info: (msg, data) => write("info", cat, msg, data),
-    warn: (msg, data) => write("warn", cat, msg, data),
-    error: (msg, data) => write("error", cat, msg, data)
-  };
+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;
+  }
 }
-function errorData(err) {
-  if (err instanceof Error) return { error: err.stack ?? err.message };
-  return { error: String(err) };
+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;
 }
-var log = {
-  ...child("system"),
-  child,
-  errorData,
-  setLevel(level) {
-    minLevel = LEVELS[level];
-  },
-  setOutput(fn) {
-    output = fn;
+
+// src/lib/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();
   }
 };
-var logger_default = log;
 
 // src/lib/rotating-log.ts
 import {
@@ -185,14 +319,11 @@ var execFileAsync = promisify(execFile);
 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 MindManager = class {
   minds = /* @__PURE__ */ new Map();
   stopping = /* @__PURE__ */ new Set();
   shuttingDown = false;
-  restartAttempts = /* @__PURE__ */ new Map();
+  restartTracker = new RestartTracker();
   pendingContext = /* @__PURE__ */ new Map();
   resolveTarget(name) {
     const [baseName, variantName] = name.split("@", 2);
@@ -285,10 +416,10 @@ var MindManager = class {
       detached: true,
       env
     };
-    const child2 = spawn(spawnCmd, spawnArgs, spawnOpts);
-    this.minds.set(name, { child: child2, port });
-    child2.stdout?.pipe(logStream);
-    child2.stderr?.pipe(logStream);
+    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(() => {
@@ -300,13 +431,13 @@ var MindManager = class {
             resolve2();
           }
         }
-        child2.stdout?.on("data", checkOutput);
-        child2.stderr?.on("data", checkOutput);
-        child2.on("error", (err) => {
+        child.stdout?.on("data", checkOutput);
+        child.stderr?.on("data", checkOutput);
+        child.on("error", (err) => {
           clearTimeout(timeout);
           reject(err);
         });
-        child2.on("exit", (code) => {
+        child.on("exit", (code) => {
           clearTimeout(timeout);
           reject(new Error(`Mind ${name} exited with code ${code} during startup`));
         });
@@ -314,20 +445,20 @@ var MindManager = class {
     } catch (err) {
       this.minds.delete(name);
       try {
-        child2.kill();
+        child.kill();
       } catch {
       }
       throw err;
     }
-    if (child2.pid) {
+    if (child.pid) {
       try {
-        writeFileSync2(pidFile, String(child2.pid));
+        writeFileSync2(pidFile, String(child.pid));
       } catch (err) {
         mlog.warn(`failed to write PID file for ${name}`, logger_default.errorData(err));
       }
     }
-    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    this.setupCrashRecovery(name, child2);
+    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
+    this.setupCrashRecovery(name, child);
     if (isVariant) {
       setVariantRunning(baseName, variantName, true);
     } else {
@@ -347,13 +478,11 @@ var MindManager = class {
     this.pendingContext.delete(name);
     const parts = [];
     if (context.type === "merge" || context.type === "merged") {
-      parts.push(`[system] Variant "${context.name}" has been merged and you have been restarted.`);
+      parts.push(await getPrompt("merge_message", { name: String(context.name ?? "") }));
     } else if (context.type === "sprouted") {
-      parts.push(
-        "[system] You've sprouted. You now have full capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details."
-      );
+      parts.push(await getPrompt("sprout_message"));
     } else {
-      parts.push("[system] You have been restarted.");
+      parts.push(await getPrompt("restart_message"));
     }
     if (context.summary) parts.push(`Changes: ${context.summary}`);
     if (context.justification) parts.push(`Why: ${context.justification}`);
@@ -371,14 +500,15 @@ var MindManager = class {
       mlog.warn(`failed to deliver pending context to ${name}`, logger_default.errorData(err));
     }
   }
-  setupCrashRecovery(name, child2) {
-    child2.on("exit", async (code) => {
+  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}`);
-      const attempts = this.restartAttempts.get(name) ?? 0;
-      if (attempts >= MAX_RESTART_ATTEMPTS) {
-        mlog.error(`${name} crashed ${attempts} times \u2014 giving up on restart`);
+      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
+      this.saveCrashAttempts();
+      if (!shouldRestart) {
+        mlog.error(`${name} crashed ${attempt} times \u2014 giving up on restart`);
         const [base, variant] = name.split("@", 2);
         if (variant) {
           setVariantRunning(base, variant, false);
@@ -387,11 +517,8 @@ var MindManager = class {
         }
         return;
       }
-      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
-      this.restartAttempts.set(name, attempts + 1);
-      this.saveCrashAttempts();
       mlog.info(
-        `crash recovery for ${name} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, restarting in ${delay}ms`
+        `crash recovery for ${name} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, restarting in ${delay}ms`
       );
       setTimeout(() => {
         if (this.shuttingDown) return;
@@ -405,25 +532,25 @@ var MindManager = class {
     const tracked = this.minds.get(name);
     if (!tracked) return;
     this.stopping.add(name);
-    const { child: child2 } = tracked;
+    const { child } = tracked;
     this.minds.delete(name);
     await new Promise((resolve2) => {
-      child2.on("exit", () => resolve2());
+      child.on("exit", () => resolve2());
       try {
-        process.kill(-child2.pid, "SIGTERM");
+        process.kill(-child.pid, "SIGTERM");
       } catch {
         resolve2();
       }
       setTimeout(() => {
         try {
-          process.kill(-child2.pid, "SIGKILL");
+          process.kill(-child.pid, "SIGKILL");
         } catch {
         }
         resolve2();
       }, 5e3);
     });
     this.stopping.delete(name);
-    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
+    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     rmSync2(mindPidPath(name), { force: true });
     if (!this.shuttingDown) {
       const [baseName, variantName] = name.split("@", 2);
@@ -454,13 +581,14 @@ var MindManager = class {
     return resolve(voluteHome(), "crash-attempts.json");
   }
   loadCrashAttempts() {
-    this.restartAttempts = loadJsonMap(this.crashAttemptsPath);
+    this.restartTracker.load(loadJsonMap(this.crashAttemptsPath));
   }
   saveCrashAttempts() {
-    saveJsonMap(this.crashAttemptsPath, this.restartAttempts);
+    saveJsonMap(this.crashAttemptsPath, this.restartTracker.save());
   }
   clearCrashAttempts() {
-    clearJsonMap(this.crashAttemptsPath, this.restartAttempts);
+    this.restartTracker.clear();
+    clearJsonMap(this.crashAttemptsPath, /* @__PURE__ */ new Map());
   }
 };
 async function killProcessOnPort(port) {
@@ -497,17 +625,22 @@ function initMindManager() {
   return instance;
 }
 function getMindManager() {
-  if (!instance) instance = new MindManager();
+  if (!instance) throw new Error("MindManager not initialized \u2014 call initMindManager() first");
   return instance;
 }
 
 export {
-  logBuffer,
-  logger_default,
+  RestartTracker,
   RotatingLog,
   loadJsonMap,
   saveJsonMap,
   clearJsonMap,
+  PROMPT_KEYS,
+  PROMPT_DEFAULTS,
+  substitute,
+  getPrompt,
+  getPromptIfCustom,
+  getMindPromptDefaults,
   MindManager,
   initMindManager,
   getMindManager

package/dist/{chunk-6BDNWYKG.js → chunk-32VR2EOH.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   execInherit
-} from "./chunk-2Y77MCFG.js";
+} from "./chunk-DYZGP3EW.js";
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/service-mode.ts
 import { execFileSync } from "child_process";