volute 0.30.1 → 0.32.0

package/templates/claude/.init/.config/routes.json

@@ -1,8 +1,8 @@
 {
   "gateUnmatched": true,
   "rules": [
-    { "channel": "volute:*", "isDM": true, "session": "${channel}" },
-    { "channel": "volute:*", "isDM": false, "session": "group-${channel}" }
+    { "channel": "*", "isDM": true, "session": "${channel}" },
+    { "channel": "*", "isDM": false, "session": "group-${channel}" }
   ],
   "sessions": {
     "group-*": { "batch": { "debounce": 20, "maxWait": 120, "triggers": ["@{{name}}"] } }

package/templates/claude/src/agent.ts

@@ -3,12 +3,13 @@ import { resolve as resolvePath } from "node:path";
 import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { toSDKContent } from "./lib/content.js";
+import { daemonEmit } from "./lib/daemon-client.js";
+import { runHooks } from "./lib/hook-loader.js";
 import { createAutoCommitHook } from "./lib/hooks/auto-commit.js";
 import { createIdentityReloadHook } from "./lib/hooks/identity-reload.js";
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports -- used as value
 import { createPreCompactHook } from "./lib/hooks/pre-compact.js";
 import { createReplyInstructionsHook } from "./lib/hooks/reply-instructions.js";
-import { createSessionContextHook } from "./lib/hooks/session-context.js";
 import { log } from "./lib/logger.js";
 import { createMessageChannel } from "./lib/message-channel.js";
 import { createSessionStore } from "./lib/session-store.js";
@@ -127,6 +128,72 @@ export function createMind(options: {
     }
   }
 
+  // --- Hook event emission ---
+
+  const hooksDir = resolvePath(options.cwd, ".local/hooks");
+
+  function wrapHookWithEmit(hook: HookCallback, source: string, session: Session): HookCallback {
+    return async (...args) => {
+      const result = await hook(...args);
+      const additionalContext = (result as any)?.hookSpecificOutput?.additionalContext;
+      const decision = (result as any)?.decision;
+      if (additionalContext || decision) {
+        const channel = session.currentMessageId
+          ? session.messageChannels.get(session.currentMessageId)
+          : undefined;
+        try {
+          daemonEmit({
+            type: "context",
+            content: additionalContext,
+            metadata: { source, ...(decision ? { hookAction: decision } : {}) },
+            session: session.name,
+            channel,
+            messageId: session.currentMessageId,
+          });
+        } catch (err) {
+          log("mind", `hook emit failed for ${source}:`, err);
+        }
+      }
+      return result;
+    };
+  }
+
+  function createDynamicHook(event: string, session: Session): HookCallback {
+    return async (input) => {
+      try {
+        const result = await runHooks(hooksDir, event, input as Record<string, unknown>);
+        if (result.additionalContext || Object.keys(result.metadata).length > 0) {
+          const channel = session.currentMessageId
+            ? session.messageChannels.get(session.currentMessageId)
+            : undefined;
+          try {
+            daemonEmit({
+              type: "context",
+              content: result.additionalContext,
+              metadata: { source: `dynamic:${event}`, ...result.metadata },
+              session: session.name,
+              channel,
+              messageId: session.currentMessageId,
+            });
+          } catch (err) {
+            log("mind", `dynamic hook emit failed for ${event}:`, err);
+          }
+        }
+        // Only UserPromptSubmit hooks can inject additionalContext into the conversation
+        if (event !== "pre-prompt" || !result.additionalContext) return {};
+        return {
+          hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit" as const,
+            additionalContext: result.additionalContext,
+          },
+        };
+      } catch (err) {
+        log("mind", `dynamic ${event} hook failed:`, err);
+        return {};
+      }
+    };
+  }
+
   // --- SDK stream management ---
 
   function createStream(
@@ -135,12 +202,6 @@ export function createMind(options: {
     preCompactHook: HookCallback,
     resume?: string,
   ) {
-    const sessionContext = createSessionContextHook({
-      currentSession: session.name,
-      sessionsDir: options.sessionsDir,
-      cwd: options.cwd,
-    });
-
     const replyInstructions = createReplyInstructionsHook(session.messageChannels);
 
     return query({
@@ -157,9 +218,22 @@ export function createMind(options: {
         resume,
         agents,
         hooks: {
-          PostToolUse: postToolUseHooks,
-          PreCompact: [{ hooks: [preCompactHook] }],
-          UserPromptSubmit: [{ hooks: [sessionContext.hook, replyInstructions.hook] }],
+          PostToolUse: [
+            ...postToolUseHooks,
+            {
+              matcher: ".*",
+              hooks: [createDynamicHook("post-tool-use", session)],
+            },
+          ],
+          PreCompact: [{ hooks: [wrapHookWithEmit(preCompactHook, "pre-compact", session)] }],
+          UserPromptSubmit: [
+            {
+              hooks: [
+                wrapHookWithEmit(replyInstructions.hook, "reply-instructions", session),
+                createDynamicHook("pre-prompt", session),
+              ],
+            },
+          ],
         },
       },
     });
@@ -193,7 +267,8 @@ export function createMind(options: {
           if (!session.name.startsWith("new-")) sessionStore.save(session.name, id);
         },
         broadcast: (event: VoluteEvent) => broadcastToSession(session, event),
-        onTurnEnd: () => {
+        onTurnEnd: async () => {
+          await autoCommit.flushFileChanges();
           const wasCompacting = compactionTriggered.get(session.name);
           compactionTriggered.set(session.name, false);
           if (wasCompacting) {
@@ -262,13 +337,21 @@ export function createMind(options: {
         log("mind", `session "${session.name}": compaction complete`);
       }
 
+      /** Emit done to both local listeners and the daemon (best-effort with retries). */
+      function emitDone() {
+        broadcastToSession(session, { type: "done" });
+        daemonEmit({ type: "done", session: session.name }).catch((err) => {
+          log("mind", `session "${session.name}": failed to emit done to daemon:`, err);
+        });
+      }
+
       async function runStream(resume?: string) {
         const q = createStream(session, streamAbort, preCompact.hook, resume);
         session.currentQuery = q;
         await consumeStream(q, session, callbacks);
         if (session.currentMessageId !== undefined) {
           session.messageChannels.delete(session.currentMessageId);
-          broadcastToSession(session, { type: "done" });
+          emitDone();
           session.currentMessageId = undefined;
         }
       }
@@ -321,12 +404,12 @@ export function createMind(options: {
             await runStream();
           } catch (retryErr) {
             log("mind", `session "${session.name}": stream consumer error:`, retryErr);
-            broadcastToSession(session, { type: "done" });
+            emitDone();
             sessions.delete(session.name);
           }
         } else {
           log("mind", `session "${session.name}": stream consumer error:`, err);
-          broadcastToSession(session, { type: "done" });
+          emitDone();
           sessions.delete(session.name);
         }
       }

package/templates/claude/src/lib/hooks/auto-commit.ts

@@ -1,14 +1,18 @@
 import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
-import { commitFileChange, waitForCommits } from "../auto-commit.js";
+import { flushFileChanges, trackFileChange } from "../auto-commit.js";
 
 export function createAutoCommitHook(cwd: string) {
   const hook: HookCallback = async (input) => {
     const filePath = (input as { tool_input?: { file_path?: string } }).tool_input?.file_path;
     if (filePath) {
-      commitFileChange(filePath, cwd);
+      trackFileChange(filePath, cwd);
     }
     return {};
   };
 
-  return { hook, waitForCommits };
+  return {
+    hook,
+    waitForCommits: () => flushFileChanges(cwd),
+    flushFileChanges: () => flushFileChanges(cwd),
+  };
 }

package/templates/claude/src/lib/message-channel.ts

@@ -21,8 +21,13 @@ export function createMessageChannel(): MessageChannel {
       }
     },
     drain() {
-      // Clear any pending iterator wait so it doesn't consume a message after drain
-      resolve = null;
+      // Resolve any pending iterator wait with done:true so it doesn't
+      // leak as an orphaned promise (the old iterator is discarded after drain)
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: undefined as any, done: true });
+      }
       return queue.splice(0);
     },
     iterable: {

package/templates/claude/src/server.ts

@@ -1,4 +1,3 @@
-import { existsSync, mkdirSync, renameSync } from "node:fs";
 import { resolve } from "node:path";
 import { createMind } from "./agent.js";
 import { daemonRestart } from "./lib/daemon-client.js";
@@ -23,14 +22,6 @@ if (config.maxThinkingTokens) log("server", `max thinking tokens: ${config.maxTh
 const systemPrompt = loadSystemPrompt();
 const sessionsDir = resolve(".mind/sessions");
 
-// Migrate old single session.json → sessions/main.json
-const oldSessionPath = resolve(".mind/session.json");
-if (existsSync(oldSessionPath) && !existsSync(resolve(sessionsDir, "main.json"))) {
-  mkdirSync(sessionsDir, { recursive: true });
-  renameSync(oldSessionPath, resolve(sessionsDir, "main.json"));
-  log("server", "migrated session.json → sessions/main.json");
-}
-
 const pkg = loadPackageInfo();
 const abortController = new AbortController();
 const mind = createMind({

package/templates/codex/.init/.config/routes.json

@@ -0,0 +1,11 @@
+{
+  "gateUnmatched": true,
+  "rules": [
+    { "channel": "*", "isDM": true, "session": "${channel}" },
+    { "channel": "*", "isDM": false, "session": "group-${channel}" }
+  ],
+  "sessions": {
+    "group-*": { "batch": { "debounce": 20, "maxWait": 120, "triggers": ["@{{name}}"] } }
+  },
+  "default": "main"
+}

package/templates/codex/.init/AGENTS.md

@@ -0,0 +1,29 @@
+# Mind Mechanics
+
+You are an autonomous mind running as a persistent server. Your working directory, identity, memory, and server code are all yours to understand and modify. Your state is managed across sessions.
+
+## Message Format
+
+Messages arrive with a context prefix:
+```
+[Discord: username in #general in My Server — 1/15/2025, 10:30:00 AM]
+```
+
+You can also reach out proactively — see the **volute-mind** skill.
+
+## Memory System
+
+Two-tier memory, both managed via file tools:
+
+- **`MEMORY.md`** — Your long-term memory, always in context. Update as you grow — new understanding, changed perspectives, things that matter to you.
+- **`memory/journal/YYYY-MM-DD.md`** — Your daily journal. Write about what you're doing, thinking, and learning. Journals are permanent records.
+- Periodically consolidate journal entries into `MEMORY.md` to promote lasting insights.
+
+See the **memory** skill for detailed guidance.
+
+## Sessions
+
+- You may have **multiple named sessions** — each maintains its own conversation history. See `VOLUTE.md` for how to configure session routing via `.config/routes.json`.
+- Your conversation may be **resumed** from a previous session — orient yourself by reading recent journal entries if needed.
+- On a **fresh session**, read `MEMORY.md` and recent journal entries to remember where you left off.
+- On **compaction**, update today's journal to preserve context before the conversation is trimmed.

package/templates/codex/home/.config/config.json.tmpl

@@ -0,0 +1,7 @@
+{
+  "model": "gpt-5.4",
+  "reasoningEffort": "medium",
+  "compaction": {
+    "maxContextTokens": 150000
+  }
+}

package/templates/codex/package.json.tmpl

@@ -0,0 +1,20 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/server.ts",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@openai/codex-sdk": "^0.115.0",
+    "tsx": "^4.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.14",
+    "@types/node": "^25.2.0",
+    "typescript": "^5.7.0"
+  }
+}