volute 0.31.0 → 0.33.0

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),
+              ],
+            },
+          ],
         },
       },
     });
@@ -263,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;
         }
       }
@@ -322,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/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/lib/stream-consumer.ts

@@ -74,6 +74,44 @@ export async function consumeStream(
         }
       }
     }
+    if (msg.type === "user") {
+      // Tool result messages — the SDK sends these after tool execution.
+      // Extract tool_result content blocks and emit them so the daemon can
+      // link outbound records to the correct turn via correlation markers.
+      const content = (msg as { message?: { content?: unknown[] } }).message?.content;
+      if (Array.isArray(content)) {
+        for (const b of content) {
+          if (
+            b &&
+            typeof b === "object" &&
+            "type" in b &&
+            b.type === "tool_result" &&
+            "content" in b
+          ) {
+            const resultContent = Array.isArray(b.content)
+              ? b.content
+                  .filter(
+                    (c: unknown): c is { type: "text"; text: string } =>
+                      !!c && typeof c === "object" && "type" in c && c.type === "text",
+                  )
+                  .map((c) => c.text)
+                  .join("")
+              : typeof b.content === "string"
+                ? b.content
+                : "";
+            if (resultContent) {
+              const toolUseId =
+                "tool_use_id" in b && typeof b.tool_use_id === "string" ? b.tool_use_id : "unknown";
+              emit(session, {
+                type: "tool_result",
+                content: resultContent,
+                metadata: { tool_use_id: toolUseId },
+              });
+            }
+          }
+        }
+      }
+    }
     if (msg.type === "result") {
       if (session.currentMessageId) {
         session.messageChannels.delete(session.currentMessageId);

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"
+  }
+}