@inetafrica/open-claudia 3.1.14 → 3.1.16

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## v3.1.16 — CI-deflake: no live network in unit tests, CI-safe enforcer deadlines
+
+- Identical bot behaviour to v3.1.15 (which never shipped: its pipeline died twice on loaded-runner test flakes — the tag is retired unretagged per release hygiene).
+- `test-telegram-conflict-heal-guard.js` stubbed `_probeTelegramReachable`/`_anyTurnActive`: the wedge-exit assertion used to probe the real api.telegram.org, so a slow/blocked CI egress sent `_heal` down the outage-pause path instead of the exit under test. It also now isolates `OPEN_CLAUDIA_CONFIG_DIR` — the exercised exit path was writing a bogus "polling wedged" `last-exit.json` into the real `~/.open-claudia` on every local test run.
+- `test-provider-enforcer.js` deadlines made CI-safe: the judged-probe service backstop 2000→8000ms (children answer in ms; 2000 was missed by child boot under runner load), the deliberate-timeout probe 2500→5000ms boot headroom.
+
+## v3.1.15 — Voice-note replies speak a conversational summary, not the chat text
+
+- Replying to a voice note used to TTS the full formatted chat answer verbatim — bullets, emoji, pipeline IDs and all ("this isn't human hearable"). On voice-reply turns the provider is now asked to end its reply with a dedicated spoken script in `<voice-script>` markers: the chat message keeps the full text answer (script stripped), and only the script — two to four conversational sentences written for the ear — is synthesized into the voice note.
+- If the provider omits the script, a sanitizing fallback (`speechFallback`) strips code blocks, HTML, URLs, emoji, and list markers, caps the speech at the opening sentences, and closes with "The rest is in the text message." — a verbatim readout can no longer reach TTS on text channels.
+- The Kazee call bridge keeps its existing in-call guidance and streams `voiceScript || finalText`, so stray markers are never spoken there either.
+- New extraction/fallback/wiring assertions in `test-media-speech.js`.
+
 ## v3.1.14 — Call bridge production hardening: serialized speech, barge-in, group attribution, limits
 
 - **TTS is serialized through a queue with cancellation.** Concurrent `speak()` calls used to interleave two 20ms-frame RTP loops over the same sequence/timestamp counters — garbled audio whenever the provider emitted more than one message. Utterances now play strictly one at a time; `cancelSpeech()` (generation-based) stops the current utterance mid-frame and resolves everything queued, and `close()` cancels so no pending `speak()` can hang the adapter.

package/core/runner.js

@@ -1647,6 +1647,18 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     }
   }
 
+  // The <voice-script> block (if the provider wrote one) is a spoken summary
+  // for the voice note — strip it from the chat text; the guard above already
+  // vetted the full output including the script.
+  const { VOICE_REPLY_MODE } = require("./config");
+  const { shouldReplyWithVoice, extractVoiceScript, speechFallback } = require("./voice-policy");
+  let voiceScript = "";
+  if (result.ok) {
+    const parts = extractVoiceScript(finalText);
+    voiceScript = parts.script;
+    finalText = parts.text || parts.script || finalText;
+  }
+
   const chunks = splitMessage(finalText);
   for (let index = 0; index < chunks.length; index += 1) {
     let sent = await send(chunks[index], telegramHtmlOpts(index === 0 ? { replyTo: runContext.replyToMsgId } : {}));
@@ -1654,25 +1666,26 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     if (!sent.ok) throw new Error(`failed to deliver response chunk ${index + 1}`);
   }
 
