volute 0.16.0 → 0.18.0

package/templates/_base/src/lib/transparency.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { DaemonEvent, EventType } from "./daemon-client.js";
+
+export type TransparencyPreset = "transparent" | "standard" | "private" | "silent";
+
+type FilterableEventType = Exclude<EventType, "inbound" | "outbound">;
+
+const PRESET_RULES: Record<
+  TransparencyPreset,
+  Record<FilterableEventType, "yes" | "name_only" | "no">
+> = {
+  transparent: {
+    thinking: "yes",
+    text: "yes",
+    tool_use: "yes",
+    tool_result: "yes",
+    log: "yes",
+    usage: "yes",
+    session_start: "yes",
+    done: "yes",
+  },
+  standard: {
+    thinking: "no",
+    text: "yes",
+    tool_use: "name_only",
+    tool_result: "no",
+    log: "yes",
+    usage: "yes",
+    session_start: "yes",
+    done: "yes",
+  },
+  private: {
+    thinking: "no",
+    text: "no",
+    tool_use: "no",
+    tool_result: "no",
+    log: "no",
+    usage: "yes",
+    session_start: "yes",
+    done: "yes",
+  },
+  silent: {
+    thinking: "no",
+    text: "no",
+    tool_use: "no",
+    tool_result: "no",
+    log: "no",
+    usage: "no",
+    session_start: "no",
+    done: "no",
+  },
+};
+
+// Communication records are always emitted (bypass transparency filtering)
+const ALWAYS_ALLOWED: ReadonlySet<string> = new Set(["inbound", "outbound"]);
+
+export function loadTransparencyPreset(): TransparencyPreset {
+  for (const file of ["home/.config/config.json", "home/.config/volute.json"]) {
+    try {
+      const config = JSON.parse(readFileSync(resolve(file), "utf-8"));
+      if (config.transparency && config.transparency in PRESET_RULES) {
+        return config.transparency as TransparencyPreset;
+      }
+    } catch {
+      // try next
+    }
+  }
+  return "standard";
+}
+
+export function filterEvent(preset: TransparencyPreset, event: DaemonEvent): DaemonEvent | null {
+  if (ALWAYS_ALLOWED.has(event.type)) return event;
+
+  const rules = PRESET_RULES[preset];
+  const rule = rules[event.type as FilterableEventType];
+
+  if (!rule) {
+    // Unknown event types: pass through in transparent mode, drop otherwise
+    return preset === "transparent" ? event : null;
+  }
+  if (rule === "no") return null;
+
+  if (rule === "name_only" && event.type === "tool_use") {
+    return { ...event, content: undefined };
+  }
+
+  return event;
+}

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

@@ -19,7 +19,6 @@ export type ChannelMeta = {
 export type HandlerMeta = ChannelMeta & {
   messageId: string;
   interrupt?: boolean;
-  autoReply: boolean;
 };
 
 export type VoluteRequest = {

package/templates/_base/src/lib/volute-server.ts

@@ -32,41 +32,9 @@ export function createVoluteServer(options: {
     if (req.method === "POST" && url.pathname === "/message") {
       try {
         const body = JSON.parse(await readBody(req)) as VoluteRequest;
-
-        let usage: { input_tokens: number; output_tokens: number } | undefined;
-        let done = false;
-
-        const { unsubscribe } = router.route(body.content, body, (event) => {
-          if (event.type === "usage") {
-            usage = { input_tokens: event.input_tokens, output_tokens: event.output_tokens };
-          }
-          if (event.type === "done") {
-            done = true;
-            clearTimeout(timeout);
-            const response: { ok: true; usage?: { input_tokens: number; output_tokens: number } } =
-              { ok: true };
-            if (usage) response.usage = usage;
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify(response));
-          }
-        });
-
-        const timeout = setTimeout(
-          () => {
-            if (!done) {
-              done = true;
-              unsubscribe();
-              res.writeHead(504, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ ok: false, error: "Mind processing timed out" }));
-            }
-          },
-          5 * 60 * 1000,
-        );
-
-        res.on("close", () => {
-          clearTimeout(timeout);
-          if (!done) unsubscribe();
-        });
+        router.route(body.content, body);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
       } catch (err) {
         if (err instanceof SyntaxError) {
           res.writeHead(400);

package/templates/claude/src/agent.ts

@@ -1,10 +1,5 @@
 import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import {
-  type AutoReplyTracker,
-  createAutoReplyTracker,
-  type MessageChannelInfo,
-} from "./lib/auto-reply.js";
 import { toSDKContent } from "./lib/content.js";
 import { createAutoCommitHook } from "./lib/hooks/auto-commit.js";
 import { createIdentityReloadHook } from "./lib/hooks/identity-reload.js";
@@ -14,6 +9,7 @@ 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";
+import { loadPrompts } from "./lib/startup.js";
 import { consumeStream } from "./lib/stream-consumer.js";
 import type {
   HandlerMeta,
@@ -31,8 +27,7 @@ type Session = {
   messageIds: (string | undefined)[];
   currentMessageId?: string;
   currentQuery?: ReturnType<typeof query>;
-  messageChannels: Map<string, MessageChannelInfo>;
-  autoReply: AutoReplyTracker;
+  messageChannels: Map<string, string>;
 };
 
 export function createMind(options: {
@@ -53,10 +48,10 @@ export function createMind(options: {
   ];
 
   const sessions = new Map<string, Session>();
-  const today = new Date().toISOString().slice(0, 10);
+  const prompts = loadPrompts();
+  const today = new Date().toLocaleDateString("en-CA");
   const compactionMessage =
-    options.compactionMessage ??
-    `Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${today}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`;
+    options.compactionMessage ?? prompts.compaction_warning.replace("${date}", today);
 
   // --- Event broadcasting ---
 
@@ -133,15 +128,13 @@ export function createMind(options: {
         const q = createStream(session, savedSessionId);
         session.currentQuery = q;
         await consumeStream(q, session, callbacks);
-        // Stream ended — flush any pending auto-reply and broadcast done if no result was emitted
-        session.autoReply.flush(session.currentMessageId);
+        // Stream ended — broadcast done if no result was emitted
         if (session.currentMessageId !== undefined) {
           session.messageChannels.delete(session.currentMessageId);
           broadcastToSession(session, { type: "done" });
           session.currentMessageId = undefined;
         }
       } catch (err) {
-        session.autoReply.reset();
         session.messageChannels.clear();
         if (savedSessionId) {
           log("mind", `session "${session.name}": resume failed, starting fresh:`, err);
@@ -150,7 +143,6 @@ export function createMind(options: {
             const q = createStream(session);
             session.currentQuery = q;
             await consumeStream(q, session, callbacks);
-            session.autoReply.flush(session.currentMessageId);
             if (session.currentMessageId !== undefined) {
               session.messageChannels.delete(session.currentMessageId);
               broadcastToSession(session, { type: "done" });
@@ -175,14 +167,12 @@ export function createMind(options: {
     const existing = sessions.get(name);
     if (existing) return existing;
 
-    const messageChannels = new Map<string, MessageChannelInfo>();
     const session: Session = {
       name,
       channel: createMessageChannel(),
       listeners: new Set(),
       messageIds: [],
-      messageChannels,
-      autoReply: createAutoReplyTracker(messageChannels),
+      messageChannels: new Map(),
     };
     sessions.set(name, session);
 
@@ -211,12 +201,9 @@ export function createMind(options: {
         };
         session.listeners.add(filteredListener);
 
-        // Track channel for auto-reply
+        // Track channel for reply instructions
         if (meta.channel) {
-          session.messageChannels.set(meta.messageId, {
-            channel: meta.channel,
-            autoReply: meta.autoReply,
-          });
+          session.messageChannels.set(meta.messageId, meta.channel);
         }
 
         // Interrupt if requested and session is mid-turn

package/templates/claude/src/lib/hooks/reply-instructions.ts

@@ -1,25 +1,22 @@
 import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
-import type { MessageChannelInfo } from "../auto-reply.js";
+import { loadPrompts } from "../startup.js";
 
-export function createReplyInstructionsHook(messageChannels: Map<string, MessageChannelInfo>) {
+export function createReplyInstructionsHook(messageChannels: Map<string, string>) {
   let fired = false;
+  const prompts = loadPrompts();
 
   const hook: HookCallback = async () => {
     if (fired) return {};
 
-    const entry = messageChannels.values().next().value;
-    if (!entry?.channel) return {};
+    const channel = messageChannels.values().next().value;
+    if (!channel) return {};
 
     fired = true;
 
-    const context = entry.autoReply
-      ? `Auto-reply is enabled for this session — your text output will automatically be sent back to ${entry.channel}. To send to a different channel: volute send <channel> "message"`
-      : `To reply to this message, use: volute send ${entry.channel} "your message"`;
-
     return {
       hookSpecificOutput: {
         hookEventName: "UserPromptSubmit" as const,
-        additionalContext: context,
+        additionalContext: prompts.reply_instructions.replace(/\$\{channel\}/g, channel),
       },
     };
   };

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

@@ -1,14 +1,14 @@
 import type { query } from "@anthropic-ai/claude-agent-sdk";
-import type { AutoReplyTracker, MessageChannelInfo } from "./auto-reply.js";
+import { daemonEmit, type EventType } from "./daemon-client.js";
 import { log, logText, logThinking, logToolUse } from "./logger.js";
+import { filterEvent, loadTransparencyPreset } from "./transparency.js";
 import type { VoluteEvent } from "./types.js";
 
 export type StreamSession = {
   name: string;
   messageIds: (string | undefined)[];
   currentMessageId?: string;
-  messageChannels: Map<string, MessageChannelInfo>;
-  autoReply: AutoReplyTracker;
+  messageChannels: Map<string, string>;
 };
 
 export type StreamCallbacks = {
@@ -17,15 +17,34 @@ export type StreamCallbacks = {
   onTurnEnd?: () => void;
 };
 
+// Loaded once at startup — mind restarts on config changes
+const preset = loadTransparencyPreset();
+
+function emit(
+  session: StreamSession,
+  event: { type: EventType; content?: string; metadata?: Record<string, unknown> },
+) {
+  const channel = session.currentMessageId
+    ? session.messageChannels.get(session.currentMessageId)
+    : undefined;
+  const filtered = filterEvent(preset, {
+    ...event,
+    session: session.name,
+    channel,
+    messageId: session.currentMessageId,
+  });
+  if (filtered) daemonEmit(filtered);
+}
+
 export async function consumeStream(
   stream: ReturnType<typeof query>,
   session: StreamSession,
   callbacks: StreamCallbacks,
 ) {
+  emit(session, { type: "session_start" });
   for await (const msg of stream) {
     if (session.currentMessageId === undefined) {
       session.currentMessageId = session.messageIds.shift();
-      session.autoReply.reset();
     }
     if ("session_id" in msg && msg.session_id) {
       callbacks.onSessionId?.(msg.session_id as string);
@@ -33,32 +52,40 @@ export async function consumeStream(
     if (msg.type === "assistant") {
       for (const b of msg.message.content) {
         if (b.type === "thinking" && "thinking" in b && b.thinking) {
-          logThinking(b.thinking as string);
+          const text = b.thinking as string;
+          logThinking(text);
+          emit(session, { type: "thinking", content: text });
         } else if (b.type === "text") {
-          logText((b as { text: string }).text);
-          session.autoReply.accumulate((b as { text: string }).text);
+          const text = (b as { text: string }).text;
+          logText(text);
+          emit(session, { type: "text", content: text });
         } else if (b.type === "tool_use") {
-          session.autoReply.flush(session.currentMessageId);
           const tb = b as { name: string; input: unknown };
           logToolUse(tb.name, tb.input);
+          emit(session, {
+            type: "tool_use",
+            content: JSON.stringify(tb.input),
+            metadata: { name: tb.name },
+          });
         }
       }
     }
     if (msg.type === "result") {
-      session.autoReply.flush(session.currentMessageId);
       if (session.currentMessageId) {
         session.messageChannels.delete(session.currentMessageId);
       }
       log("mind", `session "${session.name}": turn done`);
       const result = msg as { usage?: { input_tokens?: number; output_tokens?: number } };
       if (result.usage) {
-        callbacks.broadcast({
-          type: "usage",
+        const usage = {
           input_tokens: result.usage.input_tokens ?? 0,
           output_tokens: result.usage.output_tokens ?? 0,
-        });
+        };
+        callbacks.broadcast({ type: "usage", ...usage });
+        emit(session, { type: "usage", metadata: usage });
       }
       callbacks.broadcast({ type: "done" });
+      emit(session, { type: "done" });
       session.currentMessageId = undefined;
       callbacks.onTurnEnd?.();
     }

package/templates/pi/src/agent.ts

@@ -7,17 +7,13 @@ import {
   SessionManager,
   SettingsManager,
 } from "@mariozechner/pi-coding-agent";
-import {
-  type AutoReplyTracker,
-  createAutoReplyTracker,
-  type MessageChannelInfo,
-} from "./lib/auto-reply.js";
 import { extractImages, extractText } from "./lib/content.js";
 import { createEventHandler } from "./lib/event-handler.js";
 import { log } from "./lib/logger.js";
 import { createReplyInstructionsExtension } from "./lib/reply-instructions-extension.js";
 import { resolveModel } from "./lib/resolve-model.js";
 import { createSessionContextExtension } from "./lib/session-context-extension.js";
+import { loadPrompts } from "./lib/startup.js";
 import type {
   HandlerMeta,
   HandlerResolver,
@@ -37,15 +33,9 @@ type PiSession = {
   unsubscribe?: () => void;
   messageIds: (string | undefined)[];
   currentMessageId?: string;
-  messageChannels: Map<string, MessageChannelInfo>;
-  autoReply: AutoReplyTracker;
+  messageChannels: Map<string, string>;
 };
 
-function defaultCompactionMessage(): string {
-  const today = new Date().toISOString().slice(0, 10);
-  return `Context is getting long — compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/${today}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`;
-}
-
 export function createMind(options: {
   systemPrompt: string;
   cwd: string;
@@ -54,7 +44,10 @@ export function createMind(options: {
   compactionMessage?: string;
 }): { resolve: HandlerResolver } {
   const sessions = new Map<string, PiSession>();
-  const compactionMessage = options.compactionMessage ?? defaultCompactionMessage();
+  const prompts = loadPrompts();
+  const today = new Date().toLocaleDateString("en-CA");
+  const compactionMessage =
+    options.compactionMessage ?? prompts.compaction_warning.replace("${date}", today);
 
   // Shared setup (created once)
   const modelStr = options.model || process.env.PI_MODEL || "anthropic:claude-sonnet-4-20250514";
@@ -68,20 +61,17 @@ export function createMind(options: {
     const existing = sessions.get(name);
     if (existing) return existing;
 
-    const messageChannels = new Map<string, MessageChannelInfo>();
     const session: PiSession = {
       name,
       agentSession: null,
       ready: Promise.resolve(),
       listeners: new Set(),
       messageIds: [],
-      messageChannels,
-      autoReply: createAutoReplyTracker(messageChannels),
+      messageChannels: new Map(),
     };
     sessions.set(name, session);
 
     session.ready = initSession(session).catch((err) => {
-      session.autoReply.reset();
       session.messageChannels.clear();
       log("mind", `session "${session.name}": init failed:`, err);
     });
@@ -197,12 +187,9 @@ export function createMind(options: {
         };
         session.listeners.add(filteredListener);
 
-        // Track channel for auto-reply
+        // Track channel for reply instructions
         if (meta.channel) {
-          session.messageChannels.set(meta.messageId, {
-            channel: meta.channel,
-            autoReply: meta.autoReply,
-          });
+          session.messageChannels.set(meta.messageId, meta.channel);
         }
 
         // Track messageId (must be pushed before prompt)

package/templates/pi/src/lib/event-handler.ts

@@ -1,14 +1,14 @@
 import { commitFileChange } from "./auto-commit.js";
-import type { AutoReplyTracker, MessageChannelInfo } from "./auto-reply.js";
+import { daemonEmit, type EventType } from "./daemon-client.js";
 import { log, logText, logThinking, logToolResult, logToolUse } from "./logger.js";
+import { filterEvent, loadTransparencyPreset } from "./transparency.js";
 import type { VoluteEvent } from "./types.js";
 
 export type EventSession = {
   name: string;
   messageIds: (string | undefined)[];
   currentMessageId?: string;
-  messageChannels: Map<string, MessageChannelInfo>;
-  autoReply: AutoReplyTracker;
+  messageChannels: Map<string, string>;
 };
 
 export type EventHandlerOptions = {
@@ -16,6 +16,25 @@ export type EventHandlerOptions = {
   broadcast: (event: VoluteEvent) => void;
 };
 
+// Loaded once at startup — mind restarts on config changes
+const preset = loadTransparencyPreset();
+
+function emit(
+  session: EventSession,
+  event: { type: EventType; content?: string; metadata?: Record<string, unknown> },
+) {
+  const channel = session.currentMessageId
+    ? session.messageChannels.get(session.currentMessageId)
+    : undefined;
+  const filtered = filterEvent(preset, {
+    ...event,
+    session: session.name,
+    channel,
+    messageId: session.currentMessageId,
+  });
+  if (filtered) daemonEmit(filtered);
+}
+
 export function createEventHandler(session: EventSession, options: EventHandlerOptions) {
   const toolArgs = new Map<string, any>();
   let textBuf = "";
@@ -24,6 +43,7 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
   function flushText() {
     if (textBuf) {
       logText(textBuf);
+      emit(session, { type: "text", content: textBuf });
       textBuf = "";
     }
   }
@@ -31,6 +51,7 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
   function flushThinking() {
     if (thinkingBuf) {
       logThinking(thinkingBuf);
+      emit(session, { type: "thinking", content: thinkingBuf });
       thinkingBuf = "";
     }
   }
@@ -40,12 +61,18 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
     flushText();
   }
 
+  let sessionStarted = false;
+
   return (event: any) => {
     try {
+      if (!sessionStarted && event.type === "agent_start") {
+        sessionStarted = true;
+        emit(session, { type: "session_start" });
+      }
+
       if (session.currentMessageId === undefined) {
         flushBuffers(); // flush any leftover from a turn that ended without agent_end
         session.currentMessageId = session.messageIds.shift();
-        session.autoReply.reset();
       }
 
       if (event.type === "message_update") {
@@ -53,7 +80,6 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
         if (ae.type === "text_delta") {
           if (thinkingBuf) flushThinking();
           textBuf += ae.delta;
-          session.autoReply.accumulate(ae.delta);
           // Log complete lines as they arrive
           for (let nl = textBuf.indexOf("\n"); nl !== -1; nl = textBuf.indexOf("\n")) {
             logText(textBuf.slice(0, nl + 1));
@@ -71,15 +97,24 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
 
       if (event.type === "tool_execution_start") {
         flushBuffers();
-        session.autoReply.flush(session.currentMessageId);
         toolArgs.set(event.toolCallId, event.args);
         logToolUse(event.toolName, event.args);
+        emit(session, {
+          type: "tool_use",
+          content: JSON.stringify(event.args),
+          metadata: { name: event.toolName },
+        });
       }
 
       if (event.type === "tool_execution_end") {
         const output =
           typeof event.result === "string" ? event.result : JSON.stringify(event.result);
         logToolResult(event.toolName, output, event.isError);
+        emit(session, {
+          type: "tool_result",
+          content: output,
+          metadata: { name: event.toolName, is_error: event.isError },
+        });
 
         // Auto-commit file changes in home/
         if ((event.toolName === "edit" || event.toolName === "write") && !event.isError) {
@@ -94,12 +129,28 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
 
       if (event.type === "agent_end") {
         flushBuffers();
-        session.autoReply.flush(session.currentMessageId);
         if (session.currentMessageId) {
           session.messageChannels.delete(session.currentMessageId);
         }
         log("mind", `session "${session.name}": turn done`);
+        // Sum usage from assistant messages
+        if (event.messages) {
+          let inputTokens = 0;
+          let outputTokens = 0;
+          for (const msg of event.messages as any[]) {
+            if (msg.role === "assistant" && msg.usage) {
+              inputTokens += msg.usage.input ?? 0;
+              outputTokens += msg.usage.output ?? 0;
+            }
+          }
+          if (inputTokens > 0 || outputTokens > 0) {
+            const usage = { input_tokens: inputTokens, output_tokens: outputTokens };
+            options.broadcast({ type: "usage", ...usage });
+            emit(session, { type: "usage", metadata: usage });
+          }
+        }
         options.broadcast({ type: "done" });
+        emit(session, { type: "done" });
         session.currentMessageId = undefined;
       }
     } catch (err) {

package/templates/pi/src/lib/reply-instructions-extension.ts

@@ -1,27 +1,24 @@
 import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
-import type { MessageChannelInfo } from "./auto-reply.js";
+import { loadPrompts } from "./startup.js";
 
 export function createReplyInstructionsExtension(
-  messageChannels: Map<string, MessageChannelInfo>,
+  messageChannels: Map<string, string>,
 ): ExtensionFactory {
+  const prompts = loadPrompts();
   return (pi) => {
     let fired = false;
     pi.on("before_agent_start", () => {
       if (fired) return {};
 
-      const entry = messageChannels.values().next().value;
-      if (!entry?.channel) return {};
+      const channel = messageChannels.values().next().value;
+      if (!channel) return {};
 
       fired = true;
 
-      const content = entry.autoReply
-        ? `Auto-reply is enabled for this session — your text output will automatically be sent back to ${entry.channel}. To send to a different channel: volute send <channel> "message"`
-        : `To reply to this message, use: volute send ${entry.channel} "your message"`;
-
       return {
         message: {
           customType: "reply-instructions",
-          content,
+          content: prompts.reply_instructions.replace(/\$\{channel\}/g, channel),
           display: true,
         },
       };