@inetafrica/open-claudia 2.6.49 → 2.6.51

package/core/recall/discoverer.js

@@ -18,6 +18,7 @@
 const graph = require("./graph");
 const metrics = require("./metrics");
 const { spawnSubagent } = require("../subagent");
+const warmWalker = require("./warm-walker");
 
 const WALKER_MODEL = process.env.RECALL_DISCOVERER_MODEL || "haiku";
 const WALKER_TIMEOUT_MS = Number(process.env.RECALL_DISCOVERER_TIMEOUT_MS || 25000);
@@ -78,6 +79,21 @@ const WALKER_SYSTEM = [
   'Reply with ONLY a JSON array: [{"id":"pack:foo","why":"shared lime theme governs this app"}]. Use [] if none.',
 ].join("\n");
 
+// Run the walker model on the prompt. Prefer the warm (reused) process for
+// low latency; on any warm-path error fall back to a cold spawn — identical
+// model/prompt/contract, so quality is unchanged and recall never silently
+// degrades to the classic engine.
+async function runWalker(prompt) {
+  const opts = { model: WALKER_MODEL, systemPrompt: WALKER_SYSTEM, timeoutMs: WALKER_TIMEOUT_MS };
+  if (warmWalker.isEnabled()) {
+    try {
+      return await warmWalker.walkWarm(prompt, opts);
+    } catch (e) { /* fall back to cold spawn below */ }
+  }
+  const { text } = await spawnSubagent(prompt, opts);
+  return text;
+}
+
 async function walk(userText, contextText, candidates) {
   if (!WALKER_ENABLED || candidates.length === 0) return null;
   const lines = candidates.map((c) => {
@@ -95,9 +111,7 @@ async function walk(userText, contextText, candidates) {
     'Reply ONLY with the JSON array of kept nodes and their why, e.g. [{"id":"' + candidates[0].id + '","why":"..."}].',
   ].join("\n");
   try {
-    const { text } = await spawnSubagent(prompt, {
-      model: WALKER_MODEL, systemPrompt: WALKER_SYSTEM, timeoutMs: WALKER_TIMEOUT_MS,
-    });
+    const text = await runWalker(prompt);
     const match = String(text || "").match(/\[[\s\S]*\]/);
     if (!match) return null;
     const arr = JSON.parse(match[0]);

package/core/recall/warm-walker.js

@@ -0,0 +1,151 @@
+// Warm walker: one long-lived `claude` process the discoverer reuses across
+// turns, instead of cold-spawning a fresh CLI for every recall.
+//
+// Why this exists: the Claude CLI initialises lazily on the FIRST message, so
+// a cold spawn pays ~3-16s of boot+init every turn. Measured: on a persistent
+// stream-json process the first message costs ~3.4s but every message after is
+// ~1.4s — init is paid once and amortised. Same model, same system prompt,
+// same JSON contract as the cold path, so recall quality is unchanged; only
+// the transport differs.
+//
+// Statelessness: stream-json keeps one growing session, so we recycle the
+// process on a small message/char budget to keep accumulated history tiny and
+// each walk effectively independent.
+//
+// Fail-open: any error here throws, and the caller (discoverer.walk) falls
+// back to the cold spawnSubagent path — never worse than before, and never a
+// drop to the classic engine.
+
+const { spawn } = require("child_process");
+const { CLAUDE_PATH, botSubprocessEnv } = require("../config");
+const { claudeSubprocessEnv } = require("../auth-flow");
+const { redactSensitive } = require("../redact");
+
+const MAX_MSGS = Number(process.env.RECALL_WARM_WALKER_MAX_MSGS || 12);
+const MAX_CHARS = Number(process.env.RECALL_WARM_WALKER_MAX_CHARS || 24000);
+const DEFAULT_TIMEOUT_MS = 25000;
+
+let child = null;          // current process, or null when none is alive
+let pending = null;        // { resolve, reject, timer } for the in-flight walk
+let chain = Promise.resolve(); // serialises walks (one message in flight)
+let msgCount = 0;          // messages sent to the current process
+let charCount = 0;         // prompt chars sent to the current process
+
+function isEnabled() {
+  return String(process.env.RECALL_WARM_WALKER || "on").toLowerCase() !== "off";
+}
+
+function killChild() {
+  const proc = child;
+  child = null;
+  if (proc) {
+    try { proc.stdin.end(); } catch (e) {}
+    try { proc.kill("SIGTERM"); } catch (e) {}
+  }
+}
+
+function spawnChild(cfg) {
+  const args = [
+    "-p",
+    "--input-format", "stream-json",
+    "--output-format", "stream-json",
+    "--verbose",
+    "--model", cfg.model || "haiku",
+    "--no-session-persistence",
+    "--append-system-prompt", cfg.systemPrompt || "",
+    "--dangerously-skip-permissions",
+  ];
+  const env = { ...botSubprocessEnv(), ...claudeSubprocessEnv() };
+  const proc = spawn(CLAUDE_PATH, args, { cwd: process.cwd(), env, stdio: ["pipe", "pipe", "pipe"] });
+  child = proc;
+  msgCount = 0;
+  charCount = 0;
+  let buf = "";
+  let asstText = "";
+
+  const settle = (fn, arg) => {
+    const p = pending;
+    pending = null;
+    if (!p) return;
+    clearTimeout(p.timer);
+    fn === "resolve" ? p.resolve(arg) : p.reject(arg);
+  };
+
+  proc.stdout.on("data", (d) => {
+    if (child !== proc) return;
+    buf += d.toString();
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let evt;
+      try { evt = JSON.parse(line); } catch (e) { continue; }
+      if (evt.type === "assistant" && evt.message && Array.isArray(evt.message.content)) {
+        for (const b of evt.message.content) {
+          if (b && b.type === "text" && typeof b.text === "string") asstText += b.text;
+        }
+      } else if (evt.type === "result") {
+        const text = (typeof evt.result === "string" && evt.result) ? evt.result : asstText;
+        asstText = "";
+        if (text && !evt.is_error) settle("resolve", redactSensitive(String(text).trim()));
+        else settle("reject", new Error("warm walker: empty/error result"));
+      }
+    }
+  });
+  proc.stderr.on("data", () => {}); // surfaced via result/close, not needed here
+  proc.on("error", (e) => {
+    if (child === proc) child = null;
+    settle("reject", e);
+  });
+  proc.on("close", () => {
+    if (child === proc) child = null;
+    settle("reject", new Error("warm walker: process closed"));
+  });
+  return proc;
+}
+
+function doWalk(promptText, opts) {
+  // Recycle before sending if the current process is over its budget, so each
+  // walk runs against a small, near-stateless context.
+  if (child && (msgCount >= MAX_MSGS || charCount >= MAX_CHARS)) killChild();
+  if (!child) spawnChild({ systemPrompt: opts.systemPrompt, model: opts.model });
+  const proc = child;
+  const timeoutMs = opts.timeoutMs || DEFAULT_TIMEOUT_MS;
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending = null;
+      if (child === proc) killChild(); // process is wedged — drop it
+      reject(new Error("warm walker: timeout"));
+    }, timeoutMs);
+    pending = { resolve, reject, timer };
+    msgCount++;
+    charCount += promptText.length;
+    const payload = JSON.stringify({ type: "user", message: { role: "user", content: promptText } }) + "\n";
+    try {
+      proc.stdin.write(payload);
+    } catch (e) {
+      clearTimeout(timer);
+      pending = null;
+      killChild();
+      reject(e);
+    }
+  });
+}
+
+// Serialise: one message in flight at a time. A failed walk must not poison the
+// queue, so the chain swallows outcomes while callers still see their result.
+function walkWarm(promptText, opts = {}) {
+  const run = () => doWalk(promptText, opts);
+  const p = chain.then(run, run);
+  chain = p.then(() => {}, () => {});
+  return p;
+}
+
+function shutdown() { killChild(); }
+function stats() { return { alive: !!child, msgCount, charCount, MAX_MSGS, MAX_CHARS }; }
+
+process.on("exit", () => { try { killChild(); } catch (e) {} });
+
+module.exports = { walkWarm, isEnabled, shutdown, stats };

