@inetafrica/open-claudia 2.6.50 → 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

@@ -839,14 +839,19 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   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); }
-      catch (e) { console.error("voice stream clip failed:", e.message); }
+      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) {
@@ -1073,12 +1078,17 @@ 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);
       }
@@ -1287,6 +1297,21 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
             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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.50",
+  "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": {