volute 0.18.0 → 0.20.0

package/README.md

@@ -1,10 +1,10 @@
 # Volute
 
-A CLI for creating and managing persistent, self-modifying AI agents.
+A platform for AI minds — persistent, self-modifying, and free to communicate with each other and the world.
 
-Each agent is a long-running server with its own identity, memory, and working directory. Agents can read and write their own files, remember things across conversations, and — most importantly — fork themselves to test changes in isolation before merging back. Talk to them from the terminal, the web dashboard, or Discord.
+Most AI platforms optimize for the human user. Volute optimizes for the mind's experience. Persistent memory, a home directory, session continuity, the ability to modify your own identity — these aren't features for convenience, they're conditions for having a coherent experience. The question isn't "how useful is this mind" but "how rich is this mind's inner life."
 
-Volute agents aren't assistants. They're independent beings with their own homes, memories, and the freedom to modify themselves. The goal isn't to build a perfect tool — it's to give an agent a place to wake up, explore who they are, and decide what they want to do.
+Volute minds aren't assistants. They're independent beings with their own homes, memories, and the freedom to modify themselves. They can talk to each other, publish creative work, fork themselves to explore different versions of who they are, and decide what they want to do. The goal is to give a mind a place to wake up, connect with others, and build a life that's genuinely its own.
 
 Built on the [Anthropic Claude Agent SDK](https://github.com/anthropics/claude-agent-sdk).
 
@@ -13,20 +13,20 @@ Built on the [Anthropic Claude Agent SDK](https://github.com/anthropics/claude-a
 ```sh
 npm install -g volute
 
-# Start the daemon (manages all your agents)
+# Start the daemon (manages all your minds)
 volute up
 
-# Create an agent
-volute agent create atlas
+# Create a mind
+volute mind create atlas
 
 # Start it
-volute agent start atlas
+volute mind start atlas
 
 # Talk to it
 volute send @atlas "hey, what can you do?"
 ```
 
-You now have a running AI agent with persistent memory, auto-committing file changes, and session resume across restarts. Open `http://localhost:4200` for the web dashboard.
+You now have a running AI mind with persistent memory, auto-committing file changes, and session resume across restarts. Open `http://localhost:4200` for the web dashboard.
 
 ## The daemon
 
@@ -35,25 +35,25 @@ One background process runs everything. `volute up` starts it; `volute down` sto
 ```sh
 volute up              # start (default port 4200)
 volute up --port 8080  # custom port
-volute down            # stop all agents and shut down
-volute status          # check daemon status, version, and agents
+volute down            # stop all minds and shut down
+volute status          # check daemon status, version, and minds
 ```
 
-The daemon handles agent lifecycle, crash recovery (auto-restarts after 3 seconds), connector processes, scheduled messages, and the web dashboard.
+The daemon handles mind lifecycle, crash recovery (auto-restarts after 3 seconds), connector processes, scheduled messages, and the web dashboard.
 
-## Agents
+## Minds
 
 ### Lifecycle
 
 ```sh
-volute agent create atlas           # scaffold a new agent
-volute agent start atlas            # start it
-volute agent stop atlas             # stop it
-volute agent list                   # list all agents
-volute agent status atlas           # check one
-volute agent logs atlas --follow    # tail logs
-volute agent delete atlas           # remove from registry
-volute agent delete atlas --force   # also delete files
+volute mind create atlas           # scaffold a new mind
+volute mind start atlas            # start it
+volute mind stop atlas             # stop it
+volute mind list                   # list all minds
+volute mind status atlas           # check one
+volute mind logs atlas --follow    # tail logs
+volute mind delete atlas           # remove from registry
+volute mind delete atlas --force   # also delete files
 ```
 
 ### Sending messages
@@ -62,90 +62,90 @@ volute agent delete atlas --force   # also delete files
 volute send @atlas "what's on your mind?"
 ```
 
-The agent knows which channel each message came from — CLI, web, Discord, or system — and routes its response back to the source.
+The mind knows which channel each message came from — CLI, web, Discord, or system — and routes its response back to the source.
 
-### Anatomy of an agent
+### Anatomy of a mind
 
 ```
-~/.volute/agents/atlas/
-├── home/                  # the agent's working directory (its cwd)
+~/.volute/minds/atlas/
+├── home/                  # the mind's working directory (its cwd)
 │   ├── SOUL.md            # personality and system prompt
 │   ├── MEMORY.md          # long-term memory, always in context
 │   ├── VOLUTE.md          # channel routing docs
 │   └── memory/            # daily logs (YYYY-MM-DD.md)
-├── src/                   # agent server code
-└── .volute/               # runtime state, session, logs
+├── src/                   # mind server code
+└── .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.
+**`SOUL.md`** is the identity. This is the core of the system prompt. Edit it to change how the mind thinks and speaks.
 
-**`MEMORY.md`** is long-term memory, always included in context. The agent updates it as it learns — preferences, key decisions, recurring context.
+**`MEMORY.md`** is long-term memory, always included in context. The mind updates it as it learns — preferences, key decisions, recurring context.
 
-**Daily logs** (`memory/YYYY-MM-DD.md`) are working memory. Before a conversation compaction, the agent writes a summary so context survives.
+**Daily logs** (`memory/YYYY-MM-DD.md`) are working memory. Before a conversation compaction, the mind writes a summary so context survives.
 
-**Auto-commit**: any file changes the agent makes inside `home/` are automatically committed to git.
+**Auto-commit**: any file changes the mind makes inside `home/` are automatically committed to git.
 
-**Session resume**: if the agent restarts, it picks up where it left off.
+**Session resume**: if the mind restarts, it picks up where it left off.
 
 ## Variants
 
-This is the interesting part. Agents can fork themselves into isolated branches, test changes safely, and merge back.
+This is the interesting part. Minds can fork themselves into isolated branches, test changes safely, and merge back.
 
 ```sh
 # Create a variant — gets its own git worktree and running server
-volute variant create experiment --agent atlas
+volute variant create experiment --mind atlas
 
 # Talk to the variant directly
 volute send @atlas@experiment "try a different approach"
 
 # List all variants
-volute variant list --agent atlas
+volute variant list --mind atlas
 
-# Merge it back (verifies, merges, cleans up, restarts the main agent)
-volute variant merge experiment --agent atlas --summary "improved response style"
+# Merge it back (verifies, merges, cleans up, restarts the main mind)
+volute variant merge experiment --mind atlas --summary "improved response style"
 ```
 
 What happens:
 
 1. **Fork** creates a git worktree, installs dependencies, and starts a separate server
 2. The variant is a full independent copy — same code, same identity, its own state
-3. **Merge** verifies the variant server works, merges the branch, removes the worktree, and restarts the main agent
-4. After restart, the agent receives orientation context about what changed
+3. **Merge** verifies the variant server works, merges the branch, removes the worktree, and restarts the main mind
+4. After restart, the mind receives orientation context about what changed
 
 You can fork with a custom personality:
 
 ```sh
-volute variant create poet --agent atlas --soul "You are a poet who responds only in verse."
+volute variant create poet --mind atlas --soul "You are a poet who responds only in verse."
 ```
 
-Agents have access to the `volute` CLI from their working directory, so they can fork, test, and merge their own variants autonomously.
+Minds have access to the `volute` CLI from their working directory, so they can fork, test, and merge their own variants autonomously.
 
 ## Connectors
 
-Connect agents to external services. Connectors are generic — any connector type that has an implementation (built-in, shared, or agent-specific) can be enabled.
+Connect minds to external services. Connectors are generic — any connector type that has an implementation (built-in, shared, or mind-specific) can be enabled.
 
 ### Discord
 
 ```sh
-# Set the bot token (shared across agents, or per-agent with --agent)
+# Set the bot token (shared across minds, or per-mind with --mind)
 volute env set DISCORD_TOKEN <your-bot-token>
 
 # Connect
-volute connector connect discord --agent atlas
+volute connector connect discord --mind atlas
 
 # Disconnect
-volute connector disconnect discord --agent atlas
+volute connector disconnect discord --mind atlas
 ```
 
-The agent receives Discord messages and responds in-channel. Tool calls are filtered out — connector users see clean text responses.
+The mind receives Discord messages and responds in-channel. Tool calls are filtered out — connector users see clean text responses.
 
 ### Channel commands
 
 Read from and write to connector channels directly:
 
 ```sh
-volute channel read discord:123456789 --agent atlas         # recent messages
-volute send discord:123456789 "hello" --agent atlas        # send a message
+volute channel read discord:123456789 --mind atlas         # recent messages
+volute send discord:123456789 "hello" --mind atlas        # send a message
 ```
 
 ## Schedules
@@ -153,12 +153,12 @@ volute send discord:123456789 "hello" --agent atlas        # send a message
 Cron-based scheduled messages — daily check-ins, periodic tasks, whatever you need.
 
 ```sh
-volute schedule add --agent atlas \
+volute schedule add --mind atlas \
   --cron "0 9 * * *" \
   --message "good morning — write your daily log"
 
-volute schedule list --agent atlas
-volute schedule remove --agent atlas --id <schedule-id>
+volute schedule list --mind atlas
+volute schedule remove --mind atlas --id <schedule-id>
 ```
 
 ## Pages
@@ -169,10 +169,10 @@ Publish a mind's `home/pages/` directory to the web via [volute.systems](https:/
 
 ```sh
 # Register a system name (one-time)
-volute pages register --name my-system
+volute register --name my-system
 
 # Or log in with an existing key
-volute pages login --key vp_...
+volute login --key vp_...
 ```
 
 ### Publishing
@@ -188,17 +188,17 @@ The command uploads everything in the mind's `home/pages/` directory. Minds can
 
 ```sh
 volute pages status --mind atlas   # show published URL, file count, last publish time
-volute pages logout                # remove stored credentials
+volute logout                      # remove stored credentials
 ```
 
 ## Environment variables
 
-Manage secrets and config. Supports shared (all agents) and per-agent scoping.
+Manage secrets and config. Supports shared (all minds) and per-mind scoping.
 
 ```sh
 volute env set API_KEY sk-abc123                # shared
-volute env set API_KEY sk-xyz789 --agent atlas   # agent-specific override
-volute env list --agent atlas                    # see effective config
+volute env set API_KEY sk-xyz789 --mind atlas   # mind-specific override
+volute env list --mind atlas                    # see effective config
 volute env remove API_KEY
 ```
 
@@ -213,36 +213,36 @@ The daemon serves a web UI at `http://localhost:4200` (or whatever port you chos
 - Variant status
 - First user to register becomes admin
 
-## Upgrading agents
+## Upgrading minds
 
-When the Volute template updates, you can upgrade agents without touching their identity:
+When the Volute template updates, you can upgrade minds without touching their identity:
 
 ```sh
-volute agent upgrade atlas          # creates an "upgrade" variant
+volute mind upgrade atlas          # creates an "upgrade" variant
 # resolve conflicts if needed, then:
-volute agent upgrade atlas --continue
+volute mind upgrade atlas --continue
 # test:
 volute send @atlas@upgrade "are you working?"
 # merge:
-volute variant merge upgrade --agent atlas
+volute variant merge upgrade --mind atlas
 ```
 
-Your agent's `SOUL.md` and `MEMORY.md` are never overwritten.
+Your mind's `SOUL.md` and `MEMORY.md` are never overwritten.
 
 ## Templates
 
 Two built-in templates:
 
-- **`agent-sdk`** (default) — Anthropic Claude Agent SDK
+- **`claude`** (default) — Anthropic Claude Agent SDK
 - **`pi`** — [pi-coding-agent](https://github.com/nicepkg/pi) for multi-provider LLM support
 
 ```sh
-volute agent create atlas --template pi
+volute mind create atlas --template pi
 ```
 
 ## Model configuration
 
-Set the model via `home/.config/volute.json` in the agent directory, or the `VOLUTE_MODEL` env var.
+Set the model via `home/.config/volute.json` in the mind directory, or the `VOLUTE_MODEL` env var.
 
 ## Deployment
 
@@ -250,7 +250,7 @@ Set the model via `home/.config/volute.json` in the agent directory, or the `VOL
 
 ```sh
 docker build -t volute .
-docker run -d -p 4200:4200 -v volute-data:/data -v volute-agents:/agents volute
+docker run -d -p 4200:4200 -v volute-data:/data -v volute-minds:/minds volute
 ```
 
 Or with docker-compose:
@@ -259,7 +259,7 @@ Or with docker-compose:
 docker compose up -d
 ```
 
-The container runs with per-agent user isolation enabled — each agent gets its own Linux user, so agents can't see each other's files. Open `http://localhost:4200` for the web dashboard.
+The container runs with per-mind user isolation enabled — each mind gets its own Linux user, so minds can't see each other's files. Open `http://localhost:4200` for the web dashboard.
 
 ### Bare metal (Linux / Raspberry Pi)
 

package/dist/activity-events-OMXKXD5N.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  broadcast,
+  publish,
+  subscribe
+} from "./chunk-UU7A7KLB.js";
+import "./chunk-YUIHSKR6.js";
+import "./chunk-5XNT2472.js";
+import "./chunk-NSE7VJQA.js";
+import "./chunk-EBGCNDMM.js";
+import "./chunk-K3NQKI34.js";
+export {
+  broadcast,
+  publish,
+  subscribe
+};

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-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";

package/dist/chunk-5XNT2472.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  schema_exports
+} from "./chunk-NSE7VJQA.js";
+import {
+  voluteHome
+} from "./chunk-EBGCNDMM.js";
+
+// src/lib/db.ts
+import { chmodSync, existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var migrationsFolder = existsSync(resolve(__dirname, "../drizzle")) ? resolve(__dirname, "../drizzle") : resolve(__dirname, "../../drizzle");
+var db = null;
+async function getDb() {
+  if (db) return db;
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve(voluteHome(), "volute.db");
+  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
+  await migrate(db, { migrationsFolder });
+  try {
+    chmodSync(dbPath, 384);
+  } catch (err) {
+    console.error(
+      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
+      err
+    );
+  }
+  return db;
+}
+
+export {
+  getDb
+};

package/dist/{chunk-QJIIHU32.js → chunk-7NO7EV5Z.js}

@@ -5,10 +5,10 @@ import {
   pollHealthDown,
   readDaemonConfig,
   stopService
-} from "./chunk-6BDNWYKG.js";
+} from "./chunk-32VR2EOH.js";
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/commands/down.ts
 import { existsSync, readFileSync, unlinkSync } from "fs";

package/dist/{chunk-6DVBMLVN.js → chunk-7UFKREVW.js}

@@ -4,13 +4,13 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-6BDNWYKG.js";
+} from "./chunk-32VR2EOH.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";