@inetafrica/open-claudia 3.1.17 → 3.1.20

package/channels/kazee/call/janus-client.js

@@ -80,7 +80,7 @@ class JanusClient {
         this.pending.delete(transaction);
         reject(new Error(`Janus ${payload.janus} timed out`));
       }, this.requestTimeoutMs);
-      this.pending.set(transaction, { resolve, reject, timer });
+      this.pending.set(transaction, { resolve, reject, timer, verb: payload.janus });
       this.socket.send(JSON.stringify(frame), (error) => {
         if (!error) return;
         clearTimeout(timer);
@@ -108,7 +108,10 @@ class JanusClient {
     try { frame = JSON.parse(raw.toString()); }
     catch (_) { return; }
     const pending = frame.transaction && this.pending.get(frame.transaction);
-    if (pending && frame.janus !== "ack") {
+    // Plugin requests get an ack then a real event, so acks must not settle
+    // them — but keepalive is answered with ONLY an ack, so waiting past it
+    // guaranteed a bogus "keepalive timed out" every interval.
+    if (pending && (frame.janus !== "ack" || pending.verb === "keepalive")) {
       clearTimeout(pending.timer);
       this.pending.delete(frame.transaction);
       if (frame.janus === "error") pending.reject(new Error(frame.error?.reason || "Janus error"));

package/channels/kazee/call/manager.js

@@ -31,9 +31,13 @@ class KazeeCallManager {
     const roomId = Number(payload.roomId);
     const callType = String(payload.callType || "");
     const owner = String(this.adapter.ownerUserId || "");
-    const reject = (reason) => this.adapter._socket?.emit("call:reject", {
-      toUserId: callerId, callType, chatId, roomId, reason,
-    });
+    console.log(`Kazee call incoming: room=${roomId} chat=${chatId} from=${callerId} type=${callType}`);
+    const reject = (reason) => {
+      console.log(`Kazee call rejected: room=${roomId} from=${callerId} reason=${reason}`);
+      this.adapter._socket?.emit("call:reject", {
+        toUserId: callerId, callType, chatId, roomId, reason,
+      });
+    };
 
     if (!callerId || !chatId || !Number.isSafeInteger(roomId)) return reject("invalid_call");
     if (callerId !== owner) return reject("not_allowed");
@@ -49,6 +53,7 @@ class KazeeCallManager {
     this.session = session;
     try {
       await session.start();
+      console.log(`Kazee call accepted: room=${roomId} from=${callerId}`);
       this.adapter._socket?.emit("call:accept", {
         toUserId: callerId, callType: "audio", chatId, roomId,
       });
@@ -70,6 +75,11 @@ class KazeeCallManager {
     // Provider narration/previews are useful in chat but must never be spoken
     // into a call. Only the settled, guarded final answer reaches send().
     callAdapter.suppressStreamPreview = true;
+    // Recall/tooltrace banners route through the same send() as the answer —
+    // without this flag the TTS reads memory-debug lines to the caller.
+    callAdapter.suppressChatVisibility = true;
+    // Prompt builder switches to phone-call brevity when it sees this.
+    callAdapter.liveCall = true;
     callAdapter.send = async (_channelId, response) => {
       await session.speak(response);
       return true;

package/channels/kazee/call/session.js

@@ -7,6 +7,12 @@ const { SpeechStream, synthesizePcm } = require("./speech-client");
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+// Per-stage call logging. The media leg (ICE/RTP) can fail with zero thrown
+// errors — a caller then hears silence while the log shows a clean
+// accept→close. Timestamped stage lines make that failure mode visible and
+// double as the STT/TTS timing measurements chat-side estimates lacked.
+const clog = (msg) => console.log(`${new Date().toISOString()} ${msg}`);
+
 const BASE_THRESHOLD_DB = -38;
 // While TTS plays, the caller's device can leak bot audio back through its mic.
 // Require a much louder signal before treating incoming audio as human speech.
@@ -20,6 +26,33 @@ const DEFAULT_JOIN_RETRY_DELAY_MS = 500;
 const MAX_DURATION_GOODBYE = "We've hit the call time limit, so I'll hang up now. Message me any time.";
 const IDLE_GOODBYE = "I haven't heard anything for a while, so I'll hang up now. Message me any time.";
 
+// Audible state cues: a short ack chime when the caller finishes speaking, then
+// a soft periodic tick while the turn is being worked on — dead air otherwise
+// reads as a dropped call.
+const THINK_TICK_INTERVAL_MS = 1600;
+const THINKING_MAX_MS = 5 * 60_000;
+
+function tonePcm48(segments, gain = 0.08) {
+  const rate = 48000;
+  const fade = Math.floor(rate * 0.012);
+  const buffers = segments.map(({ freq, ms }) => {
+    const samples = Math.floor((rate * ms) / 1000);
+    const buf = Buffer.alloc(samples * 2);
+    for (let i = 0; i < samples; i += 1) {
+      let a = gain;
+      if (i < fade) a *= i / fade;
+      if (i > samples - fade) a *= Math.max(0, (samples - i) / fade);
+      buf.writeInt16LE(Math.round(Math.sin((2 * Math.PI * freq * i) / rate) * a * 32767), i * 2);
+    }
+    return buf;
+  });
+  return Buffer.concat(buffers);
+}
+
+// Rising two-tone "heard you", and a quieter single "still here" pulse.
+const ACK_CHIME_PCM48 = tonePcm48([{ freq: 660, ms: 90 }, { freq: 990, ms: 110 }], 0.09);
+const THINK_TICK_PCM48 = tonePcm48([{ freq: 520, ms: 90 }], 0.045);
+
 class KazeeCallSession {
   constructor({ roomId, chatId, callerId, botUserId, janusUrl, iceServers = [], onTranscript, onEnded,
     maxCallMs, idleMs, synthesize = synthesizePcm,
@@ -53,6 +86,8 @@ class KazeeCallSession {
     this._lastSpokeAt = 0;
     this._limitTimer = null;
     this._ending = false;
+    this._thinkTimer = null;
+    this._thinkingSince = 0;
     this.sequence = Math.floor(Math.random() * 65535);
     this.timestamp = Math.floor(Math.random() * 0xffffffff);
     this.ssrc = Math.floor(Math.random() * 0xffffffff);
@@ -102,7 +137,10 @@ class KazeeCallSession {
         await this._subscribe(feedId, publisher.display);
       }
     }
-    if (data.videoroom === "joined" && !this.publisher) await this._publish();
+    if (data.videoroom === "joined") {
+      clog(`Kazee call room joined: room=${this.roomId} publishers=${(data.publishers || []).length}`);
+      if (!this.publisher) await this._publish();
+    }
     const gone = Number(data.leaving || data.unpublished || 0);
     if (gone && this.subscribers.has(gone)) await this._removeSubscriber(gone);
     if (data.videoroom === "destroyed") await this.close("room-destroyed");
@@ -111,6 +149,7 @@ class KazeeCallSession {
   async _publish() {
     if (this.publisher) return;
     const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    pc.iceConnectionStateChange?.subscribe?.((state) => clog(`Kazee call publisher ICE: ${state} room=${this.roomId}`));
     const track = new MediaStreamTrack({ kind: "audio" });
     const sender = pc.addTrack(track);
     this.publisher = { pc, track, sender };
@@ -120,11 +159,14 @@ class KazeeCallSession {
     const answer = configured?.jsep;
     if (!answer) throw new Error("Janus publisher configure did not return SDP");
     await pc.setRemoteDescription(answer);
+    clog(`Kazee call publisher configured: room=${this.roomId}`);
   }
 
   async _subscribe(feedId, display) {
+    clog(`Kazee call subscribing: feed=${feedId} display=${String(display || "")}`);
     const handle = await this.janus.attach();
     const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    pc.iceConnectionStateChange?.subscribe?.((state) => clog(`Kazee call subscriber ICE: ${state} feed=${feedId}`));
     const sub = {
       handle,
       pc,
@@ -142,7 +184,10 @@ class KazeeCallSession {
     this.janus.onHandle(handle, (frame) => this._onSubscriberEvent(feedId, frame));
     const attached = await this.janus.message(handle, { request: "join", ptype: "subscriber", room: this.roomId, feed: feedId });
     await this._consumeSubscriberFrame(feedId, attached);
-    await sub.stt.connect().catch((error) => console.error("Kazee call STT connect:", error.message));
+    await sub.stt.connect().then(
+      () => clog(`Kazee call STT connected: feed=${feedId}`),
+      (error) => console.error("Kazee call STT connect:", error.message),
+    );
   }
 
   async _onSubscriberEvent(feedId, frame) {
@@ -165,11 +210,18 @@ class KazeeCallSession {
       const answer = await sub.pc.createAnswer();
       await sub.pc.setLocalDescription(answer);
       await this.janus.message(sub.handle, { request: "start", room: this.roomId }, sub.pc.localDescription);
+      clog(`Kazee call subscriber started: feed=${feedId}`);
     }
   }
 
   _onFeedTranscript(feedId, text) {
     const sub = this.subscribers.get(feedId);
+    const len = String(text || "").trim().length;
+    clog(`Kazee call transcript: feed=${feedId} chars=${len}${len ? "" : " (noise commit)"}`);
+    if (String(text || "").trim()) this._startThinking();
+    // Empty finalization (noise commit): nothing dispatches, no reply is
+    // coming — don't tick into the void.
+    else if (!this._speakActive && !this._speakQueue.length) this._stopThinking();
     this.onTranscript(text, {
       feedId,
       display: sub?.display || "",
@@ -177,10 +229,49 @@ class KazeeCallSession {
     });
   }
 
+  // Writes a short cue into the outbound track. Yields to real speech: the
+  // moment an utterance is active (or starting), remaining frames are dropped.
+  async _playCue(pcm48) {
+    if (this.closed || this.speaking || this._speakActive || !this.publisher) return;
+    for (let offset = 0; offset < pcm48.length; offset += WEBRTC_SAMPLES * 2) {
+      if (this.closed || this.speaking || this._speakActive) return;
+      let frame = pcm48.subarray(offset, offset + WEBRTC_SAMPLES * 2);
+      if (frame.length < WEBRTC_SAMPLES * 2) frame = Buffer.concat([frame, Buffer.alloc(WEBRTC_SAMPLES * 2 - frame.length)]);
+      const opus = this.codec.encode(frame);
+      const payloadType = this.publisher?.sender?.codec?.payloadType || 111;
+      this.publisher?.track?.writeRtp(new RtpPacket(new RtpHeader({
+        payloadType, sequenceNumber: this.sequence++ & 0xffff, timestamp: this.timestamp >>> 0, ssrc: this.ssrc,
+      }), opus));
+      this.timestamp = (this.timestamp + WEBRTC_SAMPLES) >>> 0;
+      await wait(20);
+    }
+  }
+
+  _startThinking() {
+    if (this.closed || this._thinkTimer) return;
+    this._thinkingSince = Date.now();
+    this._thinkTimer = setInterval(() => {
+      if (this.closed || Date.now() - this._thinkingSince > THINKING_MAX_MS) return this._stopThinking();
+      if (this.speaking || this._speakActive) return;
+      this._playCue(THINK_TICK_PCM48).catch(() => {});
+    }, THINK_TICK_INTERVAL_MS);
+    if (typeof this._thinkTimer.unref === "function") this._thinkTimer.unref();
+  }
+
+  _stopThinking() {
+    if (!this._thinkTimer) return;
+    clearInterval(this._thinkTimer);
+    this._thinkTimer = null;
+  }
+
   _onFeedRtp(feedId, packet) {
     if (this.closed || !packet?.payload?.length) return;
     const sub = this.subscribers.get(feedId);
     if (!sub) return;
+    if (!sub.firstRtpAt) {
+      sub.firstRtpAt = Date.now();
+      clog(`Kazee call first RTP: feed=${feedId}`);
+    }
     let pcm;
     try { pcm = sub.codec.decode(packet.payload); } catch (_) { return; }
     sub.vad.thresholdDb = this.speaking ? SPEAKING_THRESHOLD_DB : BASE_THRESHOLD_DB;
@@ -193,14 +284,21 @@ class KazeeCallSession {
     }
     if (event?.type === "start") {
       this._lastHeard = Date.now();
+      clog(`Kazee call VAD start: feed=${feedId}`);
       // Barge-in: the human wins — stop talking and listen.
       if (this.speaking) this.cancelSpeech();
+      this._stopThinking();
       for (const frame of sub.prebuffer.splice(0)) this._feedAudio(sub, frame);
     }
     this._feedAudio(sub, pcm16);
     if (event?.type === "commit") {
       this._lastHeard = Date.now();
+      clog(`Kazee call VAD commit: feed=${feedId}`);
       sub.stt.commit().catch((error) => console.error("Kazee call STT commit:", error.message));
+      this._playCue(ACK_CHIME_PCM48).catch(() => {});
+      // STT finalization takes seconds; start ticking at commit so the
+      // chime→first-tick stretch doesn't read as a dead line.
+      this._startThinking();
     }
   }
 
@@ -241,9 +339,12 @@ class KazeeCallSession {
   }
 
   async _playUtterance(text, gen) {
+    const synthStart = Date.now();
     const synthesized = await this.synthesize(text);
     if (this.closed || gen !== this._speakGen) return false;
     const pcm48 = upsampleTo48(synthesized.pcm, synthesized.sampleRate);
+    clog(`Kazee call speak: synth=${Date.now() - synthStart}ms chars=${text.length}`);
+    this._stopThinking();
     this.speaking = true;
     try {
       for (let offset = 0; offset < pcm48.length; offset += WEBRTC_SAMPLES * 2) {
@@ -268,7 +369,9 @@ class KazeeCallSession {
     if (this.closed || this._ending) return;
     const now = Date.now();
     const overMax = now - this._startedAt >= this.maxCallMs;
-    const speechIdle = !this.speaking && !this._speakActive && !this._speakQueue.length;
+    // An audible thinking loop means a turn is still being worked on — that is
+    // not idleness, or long provider turns would get hung up on mid-answer.
+    const speechIdle = !this.speaking && !this._speakActive && !this._speakQueue.length && !this._thinkTimer;
     const idle = speechIdle && now - Math.max(this._lastHeard, this._lastSpokeAt) >= this.idleMs;
     if (!overMax && !idle) return;
     this._ending = true;
@@ -295,7 +398,9 @@ class KazeeCallSession {
   async close(reason = "ended") {
     if (this.closed) return;
     this.closed = true;
+    console.log(`Kazee call session closed: room=${this.roomId} reason=${reason}`);
     if (this._limitTimer) { clearInterval(this._limitTimer); this._limitTimer = null; }
+    this._stopThinking();
     this.cancelSpeech();
     for (const feed of [...this.subscribers.keys()]) await this._removeSubscriber(feed);
     try { await this.publisher?.pc?.close(); } catch (_) {}

package/core/handlers.js

@@ -1166,7 +1166,7 @@ register({
 });
 
 register({
-  name: "engine", description: "Switch memory recall engine", args: "[classic|discoverer]",
+  name: "engine", description: "Switch memory recall engine", args: "[classic|discoverer|ask]",
   handler: async (env, { tail }) => {
     if (!authorized(env)) return;
     const { settings } = currentState();
@@ -1183,9 +1183,11 @@ register({
     send(
       `Recall engine: ${active}${settings.recallEngine ? "" : " (default)"}\n\n` +
       "• discoverer — typed-edge graph + spreading activation + why-bullets (default)\n" +
-      "• classic — keyword FTS + relevance judge (opt-out fallback)",
+      "• classic — keyword FTS + relevance judge (opt-out fallback)\n" +
+      "• ask — nothing auto-injected; I pull my own notes on demand and say so",
       { keyboard: { inline_keyboard: [
         [{ text: "Discoverer (default)", callback_data: "eng:discoverer" }, { text: "Classic", callback_data: "eng:classic" }],
+        [{ text: "Ask (on-demand)", callback_data: "eng:ask" }],
       ] } },
     );
   },

package/core/recall/ask.js

@@ -0,0 +1,48 @@
+// Ask recall engine: no automatic memory injection. Recall becomes something
+// the working model ASKS for instead of something done to it every turn.
+//
+// Why: the push engines' own KPIs (recall-kpi.jsonl, 3 weeks to 2026-07-23)
+// graded 51-89% of injected packs as noise, only ~7% of injections were ever
+// opened, and the discoverer walk taxed full-tier turns 10-16s. Meanwhile the
+// jobs that genuinely need always-on delivery (lessons, speaker notes) never
+// lived in this pipeline. So this engine injects nothing and instead tells
+// the model how to pull: `open-claudia recall query` (the same seed → graph →
+// walker pipeline, run on demand with the model's OWN question) plus the
+// direct pack/entity/transcript commands.
+//
+// The block below is the entire per-turn cost: identical every turn, a few
+// hundred bytes, zero matching, zero walker spawn, zero latency.
+
+const ASK_BLOCK = [
+  "## Memory (on-demand mode)",
+  "No long-term memory was auto-injected this turn. Your notes (context packs, entities, tools, past conversations) are available when YOU decide they're needed:",
+  "- `open-claudia recall query \"<question>\" [--context \"<working context>\"] [--json]` — graph walk + cheap-model judgement over the whole memory corpus; returns relevant notes with why + pointers.",
+  "- Direct: `open-claudia pack show <dir>` · `entity show <slug>` · `tool search <query>` · `transcript-search \"<query>\"`.",
+  "Ask whenever the topic plausibly has history — a person, project, preference, or prior decision you can't fully place. When you do, say so in one short line (e.g. \"taking a look at my notes on X\") so the user sees the lookup.",
+  "",
+  "",
+].join("\n");
+
+async function run(ctx) {
+  try {
+    require("./metrics").logTurn({
+      engine: "ask",
+      provider: ctx?.provider || "",
+      model: "",
+      query: String(ctx?.userText || ""),
+      tier: "ask",
+      seeds: [],
+      activated: [],
+      cand: [],
+      kept: [],
+      gated: false,
+      latencyMs: 0,
+      walkerMs: 0,
+      walker: "off",
+      costUsd: 0,
+    });
+  } catch (e) { /* metrics continuity is best-effort */ }
+  return { packBlock: ASK_BLOCK, entityBlock: "", packMatches: [], entityMatches: [] };
+}
+
+module.exports = { name: "ask", run, ASK_BLOCK };

package/core/recall/index.js

@@ -7,14 +7,18 @@
 // to the RECALL_ENGINE env var, then to DEFAULT_ENGINE. Unknown names fall
 // back to the default so a bad value can never break recall. The discoverer is
 // the default: it's fail-open (falls back to the classic keyword baseline on
-// any error), so it never recalls worse than classic, only better.
+// any error), so it never recalls worse than classic, only better. `ask`
+// injects nothing and points the model at on-demand recall instead
+// (`open-claudia recall query`) — pull, not push.
 
 const classic = require("./classic");
 const discoverer = require("./discoverer");
+const ask = require("./ask");
 
 const ENGINES = {
   classic,
   discoverer,
+  ask,
 };
 
 // The default recall engine for channels that haven't explicitly chosen one

package/core/runner.js

@@ -224,6 +224,13 @@ function telegramHtmlOpts(extra = {}) {
   return adapter?.type === "telegram" ? { ...extra, parseMode: "HTML" } : extra;
 }
 
+// Status chatter (queue acks, usage alerts, reviewer/guardrail notes) must not
+// reach an adapter whose send() is spoken aloud (live call turns) — only the
+// settled reply belongs on the line.
+function statusChatterMuted() {
+  try { return currentAdapter()?.suppressChatVisibility === true; } catch (e) { return false; }
+}
+
 function stableRunError(message, code = "PROVIDER_RUN_FAILED", details = {}) {
   const error = new Error(redactSensitive(String(message || "Provider run failed")));
   error.name = "ProviderRunError";
@@ -1523,7 +1530,7 @@ async function persistForegroundUsage(result, runContext, state = currentState()
       state,
       usage,
       result.costUsd || 0,
-      (text) => chatContext.run(store, () => send(text)),
+      (text) => chatContext.run(store, () => (statusChatterMuted() ? true : send(text))),
       {
         backend: runContext.provider,
         model: runContext.providerSettings?.model || null,
@@ -1925,7 +1932,7 @@ async function handoffMemoryReview(result, runContext, store, state) {
         return speaker ? { name: speaker.name, isOwner: !!speaker.isOwner } : null;
       } catch (_) { return null; }
     })(),
-    announce: showRecall ? (text) => chatContext.run(store, () => send(text)) : null,
+    announce: showRecall ? (text) => chatContext.run(store, () => (statusChatterMuted() ? true : send(text))) : null,
   });
 }
 
@@ -1941,7 +1948,7 @@ async function considerGuardrail(result, runContext, store) {
     const relationship = require("./relationship");
     const speaker = relationship.speakerFor(store?.adapter?.type, store?.channelId, store?.userId);
     if (relationship.guardActive(speaker)) return; // external speakers never capture
-    const announce = (text, opts) => chatContext.run(store, () => send(text, opts));
+    const announce = (text, opts) => chatContext.run(store, () => (statusChatterMuted() ? true : send(text, opts)));
     await guardrail.consider({ text: runContext.userPrompt, speaker, announce });
   } catch (e) { /* best-effort — a guardrail miss must never break a turn */ }
 }
@@ -2132,9 +2139,9 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
     state.messageQueue.push({ runContext, store, deferred, queuedAt: Date.now() });
     // Transient queue/compaction acks are a chat-UX affordance (Telegram/Kazee).
     // On a Spaces task thread they'd post a throwaway "Queued." comment on the
-    // task — noise. Spaces stays quiet and just posts the real reply when its
-    // turn runs.
-    if (currentAdapter()?.type !== "spaces") {
+    // task — noise. On a live call, send() is the TTS line: "Queued." would be
+    // spoken to the caller. Both stay quiet and just deliver the real reply.
+    if (currentAdapter()?.type !== "spaces" && !statusChatterMuted()) {
       send(state.isCompacting ? "Compacting context, will pick this up next…" : "Queued.", { replyTo: replyToMsgId }).catch(() => {});
     }
     return deferred.promise;

package/core/system-prompt.js

@@ -361,7 +361,9 @@ function buildSpeakerContextBlock() {
     : "unscoped chat";
   const blocks = [
     "## Channel context",
-    `- Interface: ${channelLabel} chat through Open Claudia.`,
+    adapter?.liveCall === true
+      ? "- Interface: LIVE VOICE CALL on Kazee — the user is speaking on an open line; replies are spoken aloud to them."
+      : `- Interface: ${channelLabel} chat through Open Claudia.`,
   ];
 
   const speaker = adapter && channelId
@@ -984,6 +986,16 @@ function bumpFtsMissCounter(n) {
 // prompt) ONLY on voice-input turns of the voice channel — i.e. exactly when the
 // reply will be read aloud by TTS (same gate as the streaming/auto-speak path in
 // the runner). Text channels (Telegram/Kazee) and typed turns never see it.
+const LIVE_CALL_GUIDANCE = [
+  "",
+  "",
+  "## Live voice call",
+  "You are on a LIVE voice call with the user right now. Their speech arrives transcribed; your final reply is synthesized straight onto the open line. Write it to be HEARD:",
+  "- Phone-call style: one to three short conversational sentences, then stop. No markdown, bullets, headings, emoji, backticks, or asterisks — they are noise when spoken.",
+  "- Do NOT read out code, file paths, command syntax, IDs, or URLs. Describe them in plain words, or offer to send the details to the chat as text.",
+  "- Tool time is dead air the caller sits through. Prefer answering from what you already know; keep any lookup to a couple of seconds, and offer to do longer digging after the call.",
+].join("\n");
+
 const VOICE_REPLY_GUIDANCE = [
   "",
   "",
@@ -1012,7 +1024,10 @@ const VOICE_NOTE_GUIDANCE = [
 
 function voiceReplyGuidance(opts = {}) {
   try {
-    const { currentTransport } = require("./context");
+    const { currentTransport, currentAdapter } = require("./context");
+    // A live Kazee call: the reply is spoken onto the open line, so call-style
+    // brevity outranks every chat-formatting rule.
+    if (currentAdapter()?.liveCall === true) return LIVE_CALL_GUIDANCE;
     const state = promptState(opts);
     if (currentTransport() === "voice") return state.lastInputWasVoice ? VOICE_REPLY_GUIDANCE : "";
     const { VOICE_REPLY_MODE } = require("./config");
@@ -1054,7 +1069,13 @@ async function buildOptionalRecallContext(prompt, opts = {}) {
   const budget = memoryRecallBudget();
   const settings = promptState(opts).settings || {};
   const recall = require("./recall");
-  const engine = recall.getEngine(recall.activeEngineName(settings));
+  // Live call: the discoverer's LLM walk is many seconds of dead air the
+  // caller sits through, so calls downgrade it to classic (~50ms keyword
+  // baseline). The ask engine is already zero-latency (injects nothing, model
+  // pulls on demand and narrates the lookup), so it rides through unchanged.
+  const activeName = recall.activeEngineName(settings);
+  const engineName = currentAdapter()?.liveCall === true && activeName === "discoverer" ? "classic" : activeName;
+  const engine = recall.getEngine(engineName);
   const recallOpts = { ...opts, recallCollector: collector };
   const recallProvider = promptRunIdentity({ ...opts, state: promptState(opts) }).provider;
   const helpers = {
@@ -1078,7 +1099,7 @@ async function buildOptionalRecallContext(prompt, opts = {}) {
   const why = result.why || {};
   collector.packDirs = (result.packMatches || []).map((match) => match.dir).filter(Boolean);
   collector.recall = {
-    engine: engine.name || recall.activeEngineName(settings),
+    engine: engine.name || engineName,
     gated: !!result.gated,
     tier: result.tier || "",
     packs: (result.packMatches || []).map((match) => ({ name: match.name || match.dir, why: why[`pack:${match.dir}`] || "" })),

package/core/turn-observer.js

@@ -38,11 +38,12 @@ function createTurnObserver({ state, store }) {
   // Spaces is a customer-facing surface that renders neither Telegram HTML nor
   // internal recall/tool banners meaningfully — a <b> banner shows the literal
   // tags. Suppress all owner-only chat visibility there; memory + graph feeding
-  // still run, only the chat emissions are muted.
+  // still run, only the chat emissions are muted. Adapters may also opt out
+  // explicitly (voice calls: send() feeds TTS, so a banner would be spoken).
   let suppressChatVisibility = false;
   try {
     const adapter = chatContext.run(store, () => currentAdapter());
-    suppressChatVisibility = adapter?.type === "spaces";
+    suppressChatVisibility = adapter?.type === "spaces" || adapter?.suppressChatVisibility === true;
   } catch (e) { suppressChatVisibility = false; }
 
   const packsLib = require("./packs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.17",
+  "version": "3.1.20",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-kazee-call-manager.js

@@ -28,6 +28,10 @@ function fixture() {
   assert.strictEqual(f.events[0].name, "call:accept");
   f.manager.session.options.onTranscript("What is on my agenda?");
   assert.strictEqual(f.inbound[0].payload.raw.ephemeralAudio, true);
+  // Call turns must mute observer banners (spoken otherwise) and flag live-call
+  // mode so the prompt builder switches to phone-style brevity.
+  assert.strictEqual(f.inbound[0].payload.adapter.suppressChatVisibility, true);
+  assert.strictEqual(f.inbound[0].payload.adapter.liveCall, true);
   await f.inbound[0].payload.adapter.send("chat", "Your agenda is clear.");
   assert.strictEqual(f.manager.session.spoken, "Your agenda is clear.");
   await f.manager.ended({ roomId: 12 });

package/test-kazee-call-session.js

@@ -228,6 +228,52 @@ async function testJoinGivesUpAfterRetries() {
   await session.close();
 }
 
+async function testThinkingCues() {
+  const { session } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 3), sampleRate: 48000 }),
+  });
+  let frames = 0;
+  session.publisher = { track: { writeRtp: () => { frames += 1; } }, sender: { codec: { payloadType: 111 } } };
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+
+  // Caller finishes a sentence: speech then sustained silence commits the turn,
+  // plays an audible "heard you" chime, and starts ticking right away — STT
+  // finalization takes seconds and must not sound like a dead line.
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  assert.strictEqual(sub.stt.commits, 1);
+  await wait(60);
+  assert(frames > 0, "commit plays the ack chime");
+  assert(session._thinkTimer, "thinking loop starts at commit, before the transcript");
+
+  // A noise commit finalizes to empty text: nothing dispatches, so the ticks
+  // stop rather than promising an answer that will never come.
+  sub.stt.onTranscript("   ");
+  assert.strictEqual(session._thinkTimer, null, "empty transcript stops the thinking loop");
+
+  // Real transcript dispatch (re)starts the loop; it counts as activity for
+  // the idle check, and the answer's playback stops it.
+  sub.stt.onTranscript("question");
+  assert(session._thinkTimer, "thinking loop starts on transcript");
+  session._startedAt = Date.now();
+  session._lastHeard = Date.now() - 10_000;
+  session._lastSpokeAt = Date.now() - 10_000;
+  session.idleMs = 50;
+  await session._enforceLimits();
+  assert.strictEqual(session.closed, false, "audible thinking is not idleness");
+  await session.speak("answer");
+  assert.strictEqual(session._thinkTimer, null, "answer playback stops the thinking loop");
+
+  // A fresh thinking loop stops the moment the caller starts talking again.
+  session._startThinking();
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  assert.strictEqual(session._thinkTimer, null, "caller speech stops the thinking loop");
+  gen.close();
+  await session.close();
+}
+
 async function testCloseResolvesSpeech() {
   const { session } = makeSession({
     synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
@@ -254,6 +300,7 @@ async function testCloseResolvesSpeech() {
   await testMaxDuration();
   await testJoinRetriesNoSuchRoom();
   await testJoinGivesUpAfterRetries();
+  await testThinkingCues();
   await testCloseResolvesSpeech();
   console.log("kazee call session: ok");
 })().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-provider-language.js

@@ -227,7 +227,31 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // the Janus publisher join through transient 426 "No such room" — the caller
 // creates the room at dial time and the bot answers faster than any human, so
 // the single naked join lost the race deterministically.
-assert.strictEqual(pkg.version, "3.1.17", "release version must remain unchanged without explicit approval");
+// 3.1.18 approved by Sumeet 2026-07-23 ("Yes those three make sense but I
+// think we need a better UI for the calls with AI… an audio sound to show
+// listening and thinking", then "still stuff like queued and token usage alert
+// etc came through"): live-call hygiene + audible UX — recall/tooltrace
+// banners, queue acks, usage alerts, and reviewer/guardrail notes are never
+// spoken into a call; a phone-style live-call prompt mode; call lifecycle
+// logging; ack chime + thinking ticks starting at VAD commit; and call turns
+// pin classic recall so memory lookup stops costing ~17s of dead air.
+// 3.1.19 approved by Sumeet 2026-07-23 ("can we make it a flag so the recall
+// mode has this as an option", after auditing push recall's own KPIs: 51-89%
+// noise, ~7% of injections ever opened, 10-16s full-tier latency tax): new
+// `ask` recall engine — /engine ask injects nothing per turn and instead
+// instructs the model to pull its own memory on demand via `open-claudia
+// recall query` and narrate the lookup; live-call pin now downgrades only the
+// discoverer to classic, so ask rides through calls at zero latency.
+// 3.1.20 approved by Sumeet 2026-07-23 ("We will come back to the voice stuff
+// just push out what we have as a new version"): call per-stage media
+// diagnostics — ISO-timestamped stage logs (ICE states, room-join publisher
+// count, subscribe/start, first RTP, VAD start/commit, STT connect, transcript
+// length, TTS synth ms) so a silent media-leg failure (accepted → nothing
+// heard → remote-ended with zero errors) becomes visible and STT/TTS timings
+// stop being estimates — plus the Janus keepalive ack fix (Janus answers
+// keepalive with ONLY an ack; acks now settle keepalive requests alone,
+// ending the bogus per-interval "keepalive timed out" log noise).
+assert.strictEqual(pkg.version, "3.1.20", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }

package/test-recall-engine.js

@@ -10,9 +10,38 @@ assert.strictEqual(recall.activeEngineName({ recallEngine: "classic" }), "classi
 assert.strictEqual(recall.activeEngineName({ recallEngine: "nope" }), "discoverer", "unknown → default");
 assert.strictEqual(recall.activeEngineName({ recallEngine: "CLASSIC" }), "classic", "case-insensitive");
 assert.ok(recall.listEngines().includes("classic"));
+assert.ok(recall.listEngines().includes("ask"), "ask engine must be selectable");
+assert.strictEqual(recall.activeEngineName({ recallEngine: "ask" }), "ask", "ask selectable per channel");
 assert.strictEqual(typeof recall.getEngine("classic").run, "function");
 assert.strictEqual(recall.getEngine("bogus").name, "classic", "getEngine hard-floor stays classic (crash-proof)");
 
+// Live-call fast-path: the discoverer's LLM walk is dead air a caller sits
+// through, so call turns downgrade discoverer→classic — but the ask engine
+// (zero injection, zero latency) must ride through unchanged.
+{
+  const fs = require("fs");
+  const src = fs.readFileSync(require.resolve("./core/system-prompt.js"), "utf8");
+  assert.match(
+    src,
+    /liveCall === true && activeName === "discoverer" \? "classic" : activeName/,
+    "live-call turns must downgrade only the discoverer, preserving ask",
+  );
+}
+
+// --- ask engine: injects nothing but the on-demand instructions ---
+(async () => {
+  const ask = recall.getEngine("ask");
+  const out = await ask.run({ userText: "hello", provider: "claude" });
+  assert.strictEqual(out.packMatches.length, 0, "ask injects no packs");
+  assert.strictEqual(out.entityMatches.length, 0, "ask injects no entities");
+  assert.strictEqual(out.entityBlock, "", "ask has no entity block");
+  assert.match(out.packBlock, /on-demand mode/, "ask block declares the mode");
+  assert.match(out.packBlock, /recall query/, "ask block must point at the pull command");
+  assert.match(out.packBlock, /taking a look at my notes/, "ask block must ask the model to narrate lookups");
+  const out2 = await ask.run({});
+  assert.strictEqual(out2.packBlock, out.packBlock, "ask block is constant — no per-turn matching");
+})().catch((e) => { console.error(e); process.exit(1); });
+
 // env override when no setting
 const prev = process.env.RECALL_ENGINE;
 process.env.RECALL_ENGINE = "classic";

package/test-runner-watchdog-static.js

@@ -22,6 +22,14 @@ assert.match(lifecycle, /killTree\(proc\?\.pid,\s*"SIGKILL"\)/, 'watchdog must f
 assert.match(lifecycle, /await terminationPromise/, 'terminal settlement must await forced descendant cleanup');
 assert.match(runner, /await drainQueuedMessages\(state\)/, 'watchdog path must not strand queued follow-up messages');
 
+// Live-call hygiene: status chatter must never be spoken down the line. Each
+// in-turn status emitter (queue ack, usage alert, memory-review + guardrail
+// announces) must consult statusChatterMuted(), which honors the call
+// adapter's suppressChatVisibility flag.
+assert.match(runner, /function statusChatterMuted\(\)[\s\S]{0,200}suppressChatVisibility === true/, 'statusChatterMuted must key off adapter.suppressChatVisibility');
+assert.match(runner, /!== "spaces" && !statusChatterMuted\(\)/, 'queue/compaction ack must stay silent on live-call turns');
+assert.strictEqual((runner.match(/statusChatterMuted\(\) \? true : send\(/g) || []).length, 3, 'usage alert, memory-review announce, and guardrail announce must all mute on live-call turns');
+
 assert.ok(monolith.split('\n').length <= 12, 'bot-agent.js must be only a compatibility shim');
 assert.match(monolith, /require\(["']\.\/bot["']\)/, 'legacy entrypoint must delegate to bot.js');
 assert.ok(!/(?:OC_TURN_IDLE_MS|CLAUDE_PATH|spawn\(|parseStream|writeFile|saveState|codex)/i.test(monolith), 'compatibility shim must contain no watchdog, provider, parser, or writer implementation');

package/test-utility-provider-policy.js

@@ -474,7 +474,12 @@ async function main() {
       },
     })),
     env: { UTILITY_PROVIDER: "claude" },
-    killGraceMs: 400,
+    // Grace must outlive scheduler starvation on a loaded runner: at 400ms the
+    // SIGKILL escalation raced the child's TERM handler before it could write
+    // drain-signal.json (same class as the 3.1.16 CI deflakes). The child
+    // normally exits on TERM within milliseconds; 2000ms only bounds the
+    // emergency path and still fits inside the 5000ms cancelAll budget.
+    killGraceMs: 2000,
   });
   const drainingRun = drainService.spawnUtilityAgent("shutdown drain", {
     purpose: "review", systemPrompt: "drain", cwd: root,