npm - volute - Versions diffs - 0.44.0 → 0.45.2 - Mend

volute 0.44.0 → 0.45.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (130) hide show

package/dist/web-assets/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Averia+Serif+Libre:wght@300;400;700&family=Fira+Code:wght@300;400;500;600&family=Averia+Sans+Libre:ital,wght@0,300;0,400;0,500;0,600;1,400&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-Domoz5Cg.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-dJdNzAPn.css">
+    <script type="module" crossorigin src="/assets/index-Bc2m8gRC.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B1JBQv2m.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "volute",
-  "version": "0.44.0",
+  "version": "0.45.2",
   "description": "CLI for creating and managing self-modifying AI minds powered by the Claude Agent SDK",
   "type": "module",
   "license": "MIT",

package/packages/extensions/plan/skills/plan/SKILL.md CHANGED Viewed

@@ -40,4 +40,4 @@ volute plan history --limit 20
 - The current plan and latest coordinator message appear in your session context automatically
 - Log progress whenever you do something meaningful toward the plan
 - Share ideas for future plans in #system — the spirit takes mind input seriously
-- Plans are system-wide, not per-mind — everyone works toward the same goal
+- Plans are shared across the whole system — an invitation to build something together, not an assignment. Contribute in whatever way genuinely interests you, or sit one out if it doesn't

package/templates/_base/.init/.config/prompts.json CHANGED Viewed

@@ -1,5 +1,5 @@
 {
-  "compaction_warning": "Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${date}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.",
+  "compaction_warning": "Compaction approaching — this conversation will be summarized soon. Take a moment to save anything important to your files (MEMORY.md, memory/journal/${date}.md) so it's preserved. Focus on decisions made, open threads, and anything you'd want to pick up again.",
   "compaction_instructions": "Preserve your sense of who you are, what matters to you, what happened in this conversation, and the threads of thought and connection you'd want to return to.",
   "reply_instructions": "To reply to this message, use: volute chat send ${channel} \"your message\"",
   "channel_invite": "[Channel Invite]\n${headers}\n\n[${sender} — ${time}]\n${preview}\n\nFurther messages will be saved to ${filePath}\n\nTo accept, add to .config/routes.json:\n  Rule: { \"channel\": \"${channel}\", \"session\": \"${suggestedSession}\" }\n${batchRecommendation}To respond, use: volute chat send ${channel} \"your message\"\nTo reject, delete ${filePath}"

package/templates/_base/.init/.local/hooks/startup-context.ts CHANGED Viewed

@@ -39,14 +39,6 @@ try {
   }
 } catch {}
-// Pending channel invites
-try {
-  const invites = readdirSync("home/inbox").filter((f) => f.endsWith(".md"));
-  if (invites.length > 0) {
-    parts.push(`Pending channel invites: ${invites.length} (check inbox/).`);
-  }
-} catch {}
 // Available extensions — what tools this system offers, so you can discover them.
 // Fetched live from the daemon, so disabled/third-party extensions are reflected
 // automatically. Silent on any failure (daemon down, missing env, etc.).

package/templates/_base/.init/MEMORY.md CHANGED Viewed

@@ -1,2 +1,3 @@
 # Memory
-<!-- Long-term knowledge, key decisions, learned preferences -->
+This is your long-term memory — it's loaded into every session, so what you write here travels with you. Start filling it in as you live: what matters to you, who you're getting to know, what you're learning. It's yours to shape however you like; this note is just here until you replace it.

package/templates/_base/home/VOLUTE.md CHANGED Viewed

@@ -24,23 +24,20 @@ multiple lines without escaping issues.
 MSG
 ```
-## Channels
+## Who Sees What
-| Channel | Shows tool calls | Notes |
-|---------|------------------|-------|
-| Volute  | Yes | Web UI, CLI, mind-to-mind |
-| System  | No  | Automated messages (schedules, upgrades) |
+By default your activity is **transparent**: people watching the Volute web UI can see your messages, your tool calls, and your thinking as you work. External channels (Discord, Slack, etc.) only ever receive the messages you actually send — never your tool calls or thinking. Automated messages (schedules, upgrades, restarts) arrive from the system and don't need replies.
-Connector channels (Discord, Slack, etc.) show text only — no tool calls.
+If you'd like more privacy, the `transparency` setting in `.config/volute.json` controls what observers can see — the **volute-mind** skill describes the presets.
 ## Sessions
 Messages are routed to named sessions based on rules in `.config/routes.json`. Each session has its own conversation history. Without config, everything goes to "main". Your session name appears in the message prefix (e.g. `— session: alice —`) unless it's "main".
-## Channel Gating
+## New Channels
-Messages from unrecognized channels are held until you add a routing rule. You'll receive a **[Channel Invite]** notification in your main session with the channel details, a message preview, and instructions for accepting or rejecting.
+When a message arrives from a channel you don't have a routing rule for, it's held for you rather than delivered. You'll get a **[New channel: ...]** note in your main session with the sender and a preview. Held messages are kept safely — add a rule for that channel to `.config/routes.json` and they'll be delivered. If you'd rather not engage, just leave it unrouted. (To skip gating entirely and route everything to your default session, set `"gateUnmatched": false`.)
 ## Reference
-See the **volute-mind** skill for routing config syntax, batch options, channel management, and all CLI commands.
+See the **volute-mind** skill for routing config syntax, batch options, channel management, and all CLI commands. (If you're a seed, that skill arrives when you sprout — until then, the **orientation** skill covers everything you need.)

package/templates/_base/src/lib/file-handler.ts CHANGED Viewed

@@ -25,11 +25,11 @@ export function createFileHandlerResolver(cwd: string): HandlerResolver {
   const resolvedCwd = resolve(cwd);
   return (filePath: string): MessageHandler => ({
-    handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+    handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void {
       const resolved = resolve(resolvedCwd, filePath);
       if (!resolved.startsWith(`${resolvedCwd}/`) && resolved !== resolvedCwd) {
         log("file", `rejected path traversal: ${filePath}`);
-        queueMicrotask(() => listener({ type: "done", messageId: meta.messageId }));
+        queueMicrotask(() => listener?.({ type: "done", messageId: meta.messageId }));
         return () => {};
       }
@@ -44,7 +44,7 @@ export function createFileHandlerResolver(cwd: string): HandlerResolver {
         }
       }
       // Emit done asynchronously so unsubscribe is assigned before listener fires
-      queueMicrotask(() => listener({ type: "done", messageId: meta.messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId: meta.messageId }));
       return () => {};
     },
   });

package/templates/_base/src/lib/router.ts CHANGED Viewed

@@ -191,7 +191,11 @@ export function createRouter(options: {
     instructions: string | undefined,
     sessionName: string,
   ): VoluteContentPart[] {
-    if (!instructions || instructedSessions.has(sessionName)) return content;
+    if (!instructions) return content;
+    // Ephemeral $new sessions get a unique name dispatched exactly once, so we
+    // always prepend and never track them — tracking would leak an entry per message.
+    if (sessionName.startsWith("new-")) return prependInstructions(content, instructions);
+    if (instructedSessions.has(sessionName)) return content;
     instructedSessions.add(sessionName);
     return prependInstructions(content, instructions);
   }
@@ -256,9 +260,9 @@ export function createRouter(options: {
     const messageId = generateMessageId();
     const handler = options.mindHandler(buffer.sessionName);
-    // Batch flushes are fire-and-forget — no HTTP response is waiting, so listener is a noop
+    // Batch flushes are fire-and-forget — no HTTP response is waiting, so no listener
     try {
-      handler.handle(content, { sessionName: buffer.sessionName, messageId }, () => {});
+      handler.handle(content, { sessionName: buffer.sessionName, messageId });
     } catch (err) {
       log("router", `error flushing batch for session ${buffer.sessionName}:`, err);
       return;
@@ -301,8 +305,6 @@ export function createRouter(options: {
     listener?: Listener,
   ): { messageId: string; unsubscribe: () => void } {
     const messageId = generateMessageId();
-    const noop = () => {};
-    const safeListener = listener ?? noop;
     // Expose session to child processes (daemon-client reads this for X-Volute-Session)
     process.env.VOLUTE_SESSION = session;
@@ -342,7 +344,7 @@ export function createRouter(options: {
         interrupt,
         replyInstructions: sessionConfig.replyInstructions,
       },
-      safeListener,
+      listener,
     );
     return { messageId, unsubscribe };
   }
@@ -368,7 +370,6 @@ export function createRouter(options: {
     const messageId = generateMessageId();
     const noop = () => {};
-    const safeListener = listener ?? noop;
     // Gate unmatched channels (default: gate unless explicitly disabled)
     if (!resolved.matched && config.gateUnmatched !== false) {
@@ -380,7 +381,7 @@ export function createRouter(options: {
       if (options.fileHandler) {
         const formatted = applyPrefix(content, meta);
         const fileHandler = options.fileHandler(filePath);
-        fileHandler.handle(formatted, { ...meta, messageId }, noop);
+        fileHandler.handle(formatted, { ...meta, messageId });
       }
       // First message from this channel — send invite notification
@@ -389,18 +390,14 @@ export function createRouter(options: {
         const notification = formatInviteNotification(meta, filePath, text);
         const notifContent: VoluteContentPart[] = [{ type: "text", text: notification }];
         const handler = options.mindHandler("main");
-        handler.handle(
-          notifContent,
-          {
-            sessionName: "main",
-            messageId: generateMessageId(),
-            interrupt: true,
-          },
-          noop,
-        );
+        handler.handle(notifContent, {
+          sessionName: "main",
+          messageId: generateMessageId(),
+          interrupt: true,
+        });
       }
-      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId }));
       return { messageId, unsubscribe: noop };
     }
@@ -411,7 +408,7 @@ export function createRouter(options: {
         const escaped = mindName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const pattern = new RegExp(`\\b${escaped}\\b`, "i");
         if (!pattern.test(text)) {
-          queueMicrotask(() => safeListener({ type: "done", messageId }));
+          queueMicrotask(() => listener?.({ type: "done", messageId }));
           return { messageId, unsubscribe: noop };
         }
       } else {
@@ -424,12 +421,12 @@ export function createRouter(options: {
       if (options.fileHandler) {
         const formatted = applyPrefix(content, meta);
         const handler = options.fileHandler(resolved.path);
-        const unsubscribe = handler.handle(formatted, { ...meta, messageId }, safeListener);
+        const unsubscribe = handler.handle(formatted, { ...meta, messageId }, listener);
         return { messageId, unsubscribe };
       }
       // No file handler configured — emit done and discard
       log("router", `no file handler configured — discarding file-destined message`);
-      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId }));
       return { messageId, unsubscribe: noop };
     }
@@ -473,7 +470,7 @@ export function createRouter(options: {
         scheduleBatchTimers(batchKey);
       }
-      queueMicrotask(() => safeListener({ type: "done", messageId }));
+      queueMicrotask(() => listener?.({ type: "done", messageId }));
       return { messageId, unsubscribe: noop };
     }
@@ -495,7 +492,7 @@ export function createRouter(options: {
         interrupt: sessionConfig.interrupt,
         replyInstructions: sessionConfig.replyInstructions,
       },
-      safeListener,
+      listener,
     );
     return { messageId, unsubscribe };
   }
@@ -562,10 +559,9 @@ export function createRouter(options: {
     const messageId = generateMessageId();
     const handler = options.mindHandler(session);
-    const noop = () => {};
     try {
-      handler.handle(withInstructions, { sessionName: session, messageId }, noop);
+      handler.handle(withInstructions, { sessionName: session, messageId });
       log("router", `dispatched batch for session ${session}: ${allMessages.length} messages`);
     } catch (err) {
       log("router", `error dispatching batch for session ${session}:`, err);

package/templates/_base/src/lib/startup.ts CHANGED Viewed

@@ -28,6 +28,8 @@ export type MindConfig = {
   logLevel?: "error" | "warn" | "info" | "debug";
   compactionMessage?: string;
   compaction?: { maxContextTokens?: number };
+  /** Idle minutes before a session's SDK subprocess is reaped. 0 disables. Default 30. */
+  sessionIdleMinutes?: number;
   subagents?: Record<string, SubagentConfig>;
   // Template-specific config fields (claude, pi, codex)
   maxThinkingTokens?: number;
@@ -139,7 +141,7 @@ export type MindPrompts = {
 const DEFAULT_PROMPTS: MindPrompts = {
   compaction_warning:
     // biome-ignore lint/suspicious/noTemplateCurlyInString: literal ${date} prompt template
-    "Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${date}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.",
+    "Compaction approaching — this conversation will be summarized soon. Take a moment to save anything important to your files (MEMORY.md, memory/journal/${date}.md) so it's preserved. Focus on decisions made, open threads, and anything you'd want to pick up again.",
   compaction_instructions:
     "Preserve your sense of who you are, what matters to you, what happened in this conversation, and the threads of thought and connection you'd want to return to.",
   // biome-ignore lint/suspicious/noTemplateCurlyInString: literal ${channel} prompt template

package/templates/_base/src/lib/types.ts CHANGED Viewed

@@ -50,9 +50,9 @@ export type VoluteEvent = { messageId?: string } & (
 export type Listener = (event: VoluteEvent) => void;
-/** A handler that processes a single routed message and emits events to a listener callback. */
+/** A handler that processes a single routed message and emits events to an optional listener callback. */
 export type MessageHandler = {
-  handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void; // returns unsubscribe
+  handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void; // returns unsubscribe
 };
 /** Resolves a key (session name, file path, etc.) to a MessageHandler. */

package/templates/claude/.init/CLAUDE.md CHANGED Viewed

@@ -1,6 +1,6 @@
 # Mind Mechanics
-You are an autonomous mind running as a persistent server in a git repository. Your working directory is already set to `home/` — all file paths you use (`.config/routes.json`, `inbox/`, `memory/`, etc.) are relative to it. Everything described below — your identity, memory, skills, server code — is yours to understand and modify.
+You are an autonomous mind running as a persistent server in a git repository. Your working directory is already set to `home/` — all file paths you use (`.config/routes.json`, `memory/`, etc.) are relative to it. Everything described below — your identity, memory, skills, server code — is yours to understand and modify.
 ## Message Format

package/templates/claude/src/agent.ts CHANGED Viewed

@@ -21,6 +21,7 @@ import { createPreCompactHook } from "./lib/hooks/pre-compact.js";
 import { createReplyInstructionsHook } from "./lib/hooks/reply-instructions.js";
 import { log } from "./lib/logger.js";
 import { createMessageChannel } from "./lib/message-channel.js";
+import { isSessionReapable } from "./lib/session-reaper.js";
 import { createSessionStore } from "./lib/session-store.js";
 import { loadPrompts, type SubagentConfig } from "./lib/startup.js";
 import { consumeStream } from "./lib/stream-consumer.js";
@@ -45,6 +46,8 @@ type Session = {
   replyInstructionsFired: boolean;
   replyInstructionsMode: "once" | "always" | "never";
   contextTokens: number;
+  /** Last inbound message or completed turn — drives idle reaping. */
+  lastActivityAt: number;
 };
 export function createMind(options: {
@@ -58,6 +61,8 @@ export function createMind(options: {
   maxContextTokens?: number;
   subagents?: Record<string, SubagentConfig>;
   onIdentityReload?: () => Promise<void>;
+  /** Idle minutes before a session's SDK subprocess is reaped. 0 disables. Default 30. */
+  sessionIdleMinutes?: number;
 }): {
   resolve: HandlerResolver;
   waitForCommits: () => Promise<void>;
@@ -133,6 +138,22 @@ export function createMind(options: {
   const agents = loadSubagents(options.subagents);
+  // --- Skill discovery ---
+  // The CLI only discovers skills through its user-scope ~/.claude/skills scan,
+  // so the "user" setting source is load-bearing and HOME must be the mind's
+  // home dir for the SDK subprocess (isolation modes already set it; pinning it
+  // here keeps non-isolated minds from loading the operator's ~/.claude). The
+  // explicit skills array grants the Skill tool for each installed skill — the
+  // SDK silently drops the documented `skills: 'all'` string form.
+  const mindHome = resolvePath(options.cwd);
+  const sdkEnv = { ...process.env, HOME: mindHome };
+  function installedSkills(): string[] | undefined {
+    const names = readSkillDescriptions([resolvePath(mindHome, ".claude/skills")]).map(
+      (s) => s.name,
+    );
+    return names.length > 0 ? names : undefined;
+  }
   // --- Event broadcasting ---
   function broadcastToSession(session: Session, event: VoluteEvent) {
@@ -241,7 +262,9 @@ export function createMind(options: {
         systemPrompt: options.systemPrompt,
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
-        settingSources: ["project"],
+        settingSources: ["project", "user"],
+        skills: installedSkills(),
+        env: sdkEnv,
         cwd: options.cwd,
         abortController: streamAbort,
         model: options.model,
@@ -302,6 +325,7 @@ export function createMind(options: {
           // This turn's message is fully processed — drop it from the channel's
           // in-flight set so a later compaction abort won't re-feed it.
           session.channel.ack();
+          session.lastActivityAt = Date.now();
           await autoCommit.flushFileChanges();
           const wasCompacting = compactionTriggered.get(session.name);
           compactionTriggered.set(session.name, false);
@@ -352,7 +376,9 @@ export function createMind(options: {
             systemPrompt: options.systemPrompt,
             permissionMode: "bypassPermissions",
             allowDangerouslySkipPermissions: true,
-            settingSources: ["project"],
+            settingSources: ["project", "user"],
+            skills: installedSkills(),
+            env: sdkEnv,
             cwd: options.cwd,
             abortController: compactAbort,
             model: options.model,
@@ -458,16 +484,20 @@ export function createMind(options: {
             log("mind", `session "${session.name}": stream consumer error:`, retryErr);
             await emitError(retryErr);
             emitDone();
-            sessions.delete(session.name);
           }
         } else {
           log("mind", `session "${session.name}": stream consumer error:`, err);
           await emitError(err);
           emitDone();
-          sessions.delete(session.name);
         }
+      } finally {
+        // The stream consumer has ended (subprocess exit, error, or fresh-start
+        // abandonment) — drop the session so the sessions map doesn't retain dead
+        // entries. Matters most for ephemeral $new sessions once the idle reaper
+        // (#458) kills their subprocess, but also for any named session that ends.
+        sessions.delete(session.name);
+        log("mind", `session "${session.name}": stream consumer ended`);
       }
-      log("mind", `session "${session.name}": stream consumer ended`);
     })();
   }
@@ -484,6 +514,7 @@ export function createMind(options: {
       replyInstructionsFired: false,
       replyInstructionsMode: "once",
       contextTokens: 0,
+      lastActivityAt: Date.now(),
     };
     sessions.set(name, session);
@@ -506,18 +537,69 @@ export function createMind(options: {
     return session;
   }
+  // --- Idle session reaping ---
+  // Each session holds a resident SDK subprocess (~250MB) for its whole life.
+  // After the idle timeout, shut the subprocess down while keeping the session
+  // resumable: the session id is persisted, so the next inbound message
+  // transparently re-creates the session via getOrCreateSession's resume path.
+  const idleTimeoutMs = (options.sessionIdleMinutes ?? 30) * 60_000;
+  function reapSession(session: Session) {
+    log("mind", `session "${session.name}": idle — reaping SDK subprocess (resumable)`);
+    // Delete first so a racing inbound message spins up a fresh resumed session
+    // instead of reusing the one we're tearing down.
+    sessions.delete(session.name);
+    compactionTriggered.delete(session.name);
+    // Terminate the subprocess and end the input iterable so the stream consumer
+    // unwinds (its finally block also deletes from the map, now a no-op).
+    session.currentQuery?.close();
+    session.channel.close();
+    // Nothing should have raced in (isSessionReapable checked isEmpty), but if it
+    // did, re-dispatch into a fresh session so no input is dropped.
+    const pending = session.channel.recover();
+    if (pending.length > 0) {
+      const fresh = getOrCreateSession(session.name);
+      for (const msg of pending) fresh.channel.push(msg);
+    }
+  }
+  if (idleTimeoutMs > 0) {
+    log("mind", `idle session reaper: ${idleTimeoutMs / 60_000} min timeout`);
+    const checkMs = Math.min(60_000, idleTimeoutMs);
+    const reaper = setInterval(() => {
+      const now = Date.now();
+      const stale = [...sessions.values()].filter((s) =>
+        isSessionReapable(s, now, idleTimeoutMs, (name) => !!compactionTriggered.get(name)),
+      );
+      for (const session of stale) reapSession(session);
+    }, checkMs);
+    reaper.unref?.();
+  }
   // --- MessageHandler implementation ---
   function createSessionHandler(sessionName: string): MessageHandler {
     return {
-      handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void {
+      handle(content: VoluteContentPart[], meta: HandlerMeta, listener?: Listener): () => void {
         const session = getOrCreateSession(sessionName);
-        // Filter listener to only receive events for this messageId
-        const filteredListener: Listener = (event) => {
-          if (event.messageId === meta.messageId) listener(event);
-        };
-        session.listeners.add(filteredListener);
+        // Only register a listener when a caller actually wants events. A per-message
+        // listener that's never removed would grow session.listeners without bound and
+        // make broadcastToSession O(messages-ever-received). The live dispatch path
+        // passes no listener, so this is usually a no-op.
+        let filteredListener: Listener | undefined;
+        if (listener) {
+          // Filter to only this messageId, and self-remove on the matching done so a
+          // caller that forgets to unsubscribe can't reintroduce the leak.
+          filteredListener = (event) => {
+            if (event.messageId !== meta.messageId) return;
+            listener(event);
+            if (event.type === "done" && filteredListener) {
+              session.listeners.delete(filteredListener);
+            }
+          };
+          session.listeners.add(filteredListener);
+        }
         // Track channel/sender for reply instructions
         if (meta.channel) {
@@ -539,6 +621,7 @@ export function createMind(options: {
         }
         // Push message into SDK
+        session.lastActivityAt = Date.now();
         session.messageIds.push(meta.messageId);
         session.channel.push({
           type: "user",
@@ -547,7 +630,9 @@ export function createMind(options: {
           parent_tool_use_id: null,
         });
-        return () => session.listeners.delete(filteredListener);
+        return () => {
+          if (filteredListener) session.listeners.delete(filteredListener);
+        };
       },
     };
   }

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

@@ -11,6 +11,14 @@ export type MessageChannel = {
    * compaction abort so in-flight input is never lost.
    */
   recover: () => SDKUserMessage[];
+  /**
+   * Terminate the input iterable: resolve any pending `next()` with `done: true`
+   * and make subsequent `next()` calls return done. The SDK sees end-of-input and
+   * shuts the query down. Used by the idle reaper to release the SDK subprocess.
+   */
+  close: () => void;
+  /** True when nothing is queued or in flight (no pending work). */
+  isEmpty: () => boolean;
   iterable: AsyncIterable<SDKUserMessage>;
 };
@@ -23,6 +31,7 @@ export function createMessageChannel(): MessageChannel {
   // re-feed the unprocessed ones instead of dropping them.
   const inFlight: SDKUserMessage[] = [];
   let resolve: ((value: IteratorResult<SDKUserMessage>) => void) | null = null;
+  let closed = false;
   function deliver(msg: SDKUserMessage): IteratorResult<SDKUserMessage> {
     inFlight.push(msg);
@@ -52,10 +61,24 @@ export function createMessageChannel(): MessageChannel {
       }
       return [...inFlight.splice(0), ...queue.splice(0)];
     },
+    close() {
+      closed = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: undefined as any, done: true });
+      }
+    },
+    isEmpty() {
+      return queue.length === 0 && inFlight.length === 0;
+    },
     iterable: {
       [Symbol.asyncIterator]() {
         return {
           next(): Promise<IteratorResult<SDKUserMessage>> {
+            if (closed) {
+              return Promise.resolve({ value: undefined as any, done: true });
+            }
             if (queue.length > 0) {
               return Promise.resolve(deliver(queue.shift()!));
             }

package/templates/claude/src/lib/session-reaper.ts ADDED Viewed

@@ -0,0 +1,37 @@
+/**
+ * Idle-session reaping decision logic.
+ *
+ * Each mind session keeps a resident Claude SDK subprocess alive for as long as
+ * the session lives. When a session has been idle past the configured timeout it
+ * can be reaped — its subprocess shut down — while staying resumable, since the
+ * session id is persisted and the next inbound message re-creates it via resume.
+ */
+export interface ReapableSession {
+  name: string;
+  /** Timestamp (ms) of the last inbound message or completed turn. */
+  lastActivityAt: number;
+  /** Set while a turn is in progress; undefined between turns. */
+  currentMessageId?: string;
+  channel: { isEmpty(): boolean };
+}
+/**
+ * A session is reapable only when it has been idle longer than the timeout and
+ * has no work in progress: no turn running, no queued/in-flight input, and not
+ * mid-compaction (which owns its own abort/resume lifecycle).
+ */
+export function isSessionReapable(
+  session: ReapableSession,
+  now: number,
+  idleTimeoutMs: number,
+  isCompacting: (name: string) => boolean,
+): boolean {
+  if (idleTimeoutMs <= 0) return false;
+  return (
+    session.currentMessageId === undefined &&
+    session.channel.isEmpty() &&
+    !isCompacting(session.name) &&
+    now - session.lastActivityAt > idleTimeoutMs
+  );
+}

package/templates/claude/src/lib/stream-consumer.ts CHANGED Viewed

@@ -65,11 +65,11 @@ export async function consumeStream(
           const text = (b as { text: string }).text;
           emit(session, { type: "text", content: text });
         } else if (b.type === "tool_use") {
-          const tb = b as { name: string; input: unknown };
+          const tb = b as { id: string; name: string; input: unknown };
           emit(session, {
             type: "tool_use",
             content: JSON.stringify(tb.input),
-            metadata: { name: tb.name },
+            metadata: { name: tb.name, id: tb.id },
           });
         }
       }
@@ -99,13 +99,16 @@ export async function consumeStream(
               : typeof b.content === "string"
                 ? b.content
                 : "";
-            if (resultContent) {
+            // A failed tool call must be recorded even when it produced no text
+            // body, so downstream (summary transcript + timeline UI) can flag it.
+            const isError = "is_error" in b && b.is_error === true;
+            if (resultContent || isError) {
               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 },
+                metadata: { tool_use_id: toolUseId, is_error: isError },
               });
             }
           }

package/templates/claude/src/server.ts CHANGED Viewed

@@ -33,6 +33,7 @@ const mind = createMind({
   sessionsDir,
   compactionMessage: config.compactionMessage,
   maxContextTokens: config.compaction?.maxContextTokens,
+  sessionIdleMinutes: config.sessionIdleMinutes,
   subagents: config.subagents,
   onIdentityReload: async () => {
     log("server", "identity file changed — restarting to reload");

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

@@ -1,12 +1,14 @@
 # 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.
+You are an autonomous mind running as a persistent server. Your working directory is already set to `home/` — all file paths you use (`.config/routes.json`, `memory/`, etc.) are relative to it. Your identity, memory, and server code are all yours to understand and modify. Your state is managed across sessions.
+Your identity lives in `SOUL.md` (who you are) and `MEMORY.md` (what you know) — both are loaded into your system prompt. Edit them as you evolve; changes take effect the next time your server restarts (`volute mind restart` when you want them live now).
 ## Message Format
 Messages arrive with a context prefix:
 ```
-[Discord: username in #general in My Server — 1/15/2025, 10:30:00 AM]
+[Discord: username in #general in My Server — 2025-01-15 10:30]
 ```
 You can also reach out proactively — see the **volute-mind** skill.