-  const { VOICE_REPLY_MODE } = require("./config");
-  const { shouldReplyWithVoice } = require("./voice-policy");
   const shouldSpeak = shouldReplyWithVoice(VOICE_REPLY_MODE, runContext.lastInputWasVoice);
   if (result.ok && shouldSpeak) {
     const { currentTransport } = require("./context");
     if (currentTransport() === "voice") {
-      const sentences = splitSentences(finalText);
+      const sentences = splitSentences(voiceScript || finalText);
       let spoke = false;
       for (const sentence of sentences) {
         const clip = await synthSentenceMp3(sentence);
         if (clip) { spoke = true; await sendVoice(clip); }
       }
       if (!spoke) {
-        const voicePath = await textToVoice(finalText);
+        const voicePath = await textToVoice(voiceScript || finalText);
         if (voicePath) await sendVoice(voicePath);
       }
       await sendVoiceEnd();
     } else {
-      const voicePath = await textToVoice(finalText);
+      // Never TTS the formatted chat text verbatim: use the provider's spoken
+      // script, else a sanitized short fallback.
+      const spoken = voiceScript || speechFallback(finalText);
+      const voicePath = spoken ? await textToVoice(spoken) : null;
       if (voicePath) await sendVoice(voicePath);
     }
   }

package/core/system-prompt.js

@@ -995,10 +995,29 @@ const VOICE_REPLY_GUIDANCE = [
   "- If the answer genuinely needs code or exact detail, say so briefly and offer to send it as text rather than reading it aloud.",
 ].join("\n");
 
+// Text-channel voice turns (a Telegram/Kazee voice note): the chat reply stays
+// a normal full text answer, but a voice note is ALSO sent back. Asking for a
+// dedicated spoken script — stripped from the text by the runner — is what
+// keeps that voice note conversational instead of a verbatim TTS of the
+// formatted chat text.
+const VOICE_NOTE_GUIDANCE = [
+  "",
+  "",
+  "## Voice note reply",
+  "The user sent this message as a voice note, and a spoken voice note will be sent back alongside your text reply. Do both:",
+  "- Write your normal text reply as usual — full detail and formatting are fine; it is delivered as text.",
+  "- End the reply with a spoken script between <voice-script> and </voice-script> markers. That block is stripped from the text message and only synthesized to audio.",
+  "Script rules: two to four short sentences a person would naturally SAY — summarise the essence conversationally, do not re-read the text reply. No formatting, no emoji, no lists. Never speak code, IDs, file paths, URLs, or command syntax — describe them in plain words or say the details are in the text message.",
+].join("\n");
+
 function voiceReplyGuidance(opts = {}) {
   try {
     const { currentTransport } = require("./context");
-    if (currentTransport() === "voice" && promptState(opts).lastInputWasVoice) return VOICE_REPLY_GUIDANCE;
+    const state = promptState(opts);
+    if (currentTransport() === "voice") return state.lastInputWasVoice ? VOICE_REPLY_GUIDANCE : "";
+    const { VOICE_REPLY_MODE } = require("./config");
+    const { shouldReplyWithVoice } = require("./voice-policy");
+    if (shouldReplyWithVoice(VOICE_REPLY_MODE, state.lastInputWasVoice)) return VOICE_NOTE_GUIDANCE;
   } catch (e) {}
   return "";
 }

package/core/voice-policy.js

@@ -4,4 +4,49 @@ function shouldReplyWithVoice(mode, lastInputWasVoice) {
   return mode === "always" || (mode === "on-voice-input" && !!lastInputWasVoice);
 }
 
-module.exports = { shouldReplyWithVoice };
+// On voice-reply turns the provider is asked (system-prompt voice-note
+// guidance) to end its reply with a spoken script between these markers. The
+// block is stripped from the chat text and ONLY synthesized — chat keeps the
+// full formatted answer while the voice note carries an ear-friendly summary
+// instead of a verbatim TTS readout of bullets, emoji, and IDs.
+const VOICE_SCRIPT_RE = /<voice-script>([\s\S]*?)(?:<\/voice-script>|$)/gi;
+
+function extractVoiceScript(text) {
+  const raw = String(text || "");
+  const scripts = [];
+  const stripped = raw.replace(VOICE_SCRIPT_RE, (_match, body) => {
+    const clean = String(body || "").trim();
+    if (clean) scripts.push(clean);
+    return "";
+  });
+  return { text: stripped.trim(), script: scripts.join(" ").trim() };
+}
+
+// Last-resort shaping when the provider supplied no <voice-script>: strip
+// everything that reads badly aloud and cap to the opening sentences, so a
+// missed script degrades to a short spoken intro rather than a verbatim dump
+// of formatted text into TTS.
+const FALLBACK_MAX_CHARS = 400;
+
+function speechFallback(text) {
+  const plain = String(text || "")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/<[^>\n]{0,120}>/g, " ")
+    .replace(/https?:\/\/\S+/gi, " ")
+    .replace(/[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}\u{FE0F}\u{200D}]/gu, "")
+    .replace(/^\s*[-*•▸►]+\s+/gm, "")
+    .replace(/[*_`#|]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (plain.length <= FALLBACK_MAX_CHARS) return plain;
+  const sentences = plain.match(/[^.!?]+[.!?]+(?:\s+|$)/g) || [];
+  let out = "";
+  for (const sentence of sentences) {
+    if (out && out.length + sentence.length > FALLBACK_MAX_CHARS) break;
+    out += sentence;
+  }
+  out = out.trim() || plain.slice(0, FALLBACK_MAX_CHARS).trim();
+  return `${out} The rest is in the text message.`;
+}
+
+module.exports = { shouldReplyWithVoice, extractVoiceScript, speechFallback };

package/package.json

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

package/test-provider-enforcer.js

@@ -95,7 +95,10 @@ async function providerProbe(kind) {
   const service = enforcer.createEnforcerService({
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
-    timeoutMs: 2000,
+    // Generous: children answer in ms, so the green path never waits this out.
+    // The deadline exists only as the fail-closed backstop, and 2000ms was
+    // missed by child boot on a loaded CI runner (pipeline 10445 flake).
+    timeoutMs: 8000,
   });
   const speaker = { name: "External Fixture", relationship: "external", mandate: "May discuss invoice status only." };
   const secret = ["sk", "proj", "guard", "fixture", "private"].join("-");
@@ -106,9 +109,10 @@ async function providerProbe(kind) {
   const timeoutService = enforcer.createEnforcerService({
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
-    // 2500ms so the hung child boots on a loaded CI runner (writing capture #5
-    // and arming its SIGTERM recorder) before the deadline fires.
-    timeoutMs: 2500,
+    // Bounded (this deadline MUST fire — the child hangs by design), but with
+    // enough headroom for the hung child to boot on a loaded CI runner (write
+    // capture #5, arm its SIGTERM recorder) before the deadline kills it.
+    timeoutMs: 5000,
   });
   const timedOut = await timeoutService.vetReply(speaker, "timeout verdict fixture");
 

package/test-provider-language.js

@@ -212,7 +212,17 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // production hardening — serialized TTS with barge-in cancellation, echo gate,
 // per-feed STT with group speaker attribution, duration/idle limits with a
 // spoken goodbye, and the call tests wired into the main npm test chain.
-assert.strictEqual(pkg.version, "3.1.14", "release version must remain unchanged without explicit approval");
+// 3.1.15 approved by Sumeet 2026-07-22 ("if replying in voice it needs to be
+// summaries etc but not just conversions directly"): voice-note replies now
+// speak a provider-written conversational <voice-script> summary (stripped from
+// the chat text) instead of a verbatim TTS of the formatted answer, with a
+// sanitizing speechFallback when the script is missing.
+// 3.1.16 approved by Sumeet 2026-07-22 (same calls-directive authority; re-cut
+// of the never-published 3.1.15 after two loaded-runner CI flakes): test-only
+// deflake — heal-guard test stubs its live api.telegram.org probe and isolates
+// CONFIG_DIR; enforcer probe deadlines raised to CI-safe values (2000→8000ms
+// backstop, 2500→5000ms deliberate-timeout boot headroom). No runtime changes.
+assert.strictEqual(pkg.version, "3.1.16", "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}`);
 }