volute 0.7.0 → 0.8.0

package/templates/_base/src/lib/auto-reply.ts

@@ -0,0 +1,38 @@
+import { daemonSend } from "./daemon-client.js";
+import { log } from "./logger.js";
+
+export type MessageChannelInfo = { channel: string; autoReply: boolean };
+
+export type AutoReplyTracker = {
+  accumulate(text: string): void;
+  flush(currentMessageId: string | undefined): void;
+  reset(): void;
+};
+
+export function createAutoReplyTracker(
+  messageChannels: Map<string, MessageChannelInfo>,
+): AutoReplyTracker {
+  let accumulator = "";
+
+  function flush(currentMessageId: string | undefined) {
+    const text = accumulator.trim();
+    accumulator = "";
+    if (!text) return;
+    const info = currentMessageId ? messageChannels.get(currentMessageId) : undefined;
+    if (info?.autoReply && info.channel) {
+      daemonSend(info.channel, text).catch((err) => {
+        log("agent", `auto-reply to ${info.channel} failed: ${err}`);
+      });
+    }
+  }
+
+  return {
+    accumulate(text: string) {
+      accumulator += text;
+    },
+    flush,
+    reset() {
+      accumulator = "";
+    },
+  };
+}

package/templates/_base/src/lib/daemon-client.ts

@@ -0,0 +1,53 @@
+const port = process.env.VOLUTE_DAEMON_PORT;
+const agent = process.env.VOLUTE_AGENT;
+const token = process.env.VOLUTE_DAEMON_TOKEN;
+
+function headers(): Record<string, string> {
+  const h: Record<string, string> = { "Content-Type": "application/json" };
+  if (token) h.Authorization = `Bearer ${token}`;
+  // Origin header required for CSRF checks on mutation requests
+  if (port) h.Origin = `http://127.0.0.1:${port}`;
+  return h;
+}
+
+export async function daemonRestart(context?: {
+  type: string;
+  [k: string]: unknown;
+}): Promise<void> {
+  if (!port || !agent) {
+    console.error("[volute] daemonRestart: VOLUTE_DAEMON_PORT or VOLUTE_AGENT not set");
+    return;
+  }
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/agents/${encodeURIComponent(agent)}/restart`, {
+      method: "POST",
+      headers: headers(),
+      body: JSON.stringify({ context }),
+    });
+  } catch {
+    // Daemon may kill us before response arrives — expected
+  }
+}
+
+export async function daemonSend(channel: string, text: string): Promise<void> {
+  if (!port || !agent) {
+    console.error("[volute] daemonSend: VOLUTE_DAEMON_PORT or VOLUTE_AGENT not set");
+    return;
+  }
+  const res = await fetch(
+    `http://127.0.0.1:${port}/api/agents/${encodeURIComponent(agent)}/message`,
+    {
+      method: "POST",
+      headers: headers(),
+      body: JSON.stringify({
+        content: text,
+        channel,
+        sender: agent,
+      }),
+    },
+  );
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`daemonSend failed (${res.status}): ${body}`);
+  }
+}

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

@@ -1,6 +1,11 @@
 import { formatPrefix, formatTypingSuffix } from "./format-prefix.js";
 import { log, logMessage } from "./logger.js";
-import { type BatchConfig, loadRoutingConfig, resolveRoute } from "./routing.js";
+import {
+  type BatchConfig,
+  loadRoutingConfig,
+  resolveRoute,
+  resolveSessionConfig,
+} from "./routing.js";
 import type { ChannelMeta, HandlerResolver, Listener, VoluteContentPart } from "./types.js";
 
 export type Router = {
@@ -72,6 +77,24 @@ function appendTypingSuffix(
   });
 }
 
