@inetafrica/open-claudia 3.2.1 → 3.3.1

package/test-kazee-call-session.js

@@ -29,8 +29,9 @@ class FakePC {
 }
 
 class FakeSpeechStream {
-  constructor({ onTranscript } = {}) {
+  constructor({ onTranscript, onPartial } = {}) {
     this.onTranscript = onTranscript;
+    this.onPartial = onPartial;
     this.audioFrames = [];
     this.commits = 0;
     this.closedStream = false;
@@ -41,12 +42,12 @@ class FakeSpeechStream {
   close() { this.closedStream = true; }
 }
 
-function makeSession({ synthesize, maxCallMs, idleMs, asCaller, greeting } = {}) {
+function makeSession({ synthesize, maxCallMs, idleMs, finalWaitMs, asCaller, greeting } = {}) {
   const ended = [];
   const transcripts = [];
   const session = new KazeeCallSession({
     roomId: 7, chatId: "chat", callerId: "owner", botUserId: "bot", janusUrl: "ws://test",
-    maxCallMs, idleMs, asCaller, greeting,
+    maxCallMs, idleMs, finalWaitMs, asCaller, greeting,
     synthesize: synthesize || (async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 2), sampleRate: 48000 })),
     onTranscript: (text, meta) => transcripts.push({ text, meta }),
     onEnded: (reason) => ended.push(reason),
@@ -127,12 +128,98 @@ async function testPrebufferAndCommit() {
   assert.strictEqual(sub.stt.audioFrames.length, 0, "silence stays out of STT");
   for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
   assert.strictEqual(sub.stt.audioFrames.length, 8, "onset flushes the prebuffer (5 quiet + 2 onset + current)");
+  sub.stt.onPartial("hello there"); // recogniser heard words, so the energy close commits directly
   for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
   assert.strictEqual(sub.stt.commits, 1, "turn commits after sustained silence");
   gen.close();
   await session.close();
 }
 
+async function testHoldForWords() {
+  const { session } = makeSession({});
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  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, 0, "energy close with zero words holds the commit");
+  assert(sub.awaitingWordsSince > 0, "hold state armed");
+  sub.stt.onPartial("hello there");
+  assert.strictEqual(sub.stt.commits, 1, "first words release the held commit");
+  assert.strictEqual(sub.awaitingWordsSince, 0);
+  assert(session._thinkTimer, "released commit acks and thinks like a normal turn");
+  gen.close();
+  await session.close();
+}
+
+async function testHoldTimeoutDropsNoiseTurn() {
+  const { session, transcripts } = makeSession({});
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  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) });
+  sub.awaitingWordsSince = Date.now() - 5000; // hold expired
+  session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  assert.strictEqual(sub.stt.commits, 1, "expired hold still finalizes the audio");
+  assert.strictEqual(sub.noiseCommit, true);
+  assert.strictEqual(session._thinkTimer, null, "noise commit stays silent — no ack, no ticking");
+  sub.stt.onTranscript("uh"); // babble leaked a stray word into the transcript
+  assert.strictEqual(transcripts.length, 0, "sub-threshold noise transcript never dispatches");
+  gen.close();
+  await session.close();
+}
+
+async function testWordStallRescue() {
+  const { session } = makeSession({});
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  sub.stt.onPartial("so the deploy");
+  sub.lastWordAt = Date.now() - 4500; // word timeline stalled well past its cadence
+  session._onFeedRtp(101, { payload: toneOpus(gen, 12000) }); // background keeps energy loud
+  assert.strictEqual(sub.stt.commits, 1, "stalled words commit even while energy stays loud");
+  assert.strictEqual(sub.vad.active, false, "rescue resets the energy turn");
+  gen.close();
+  await session.close();
+}
+
+async function testInterimFallbackAndLateFinal() {
+  const { session, transcripts } = makeSession({ finalWaitMs: 30 });
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  sub.stt.onPartial("here is my answer");
+  for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  assert.strictEqual(sub.stt.commits, 1);
+  assert.strictEqual(transcripts.length, 0, "dispatch waits for the final first");
+  await wait(80);
+  assert.strictEqual(transcripts.length, 1, "missing final falls back to the interim");
+  assert.strictEqual(transcripts[0].text, "here is my answer");
+  sub.stt.onTranscript("here is my answer sir");
+  assert.strictEqual(transcripts.length, 1, "late final after fallback is dropped, not double-answered");
+  gen.close();
+  await session.close();
+}
+
+async function testTrickleBuffering() {
+  const { session } = makeSession({});
+  const added = [];
+  session.publisher = { pc: { addIceCandidate: async (c) => { added.push(c.candidate); } }, pending: [], remoteSet: false };
+  session._onPublisherEvent({ janus: "trickle", candidate: { candidate: "cand-early", sdpMid: "0" } });
+  assert.strictEqual(added.length, 0, "candidates before the answer are buffered");
+  assert.strictEqual(session.publisher.pending.length, 1);
+  session._flushTrickle(session.publisher);
+  assert.deepStrictEqual(added, ["cand-early"], "buffered candidates flush once the answer lands");
+  session._onPublisherEvent({ janus: "trickle", candidate: { candidate: "cand-late", sdpMid: "0" } });
+  assert.deepStrictEqual(added, ["cand-early", "cand-late"], "later candidates apply directly");
+  session._onPublisherEvent({ janus: "trickle", candidate: { completed: true } });
+  assert.strictEqual(added.length, 2, "end-of-candidates marker is ignored");
+  await session.close();
+}
+
 async function testTranscriptAttribution() {
   const { session, transcripts } = makeSession({});
   await session._subscribe(101, "alice@kazee");
@@ -245,8 +332,11 @@ async function testCallerModeRoomLifecycle() {
   const spoken = [];
   session.speak = async (text) => { spoken.push(text); return true; };
   await session._subscribe(101, "sumeet@kazee");
+  assert.deepStrictEqual(spoken, [], "no greeting while the publisher media leg is still down");
+  session._publisherUp = true;
+  session._maybeGreet();
   await session._subscribe(102, "second@kazee");
-  assert.deepStrictEqual(spoken, ["hi there"], "greeting speaks exactly once, on first remote feed");
+  assert.deepStrictEqual(spoken, ["hi there"], "greeting speaks exactly once, after media-up + first remote feed");
   await session.close();
   const destroy = messages.find((m) => m?.request === "destroy");
   assert.ok(destroy && destroy.room === 7, "created room is destroyed on close");
@@ -283,6 +373,7 @@ async function testThinkingCues() {
   // 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) });
+  sub.stt.onPartial("what is the status");
   for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
   assert.strictEqual(sub.stt.commits, 1);
   await wait(60);
@@ -335,6 +426,11 @@ async function testCloseResolvesSpeech() {
   await testSpeakCancellation();
   await testEchoGateAndBargeIn();
   await testPrebufferAndCommit();
+  await testHoldForWords();
+  await testHoldTimeoutDropsNoiseTurn();
+  await testWordStallRescue();
+  await testInterimFallbackAndLateFinal();
+  await testTrickleBuffering();
   await testTranscriptAttribution();
   await testIdleTimeout();
   await testIdleBargeInKeepsCall();

package/test-provider-language.js

@@ -351,7 +351,35 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // fix from the chat-central outage, the call-platform batch (outgoing calls,
 // greetings, TURN via /webrtc/config, ring-phase teardown fixes), the
 // received-media .bin extension fix, and the tts/transcribe agent verbs.
-assert.strictEqual(pkg.version, "3.2.1", "release version must remain unchanged without explicit approval");
+// 3.2.2 approved by Sumeet 2026-08-09 ("Yeh", answering "Want me to build the
+// chip fix now and fold it in? Then a single /restart live-verifies everything
+// and I cut"): the presence-chip batch — thinking-on-receipt (heartbeat starts
+// the moment a turn-bound message arrives, covering enforcer triage/download/
+// STT dead air), tool stretches re-enter "thinking" instead of decaying the
+// chip, /stop emits an explicit typing:stop, and the dedup adjudicator's
+// "dedup" utility purpose registered so the journal dedup gate actually runs.
+// 3.2.3 approved by Sumeet 2026-08-13 ("While we wait can we update open
+// Claudia so a watcher requires a timeout or defaults to something so that
+// when it expires it acts as a wake up so no watcher can silently fail?"):
+// watch expiry — every new watch carries expiresAt (--timeout flag, default
+// 2h); a lapsed deadline with a still-failing check fires the wake anyway as
+// a marked "Watch expired" prompt and removes the watch, so a watch whose
+// condition never comes true can no longer end silently.
+// 3.3.0 cut 2026-08-14 (verify-contact batch: owner-only verify flow, HMAC
+// speaker attest on owner-gated loopback kinds, closed relay/transcript
+// egress) — but the release commit bumped package.json WITHOUT this pin, so
+// the tag's build job failed on this very assert: npm kept 3.2.3 and nothing
+// was published. Never retag a failed version — re-cut as +1.
+// 3.3.1 approved by Sumeet 2026-08-19 ("The tts timeout for long messages is
+// getting to be a problem Please fix it", with the sales-bot failure
+// screenshot): pocket TTS sentence-packs long text into ≤450-char chunks,
+// synthesizes each inside its own 120s window (one retry per chunk), and
+// ffmpeg-concats the wavs into ONE ogg — message length can no longer abort
+// the single gateway request and strand pods (no ElevenLabs key, no macOS
+// say) voiceless. Carries the unpublished 3.3.0 content plus the Kazee calls
+// batch (trickle ICE + streaming TTS playback, ringing-on-invite/deferred
+// publish, werift ICE rejection suppression). Plus this pin repair.
+assert.strictEqual(pkg.version, "3.3.1", "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-scheduler.js

@@ -826,6 +826,40 @@ async function watchGateProbe(createSchedulerService) {
   assert.strictEqual(repeatJob.status, "pending");
   assert.strictEqual(repeatJob.occurrenceId, "next-occ-1", "repeat watch advances to a new occurrence");
 
+  // Failing check with a FUTURE expiry → still the normal silent idle skip.
+  const pending = schedulerHarness(createSchedulerService, [watchJob({ id: "watch-pending", expiresAt: 1_720_000_100_000 })], {
+    runWatchCheck: async () => ({ code: 1, timedOut: false }),
+    outcomes: [successOutcome()],
+  });
+  const pendingResult = await pending.service.fireJob("watch-pending");
+  assert.strictEqual(pendingResult.status, "watch-idle");
+  assert.strictEqual(pending.runCalls.length, 0, "unexpired failing check stays silent");
+
+  // Failing check with a LAPSED expiry → fires anyway as an expiry wake-up:
+  // distinct header, advisory says timed out, removed even though repeat=true.
+  const expired = schedulerHarness(createSchedulerService, [watchJob({ id: "watch-expired", repeat: true, expiresAt: 1_720_000_000_000 })], {
+    runWatchCheck: async () => ({ code: 1, timedOut: false }),
+    outcomes: [successOutcome()],
+  });
+  const expiredResult = await expired.service.fireJob("watch-expired");
+  assert.strictEqual(expiredResult.ok, true);
+  assert.strictEqual(expiredResult.status, "succeeded");
+  assert.strictEqual(expired.runCalls.length, 1, "expired watch wakes the agent exactly once");
+  assert.match(expired.runCalls[0].prompt, /Watch expired/, "expiry fire carries the Watch expired header");
+  assert.match(expired.runCalls[0].prompt, /did NOT happen/, "expiry fire tells the agent the condition never came true");
+  assert.ok(expired.sends.some((text) => /timed out without triggering/.test(text)), "expiry advisory says it timed out");
+  assert.strictEqual(expired.jobsStore.get("watch-expired"), null, "expired watch is removed even when repeat was requested");
+
+  // Check that passes ON the expiry tick → a normal trigger, not an expiry.
+  const lastGasp = schedulerHarness(createSchedulerService, [watchJob({ id: "watch-lastgasp", expiresAt: 1_720_000_000_000 })], {
+    runWatchCheck: async () => ({ code: 0, timedOut: false }),
+    outcomes: [successOutcome()],
+  });
+  await lastGasp.service.fireJob("watch-lastgasp");
+  assert.strictEqual(lastGasp.runCalls.length, 1);
+  assert.match(lastGasp.runCalls[0].prompt, /Watch triggered/, "a passing check at the deadline is a real trigger");
+  assert.ok(!/Watch expired/.test(lastGasp.runCalls[0].prompt), "a passing check never reports as expired");
+
   // Global master switch OFF → skip before the check even runs.
   fs.writeFileSync(watchesEnabledFile, "off");
   let checkRan = false;
@@ -841,6 +875,45 @@ async function watchGateProbe(createSchedulerService) {
   fs.rmSync(watchesEnabledFile, { force: true });
 }
 
+function watchExpiryStampProbe(createSchedulerService, DEFAULT_WATCH_TIMEOUT_MS) {
+  assert.strictEqual(typeof DEFAULT_WATCH_TIMEOUT_MS, "number", "scheduler must export the default watch timeout");
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "alpha", dir: "/workspace/alpha" },
+    settings: { backend: "claude" },
+    activeSessions: { alpha: { claude: "thread-alpha" } },
+    providerSettings: { claude: {} },
+  };
+  const service = createSchedulerService({
+    jobsStore: memoryJobsStore([]),
+    currentState: () => state,
+    now: () => 1_720_000_000_500,
+    setTimer: () => ({}),
+    clearTimer: () => {},
+    scheduleCron: () => ({ stop() {} }),
+  });
+  const stamped = service.addWatch({
+    adapter: "telegram-fixture",
+    adapterType: "telegram",
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    check: "true",
+    prompt: "watch prompt",
+  });
+  assert.strictEqual(stamped.expiresAt, 1_720_000_000_500 + DEFAULT_WATCH_TIMEOUT_MS, "watch-add stamps the default expiry when none is given");
+  const explicit = service.addWatch({
+    adapter: "telegram-fixture",
+    adapterType: "telegram",
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    check: "true",
+    prompt: "watch prompt 2",
+    expiresAt: 1_720_000_999_999,
+  });
+  assert.strictEqual(explicit.expiresAt, 1_720_000_999_999, "an explicit --timeout expiry passes through unchanged");
+  service.stopAll();
+}
+
 function staticSchedulingProbe() {
   const files = [
     "core/jobs.js",
@@ -863,6 +936,12 @@ function staticSchedulingProbe() {
   assert.match(source["core/loopback.js"], /watch-add/, "loopback must route watch-add");
   assert.match(source["bin/schedule.js"], /runWatchAdd/, "schedule CLI must expose watch-add");
   assert.match(source["bin/cli.js"], /watch-add/, "cli must dispatch watch-add");
+
+  // Watch expiry must be wired end to end: default stamp → gate → CLI flag.
+  assert.match(source["core/scheduler.js"], /DEFAULT_WATCH_TIMEOUT_MS/, "scheduler must define the default watch timeout");
+  assert.match(source["core/scheduler.js"], /watchExpired/, "scheduler must mark expiry fires distinctly");
+  assert.match(source["core/loopback.js"], /expiresAt/, "loopback must pass the watch expiry through");
+  assert.match(source["bin/schedule.js"], /--timeout/, "watch-add CLI must expose --timeout");
 }
 
 async function main() {
@@ -884,6 +963,7 @@ async function main() {
   await unavailableAndFallbackProbe(schedulerApi.createSchedulerService);
   await cronOccurrenceProbe(schedulerApi.createSchedulerService);
   await watchGateProbe(schedulerApi.createSchedulerService);
+  watchExpiryStampProbe(schedulerApi.createSchedulerService, schedulerApi.DEFAULT_WATCH_TIMEOUT_MS);
   creationEnrichmentProbe(schedulerApi.createSchedulerService);
   loopbackMetadataProbe(require("./core/runner"), require("./bin/loopback-client"));
   staticSchedulingProbe();

package/test-utility-provider-policy.js

@@ -185,6 +185,28 @@ async function main() {
     "legacy Claude model aliases never leak into Codex",
   );
 
+  // v3.2.2: "dedup" (journal dedup adjudicator) used to be rejected outright
+  // with INVALID_UTILITY_PURPOSE, silently disabling the dedup gate on every
+  // memory review. It rides the review pipeline: MEMORY_PROVIDER steers it,
+  // PACK_DEDUP_MODEL is its legacy Claude model alias.
+  assert.ok(
+    createUtilityPolicy({ registry: allReady, env: { UTILITY_PROVIDER: "claude" } })
+      .resolve({ purpose: "dedup", tier: "low" }).providerId,
+    "dedup is a valid utility purpose",
+  );
+  assert.strictEqual(
+    createUtilityPolicy({ registry: allReady, env: { UTILITY_PROVIDER: "claude", MEMORY_PROVIDER: "codex" } })
+      .resolve({ purpose: "dedup", tier: "low" }).providerId,
+    "codex",
+    "dedup follows the review pipeline's MEMORY_PROVIDER override",
+  );
+  assert.strictEqual(
+    createUtilityPolicy({ registry: allReady, env: { UTILITY_PROVIDER: "claude", PACK_DEDUP_MODEL: "legacy-claude-dedup" } })
+      .resolve({ purpose: "dedup", tier: "low" }).model,
+    "legacy-claude-dedup",
+    "dedup honors its PACK_DEDUP_MODEL legacy alias",
+  );
+
   const fallbackRegistry = registry(map, {
     claude: { availability: { state: "missing", executable: null, reason: "fixture unavailable" } },
   });