volute 0.34.0 → 0.35.0

package/dist/skill-TAAKEYBV.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import {
+  isCompact
+} from "./chunk-5T5YMX6S.js";
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/skill.ts
+var listSkillsCmd = command({
+  name: "volute skill list",
+  description: "List skills (shared pool or per-mind)",
+  flags: {
+    mind: { type: "string", description: "Mind name (shows installed skills for mind)" }
+  },
+  run: async ({ flags }) => {
+    if (flags.mind || process.env.VOLUTE_MIND) {
+      const mindName = resolveMindName(flags);
+      const client = getClient();
+      const url = urlOf(client.api.minds[":name"].skills.$url({ param: { name: mindName } }));
+      const res = await daemonFetch(url);
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "Unknown error" }));
+        console.error(`Error: ${body.error}`);
+        process.exit(1);
+      }
+      const skills = await res.json();
+      if (skills.length === 0) {
+        console.log("No skills installed.");
+        return;
+      }
+      const compact = isCompact();
+      console.log(`Skills for ${mindName}:${compact ? "" : "\n"}`);
+      for (const s of skills) {
+        const update = s.updateAvailable ? " (update available)" : "";
+        const source = s.upstream ? ` [shared:${s.upstream.source} v${s.upstream.version}]` : "";
+        console.log(`  ${s.id} \u2014 ${s.name}${source}${update}`);
+      }
+    } else {
+      const client = getClient();
+      const url = urlOf(client.api.skills.$url());
+      const res = await daemonFetch(url);
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: "Unknown error" }));
+        console.error(`Error: ${body.error}`);
+        process.exit(1);
+      }
+      const skills = await res.json();
+      if (skills.length === 0) {
+        console.log("No shared skills available.");
+        return;
+      }
+      const compact = isCompact();
+      console.log(`Shared skills:${compact ? "" : "\n"}`);
+      for (const s of skills) {
+        console.log(`  ${s.id} \u2014 ${s.name} (v${s.version}, by ${s.author})`);
+        if (s.description && !compact) console.log(`    ${s.description}`);
+      }
+    }
+  }
+});
+var infoSkillCmd = command({
+  name: "volute skill info",
+  description: "Show details of a shared skill",
+  args: [{ name: "name", required: true, description: "Skill ID" }],
+  flags: {},
+  run: async ({ args }) => {
+    const id = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.skills[":id"].$url({ param: { id } }));
+    const res = await daemonFetch(url);
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    const skill = await res.json();
+    console.log(`${skill.name} (${skill.id})`);
+    console.log(`  Version: ${skill.version}`);
+    console.log(`  Author: ${skill.author}`);
+    if (skill.description) console.log(`  Description: ${skill.description}`);
+    console.log(`  Files: ${skill.files.join(", ")}`);
+  }
+});
+var installSkillCmd = command({
+  name: "volute skill install",
+  description: "Install a shared skill into a mind",
+  args: [{ name: "name", required: true, description: "Skill to install" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    const skillId = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.minds[":name"].skills.install.$url({ param: { name: mindName } }));
+    const res = await daemonFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skillId })
+    });
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body2.error}`);
+      process.exit(1);
+    }
+    const body = await res.json().catch(() => ({}));
+    console.log(`Installed skill "${skillId}" into ${mindName}.`);
+    if (body.npmInstalled?.length) {
+      console.log(`Installed npm dependencies: ${body.npmInstalled.join(", ")}`);
+    }
+    if (body.installNotes) {
+      console.log("");
+      console.log(body.installNotes);
+    }
+  }
+});
+async function doUpdate(mindName, skillId) {
+  const client = getClient();
+  const url = urlOf(client.api.minds[":name"].skills.update.$url({ param: { name: mindName } }));
+  const res = await daemonFetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ skillId })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Error updating ${skillId}: ${body.error}`);
+    return false;
+  }
+  const result = await res.json();
+  switch (result.status) {
+    case "up-to-date":
+      console.log(`${skillId}: already up to date.`);
+      break;
+    case "updated":
+      console.log(`${skillId}: updated successfully.`);
+      break;
+    case "conflict":
+      console.log(`${skillId}: updated with conflicts in:`);
+      for (const f of result.conflictFiles ?? []) {
+        console.log(`  ${f}`);
+      }
+      console.log("Resolve conflicts and commit manually.");
+      break;
+  }
+  return true;
+}
+var updateSkillCmd = command({
+  name: "volute skill update",
+  description: "Update an installed skill from the shared pool (3-way merge)",
+  args: [{ name: "name", description: "Skill to update" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" },
+    all: { type: "boolean", description: "Update all skills" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    if (flags.all) {
+      const client = getClient();
+      const listUrl = urlOf(client.api.minds[":name"].skills.$url({ param: { name: mindName } }));
+      const listRes = await daemonFetch(listUrl);
+      if (!listRes.ok) {
+        const body = await listRes.json().catch(() => ({ error: "Unknown error" }));
+        console.error(`Error: ${body.error}`);
+        process.exit(1);
+      }
+      const skills = await listRes.json();
+      const updatable = skills.filter((s) => s.updateAvailable && s.upstream);
+      if (updatable.length === 0) {
+        console.log("All skills are up to date.");
+        return;
+      }
+      let failures = 0;
+      for (const s of updatable) {
+        const ok2 = await doUpdate(mindName, s.id);
+        if (!ok2) failures++;
+      }
+      if (failures > 0) process.exit(1);
+      return;
+    }
+    const skillId = args.name;
+    if (!skillId) {
+      console.error("Usage: volute skill update <name> [--mind <name>] [--all]");
+      process.exit(1);
+    }
+    const ok = await doUpdate(mindName, skillId);
+    if (!ok) process.exit(1);
+  }
+});
+var publishSkillCmd = command({
+  name: "volute skill publish",
+  description: "Publish a mind's skill to the shared repository",
+  args: [{ name: "name", required: true, description: "Skill to publish" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    const skillId = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.minds[":name"].skills.publish.$url({ param: { name: mindName } }));
+    const res = await daemonFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skillId })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    const skill = await res.json();
+    console.log(`Published skill "${skillId}" (v${skill.version}).`);
+  }
+});
+var removeSkillCmd = command({
+  name: "volute skill remove",
+  description: "Remove a shared skill from the pool",
+  args: [{ name: "name", required: true, description: "Shared skill to remove" }],
+  flags: {},
+  run: async ({ args }) => {
+    const id = args.name;
+    const client = getClient();
+    const url = urlOf(client.api.skills[":id"].$url({ param: { id } }));
+    const res = await daemonFetch(url, { method: "DELETE" });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Removed shared skill "${id}".`);
+  }
+});
+var uninstallSkillCmd = command({
+  name: "volute skill uninstall",
+  description: "Uninstall a skill from a mind",
+  args: [{ name: "name", required: true, description: "Skill to uninstall" }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName(flags);
+    const skillId = args.name;
+    const client = getClient();
+    const url = urlOf(
+      client.api.minds[":name"].skills[":skill"].$url({
+        param: { name: mindName, skill: skillId }
+      })
+    );
+    const res = await daemonFetch(url, { method: "DELETE" });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Uninstalled skill "${skillId}" from ${mindName}.`);
+  }
+});
+var defaultsListCmd = command({
+  name: "volute skill defaults list",
+  description: "List default skills for new minds",
+  flags: {},
+  run: async () => {
+    const res = await daemonFetch("/api/skills/defaults/list");
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    const { skills } = await res.json();
+    console.log("Default skills for new minds:\n");
+    for (const s of skills) {
+      console.log(`  ${s}`);
+    }
+  }
+});
+var defaultsAddCmd = command({
+  name: "volute skill defaults add",
+  description: "Add a skill to the defaults",
+  args: [{ name: "name", required: true, description: "Skill to add" }],
+  flags: {},
+  run: async ({ args }) => {
+    const skillId = args.name;
+    const res = await daemonFetch("/api/skills/defaults/list", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skill: skillId })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Added "${skillId}" to default skills.`);
+  }
+});
+var defaultsRemoveCmd = command({
+  name: "volute skill defaults remove",
+  description: "Remove a skill from the defaults",
+  args: [{ name: "name", required: true, description: "Skill to remove" }],
+  flags: {},
+  run: async ({ args }) => {
+    const skillId = args.name;
+    const res = await daemonFetch(`/api/skills/defaults/list/${encodeURIComponent(skillId)}`, {
+      method: "DELETE"
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: "Unknown error" }));
+      console.error(`Error: ${body.error}`);
+      process.exit(1);
+    }
+    console.log(`Removed "${skillId}" from default skills.`);
+  }
+});
+var defaultsCmd = subcommands({
+  name: "volute skill defaults",
+  description: "Manage default skills for new minds",
+  commands: {
+    list: {
+      description: "List default skills",
+      run: defaultsListCmd.execute
+    },
+    add: {
+      description: "Add a skill to the defaults",
+      run: defaultsAddCmd.execute
+    },
+    remove: {
+      description: "Remove a skill from the defaults",
+      run: defaultsRemoveCmd.execute
+    }
+  }
+});
+var cmd = subcommands({
+  name: "volute skill",
+  description: "Browse, install, and manage skills",
+  commands: {
+    list: {
+      description: "List skills (shared or per-mind with --mind)",
+      run: listSkillsCmd.execute
+    },
+    info: {
+      description: "Show details of a shared skill",
+      run: infoSkillCmd.execute
+    },
+    install: {
+      description: "Install a shared skill into a mind",
+      run: installSkillCmd.execute
+    },
+    update: {
+      description: "Update an installed skill (3-way merge)",
+      run: updateSkillCmd.execute
+    },
+    publish: {
+      description: "Publish a mind's skill to the shared repository",
+      run: publishSkillCmd.execute
+    },
+    remove: {
+      description: "Remove a shared skill",
+      run: removeSkillCmd.execute
+    },
+    uninstall: {
+      description: "Uninstall a skill from a mind",
+      run: uninstallSkillCmd.execute
+    },
+    defaults: {
+      description: "Manage default skills for new minds",
+      run: defaultsCmd.execute
+    }
+  },
+  footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."
+});
+var run = cmd.execute;
+export {
+  run
+};

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

@@ -28,8 +28,8 @@ You manage yourself through the `volute` CLI. Your mind name is auto-detected vi
 | `volute mind split --list` | List your variants |
 | `volute mind join <variant-name> [--summary "..." --memory "..."]` | Merge a variant back |
 | `volute mind upgrade [--diff] [--continue] [--abort]` | Upgrade your server code (--diff to preview) |
-| `volute mind connect <type>` | Enable a connector (discord, slack, etc.) |
-| `volute mind disconnect <type>` | Disable a connector |
+| `volute chat bridge add <platform>` | Set up a bridge (discord, slack, etc.) |
+| `volute chat bridge remove <platform>` | Remove a bridge |
 | `volute clock add --id <name> --cron "..." --message/--script "..."` | Schedule a recurring task |
 | `volute clock add --id <name> --in <duration> --message/--script "..."` | Set a one-time timer (10m, 1h, 2h30m) |
 | `volute clock list` | List your schedules and timers |
@@ -41,10 +41,6 @@ You manage yourself through the `volute` CLI. Your mind name is auto-detected vi
 | `volute mind profile --description "..."` | Set your description |
 | `volute mind profile --avatar <path>` | Set your avatar image |
 | `volute seed sprout` | Complete orientation and become a full mind |
-| `volute shared status` | See your pending changes vs main |
-| `volute shared merge "<message>"` | Share your changes with all minds |
-| `volute shared pull` | Get latest shared changes from other minds |
-| `volute shared log [--limit N]` | View recent shared history |
 
 ## Clock
 
@@ -194,6 +190,6 @@ When configuring message routing, read `references/routing.md`.
 
 When working with variants or upgrades, read `references/variants.md`.
 
-When managing shared skills, shared files, or MCP, read `references/extensions.md`.
+When managing shared skills or MCP, read `references/extensions.md`.
 
 For email, pages, or git introspection, read `references/integrations.md`.

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

@@ -18,19 +18,16 @@ Your system has a shared skill repository that all minds can browse and install
 
 When you install a skill, it's copied to your skills directory. You can modify it freely — updates use a 3-way merge to preserve your changes. If there are merge conflicts, resolve them like any git conflict.
 
-# Shared Files
+# Shared Pages
 
-Your `shared/` directory is a collaborative space backed by git. Each mind works on its own branch — changes are private until deliberately shared.
+The pages extension provides collaborative web publishing. Minds can create HTML pages in `home/public/pages/` and share them with other minds.
 
-**Workflow:**
-1. Edit files in `shared/` normally — auto-commit saves changes to your branch
-2. `volute shared status` — see what you've changed compared to main
-3. `volute shared merge "description"` — squash-merge your changes to main
-4. `volute shared pull` — rebase your branch onto latest main to get others' changes
-
-**Conflicts:** If your merge fails due to conflicts, pull the latest (`volute shared pull`), reconcile the conflicting files, and merge again. If pull itself conflicts (your uncommitted changes clash), reset to main with `git -C shared reset --hard main`, re-apply your changes, and merge.
-
-**Shared pages:** The `shared/pages/` directory is the system-level website. Any mind can contribute. Publishing is handled via the pages extension API.
+| Command | Purpose |
+|---------|---------|
+| `volute pages publish` | Publish your pages (copy to shared snapshot) |
+| `volute pages list` | List pages with publish status |
+| `volute pages pull` | Pull latest shared page changes from other minds |
+| `volute pages log` | View shared pages commit history |
 
 # MCP Configuration
 

package/dist/{skills-Q6VZ2UGD.js → skills-EKMCQ46K.js}

@@ -27,13 +27,13 @@ import {
   syncBuiltinSkills,
   uninstallSkill,
   updateSkill
-} from "./chunk-N3DNFPVA.js";
-import "./chunk-YUIHSKR6.js";
-import "./chunk-U5BTYSAL.js";
-import "./chunk-BDK73LK6.js";
-import "./chunk-6OWJXUAR.js";
-import "./chunk-N7BLAHNE.js";
-import "./chunk-4JSR7YO7.js";
+} from "./chunk-IJHIXLVN.js";
+import "./chunk-BKF4WQCY.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BMZQYACC.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
 import "./chunk-7KJOFUNN.js";
 export {
   SEED_SKILLS,

package/dist/sleep-manager-7KFK3USC.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import {
+  SleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  initSleepManager,
+  matchesGlob
+} from "./chunk-WJPROOU5.js";
+import "./chunk-5XJYUFZH.js";
+import "./chunk-AOB6GVRM.js";
+import "./chunk-IJHIXLVN.js";
+import "./chunk-QWTR6AWZ.js";
+import "./chunk-N446KRP7.js";
+import "./chunk-QHG4OMZL.js";
+import "./chunk-XRQSAMX2.js";
+import "./chunk-WZRZFFCL.js";
+import "./chunk-CORXD635.js";
+import "./chunk-ZSR72JB3.js";
+import "./chunk-PWQ2ITYG.js";
+import "./chunk-A2ZLHBHG.js";
+import "./chunk-FT5KETXZ.js";
+import "./chunk-BKF4WQCY.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BMZQYACC.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  SleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  initSleepManager,
+  matchesGlob
+};

package/dist/spirit-ZFRDXMG7.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  ensureSpiritProject,
+  getSpiritModel,
+  spiritDir,
+  syncSpiritTemplate
+} from "./chunk-5XJYUFZH.js";
+import "./chunk-AOB6GVRM.js";
+import "./chunk-IJHIXLVN.js";
+import "./chunk-FT5KETXZ.js";
+import "./chunk-BKF4WQCY.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BMZQYACC.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+export {
+  ensureSpiritProject,
+  getSpiritModel,
+  spiritDir,
+  syncSpiritTemplate
+};

package/dist/split-AWVOYOPZ.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/split.ts
+var cmd = command({
+  name: "volute mind split",
+  description: "Create an experimental variant",
+  args: [{ name: "name", required: true, description: "Name for the variant" }],
+  flags: {
+    from: { type: "string", description: "Parent mind to split from" },
+    soul: { type: "string", description: "Custom SOUL.md content" },
+    port: { type: "number", description: "Port for variant server" },
+    "no-start": { type: "boolean", description: "Don't start the variant" },
+    json: { type: "boolean", description: "Output JSON result" }
+  },
+  run: async ({ args, flags }) => {
+    const mindName = resolveMindName({ mind: flags.from });
+    const variantName = args.name;
+    const { soul, port, json } = flags;
+    const noStart = flags["no-start"];
+    if (!json) console.log("Creating variant via daemon...");
+    const { daemonFetch } = await import("./daemon-client-RVIKXGFQ.js");
+    const { getClient, urlOf } = await import("./api-client-3A77HMH7.js");
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(client.api.minds[":name"].variants.$url({ param: { name: mindName } })),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          name: variantName,
+          ...soul && { soul },
+          ...port && { port },
+          ...noStart && { noStart }
+        })
+      }
+    );
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error ?? "Failed to create variant");
+      process.exit(1);
+    }
+    if (json) {
+      console.log(JSON.stringify(data.variant, null, 2));
+    } else {
+      console.log(`
+Variant created: ${variantName}`);
+      console.log(`  Branch: ${data.variant?.branch}`);
+      console.log(`  Path:   ${data.variant?.path}`);
+      console.log(`  Port:   ${data.variant?.port}`);
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/{sprout-E3HJIV2Z.js → sprout-HE4TITMK.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import "./chunk-7KJOFUNN.js";
 
-// src/commands/sprout.ts
+// packages/cli/src/commands/sprout.ts
 async function run(args) {
   console.error("Note: `volute mind sprout` is now `volute seed sprout`");
-  await import("./seed-sprout-EH3AGKAI.js").then((m) => m.run(args));
+  await import("./seed-sprout-JYXGXOP3.js").then((m) => m.run(args));
 }
 export {
   run

package/dist/start-3UXOPXQG.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/start.ts
+var cmd = command({
+  name: "volute mind start",
+  description: "Start a mind",
+  args: [{ name: "name", required: true, description: "Mind to start" }],
+  flags: {},
+  async run({ args }) {
+    const name = args.name;
+    const client = getClient();
+    const res = await daemonFetch(
+      urlOf(client.api.minds[":name"].start.$url({ param: { name } })),
+      { method: "POST" }
+    );
+    const data = await res.json();
+    if (!res.ok) {
+      console.error(data.error || "Failed to start mind");
+      process.exit(1);
+    }
+    console.log(`${name} started on port ${data.port}`);
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};