+function prependInstructions(
+  content: VoluteContentPart[],
+  instructions: string | undefined,
+): VoluteContentPart[] {
+  if (!instructions) return content;
+  const prefix = `[Session instructions: ${instructions}]\n\n`;
+  const firstTextIdx = content.findIndex((p) => p.type === "text");
+  if (firstTextIdx === -1) {
+    return [{ type: "text", text: prefix.trimEnd() }, ...content];
+  }
+  return content.map((part, i) => {
+    if (i === firstTextIdx) {
+      return { type: "text" as const, text: prefix + (part as { text: string }).text };
+    }
+    return part;
+  });
+}
+
 function sanitizeChannelPath(channel: string): string {
   return channel
     .replace(/[/\\:]/g, "-")
@@ -107,20 +130,21 @@ function formatInviteNotification(
   lines.push("");
   lines.push(`Further messages will be saved to ${filePath}`);
   lines.push("");
-  lines.push("To accept, add a routing rule to .config/routes.json:");
+  lines.push("To accept, add to .config/routes.json:");
   const suggestedSession = sanitizeChannelPath(meta.channel ?? "unknown");
   const otherCount = (meta.participantCount ?? 1) - 1;
   if (otherCount > 1) {
+    lines.push(`  Rule: { "channel": "${meta.channel}", "session": "${suggestedSession}" }`);
     lines.push(
-      `  { "channel": "${meta.channel}", "session": "${suggestedSession}", "batch": { "debounce": 20, "maxWait": 120 } }`,
+      `  Session config: "${suggestedSession}": { "batch": { "debounce": 20, "maxWait": 120 } }`,
     );
     lines.push(
       `(batch recommended — ${otherCount} other participants may generate frequent messages)`,
     );
   } else {
-    lines.push(`  { "channel": "${meta.channel}", "session": "${suggestedSession}" }`);
+    lines.push(`  Rule: { "channel": "${meta.channel}", "session": "${suggestedSession}" }`);
   }
-  lines.push(`To respond, use: volute channel send ${meta.channel ?? "unknown"} "your message"`);
+  lines.push(`To respond, use: volute send ${meta.channel ?? "unknown"} "your message"`);
   lines.push(`To reject, delete ${filePath}`);
   return lines.join("\n");
 }
@@ -175,15 +199,25 @@ export function createRouter(options: {
 
     const lastTyping = messages[messages.length - 1]?.typing;
     const typingSuffix = formatTypingSuffix(lastTyping);
-    const content: VoluteContentPart[] = [
+    let content: VoluteContentPart[] = [
       { type: "text", text: `${header}\n\n${body}${typingSuffix}` },
     ];
+
+    // Resolve session config for instructions
+    const config = options.configPath ? loadRoutingConfig(options.configPath) : {};
+    const sessionConfig = resolveSessionConfig(config, buffer.sessionName);
+    content = prependInstructions(content, sessionConfig.instructions);
+
     const messageId = generateMessageId();
     const handler = options.agentHandler(buffer.sessionName);
 
     // Batch flushes are fire-and-forget — no HTTP response is waiting, so listener is a noop
     try {
-      handler.handle(content, { sessionName: buffer.sessionName, messageId }, () => {});
+      handler.handle(
+        content,
+        { sessionName: buffer.sessionName, messageId, autoReply: false },
+        () => {},
+      );
     } catch (err) {
       log("router", `error flushing batch for session ${buffer.sessionName}:`, err);
       return;
@@ -250,7 +284,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, autoReply: false }, noop);
       }
 
       // First message from this channel — send invite notification
@@ -261,7 +295,12 @@ export function createRouter(options: {
         const handler = options.agentHandler("main");
         handler.handle(
           notifContent,
-          { sessionName: "main", messageId: generateMessageId(), interrupt: true },
+          {
+            sessionName: "main",
+            messageId: generateMessageId(),
+            interrupt: true,
+            autoReply: false,
+          },
           noop,
         );
       }
@@ -275,7 +314,11 @@ 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, autoReply: false },
+          safeListener,
+        );
         return { messageId, unsubscribe };
       }
       // No file handler configured — emit done and discard
