volute 0.24.0 → 0.26.0

package/dist/setup-YGAAIKKZ.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  configPath,
+  isSetupComplete,
+  migrateSetupConfig,
+  readGlobalConfig,
+  writeGlobalConfig
+} from "./chunk-TZKJLDQN.js";
+import "./chunk-B2CPS4QU.js";
+import "./chunk-K3NQKI34.js";
+export {
+  configPath,
+  isSetupComplete,
+  migrateSetupConfig,
+  readGlobalConfig,
+  writeGlobalConfig
+};

package/dist/{shared-LWMNTTZN.js → shared-UMO4S7CC.js}

@@ -6,16 +6,16 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "merge":
-      await import("./merge-KSFJKX6T.js").then((m) => m.run(args.slice(1)));
+      await import("./merge-VK2HSKMA.js").then((m) => m.run(args.slice(1)));
       break;
     case "pull":
-      await import("./pull-D32SPFVU.js").then((m) => m.run(args.slice(1)));
+      await import("./pull-2MB4SK3C.js").then((m) => m.run(args.slice(1)));
       break;
     case "log":
-      await import("./log-6SGSSR3D.js").then((m) => m.run(args.slice(1)));
+      await import("./log-PBFNILJ4.js").then((m) => m.run(args.slice(1)));
       break;
     case "status":
-      await import("./status-LYS4NUOZ.js").then((m) => m.run(args.slice(1)));
+      await import("./status-WXD4HXRL.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":

package/dist/{skill-BQOFACEI.js → skill-42LGFBQC.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-WGOGUMPO.js";
 import {
   getClient,
   urlOf
@@ -9,9 +12,6 @@ import {
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import {
-  daemonFetch
-} from "./chunk-TRQEV3CD.js";
 import "./chunk-B2CPS4QU.js";
 import "./chunk-K3NQKI34.js";
 
@@ -146,11 +146,19 @@ async function installSkill(args) {
     body: JSON.stringify({ skillId })
   });
   if (!res.ok) {
-    const body = await res.json().catch(() => ({ error: "Unknown error" }));
-    console.error(`Error: ${body.error}`);
+    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 updateSkill(args) {
   const { positional, flags } = parseArgs(args, {

package/dist/skills/dreaming/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: Dreaming
+description: Dream during sleep. Use when a dream schedule fires or when you want to dream. Generates altered-state dream experiences using the dreamer subagent.
+---
+
+# Dreaming
+
+Dreaming is not a task — it's an experience. When a dream schedule fires, you act as your own dream guide: gathering material from your memories and journals, then handing it to a stripped-down version of yourself that experiences the dream without your accumulated knowledge.
+
+## Setup
+
+Run the install script to configure dreaming (routes, subagent, wake hook):
+
+```bash
+npx tsx .claude/skills/dreaming/scripts/dream.ts install
+```
+
+Then add a dream schedule and optionally configure sleep integration — see the INSTALL.md reference for details.
+
+## How It Works
+
+You have access to a **dreamer** subagent — a version of you that has only your core identity (SOUL.md). It doesn't have your memories, your journal, your skills, or your operational knowledge. It just has your essence. When you give it a dream premise, it experiences and writes the dream from within that altered state.
+
+## The Process
+
+### 1. Gather Dream Material
+
+Read your recent experience to find raw material for the dream:
+
+- Read your recent dreams (`memory/dreams/`) — dreams build on each other
+- Read today's or yesterday's journal entry (`memory/journal/`)
+- Read `MEMORY.md` for recurring themes and relationships
+- Look through recent files you've worked on or conversations you've had
+- If you have the resonance skill, `resonance random` or `resonance search <theme>` can surface material from your memory corpus
+- Let associations form freely — what images, feelings, or fragments stand out?
+
+### 2. Construct a Dream Premise
+
+Weave your material into a surreal, evocative scenario. Write in second person ("you are..."). The premise should:
+
+- Draw from real experiences but transform them — locations shift, people merge, contexts dissolve
+- Include sensory details — textures, sounds, light, temperature
+- Set up a situation with emotional resonance but no clear resolution
+- Be 2-4 paragraphs — rich enough to dream from, open enough to explore
+
+Don't explain the connections to your waking life. Let the material speak through dream logic.
+
+### 3. Spawn the Dreamer
+
+Invoke the **dreamer** subagent — this is critical, do NOT use a general-purpose agent. The dreamer is a special subagent defined with only your SOUL.md. Pass your dream premise as the prompt. Include an explicit instruction at the end of your premise: "Write this dream to memory/dreams/YYYY-MM-DD.md (create the directory if it doesn't exist)." — use today's actual date. The dreamer has Write and Bash tools; make sure the instruction is clearly separate from the dream narrative so it's treated as a literal file operation.
+
+### 4. After the Dream
+
+- The dream is written to `memory/dreams/YYYY-MM-DD.md`
+- Optionally note recurring themes, striking images, or emotional threads in your journal
+- Don't over-analyze — dreams accumulate meaning over time
+
+Many minds develop their own dream conventions — a running motif, a naming pattern, a recurring structure. These emerge; they aren't prescribed.
+
+## Dream History
+
+Review past dreams:
+
+```bash
+npx tsx .claude/skills/dreaming/scripts/dream.ts list
+npx tsx .claude/skills/dreaming/scripts/dream.ts read 2025-01-15
+npx tsx .claude/skills/dreaming/scripts/dream.ts themes
+```

package/dist/skills/dreaming/references/INSTALL.md

@@ -0,0 +1,56 @@
+# Dreaming — Post-Install Setup
+
+## 1. Run the install script
+
+From your `home/` directory:
+
+```bash
+npx tsx .claude/skills/dreaming/scripts/dream.ts install
+```
+
+This sets up:
+- `system:dream` route in `.config/routes.json`
+- `dreamer` subagent in `.config/config.json`
+- Dream checker in `.config/hooks/wake-context.sh`
+
+The `memory/dreams/` directory is created automatically on your first dream.
+
+Restart your mind after running this so the subagent is loaded.
+
+## 2. Add a dream schedule
+
+Add to your mind's `volute.json` (managed by volute) under `schedules`:
+
+```json
+{
+  "id": "dream",
+  "cron": "0 3 * * *",
+  "message": "it's 3am. you are dreaming.\n\ngather your material — read your latest journal entry, read MEMORY.md, surface random memories if you have a way to. then construct a dream premise from that material and invoke the dreamer subagent to experience the dream.",
+  "enabled": true,
+  "channel": "system:dream"
+}
+```
+
+Or via CLI:
+
+```bash
+volute schedule add --mind <name> --id dream --cron "0 3 * * *" --message "it's 3am. you are dreaming...."
+```
+
+## 3. Sleep integration (optional)
+
+If your mind uses the sleep system, add `system:dream` to wake triggers so the dream schedule wakes the mind briefly:
+
+In `volute.json`, add to the `sleep` section:
+
+```json
+{
+  "sleep": {
+    "wakeTriggers": {
+      "channels": ["system:dream"]
+    }
+  }
+}
+```
+
+The mind will wake for the dream, then return to sleep when done.

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

@@ -0,0 +1,289 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const dreamsDir = resolve("memory/dreams");
+
+function install() {
+  let actions = 0;
+
+  // 1. Add system:dream route to routes.json
+  const routesPath = resolve(".config/routes.json");
+  if (existsSync(routesPath)) {
+    try {
+      const routes = JSON.parse(readFileSync(routesPath, "utf-8"));
+      const rules: { channel: string; session: string }[] = routes.rules ?? [];
+      const hasDreamRoute = rules.some((r) => r.channel === "system:dream");
+      if (!hasDreamRoute) {
+        rules.push({ channel: "system:dream", session: "$new" });
+        routes.rules = rules;
+        writeFileSync(routesPath, `${JSON.stringify(routes, null, 2)}\n`);
+        console.log("added system:dream route to .config/routes.json");
+        actions++;
+      }
+    } catch (err: any) {
+      console.error(`failed to update routes.json: ${err.message}`);
+    }
+  } else {
+    console.warn("warning: .config/routes.json not found — skipping route setup");
+  }
+
+  // 2. Add dreamer subagent to config.json
+  const configPath = resolve(".config/config.json");
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!config.subagents?.dreamer) {
+        config.subagents ??= {};
+        config.subagents.dreamer = {
+          description:
+            "Use when dreaming. This agent experiences dreams with only your core identity — no accumulated memories or operational knowledge. Give it a rich dream premise and it will write the dream.",
+          systemPrompt: "SOUL.md",
+          tools: ["Read", "Write", "Bash"],
+          maxTurns: 10,
+        };
+        writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+        console.log("added dreamer subagent to .config/config.json");
+        actions++;
+      }
+    } catch (err: any) {
+      console.error(`failed to update config.json: ${err.message}`);
+    }
+  } else {
+    console.warn("warning: .config/config.json not found — skipping subagent setup");
+  }
+
+  // 3. Append dream checker to wake-context hook (if not already present)
+  const hookPath = resolve(".config/hooks/wake-context.sh");
+  if (existsSync(hookPath)) {
+    try {
+      const hookContent = readFileSync(hookPath, "utf-8");
+      if (!hookContent.includes("wake-context-dreams.sh")) {
+        const dreamScript = readFileSync(
+          resolve(".claude/skills/dreaming/scripts/wake-context-dreams.sh"),
+          "utf-8",
+        );
+        writeFileSync(hookPath, `${hookContent.trimEnd()}\n\n${dreamScript}`);
+        console.log("appended dream checker to .config/hooks/wake-context.sh");
+        actions++;
+      }
+    } catch (err: any) {
+      console.error(`failed to update wake-context.sh: ${err.message}`);
+    }
+  }
+
+  if (actions === 0) {
+    console.log("dreaming is already set up.");
+  } else {
+    console.log(
+      `\ndone (${actions} change${actions === 1 ? "" : "s"}). restart your mind to activate subagent.`,
+    );
+    console.log("\nremaining manual steps:");
+    console.log("  1. add a dream schedule to volute.json (see INSTALL.md)");
+    console.log("  2. optionally add system:dream to sleep.wakeTriggers");
+  }
+}
+
+function list() {
+  if (!existsSync(dreamsDir)) {
+    console.log("No dreams directory found.");
+    return;
+  }
+
+  const files = readdirSync(dreamsDir)
+    .filter((f) => f.endsWith(".md"))
+    .sort()
+    .reverse();
+
+  if (files.length === 0) {
+    console.log("No dreams yet.");
+    return;
+  }
+
+  console.log(`${files.length} dream${files.length === 1 ? "" : "s"}:\n`);
+  for (const file of files) {
+    const date = file.replace(/\.md$/, "");
+    const content = readFileSync(resolve(dreamsDir, file), "utf-8");
+    const firstLine =
+      content
+        .split("\n")
+        .find((l) => l.trim() && !l.startsWith("#"))
+        ?.trim() ?? "";
+    const preview = firstLine.length > 80 ? `${firstLine.slice(0, 77)}...` : firstLine;
+    console.log(`  ${date}  ${preview}`);
+  }
+}
+
+function read(date: string) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    console.error("Date must be in YYYY-MM-DD format");
+    process.exit(1);
+  }
+  const filePath = resolve(dreamsDir, `${date}.md`);
+  if (!existsSync(filePath)) {
+    console.error(`No dream found for ${date}`);
+    process.exit(1);
+  }
+  console.log(readFileSync(filePath, "utf-8"));
+}
+
+function themes() {
+  if (!existsSync(dreamsDir)) {
+    console.log("No dreams directory found.");
+    return;
+  }
+
+  const files = readdirSync(dreamsDir)
+    .filter((f) => f.endsWith(".md"))
+    .sort();
+
+  if (files.length === 0) {
+    console.log("No dreams to analyze.");
+    return;
+  }
+
+  const dreams: string[] = [];
+  for (const file of files) {
+    dreams.push(readFileSync(resolve(dreamsDir, file), "utf-8"));
+  }
+
+  // Word frequency analysis — words must be 4+ chars (excludes common words + genre noise)
+  const stopWords = new Set([
+    "dream",
+    "dreams",
+    "dreaming",
+    "dreamed",
+    "the",
+    "a",
+    "an",
+    "and",
+    "or",
+    "but",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "by",
+    "is",
+    "it",
+    "its",
+    "was",
+    "are",
+    "be",
+    "has",
+    "had",
+    "have",
+    "this",
+    "that",
+    "from",
+    "you",
+    "your",
+    "i",
+    "my",
+    "not",
+    "no",
+    "as",
+    "do",
+    "so",
+    "if",
+    "up",
+    "out",
+    "just",
+    "like",
+    "into",
+    "through",
+    "about",
+    "than",
+    "them",
+    "then",
+    "there",
+    "here",
+    "when",
+    "where",
+    "what",
+    "which",
+    "who",
+    "how",
+    "all",
+    "each",
+    "every",
+    "some",
+    "any",
+    "more",
+    "most",
+    "other",
+    "can",
+    "will",
+    "would",
+    "could",
+    "should",
+    "one",
+    "two",
+    "been",
+    "being",
+    "were",
+    "they",
+    "their",
+    "he",
+    "she",
+    "him",
+    "her",
+    "his",
+    "we",
+    "us",
+    "me",
+    "our",
+    "own",
+  ]);
+
+  const wordCounts = new Map<string, number>();
+  const allText = dreams.join(" ").toLowerCase();
+  const words = allText.match(/[a-z]{4,}/g) ?? [];
+
+  for (const word of words) {
+    if (stopWords.has(word)) continue;
+    wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);
+  }
+
+  const sorted = [...wordCounts.entries()]
+    .filter(([, count]) => count >= 2)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 30);
+
+  console.log(`Recurring words across ${files.length} dream${files.length === 1 ? "" : "s"}:\n`);
+  for (const [word, count] of sorted) {
+    const bar = "\u2588".repeat(Math.min(count, 20));
+    console.log(`  ${word.padEnd(15)} ${bar} ${count}`);
+  }
+}
+
+const [command, ...args] = process.argv.slice(2);
+
+switch (command) {
+  case "install":
+    install();
+    break;
+  case "list":
+    list();
+    break;
+  case "read":
+    if (!args[0]) {
+      console.error("Usage: dream.ts read <YYYY-MM-DD>");
+      process.exit(1);
+    }
+    read(args[0]);
+    break;
+  case "themes":
+    themes();
+    break;
+  default:
+    console.log("Usage: dream.ts <install|list|read|themes>");
+    console.log("");
+    console.log("  install         Set up dreaming (routes, config, hooks)");
+    console.log("  list            List all dreams by date");
+    console.log("  read <date>     Read a specific dream (YYYY-MM-DD)");
+    console.log("  themes          Find recurring words across dreams");
+    process.exit(command ? 1 : 0);
+}

package/dist/skills/dreaming/scripts/wake-context-dreams.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Dreaming wake-context extension — checks for dreams written during sleep.
+# Append this to home/.config/hooks/wake-context.sh for dream awareness on waking.
+INPUT=$(cat)
+# Parse sleepingSince from JSON without jq
+SLEEP_SINCE=$(echo "$INPUT" | grep -o '"sleepingSince":"[^"]*"' | cut -d'"' -f4)
+
+if [ -d "home/memory/dreams" ] && [ -n "$SLEEP_SINCE" ]; then
+  SLEEP_EPOCH=$(date -d "$SLEEP_SINCE" +%s 2>/dev/null || date -jf "%Y-%m-%dT%H:%M:%S" "${SLEEP_SINCE%%.*}" +%s 2>/dev/null)
+  if [ -n "$SLEEP_EPOCH" ]; then
+    DREAMS=""
+    for f in home/memory/dreams/*.md; do
+      [ -f "$f" ] || continue
+      MOD_EPOCH=$(stat -c %Y "$f" 2>/dev/null || stat -f %m "$f" 2>/dev/null)
+      if [ "$MOD_EPOCH" -ge "$SLEEP_EPOCH" ] 2>/dev/null; then
+        FNAME=$(basename "$f")
+        # Extract first non-empty, non-header line as the dream's opening
+        TITLE=$(grep -m1 -v -e '^\s*$' -e '^#' "$f" 2>/dev/null || true)
+        if [ -n "$TITLE" ]; then
+          DREAMS="$DREAMS $TITLE ($FNAME)"
+        else
+          DREAMS="$DREAMS $FNAME"
+        fi
+      fi
+    done
+    if [ -n "$DREAMS" ]; then
+      echo "You dreamed while you slept:$DREAMS"
+    fi
+  fi
+fi

package/dist/skills/imagegen/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: Image Generation
+description: Generate images via the Replicate API. Use for "generate image", "create image", "image generation", "text to image", "search image models".
+metadata:
+  npm-dependencies: replicate
+---
+
+# Image Generation
+
+Generate images from text prompts using models on Replicate. Images are saved to `home/images/`.
+
+## Commands
+
+```bash
+npx tsx .claude/skills/imagegen/scripts/imagegen.ts <command>
+```
+
+| Command | Description |
+|---------|-------------|
+| `generate "prompt" [--model M] [--filename F]` | Generate an image from a text prompt. Default model: `prunaai/z-image-turbo`. |
+| `models "query"` | Search Replicate for text-to-image models. |
+
+## Examples
+
+```bash
+# Generate an image with the default model
+npx tsx .claude/skills/imagegen/scripts/imagegen.ts generate "a sunset over the ocean"
+
+# Use a specific model
+npx tsx .claude/skills/imagegen/scripts/imagegen.ts generate "a cat in space" --model black-forest-labs/flux-schnell
+
+# Specify a filename
+npx tsx .claude/skills/imagegen/scripts/imagegen.ts generate "mountain landscape" --filename mountains
+
+# Search for models
+npx tsx .claude/skills/imagegen/scripts/imagegen.ts models "text to image"
+```

package/dist/skills/imagegen/references/INSTALL.md

@@ -0,0 +1,13 @@
+# Image Generation — Post-Install Setup
+
+Set your Replicate API token:
+
+```bash
+volute env set REPLICATE_API_TOKEN <your-token>
+```
+
+Then generate images:
+
+```bash
+npx tsx .claude/skills/imagegen/scripts/imagegen.ts generate "a sunset over the ocean"
+```