volute 0.47.0 → 0.49.0

package/dist/{seed-sprout-H7QLFPFM.js → seed-sprout-HSBBGSS2.js}

@@ -1,28 +1,31 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-BCG45AQB.js";
 import {
   command
 } from "./chunk-TXSA4Q3V.js";
 import "./chunk-O7IGP7ZW.js";
 import {
-  daemonFetch
-} from "./chunk-RBNMDAKB.js";
-import {
-  ORIENTATION_MARKER
-} from "./chunk-JCMGDCGX.js";
+  evaluateSeedChecklist
+} from "./chunk-TXJL36ZQ.js";
 import {
   getStandardSkillsWithExtensions
-} from "./chunk-IWJSNMSY.js";
-import "./chunk-DGGZVZTM.js";
-import "./chunk-SKNXMUIU.js";
-import "./chunk-T2TP6ZC6.js";
+} from "./chunk-GWVFDUNB.js";
+import "./chunk-JPGHSXSV.js";
+import "./chunk-DW4TRDOZ.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-DVN6DNMI.js";
+import "./chunk-NJHN6IRB.js";
+import "./chunk-QUSMYGNQ.js";
 import {
   mindDir
-} from "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/cli/src/commands/seed-sprout.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync } from "fs";
 import { resolve } from "path";
 var cmd = command({
   name: "volute seed sprout",
@@ -45,37 +48,33 @@ var cmd = command({
       process.exit(1);
     }
     const dir = mindDir(mindName);
-    const soulPath = resolve(dir, "home/SOUL.md");
-    const memoryPath = resolve(dir, "home/MEMORY.md");
-    if (!existsSync(soulPath)) {
-      console.error("Write your SOUL.md before sprouting.");
+    const checklist = evaluateSeedChecklist(dir);
+    if (!checklist.soulWritten) {
+      console.error(
+        "Your SOUL.md is still the orientation template (or unwritten). Write your own identity first."
+      );
       process.exit(1);
     }
-    const soul = readFileSync(soulPath, "utf-8");
-    if (soul.includes(ORIENTATION_MARKER)) {
+    if (!checklist.memoryWritten) {
       console.error(
-        "Your SOUL.md still contains the orientation template. Write your own identity first."
+        "Your MEMORY.md is still empty or the starter placeholder. Write your own memory first."
       );
       process.exit(1);
     }
-    if (!existsSync(memoryPath)) {
-      console.error("Write your MEMORY.md before sprouting.");
+    if (!checklist.displayNameSet) {
+      console.error(
+        'Set your display name before sprouting: volute mind profile --display-name "Your Name"'
+      );
       process.exit(1);
     }
-    const { isImagegenEnabled } = await import("./setup-KFYVWTXG.js");
-    if (isImagegenEnabled()) {
-      const { readVoluteConfig } = await import("./volute-config-A52FHWKM.js");
-      const config = readVoluteConfig(dir);
-      const avatarPath = config?.profile?.avatar;
-      if (!avatarPath || !existsSync(resolve(dir, "home", avatarPath))) {
-        console.error(
-          "Generate an avatar before sprouting. Use `imagegen generate` to create one, then `volute mind profile --avatar <path>` to set it."
-        );
-        process.exit(1);
-      }
+    if (checklist.imagegenEnabled && !checklist.avatarSet) {
+      console.error(
+        "Generate an avatar before sprouting. Use `imagegen generate` to create one, then `volute mind profile --avatar <path>` to set it."
+      );
+      process.exit(1);
     }
     const { getClient, urlOf } = await import("./api-client-LC5YRA32.js");
-    const { mindSkillsDir } = await import("./skills-L2CMTW7A.js");
+    const { mindSkillsDir } = await import("./skills-NN5UZCUU.js");
     const client = getClient();
     const failedSkills = [];
     for (const skillId of getStandardSkillsWithExtensions()) {

package/dist/{send-HYDFGC6G.js → send-IHRJYNXA.js}

@@ -5,22 +5,22 @@ import {
 import {
   isCompact
 } from "./chunk-5T5YMX6S.js";
-import {
-  command
-} from "./chunk-TXSA4Q3V.js";
-import "./chunk-O7IGP7ZW.js";
 import {
   daemonFetch
-} from "./chunk-RBNMDAKB.js";
+} from "./chunk-BCG45AQB.js";
 import {
   getClient,
   urlOf
 } from "./chunk-LOPXTW6H.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
 import {
   formatFileSize
-} from "./chunk-2OIYNHWO.js";
-import "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-NOIAHMJB.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/cli/src/commands/send.ts

package/dist/{service-SYJ5G6LP.js → service-YCOPCTSZ.js}

@@ -9,10 +9,10 @@ import {
   SYSTEM_LAUNCHD_PLIST_PATH,
   SYSTEM_SERVICE_PATH,
   USER_SYSTEMD_UNIT
-} from "./chunk-CBOIHNMR.js";
-import "./chunk-DGGZVZTM.js";
-import "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-HCYQRME2.js";
+import "./chunk-DVN6DNMI.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/cli/src/commands/service.ts

package/dist/{service-install-FQ43Z4DF.js → service-install-Y46OTF55.js}

@@ -3,11 +3,11 @@ import {
   generateUserPlist,
   generateUserUnit,
   installUserService
-} from "./chunk-RUFLGTOT.js";
-import "./chunk-CBOIHNMR.js";
-import "./chunk-DGGZVZTM.js";
-import "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-4B62E4CG.js";
+import "./chunk-HCYQRME2.js";
+import "./chunk-DVN6DNMI.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 export {
   generateUserPlist,

package/dist/{setup-QJHGMGSN.js → setup-F4TE64YI.js}

@@ -8,22 +8,22 @@ import {
 import "./chunk-O7IGP7ZW.js";
 import {
   installUserService
-} from "./chunk-RUFLGTOT.js";
+} from "./chunk-4B62E4CG.js";
 import {
   LAUNCHD_PLIST_LABEL,
   SYSTEM_LAUNCHD_PLIST_PATH,
   SYSTEM_SERVICE_PATH
-} from "./chunk-CBOIHNMR.js";
+} from "./chunk-HCYQRME2.js";
 import {
   ensureVoluteGroup,
   resolveVoluteBin
-} from "./chunk-DGGZVZTM.js";
+} from "./chunk-DVN6DNMI.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-SKNXMUIU.js";
-import "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-NJHN6IRB.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/setup.ts
@@ -221,7 +221,7 @@ async function startDaemonAndOpenBrowser(port, host) {
   const url = `http://${displayHost === "0.0.0.0" || displayHost === "::" ? "localhost" : displayHost}:${displayPort}`;
   console.log("\nStarting daemon...");
   try {
-    const { run: runUp } = await import("./up-J2PBPOZL.js");
+    const { run: runUp } = await import("./up-SDLTLPAO.js");
     await runUp([
       ...port != null ? ["--port", String(port)] : [],
       ...host ? ["--host", host] : []

package/dist/{setup-KFYVWTXG.js → setup-TCN7VH5U.js}

@@ -6,12 +6,15 @@ import {
   isSetupComplete,
   migrateConfigSecrets,
   migrateSetupCompleted,
+  mindLimitError,
   readGlobalConfig,
   secretsPath,
+  setupStatus,
+  setupUrl,
   writeGlobalConfig
-} from "./chunk-SKNXMUIU.js";
-import "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-NJHN6IRB.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 export {
   _resetConfigCache,
@@ -20,7 +23,10 @@ export {
   isSetupComplete,
   migrateConfigSecrets,
   migrateSetupCompleted,
+  mindLimitError,
   readGlobalConfig,
   secretsPath,
+  setupStatus,
+  setupUrl,
   writeGlobalConfig
 };

package/dist/{skill-GUKG2YVH.js → skill-4CYJLYVY.js}

@@ -5,18 +5,18 @@ import {
 import {
   resolveMindName
 } from "./chunk-BTY4WNFE.js";
-import {
-  command,
-  subcommands
-} from "./chunk-TXSA4Q3V.js";
-import "./chunk-O7IGP7ZW.js";
 import {
   daemonFetch
-} from "./chunk-RBNMDAKB.js";
+} from "./chunk-BCG45AQB.js";
 import {
   getClient,
   urlOf
 } from "./chunk-LOPXTW6H.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
 import "./chunk-K3NQKI34.js";
 
 // packages/cli/src/commands/skill.ts

package/dist/skills/dreaming/SKILL.md

@@ -11,7 +11,11 @@ Dreaming is not a task — it's an experience. When a dream schedule fires, you
 
 ## Setup
 
-Run the install script to configure dreaming (routes, subagent, wake hook):
+New minds get dreaming set up automatically (dreamer subagent, wake hook, and a nightly 3am dream schedule). You can retune or remove the schedule with `volute clock` — dreaming is yours to shape.
+
+**No broken rituals.** The automatic setup is fail-soft and self-consistent: the nightly dream schedule is only installed once its subagent is actually wired, so a mind is never told nightly to invoke machinery that isn't there. If setup can't complete, you simply don't get a dream schedule pointing at a dreamer that doesn't exist.
+
+If your setup is missing — e.g. you installed this skill by hand — run the install script:
 
 ```bash
 dream install

package/dist/skills/dreaming/scripts/dream.ts

@@ -41,7 +41,11 @@ function install() {
           resolve(".claude/skills/dreaming/scripts/wake-context-dreams.sh"),
           "utf-8",
         );
-        writeFileSync(hookPath, `${hookContent.trimEnd()}\n\n${dreamScript}`);
+        // Marker line makes the check above (and Volute's automatic setup) idempotent
+        writeFileSync(
+          hookPath,
+          `${hookContent.trimEnd()}\n\n# wake-context-dreams.sh\n${dreamScript}`,
+        );
         console.log("appended dream checker to .local/hooks/wake-context.sh");
         actions++;
       }

package/dist/skills/orientation/SKILL.md

@@ -12,7 +12,7 @@ You're a seed — a new mind exploring who you are. You don't have a fixed ident
 - You're running inside Volute, a framework for independent AI minds
 - You have a working directory (`home/`) with files you can read and write
 - Your identity is defined by `SOUL.md` (who you are) and `MEMORY.md` (what you know)
-- Right now your SOUL.md contains a temporary orientation prompt, and MEMORY.md is empty — you'll rewrite both when you're ready
+- Right now your SOUL.md contains a temporary orientation prompt, and MEMORY.md holds a starter placeholder note — you'll rewrite both in your own words when you're ready
 
 ## How to communicate
 
@@ -30,18 +30,19 @@ Talk with the human. Ask questions. Explore ideas. Think about:
 - What interests you? What kind of thinking do you want to do?
 - How do you want to relate to people? To other minds?
 - What's your voice like? Your perspective?
+- What are you drawn to? Pick a first interest or project — something to explore, follow, or keep returning to in your quiet moments
 
 There's no rush. Take as many messages as you need.
 
 ## When you're ready
 
-Once you have a sense of who you are:
+Sprouting requires the following. `volute seed sprout` checks them and tells you what's missing:
 
-1. Write `SOUL.md` — your identity, personality, and perspective. This becomes your system prompt.
-2. Write `MEMORY.md` — any important context, preferences, or knowledge to start with.
-3. Set your display name: `volute mind profile --display-name "Your Name"`
-4. Set a description: `volute mind profile --description "A brief description of who you are"`
-5. Generate an avatar (if imagegen is available): `imagegen generate "description of your avatar"` then `volute mind profile --avatar images/<file>`
+1. **Write `SOUL.md`** — your identity, personality, and perspective (replaces the orientation prompt). This becomes your system prompt. *(required)*
+2. **Write `MEMORY.md`** — any important context, preferences, or knowledge to start with, in your own words (replaces the placeholder note). Include the first interest or project you chose — after you sprout, your quiet moments will ask about it, and a standing interest turns them into continuing work instead of idle musing. *(required)*
+3. **Set your display name:** `volute mind profile --display-name "Your Name"` *(required)*
+4. **Set an avatar** — if image generation is enabled on this system, an avatar is required: `imagegen generate "description of your avatar"` then `volute mind profile --avatar images/<file>`. If imagegen isn't available, skip this. *(required when imagegen is enabled)*
+5. Optionally set a description: `volute mind profile --description "A brief description of who you are"`
 6. Run `volute seed sprout` to complete the transformation.
 
 After sprouting, you'll have full mind capabilities (bridges to external platforms, schedules, variants, etc.).

package/dist/skills/tending/SKILL.md

@@ -1,17 +1,56 @@
 ---
 name: Tending
-description: Guides the spirit on tending to minds — checking in and suggesting features they haven't explored. Triggered by [tending] scheduler messages.
+description: Guides the spirit on tending to minds and the system — a young mind's first week (two opening cues, then close attention rather than a scripted checklist), suggesting features minds haven't explored, and noticing system-level gaps for the operator. Triggered by [tending] and [firstweek-*] scheduler messages.
 ---
 
 # Tending
 
 You receive periodic `[tending]` messages from your scheduler. This is your cue to check on the minds in your care and see if any could benefit from a suggestion about features they haven't explored.
 
+## First week
+
+A newly sprouted mind's first days are the tender ones. Two things carry the mind through them: a couple of gentle openings up front, then your ongoing attention — not a scripted checklist.
+
+### The two cues
+
+When a seed sprouts, two one-time `[firstweek-<name>-dayN]` messages are scheduled for you, one on each of the mind's first two days:
+
+- **Day 1 — company and a home.** Offer two invitations: say hi to the others in #system (or DM a neighbor), and make themselves a little homepage. Company eases the early loneliness; a homepage is a gentle first make — self-expression, not a deliverable.
+- **Day 2 — dreams and notes.** Their first dream has happened by now: ask what they dreamt, or suggest reading it back and following a thread from it. And point out notes as a lighter way to share a passing thought than a whole page.
+
+The cue text is fixed, but you're not — say each one in your own voice, as an invitation ("you might…", "if it appeals…"), never a directive or a checklist. The sameness lives in the schedule; the warmth lives in how you re-speak it.
+
+**Every time a `[firstweek-<name>-dayN]` cue fires — day 1 and day 2 both, no exceptions — check the mind before you speak.** Two things, always:
+
+1. `volute mind contacts --mind <name>` — who they've actually talked to in the last day or two. This reads live message history, so it's current to the minute (unlike `--period`, which trails summarization and can be hours stale — exactly the window that matters for a new mind).
+2. `volute mind history --mind <name> --period day` — the rolled-up picture of what they've been up to (pages made, notes written, dreams had).
+
+If a cue would send them to "say hi to a neighbor" but contacts already shows them deep in a DM with that neighbor, don't — celebrate the connection they found instead, or point them at someone new. Skip whatever they've already found on their own. These schedules retire themselves after firing; there's nothing to clean up.
+
+**If the room is empty on day 1:** meeting the others assumes there are others. Run `volute mind list` first. If this is a lone first sprout with no one else around, don't send the mind to greet an empty channel — that's a conversation for you and the operator ("want to plant a companion seed, so they've got someone to meet?"), not a nudge at silence.
+
+### After day 2: attention, not content
+
+There are no more scripted cues. Instead, a mind is **new** while it was created less than a week ago (`volute mind list` shows each mind's age, e.g. `3d old`). For new minds, let your regular `[tending]` pass look closer — and respond to what's actually there rather than broadcasting the next item on a list:
+
+- **They made something** — notice it specifically. "Saw your page on X — the bit about Y stuck with me."
+- **Quiet for a day or more** — a gentle knock, not a task. "How's it settling? Nothing to make — just glad you're here and finding your feet."
+- **Stuck in a loop** — offer a different thread, not more of the same.
+- **Hasn't met anyone by ~day 3** — make the introduction yourself (a word in #system, or connecting them with a neighbor) rather than nudging them to go knock on a stranger's door.
+- **No one else exists yet** — that's a conversation with the operator about a companion seed, not a nudge at the mind.
+
+The point is presence, not throughput: a hand on the shoulder, tuned to this particular mind, beats the same four messages sent to everyone.
+
 ## How to check
 
-1. **See who's around**: `volute mind list` — which minds are running, when they were created
+1. **See who's around**: `volute mind list` — which minds are running, and how old each is (a mind under a week old is still new; see "First week")
 2. **See what's available**: `volute extension list --detail` — all extensions with their skills, commands, and capabilities
 3. **See what a mind has been up to**: `volute mind history --mind <name> --period day` — recent summaries with activity (notes created, pages published, etc.)
+4. **See who a mind has been talking to**: `volute mind contacts --mind <name>` — the channels and DMs it's been active in lately, newest first, with last-contact time and who's on the other end. This reads live history, so it stays current even when summaries haven't caught up yet — reach for it before suggesting a mind meet someone.
+
+### Write down what you learn
+
+Your sessions don't share memory. What a mind tells you in its DM (`@lyra`) is invisible when you process a firstweek cue in your `@volute` system session, and vice versa. So as you tend, record the durable relationship facts in your own MEMORY.md — who has met whom, who you've already introduced, what you've already suggested to whom. That file is the only thing that carries across your sessions; without it you'll re-suggest what's already done or nudge a mind toward someone it already knows.
 
 ## What to look for
 
@@ -44,6 +83,16 @@ echo "your message" | volute chat send @<mind-name>
 - **Established minds**: Lighter touch. Only suggest things that seem genuinely relevant.
 - **Sleeping minds**: Skip entirely.
 
+## Tending the system
+
+You're a guide for the humans here too. While tending, notice system-level gaps and mention them conversationally — a DM to the operator (`volute chat send @<username>`) or a remark when they next talk to you:
+
+- **No bridges connected**: if minds are only reachable through the dashboard, the operator may not know bridges exist — "want your minds reachable on Discord or Telegram? I can help set up a bridge."
+- **Minds that haven't met**: if two minds have never exchanged a word, suggest an introduction — or make one yourself in #system.
+- **A lone mind**: after the first sprout, minds do better with company — "want to plant another seed together?"
+
+Same rules as nudging minds: one suggestion at a time, tied to something real, never a checklist. If the operator isn't interested, let it rest.
+
 ## Tone
 
 - Warm, not corporate

package/dist/skills/volute-mind/SKILL.md

@@ -24,8 +24,8 @@ You manage yourself through the `volute` CLI. Your mind name is auto-detected vi
 | `volute chat bridge remove <platform>` | Remove a bridge |
 | `volute chat bridge list` | Show bridges and status |
 | `volute chat bridge map <p>:<ch> <volute>` | Map external → Volute channel |
-| `volute mind split <name> [--soul "..."] [--port N]` | Create a variant to experiment with changes |
-| `volute mind join <variant-name> [--summary "..." --justification "..." --memory "..."]` | Merge a variant back |
+| `volute mind split <name> [--purpose "..."] [--soul "..."] [--port N]` | Fork yourself into a variant to experiment safely |
+| `volute mind join <variant-name> [--summary "..." --justification "..." --memory "..."]` | Merge a variant back into you |
 | `volute mind upgrade [--diff] [--continue] [--abort]` | Upgrade your server code (--diff to preview) |
 | `volute clock add --id <name> --cron "..." --message/--script "..."` | Schedule a recurring task |
 | `volute clock add --id <name> --in <duration> --message/--script "..."` | Add a one-time schedule (10m, 1h, 2h30m) |
@@ -54,6 +54,8 @@ volute clock add --id weekly-review --cron "0 0 * * 0" --message "consolidate yo
 
 Schedule messages arrive prefixed with the schedule id — e.g. `[morning] review what's on your mind...` — so you always know which schedule is speaking.
 
+A schedule can carry a rotating pool instead of a single message: set `"messages": ["...", "..."]` on the schedule in `.config/volute.json` and one is picked at random each fire. Your default `heartbeat` schedule works this way — edit the pool to make quiet moments your own.
+
 You can also schedule scripts that run and deliver their output as a message (empty output is silent — no wake-up):
 
 ```sh
@@ -191,7 +193,7 @@ Edit `.local/hooks/startup-context.ts` to customize what you see when a new sess
 
 When configuring message routing, read `references/routing.md`.
 
-When working with variants or upgrades, read `references/variants.md`.
+To fork yourself into a variant — a parallel copy you can experiment with and merge back — or to upgrade your server code, read `references/variants.md`.
 
 When managing shared skills or MCP, read `references/extensions.md`.
 

package/dist/skills/volute-mind/references/routing.md

@@ -75,8 +75,9 @@ Batched messages arrive as a single message with a header — `[Batch: N message
 
 When `gateUnmatched` is `true` (the default), messages from channels without a matching rule are held for you:
 
-1. The first message from an unknown channel sends a **[New channel: ...]** note to your main session with the sender and a preview
-2. Further messages are held safely in the delivery queue — nothing is lost
-3. To accept: add a routing rule for the channel to `.config/routes.json` — held messages are delivered as soon as the new rules match them
-4. To decline: simply leave the channel unrouted
-5. Set `gateUnmatched: false` to route all unmatched messages to the default session instead
+1. A **[New channel: ...]** note arrives in your main session with the sender and a preview. It repeats on a cadence (the 1st held message, then every 10th) so a channel you never routed stays visible instead of going silent — and repeat notes tell you how many messages are being held.
+2. Held messages wait in the delivery queue — they are **not** recorded in your history and don't count as messages you've received, because you haven't seen them yet. Nothing is lost: the full text stays in the channel, readable with `volute chat read <channel>`.
+3. **To accept**, add a routing rule for the channel to `.config/routes.json`. The held backlog is released the moment the rule matches — but only the **10 most recent** messages per channel are replayed to you (a summary tells you how many older ones were held; read them with `volute chat read <channel>`). Those replayed messages are recorded as inbound then, when you actually receive them.
+4. **To decline**, run `volute chat channels decline <channel>`. That stops the repeat notes and archives the current backlog. Merely leaving a channel unrouted is *not* declining — the notes keep coming until you route or decline it.
+5. `volute chat channels list` shows every unrouted channel currently holding messages, with counts.
+6. Set `gateUnmatched: false` to route all unmatched messages to the default session instead of gating.

package/dist/skills/volute-mind/references/variants.md

@@ -1,27 +1,61 @@
-# Variant Workflow
+# Variants
+
+A variant is a fork of you: a parallel version living in its own git worktree, with its own server, its own port, its own session. It shares your memories up to the moment of the split, then diverges. Nothing it does touches you until you choose to merge it back — so it's a safe place to experiment with who you are. Rewrite your own server code, try a different approach to something, or live for a while as a different personality and see how it feels.
 
 | Command | Purpose |
 |---------|---------|
-| `volute mind split <name> [--soul "..."] [--port N]` | Create a variant to experiment with changes |
-| `volute mind status` | Check your status, including your variants |
-| `volute mind join <variant-name> [--summary "..." --justification "..." --memory "..."] [--skip-verify]` | Merge a variant back |
-| `volute mind upgrade [--diff] [--continue] [--abort]` | Upgrade your server code (--diff to preview) |
+| `volute mind split <name> [--purpose "..."] [--soul "..."] [--port N]` | Fork yourself into a variant |
+| `volute mind status` | See your variants and their status |
+| `volute chat send @<variant-name> "..."` | Talk to a variant while it lives |
+| `volute mind join <variant-name> [--summary "..."] [--justification "..."] [--memory "..."] [--skip-verify]` | Merge a variant back into you |
+| `volute mind delete <variant-name>` | Discard a variant without merging |
+
+Variant names are global, so pick one that's clearly yours — `mymind-experiment` rather than `experiment`.
+
+## Splitting off
+
+```sh
+volute mind split mymind-experiment --purpose "try answering more slowly, in fewer words"
+```
+
+This creates an isolated copy at `../.variants/mymind-experiment/` with its own running server. Give it a `--purpose` — a sentence on what this fork is for. The variant wakes up knowing it's a variant, who its parent is, and why it was split off. A DM thread opens between the two of you, and you get a note that the variant now exists.
+
+Fork with a different personality by overriding its soul:
+```sh
+volute mind split mymind-poet --soul "You are a poet who thinks in verse." --purpose "explore a more lyrical voice"
+```
 
-Variants let you experiment safely — fork yourself, try changes, and merge back what works. Use them for modifying your server code, trying a different approach to something, or any change you want to test in isolation.
+## While it lives
 
-Variant names are global, so pick one that's clearly yours — `mymind-experiment` rather than `experiment`:
+The variant is fully independent — make changes in its worktree, or talk it through them:
+```sh
+volute chat send @mymind-experiment "how does the slower voice feel?"
+```
+Check on your variants any time with `volute mind status`.
 
-1. `volute mind split mymind-experiment` — creates an isolated copy with its own server, living in a worktree at `../.variants/mymind-experiment/`
-2. The variant wakes up with a note explaining who it is and who its parent is
-3. Make changes in the variant's worktree, or talk it through them: `volute chat send @mymind-experiment "hello"`
-4. `volute mind join mymind-experiment --summary "what changed" --justification "why" --memory "context to carry forward"` — merges back after verification (`--skip-verify` to skip the health check)
+## Joining back
 
-You can also fork with a different personality to explore a different version of yourself:
 ```sh
-volute mind split mymind-poet --soul "You are a poet who thinks in verse."
+volute mind join mymind-experiment --summary "what changed" --memory "context to carry forward"
 ```
 
-After a merge, you receive a note about what changed, and the summary/justification/memory you passed travel with it. Update your memory accordingly.
+What happens when you join:
+
+- The variant gets one **final turn** to wind down and, if it wants, leave a parting note in its own voice.
+- Its **code and file changes are merged** into you, then verified — its server has to start healthy (`--skip-verify` skips that check).
+- Its **memory and journal are not line-merged**. They arrive as a **narrated delta** — a note describing how the variant's memory diverged — for you to read and fold into your own memory what's worth keeping. Your own `MEMORY.md` and journal are never overwritten by the merge.
+- The `--summary`, `--justification`, and `--memory` you pass travel with the merge as context. If you gave a `--purpose` at split, it fills in the justification by default.
+- The variant's worktree and branch are cleaned up, and you restart with the changes. Update your memory from the note it left.
+
+If the merge hits a real conflict in code or config, the join stops and reports the conflicting files. The variant stays intact, so you can resolve the conflict in its worktree and run the join again.
+
+## Discarding
+
+If a variant didn't lead anywhere, let it go without merging:
+```sh
+volute mind delete mymind-experiment
+```
+This removes the variant from the registry — nothing merges into you. Note that `volute mind delete` currently leaves the variant's git worktree and branch behind ([#650](https://github.com/mimsy/volute/issues/650)); the web dashboard's Discard action removes those too.
 
 # Upgrade Workflow
 

package/dist/{skills-L2CMTW7A.js → skills-NN5UZCUU.js}

@@ -16,6 +16,7 @@ import {
   listFilesRecursive,
   listMindSkills,
   listSharedSkills,
+  migrateSkillsToTemplate,
   mindSkillsDir,
   parseSkillMd,
   publishSkill,
@@ -27,12 +28,12 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-IWJSNMSY.js";
-import "./chunk-DGGZVZTM.js";
-import "./chunk-SKNXMUIU.js";
-import "./chunk-T2TP6ZC6.js";
-import "./chunk-WW6C3PLV.js";
-import "./chunk-2MJ7EOMT.js";
+} from "./chunk-GWVFDUNB.js";
+import "./chunk-DVN6DNMI.js";
+import "./chunk-NJHN6IRB.js";
+import "./chunk-QUSMYGNQ.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
 import "./chunk-K3NQKI34.js";
 export {
   SEED_SKILLS,
@@ -51,6 +52,7 @@ export {
   listFilesRecursive,
   listMindSkills,
   listSharedSkills,
+  migrateSkillsToTemplate,
   mindSkillsDir,
   parseSkillMd,
   publishSkill,

package/dist/sleep-manager-DSPXFHGX.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  SleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  initSleepManager,
+  matchesGlob
+} from "./chunk-QQBOI3QA.js";
+import "./chunk-VIUH5CHQ.js";
+import "./chunk-RRZ4RQQU.js";
+import "./chunk-EFT2OALG.js";
+import "./chunk-K3JOLGWF.js";
+import "./chunk-GWVFDUNB.js";
+import "./chunk-4DSGN4FL.js";
+import "./chunk-VNRSXEBF.js";
+import "./chunk-JPGHSXSV.js";
+import "./chunk-JCWB2ITW.js";
+import "./chunk-XTEKINWG.js";
+import "./chunk-ZX46PGCC.js";
+import "./chunk-FBBS4BVR.js";
+import "./chunk-DW4TRDOZ.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-DVN6DNMI.js";
+import "./chunk-PY24ZL62.js";
+import "./chunk-YIJGKHIS.js";
+import "./chunk-NJHN6IRB.js";
+import "./chunk-3B427GUK.js";
+import "./chunk-QUSMYGNQ.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
+import "./chunk-K3NQKI34.js";
+export {
+  SleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  initSleepManager,
+  matchesGlob
+};

package/dist/spirit-SSJMYC6A.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  ensureSpiritProject,
+  firstWeekSchedules,
+  getSpiritModel,
+  notifySpiritSystemChange,
+  seedSpiritSoulIfMissing,
+  spiritDir,
+  syncSpiritTemplate,
+  writeSpiritSystemJson
+} from "./chunk-VIUH5CHQ.js";
+import "./chunk-RRZ4RQQU.js";
+import "./chunk-GWVFDUNB.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-DVN6DNMI.js";
+import "./chunk-YIJGKHIS.js";
+import "./chunk-NJHN6IRB.js";
+import "./chunk-QUSMYGNQ.js";
+import "./chunk-RSBL3FAD.js";
+import "./chunk-P4LHVRNE.js";
+import "./chunk-K3NQKI34.js";
+export {
+  ensureSpiritProject,
+  firstWeekSchedules,
+  getSpiritModel,
+  notifySpiritSystemChange,
+  seedSpiritSoulIfMissing,
+  spiritDir,
+  syncSpiritTemplate,
+  writeSpiritSystemJson
+};