@@ -290,10 +333,12 @@ export function createRouter(options: {
       sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     }
 
+    const sessionConfig = resolveSessionConfig(config, sessionName);
+
     // Batch mode: buffer the message and return immediate done
-    if (resolved.batch != null) {
+    if (sessionConfig.batch != null) {
       const batchKey = `batch:${sessionName}`;
-      const batchConfig = resolved.batch;
+      const batchConfig = sessionConfig.batch;
 
       if (!batchBuffers.has(batchKey)) {
         batchBuffers.set(batchKey, {
@@ -332,10 +377,17 @@ export function createRouter(options: {
     // Direct dispatch to agent
     const formatted = applyPrefix(content, { ...meta, sessionName });
     const withTyping = appendTypingSuffix(formatted, meta.typing);
+    const withInstructions = prependInstructions(withTyping, sessionConfig.instructions);
     const handler = options.agentHandler(sessionName);
     const unsubscribe = handler.handle(
-      withTyping,
-      { ...meta, sessionName, messageId, interrupt: resolved.interrupt },
+      withInstructions,
+      {
+        ...meta,
+        sessionName,
+        messageId,
+        interrupt: sessionConfig.interrupt,
+        autoReply: sessionConfig.autoReply,
+      },
       safeListener,
     );
     return { messageId, unsubscribe };

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

@@ -11,16 +11,29 @@ export type RoutingRule = {
   session?: string;
   destination?: "agent" | "file";
   path?: string; // file path for file destination
-  interrupt?: boolean; // interrupt in-progress agent turn (default: true for agent)
-  batch?: number | BatchConfig; // number = minutes (legacy), object = fine-grained control
   channel?: string;
   sender?: string;
   isDM?: boolean; // match on isDM metadata
   participants?: number; // match on participant count (e.g. 2 = DM)
 };
 
+export type SessionConfig = {
+  autoReply?: boolean;
+  batch?: number | BatchConfig;
+  interrupt?: boolean;
+  instructions?: string;
+};
+
+export type ResolvedSessionConfig = {
+  autoReply: boolean;
+  batch?: BatchConfig;
+  interrupt: boolean;
+  instructions?: string;
+};
+
 export type RoutingConfig = {
   rules?: RoutingRule[];
+  sessions?: Record<string, SessionConfig>;
   default?: string;
   gateUnmatched?: boolean;
 };
@@ -29,8 +42,6 @@ export type ResolvedRoute =
   | {
       destination: "agent";
       session: string;
-      interrupt: boolean;
-      batch?: BatchConfig;
       matched: boolean;
     }
   | { destination: "file"; path: string; matched: boolean };
@@ -63,7 +74,7 @@ function globMatch(pattern: string, value: string): boolean {
 }
 
 const GLOB_MATCH_KEYS = new Set(["channel", "sender"]);
-const NON_MATCH_KEYS = new Set(["session", "batch", "destination", "path", "interrupt"]);
+const NON_MATCH_KEYS = new Set(["session", "destination", "path"]);
 
 type MatchMeta = { channel?: string; sender?: string; isDM?: boolean; participantCount?: number };
 
@@ -107,7 +118,7 @@ export function resolveRoute(config: RoutingConfig, meta: MatchMeta): ResolvedRo
   const fallback = config.default ?? "main";
 
   if (!config.rules) {
-    return { destination: "agent", session: fallback, interrupt: true, matched: false };
+    return { destination: "agent", session: fallback, matched: false };
   }
 
   for (const rule of config.rules) {
@@ -122,14 +133,42 @@ export function resolveRoute(config: RoutingConfig, meta: MatchMeta): ResolvedRo
       return {
         destination: "agent",
         session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
-        interrupt: rule.interrupt ?? true,
-        batch: rule.batch != null ? normalizeBatch(rule.batch) : undefined,
         matched: true,
       };
     }
   }
 
-  return { destination: "agent", session: fallback, interrupt: true, matched: false };
+  return { destination: "agent", session: fallback, matched: false };
+}
+
+/**
+ * Resolve session config by matching session name against glob-pattern keys in config.sessions.
+ * First match wins. Returns defaults if no match.
+ */
+export function resolveSessionConfig(
+  config: RoutingConfig,
+  sessionName: string,
+): ResolvedSessionConfig {
+  const defaults: ResolvedSessionConfig = { autoReply: false, interrupt: true };
+
+  if (!config.sessions) return defaults;
+
+  for (const [pattern, sessionConfig] of Object.entries(config.sessions)) {
+    if (globMatch(pattern, sessionName)) {
+      const batch = sessionConfig.batch != null ? normalizeBatch(sessionConfig.batch) : undefined;
+      if (sessionConfig.autoReply && batch != null) {
+        log("routing", `autoReply is not supported with batch mode — autoReply will be ignored`);
+      }
+      return {
+        autoReply: batch != null ? false : (sessionConfig.autoReply ?? false),
+        batch,
+        interrupt: sessionConfig.interrupt ?? true,
+        instructions: sessionConfig.instructions,
+      };
+    }
+  }
+
+  return defaults;
 }
 
 function sanitizeSessionName(name: string): string {

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

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { log } from "./logger.js";
 
@@ -61,30 +61,6 @@ export function loadPackageInfo(): { name: string; version: string } {
   }
 }
 
-export function handleMergeContext(sendMessage: (content: string) => void): boolean {
-  const mergedPath = resolve(".volute/merged.json");
-  if (!existsSync(mergedPath)) return false;
-
-  try {
-    const merged = JSON.parse(readFileSync(mergedPath, "utf-8"));
-    unlinkSync(mergedPath);
-
-    const parts = [
-      `[system] Variant "${merged.name}" has been merged and you have been restarted.`,
-    ];
-    if (merged.summary) parts.push(`Changes: ${merged.summary}`);
-    if (merged.justification) parts.push(`Why: ${merged.justification}`);
-    if (merged.memory) parts.push(`Context: ${merged.memory}`);
-
-    sendMessage(parts.join("\n"));
-    log("server", `sent post-merge orientation for variant: ${merged.name}`);
-    return true;
-  } catch (e) {
-    log("server", "failed to process merged.json:", e);
-    return false;
-  }
-}
-
 export async function handleStartupContext(sendMessage: (content: string) => void): Promise<void> {
   const scriptPath = resolve("home/.config/hooks/startup-context.sh");
   if (!existsSync(scriptPath)) return;

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

@@ -19,6 +19,7 @@ export type ChannelMeta = {
 export type HandlerMeta = ChannelMeta & {
   messageId: string;
   interrupt?: boolean;
+  autoReply: boolean;
 };
 
 export type VoluteRequest = {
@@ -37,7 +38,7 @@ export type VoluteEvent = { messageId?: string } & (
 
 export type Listener = (event: VoluteEvent) => void;
 
-/** A handler that processes a single routed message and streams events to a listener. */
+/** A handler that processes a single routed message and emits events to a listener callback. */
 export type MessageHandler = {
   handle(content: VoluteContentPart[], meta: HandlerMeta, listener: Listener): () => void; // returns unsubscribe
 };

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

@@ -33,25 +33,40 @@ export function createVoluteServer(options: {
       try {
         const body = JSON.parse(await readBody(req)) as VoluteRequest;
 
-        res.writeHead(200, {
-          "Content-Type": "application/x-ndjson",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive",
-        });
+        let usage: { input_tokens: number; output_tokens: number } | undefined;
+        let done = false;
 
         const { unsubscribe } = router.route(body.content, body, (event) => {
-          try {
-            res.write(`${JSON.stringify(event)}\n`);
-            if (event.type === "done") {
-              res.end();
-            }
-          } catch (err) {
-            log("server", "write error, disconnecting:", err);
-            unsubscribe();
+          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));
           }
         });
 
-        res.on("close", () => unsubscribe());
+        const timeout = setTimeout(
+          () => {
+            if (!done) {
+              done = true;
+              unsubscribe();
+              res.writeHead(504, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: false, error: "Agent processing timed out" }));
+            }
+          },
+          5 * 60 * 1000,
+        );
+
+        res.on("close", () => {
+          clearTimeout(timeout);
+          if (!done) unsubscribe();
+        });
       } catch (err) {
         if (err instanceof SyntaxError) {
           res.writeHead(400);