package/core/router.js

@@ -120,12 +120,17 @@ async function handleVoice(envelope) {
       return send(`Voice note too large (${Math.round(media.size / 1024 / 1024)}MB). Max: ${MAX_VOICE_SIZE / 1024 / 1024}MB`);
     }
     envelope.adapter.typing(envelope.channelId).catch(() => {});
+    const tStart = Date.now();
     const oggPath = await envelope.adapter.downloadMedia(media);
+    const tAfterDownload = Date.now();
     const transcript = transcribeAudio(oggPath);
+    const tAfterStt = Date.now();
     try { fs.unlinkSync(oggPath); } catch (e) {}
     if (!transcript) return send("Couldn't transcribe. Try typing it.");
     await send(`Heard: "${transcript}"`, { replyTo: envelope.messageId });
     state.lastInputWasVoice = true;
+    // Per-stage latency for the voice pipeline; the runner fills in the rest.
+    state.voiceLat = { startAt: tStart, downloadMs: tAfterDownload - tStart, sttMs: tAfterStt - tAfterDownload };
     await runClaude(transcript, state.currentSession.dir, envelope.messageId);
   } catch (err) { await send(`Voice failed: ${err.message}`); }
 }

package/core/runner.js

@@ -315,6 +315,15 @@ async function buildClaudeArgs(prompt, opts = {}) {
   if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
   else args.push("--dangerously-skip-permissions");
   if (settings.worktree) args.push("--worktree");
+  // Voice turns stream partial text so the spoken reply can start mid-generation
+  // (see the streaming-out handler in the runner). Strictly gated to the voice
+  // channel — zero behaviour change for Telegram/Kazee.
+  if (state.lastInputWasVoice) {
+    try {
+      const { currentTransport } = require("./context");
+      if (currentTransport() === "voice") args.push("--include-partial-messages");
+    } catch { /* context not ready — skip streaming flag */ }
+  }
   // Dynamic state rides in the user prompt so the appended system prompt
   // stays byte-stable across turns and the prompt-cache prefix survives.
   args.push(await promptWithDynamicContext(prompt));
@@ -814,6 +823,55 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   state.statusMessageId = null;
   state.streamBuffer = "";
   let assistantText = "";
+
+  // Voice streaming-out: on voice turns we speak each finished sentence as it is
+  // generated (off the partial text_delta events) so the first audio plays while
+  // the rest of the reply is still being written — far lower time-to-first-sound
+  // than synthesizing one pass over the whole reply at the end. Reads the delta
+  // stream only; the text/transcript channel still reads whole-message events, so
+  // chat transports are completely unaffected.
+  let voiceStreaming = false;
+  try {
+    const { currentTransport } = require("./context");
+    voiceStreaming = !!state.lastInputWasVoice && currentTransport() === "voice";
+  } catch { voiceStreaming = false; }
+  let spokenBuf = "";                 // text_delta accumulator awaiting a sentence boundary
+  let ttsChain = Promise.resolve();   // ordered send queue so clips play in order
+  let spokeAnyStreamed = false;
+  const SPOKEN_MIN_CHARS = 40;        // don't fire TTS on tiny fragments ("Hi.")
+  // Voice latency probe (measurement only) — timestamps filled in as the turn runs.
+  // Spawn time is `startTime` (captured just after spawn below).
+  let vlFirstSysAt = null, vlFirstTokenAt = null, vlFirstAudioAt = null, vlResultAt = null;
+  function dispatchSpoken(text) {
+    const clean = redactSensitive(text);
+    if (!clean.trim()) return;
+    spokeAnyStreamed = true;
+    const synthP = synthSentenceMp3(clean); // start synth now (parallel)
+    ttsChain = ttsChain.then(async () => {  // but send strictly in order
+      try {
+        const clip = await synthP;
+        if (clip) { await sendVoice(clip); if (vlFirstAudioAt == null) vlFirstAudioAt = Date.now(); }
+      } catch (e) { console.error("voice stream clip failed:", e.message); }
+    });
+  }
+  function pumpSpoken(flush) {
+    // Cut the smallest prefix that ends in a sentence terminator and is at least
+    // SPOKEN_MIN_CHARS long, dispatch it, repeat. On flush, send whatever remains.
+    while (true) {
+      const re = /[.!?]+(?=\s|$)/g;
+      let idx = -1, m;
+      while ((m = re.exec(spokenBuf)) !== null) {
+        const end = m.index + m[0].length;
+        if (end >= SPOKEN_MIN_CHARS) { idx = end; break; }
+      }
+      if (idx === -1) break;
+      const sentence = spokenBuf.slice(0, idx).trim();
+      spokenBuf = spokenBuf.slice(idx).replace(/^\s+/, "");
+      if (sentence) dispatchSpoken(sentence);
+    }
+    if (flush) { const tail = spokenBuf.trim(); spokenBuf = ""; if (tail) dispatchSpoken(tail); }
+  }
+
   let toolUses = [];
   let currentTool = null;
   let currentToolDetail = "";
@@ -1020,6 +1078,20 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     const lastNewline = state.streamBuffer.lastIndexOf("\n");
     state.streamBuffer = lastNewline >= 0 ? state.streamBuffer.slice(lastNewline + 1) : state.streamBuffer;
     for (const evt of events) {
+      // Voice latency probe: first "system" event = CLI ready (cold-start done);
+      // "result" = generation finished (before the TTS tail drains).
+      if (voiceStreaming && vlFirstSysAt == null && evt.type === "system") vlFirstSysAt = Date.now();
+      if (voiceStreaming && vlResultAt == null && evt.type === "result") vlResultAt = Date.now();
+      // Voice streaming-out: speak finished sentences as the model writes them.
+      // Only text_delta is spoken; thinking_delta and tool events are ignored.
+      if (voiceStreaming && evt.type === "stream_event"
+          && evt.event?.type === "content_block_delta"
+          && evt.event.delta?.type === "text_delta"
+          && typeof evt.event.delta.text === "string") {
+        if (vlFirstTokenAt == null) vlFirstTokenAt = Date.now();
+        spokenBuf += evt.event.delta.text;
+        pumpSpoken(false);
+      }
       if (evt.type === "assistant" && evt.message?.usage) {
         const callPrefix = usageParts(evt.message.usage, settings.backend || "claude").context;
         if (callPrefix > peakContextTokens) peakContextTokens = callPrefix;
@@ -1212,25 +1284,52 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
       if (state.lastInputWasVoice) {
         state.lastInputWasVoice = false;
-        // Spoken replies belong to the hands-free voice channel. On chat
-        // transports (Telegram/Kazee) an auto voice note on every voice
-        // input is unwanted noise, so gate it to the voice channel.
-        const { currentTransport } = require("./context");
-        if (currentTransport() === "voice") {
-          // Stream the spoken reply sentence-by-sentence so the first audio
-          // plays while the rest still synthesizes — far lower time-to-first-
-          // sound than waiting for one TTS pass over the whole reply.
-          const sentences = splitSentences(finalText);
-          let spokeAny = false;
-          for (const sentence of sentences) {
-            const clip = await synthSentenceMp3(sentence);
-            if (clip) { spokeAny = true; await sendVoice(clip); }
-          }
-          if (!spokeAny) {
+        if (voiceStreaming) {
+          // Sentences were already being spoken as the model wrote them. Flush
+          // the trailing partial sentence, wait for the ordered send queue to
+          // drain, then close the turn so the client re-arms the mic.
+          pumpSpoken(true);
+          await ttsChain;
+          if (!spokeAnyStreamed) {
+            // Tool-only / empty turn produced no spoken text — say the final
+            // text once so the user still hears a reply.
             const voicePath = await textToVoice(finalText);
             if (voicePath) await sendVoice(voicePath);
           }
           await sendVoiceEnd();
+          // Per-stage latency breakdown (measurement only — temporary debug footer).
+          try {
+            const vl = state.voiceLat || {};
+            const endAt = Date.now();
+            const sec = (n) => n != null ? (n / 1000).toFixed(1) + "s" : "?";
+            const diff = (a, b) => (a != null && b != null) ? sec(b - a) : "?";
+            const fromStart = (t) => diff(vl.startAt, t);
+            const line = `⏱ dl ${sec(vl.downloadMs)} · stt ${sec(vl.sttMs)}`
+              + ` · cli ${diff(startTime, vlFirstSysAt)} · ttft ${diff(vlFirstSysAt, vlFirstTokenAt)}`
+              + ` · gen ${diff(vlFirstTokenAt, vlResultAt)} · 1st-audio ${fromStart(vlFirstAudioAt)}`
+              + ` · total ${fromStart(endAt)}`;
+            console.log(`[VOICE-LAT] ${line}`);
+            await send(line);
+          } catch (e) { /* metrics best-effort */ }
+          state.voiceLat = null;
+        } else {
+          // Non-streamed fallback. Spoken replies belong to the hands-free voice
+          // channel; on chat transports (Telegram/Kazee) an auto voice note on
+          // every voice input is unwanted noise, so gate it to the voice channel.
+          const { currentTransport } = require("./context");
+          if (currentTransport() === "voice") {
+            const sentences = splitSentences(finalText);
+            let spokeAny = false;
+            for (const sentence of sentences) {
+              const clip = await synthSentenceMp3(sentence);
+              if (clip) { spokeAny = true; await sendVoice(clip); }
+            }
+            if (!spokeAny) {
+              const voicePath = await textToVoice(finalText);
+              if (voicePath) await sendVoice(voicePath);
+            }
+            await sendVoiceEnd();
+          }
         }
       }
     } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.49",
+  "version": "2.6.51",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {