@inetafrica/open-claudia 3.4.15 → 3.4.16

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 3.4.16
+
+- Start live-call answer generation without waiting for an auxiliary memory-relevance model. Calls keep local matches from the current utterance, bounded spoken history, and full policy; context-only keyword matches remain excluded without a relevance judgment. Ordinary chat filtering and explicit on-demand recall are unchanged.
+- Log live-call provider preparation, prompt readiness, process start and completion with elapsed time, so recognition delay can be distinguished from reply startup and generation.
+- Reproduce the call-path regression through the actual prompt builder and classic matcher, covering both configured recall engines, context-only exclusions, ordinary chat filtering and on-demand recall.
+
 ## 3.4.15
 
 - Preserve complete Kazee speech turns with protocol-2 segment matching, bounded pending finals, and cancellation when speech resumes during an endpoint decision. Keep compatibility with older speech servers, including a delayed protocol-ready message.

package/core/runner.js

@@ -1936,6 +1936,10 @@ function createStreamPreview({ state, store }) {
 
 function createForegroundService({ state, store, stopTyping, capture, ownsAdmissionLock, persistCapture = true }) {
   const callSpeechLeases = new Map();
+  const callStage = (stage, runContext) => {
+    if (capture || runContext?.liveCall !== true) return;
+    console.log(`${new Date().toISOString()} Kazee call provider: stage=${stage} run=${runContext.runId} elapsed=${Math.max(0, Date.now() - runContext.admittedAt)}ms`);
+  };
   const persistEffects = !capture || persistCapture;
   const preview = capture ? null : createStreamPreview({ state, store });
   // Chat-visibility + learning-signal layer (skill/pack/tool announcements,
@@ -1946,7 +1950,10 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
     getStore: () => store,
     isObsolete: () => obsoleteCallTurn(store),
     resolveProvider: resolveForegroundProvider,
-    buildTurnPrompt,
+    buildTurnPrompt(prompt, opts) {
+      callStage("preparing", opts.runContext);
+      return buildTurnPrompt(prompt, opts);
+    },
     buildInvocation(provider, context) {
       if (context.purpose === "compact-seed" && typeof provider.buildCompactionInvocation === "function") {
         return provider.buildCompactionInvocation(context);
@@ -1969,6 +1976,7 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
     persistSession: persistEffects ? ((result, runContext) => persistForegroundSession(result, runContext, state)) : null,
     deliver: capture ? null : (result, runContext) => deliverForegroundResult(result, runContext, state),
     onSpawn(proc, runContext) {
+      callStage("started", runContext);
       callSpeechLeases.get(runContext.runId)?.activate();
       state.runningProcess = proc;
       if (ownsAdmissionLock) state.preparingRun = false;
@@ -1980,10 +1988,12 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
       return true;
     },
     onPromptBundle(bundle, runContext) {
+      callStage("prompt-ready", runContext);
       if (!observer || runContext.purpose !== "foreground") return;
       observer.onRecallSurfaced(bundle.recallMetadata);
     },
     onEvent(event, runContext) {
+      if (event.type === "result" || event.type === "error") callStage("finished", runContext);
       if (event.type === "result" || event.type === "error") callSpeechLeases.get(runContext.runId)?.close();
       // Streaming text reads as "typing"; tool work re-enters "thinking" so
       // the chip doesn't decay to a stale "typing" through long tool stretches.

package/core/system-prompt.js

@@ -997,6 +997,10 @@ async function filterMatches(userText, contextText, packMatches, entityMatches,
     packMatches: packMatches.filter((m) => m.origin === "user"),
     entityMatches: entityMatches.filter((m) => m.origin === "user"),
   });
+  // The classic engine still uses an auxiliary model. On a live call that
+  // adds seconds before the answering model can even start. Keep the local
+  // user-keyword baseline; context-only hits still need a relevance judge.
+  if (opts.liveCall === true) return failOpen();
   if (packMatches.length === 0 && entityMatches.length === 0) {
     return { packMatches, entityMatches };
   }
@@ -1176,12 +1180,12 @@ async function buildOptionalRecallContext(prompt, opts = {}) {
   const budget = memoryRecallBudget();
   const settings = promptState(opts).settings || {};
   const recall = require("./recall");
-  // 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.
+  // Calls use classic matching with the auxiliary relevance model disabled
+  // below. Merely selecting classic still waits on that model. Explicit ask
+  // mode continues to retrieve memory on demand.
+  const liveCall = opts.runContext?.liveCall ?? (currentAdapter()?.liveCall === true);
   const activeName = recall.activeEngineName(settings);
-  const engineName = currentAdapter()?.liveCall === true && activeName === "discoverer" ? "classic" : activeName;
+  const engineName = liveCall === true && activeName === "discoverer" ? "classic" : activeName;
   const engine = recall.getEngine(engineName);
   const recallOpts = { ...opts, recallCollector: collector };
   const recallProvider = promptRunIdentity({ ...opts, state: promptState(opts) }).provider;
@@ -1194,7 +1198,7 @@ async function buildOptionalRecallContext(prompt, opts = {}) {
       context,
       packMatches,
       entityMatches,
-      { provider: recallProvider },
+      { provider: recallProvider, liveCall },
     ),
     logRecall,
     buildPackBlock: (matches, recallBudget, engineOpts) => buildPackBlock(matches, recallBudget, { ...recallOpts, ...(engineOpts || {}) }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.4.15",
+  "version": "3.4.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-language.js

@@ -468,7 +468,8 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // 3.4.13: Codex usage accounting fix — Sumeet approved the three-bug fix on 2026-09-05 ("Yes");
 // prepared 2026-09-06 for his release go. Rollout-based Codex context, per-turn ledger, sub-agent + quota accounting.
 // 3.4.15: conversation flow and checked sentence speech; authorized calling rollout, 2026-09-05/06.
-assert.strictEqual(pkg.version, "3.4.15", "release version must remain unchanged without explicit approval");
+// 3.4.16: remove the auxiliary recall-model delay from live replies; Sumeet's approved calling rollout, 2026-09-05/06.
+assert.strictEqual(pkg.version, "3.4.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}`);
 }

package/test-provider-recall.js

@@ -253,6 +253,52 @@ async function main() {
   recall.getEngine = originalGetEngine;
   assert.strictEqual(admittedProvider, "codex");
 
+  // Real call prompt -> classic matcher -> relevance filter. A second model
+  // must not hold a live reply; context-only hits still require a judge and
+  // cannot be promoted just because calls use the local keyword baseline.
+  const packsLib = require("./core/packs");
+  const entitiesLib = require("./core/entities");
+  const transcriptsLib = require("./core/transcripts");
+  const filterLib = require("./core/recall-filter");
+  const saved = { matchPacks: packsLib.matchPacks, matchEntities: entitiesLib.matchEntities,
+    recentTranscriptText: transcriptsLib.recentTranscriptText, judgeRelevance: filterLib.judgeRelevance };
+  const { chatContext } = require("./core/context");
+  let judgeCalls = 0;
+  try {
+    packsLib.matchPacks = text => [{ dir: text === "Current deployment" ? "current-topic" : "stale-chat-topic", score: 10 }];
+    entitiesLib.matchEntities = () => [];
+    transcriptsLib.recentTranscriptText = () => "Earlier unrelated chat discussion";
+    filterLib.judgeRelevance = async () => { judgeCalls++; return new Set(["pack:current-topic", "pack:stale-chat-topic"]); };
+    for (const recallEngine of ["discoverer", "classic"]) {
+      const callRecall = await chatContext.run({ adapter: { type: "kazee", liveCall: true } }, () =>
+        systemPrompt.buildOptionalRecallContext("Current deployment", {
+          state: { ...mutableState, settings: { backend: "codex", recallEngine } },
+          runContext: { provider: "codex", liveCall: true, purpose: "foreground", project: { name: "project-a", dir: root }, runId: `call-${recallEngine}` },
+        }));
+      assert.strictEqual(judgeCalls, 0, "live call must reach answer generation without a second model for recall");
+      assert.deepStrictEqual(callRecall.metadata.packDirs, ["current-topic"], "retain current-topic keyword memory, exclude stale context-only matches");
+    }
+    const ordinaryRecall = await chatContext.run({ adapter: { type: "kazee" } }, () =>
+      systemPrompt.buildOptionalRecallContext("Current deployment", {
+        state: { ...mutableState, settings: { backend: "codex", recallEngine: "classic" } },
+        runContext: { provider: "codex", purpose: "foreground", project: { name: "project-a", dir: root }, runId: "ordinary-classic" },
+      }));
+    assert.strictEqual(judgeCalls, 1, "ordinary chat retains its model-based relevance filter");
+    assert.deepStrictEqual(ordinaryRecall.metadata.packDirs, ["current-topic", "stale-chat-topic"]);
+    const askRecall = await chatContext.run({ adapter: { type: "kazee", liveCall: true } }, () =>
+      systemPrompt.buildOptionalRecallContext("Current deployment", {
+        state: { ...mutableState, settings: { backend: "codex", recallEngine: "ask" } },
+        runContext: { provider: "codex", liveCall: true, purpose: "foreground", project: { name: "project-a", dir: root }, runId: "call-ask" },
+      }));
+    assert.strictEqual(askRecall.metadata.engine, "ask", "explicit on-demand recall remains on-demand during calls");
+    assert.strictEqual(judgeCalls, 1);
+  } finally {
+    packsLib.matchPacks = saved.matchPacks;
+    entitiesLib.matchEntities = saved.matchEntities;
+    transcriptsLib.recentTranscriptText = saved.recentTranscriptText;
+    filterLib.judgeRelevance = saved.judgeRelevance;
+  }
+
   // ── compaction recall policy: the summary meta-turn skips recall entirely;
   //    the seed turn matches on the runner-supplied recallQuery (condensed
   //    brief + task titles), never the seed prompt's boilerplate ──