@inetafrica/open-claudia 3.1.28 → 3.2.1

package/channels/kazee/call/session.js

@@ -55,12 +55,16 @@ 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,
+    maxCallMs, idleMs, synthesize = synthesizePcm, asCaller = false, greeting = null,
     JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
     this.roomId = Number(roomId);
     this.chatId = String(chatId);
     this.callerId = String(callerId);
     this.botUserId = String(botUserId);
+    this.asCaller = !!asCaller;
+    this.greeting = greeting ? String(greeting) : null;
+    this._greeted = false;
+    this._createdRoom = false;
     this.janus = new JanusClientImpl({ url: janusUrl });
     this.PeerConnectionImpl = PeerConnectionImpl;
     this.SpeechStreamImpl = SpeechStreamImpl;
@@ -97,6 +101,21 @@ class KazeeCallSession {
     await this.janus.connect();
     this.publisherHandle = await this.janus.attach();
     this.janus.onHandle(this.publisherHandle, (frame) => this._onPublisherEvent(frame));
+    if (this.asCaller) {
+      // Outbound: the caller side owns room lifecycle, mirroring the web
+      // client's create params (audio-only, so no videocodec).
+      const created = await this.janus.message(this.publisherHandle, {
+        request: "create", room: this.roomId, publishers: 6, audiocodec: "opus",
+        description: `Call room ${this.roomId}`, permanent: false,
+      });
+      const cdata = created?.plugindata?.data || {};
+      const exists = Number(cdata.error_code) === 427 || /already exists/i.test(String(cdata.error || ""));
+      if (cdata.videoroom !== "created" && !exists) {
+        throw new Error(cdata.error || "Janus room create failed");
+      }
+      this._createdRoom = true;
+      clog(`Kazee call room created: room=${this.roomId}`);
+    }
     // The caller creates the Janus room during its own call setup, which can
     // land a beat after the invite reaches us — and a bot answers faster than
     // any human. Poll join through transient 426 "No such room" like the web
@@ -163,31 +182,47 @@ class KazeeCallSession {
   }
 
   async _subscribe(feedId, display) {
+    if (this.subscribers.has(feedId)) return;
+    // Reserve the slot before the first await: the join response and the async
+    // publishers event both list the same feed, and while attach() is in
+    // flight the second frame passes the caller's has() check and subscribes
+    // this feed twice, orphaning a PeerConnection (diagnosed 2026-07-30).
+    this.subscribers.set(feedId, null);
     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,
-      display: String(display || ""),
-      // Opus decoders are stateful, so each feed needs its own.
-      codec: new OpusAudioCodec(),
-      vad: new TurnDetector({ thresholdDb: BASE_THRESHOLD_DB }),
-      stt: new this.SpeechStreamImpl({ onTranscript: (text) => this._onFeedTranscript(feedId, text) }),
-      prebuffer: [],
-    };
-    this.subscribers.set(feedId, sub);
-    pc.onTrack.subscribe((track) => {
-      if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onFeedRtp(feedId, packet));
-    });
-    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().then(
-      () => clog(`Kazee call STT connected: feed=${feedId}`),
-      (error) => console.error("Kazee call STT connect:", error.message),
-    );
+    try {
+      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,
+        display: String(display || ""),
+        // Opus decoders are stateful, so each feed needs its own.
+        codec: new OpusAudioCodec(),
+        vad: new TurnDetector({ thresholdDb: BASE_THRESHOLD_DB }),
+        stt: new this.SpeechStreamImpl({ onTranscript: (text) => this._onFeedTranscript(feedId, text) }),
+        prebuffer: [],
+      };
+      this.subscribers.set(feedId, sub);
+      pc.onTrack.subscribe((track) => {
+        if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onFeedRtp(feedId, packet));
+      });
+      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().then(
+        () => clog(`Kazee call STT connected: feed=${feedId}`),
+        (error) => console.error("Kazee call STT connect:", error.message),
+      );
+      // First remote feed up = both media legs established; greet exactly once.
+      if (this.greeting && !this._greeted) {
+        this._greeted = true;
+        this.speak(this.greeting).catch((error) => console.error("Kazee call greeting:", error.message));
+      }
+    } catch (error) {
+      if (this.subscribers.get(feedId) === null) this.subscribers.delete(feedId);
+      throw error;
+    }
   }
 
   async _onSubscriberEvent(feedId, frame) {
@@ -403,6 +438,9 @@ class KazeeCallSession {
     this._stopThinking();
     this.cancelSpeech();
     for (const feed of [...this.subscribers.keys()]) await this._removeSubscriber(feed);
+    if (this._createdRoom) {
+      try { await this.janus.message(this.publisherHandle, { request: "destroy", room: this.roomId }); } catch (_) {}
+    }
     try { await this.publisher?.pc?.close(); } catch (_) {}
     try { await this.janus.detach(this.publisherHandle); } catch (_) {}
     try { await this.janus.close(); } catch (_) {}

package/channels/kazee/socket.js

@@ -5,6 +5,8 @@ let io;
 try { io = require("socket.io-client").io; }
 catch (e) { io = null; }
 
+const { wireTerminalReconnect } = require("../../core/socket-reconnect");
+
 function createKazeeSocket({ url, token, userId, onConnect, onDisconnect, onError }) {
   if (!io) {
     throw new Error("socket.io-client is not installed. Run `npm install` to install dependencies.");
@@ -22,6 +24,7 @@ function createKazeeSocket({ url, token, userId, onConnect, onDisconnect, onErro
   socket.on("connect", () => { if (onConnect) onConnect(socket); });
   socket.on("disconnect", (reason) => { if (onDisconnect) onDisconnect(reason); });
   socket.on("connect_error", (err) => { if (onError) onError(err); });
+  wireTerminalReconnect(socket, { label: `kazee socket (${url})` });
   return socket;
 }
 

package/channels/spaces/socket.js

@@ -14,6 +14,8 @@ let io;
 try { io = require("socket.io-client").io; }
 catch (e) { io = null; }
 
+const { wireTerminalReconnect } = require("../../core/socket-reconnect");
+
 function createSpacesSocket({ url, token, onNotification, onConnect, onDisconnect, onError }) {
   if (!io) {
     throw new Error("socket.io-client is not installed. Run `npm install` to install dependencies.");
@@ -34,6 +36,7 @@ function createSpacesSocket({ url, token, onNotification, onConnect, onDisconnec
       catch (e) { console.error("spaces notification handler:", e.message); }
     }
   });
+  wireTerminalReconnect(socket, { label: `spaces socket (${url})` });
   return socket;
 }
 

package/channels/telegram/adapter.js

@@ -672,11 +672,15 @@ class TelegramAdapter {
     if (!media || !media.fileId) return null;
     const file = await this.bot.getFile(media.fileId);
     const fileUrl = `https://api.telegram.org/file/bot${this.token}/${file.file_path}`;
-    const ext = media.fileName ? path.extname(media.fileName) || ".bin"
-      : media.type === "voice" ? ".ogg"
-      : media.type === "audio" ? path.extname(media.fileName || "") || ".ogg"
-      : media.type === "photo" ? ".jpg"
-      : ".bin";
+    // Telegram's file_path carries the real extension even when the message
+    // has no fileName (e.g. videos), so prefer it over the .bin fallback.
+    const ext = path.extname(media.fileName || "")
+      || path.extname(file.file_path || "")
+      || (media.type === "voice" ? ".ogg"
+        : media.type === "audio" ? ".ogg"
+        : media.type === "photo" ? ".jpg"
+        : media.type === "video" ? ".mp4"
+        : ".bin");
     const baseDir = media.type === "document" ? FILES_DIR : TEMP_DIR;
     const localPath = media.type === "document" && media.fileName
       ? path.join(baseDir, media.fileName)

package/core/apprenticeship.js

@@ -0,0 +1,104 @@
+"use strict";
+
+// C4: apprenticeship radar. A deterministic 7-day scan of the project
+// transcripts for repeated manual work — the same ad-hoc command re-derived by
+// the agent, or the owner asking for the same thing again and again. The scan
+// only gathers EVIDENCE; the dream's introspection pass turns it into at most
+// two /learn CANDIDATES in its report. Report-only end to end: /learn remains
+// the owner-triggered capture, and nothing here creates a pack or tool.
+
+const fs = require("fs");
+const path = require("path");
+const { TRANSCRIPTS_DIR } = require("./config");
+
+const WINDOW_DAYS = 7;
+const MIN_REPEATS = 3;
+const MIN_DAYS = 2;
+const MAX_CANDIDATES = 2;
+const MIN_COMMAND_CHARS = 12;
+const MIN_REQUEST_CHARS = 16;
+const MAX_REQUEST_CHARS = 200;
+
+function normalize(s) {
+  return String(s || "").replace(/\s+/g, " ").trim();
+}
+
+// Commands the assistant quoted in a turn: inline code spans plus "$ "-prefixed
+// lines. The bot's own bookkeeping CLI is excluded — /learn-ing `open-claudia
+// task list` would be circular.
+function commandsIn(text) {
+  const out = [];
+  const t = String(text || "");
+  for (const m of t.matchAll(/`([^`\n]{4,160})`/g)) out.push(m[1]);
+  for (const m of t.matchAll(/^\s*\$\s+(.{4,160})$/gm)) out.push(m[1]);
+  return out
+    .map(normalize)
+    .filter((c) => c.length >= MIN_COMMAND_CHARS)
+    .filter((c) => !c.startsWith("open-claudia "))
+    .filter((c) => /^[a-zA-Z_./~]/.test(c) && /\s/.test(c)); // looks like an invocation, not a bare word or path
+}
+
+function scanForApprenticeship({
+  now = Date.now(), days = WINDOW_DAYS, dir = TRANSCRIPTS_DIR,
+  minRepeats = MIN_REPEATS, minDays = MIN_DAYS, max = MAX_CANDIDATES,
+} = {}) {
+  let files;
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl")); }
+  catch (e) { return []; }
+  const from = now - days * 86400000;
+  const tally = new Map(); // key → {kind, sample, count, days:Set, files:Set, lastAt}
+  const bump = (kind, sample, day, file, at) => {
+    const key = `${kind}:${sample.toLowerCase()}`;
+    const e = tally.get(key) || { kind, sample, count: 0, days: new Set(), files: new Set(), lastAt: "" };
+    e.count += 1;
+    e.days.add(day);
+    e.files.add(file);
+    if (at > e.lastAt) { e.lastAt = at; e.sample = sample; }
+    tally.set(key, e);
+  };
+  for (const f of files) {
+    let raw;
+    try { raw = fs.readFileSync(path.join(dir, f), "utf-8"); } catch (e) { continue; }
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let rec;
+      try { rec = JSON.parse(line); } catch (e) { continue; }
+      const t = Date.parse(rec.timestamp || "");
+      if (!Number.isFinite(t) || t < from || t > now) continue;
+      const day = new Date(t).toISOString().slice(0, 10);
+      if (rec.role === "assistant") {
+        for (const cmd of new Set(commandsIn(rec.text))) bump("command", cmd, day, f, rec.timestamp);
+      } else if (rec.role === "user") {
+        const req = normalize(rec.text);
+        if (req.length >= MIN_REQUEST_CHARS && req.length <= MAX_REQUEST_CHARS && !req.startsWith("/")) {
+          bump("request", req, day, f, rec.timestamp);
+        }
+      }
+    }
+  }
+  return [...tally.values()]
+    .filter((e) => e.count >= minRepeats && e.days.size >= minDays)
+    .sort((a, b) => b.count - a.count || b.days.size - a.days.size)
+    .slice(0, max)
+    .map((e) => ({ kind: e.kind, sample: e.sample, count: e.count, days: e.days.size, sessions: e.files.size }));
+}
+
+// Prompt block for the dream's introspection pass. Empty string when nothing
+// repeated — the section only exists when there is evidence (no standing cost).
+function radarSection(opts = {}) {
+  const found = scanForApprenticeship(opts);
+  if (!found.length) return "";
+  const lines = found.map((c) =>
+    `- [${c.kind}] ${c.kind === "command" ? `\`${c.sample}\`` : `"${c.sample}"`} — ${c.count}× across ${c.days} day${c.days === 1 ? "" : "s"} (${c.sessions} session${c.sessions === 1 ? "" : "s"})`);
+  return [
+    "═══ APPRENTICESHIP RADAR (deterministic scan of the last 7 days of transcripts) ═══",
+    "Repeated manual work — the same thing re-derived by hand instead of taught once:",
+    ...lines,
+    `In your report, offer at most ${MAX_CANDIDATES} of these as /learn candidates ("want to teach me this properly? say /learn after we next do it"), citing the counts above as evidence. Report-only: /learn stays owner-triggered — NEVER capture a pack, tool, or lesson from this radar yourself.`,
+  ].join("\n");
+}
+
+module.exports = {
+  WINDOW_DAYS, MIN_REPEATS, MIN_DAYS, MAX_CANDIDATES,
+  commandsIn, scanForApprenticeship, radarSection,
+};

package/core/approvals.js

@@ -231,6 +231,43 @@ function consume(id, commandLine) {
   } finally { releaseRecordLock(held); }
 }
 
+// Read-side for the reviewer's denied-approval mining (C5): recent decided
+// records, newest first. The ledger itself is already persisted per-record —
+// this only lists it.
+function listDecided({ withinMs = MAX_AGE_MS, statuses = ["denied", "approved"] } = {}) {
+  let entries;
+  try { entries = fs.readdirSync(APPROVALS_DIR); } catch (e) { return []; }
+  const wanted = new Set(statuses);
+  const cutoff = Date.now() - withinMs;
+  const out = [];
+  for (const f of entries) {
+    if (!f.endsWith(".json")) continue;
+    let rec;
+    try { rec = JSON.parse(fs.readFileSync(path.join(APPROVALS_DIR, f), "utf-8")); } catch (e) { continue; }
+    if (!rec || !wanted.has(rec.status)) continue;
+    const decidedAt = Date.parse(rec.decidedAt || "");
+    if (!Number.isFinite(decidedAt) || decidedAt < cutoff) continue;
+    out.push(rec);
+  }
+  return out.sort((a, b) => Date.parse(b.decidedAt) - Date.parse(a.decidedAt));
+}
+
+// Stamp records the reviewer has already been shown, so each deny is fed to
+// the correction-detector exactly once.
+function markMined(ids) {
+  for (const id of ids || []) {
+    const held = acquireRecordLock(id);
+    if (!held) continue;
+    try {
+      const rec = read(id);
+      if (rec && !rec.minedAt) {
+        rec.minedAt = new Date().toISOString();
+        writeRecord(rec);
+      }
+    } finally { releaseRecordLock(held); }
+  }
+}
+
 module.exports = {
   APPROVALS_DIR,
   MAX_COMMAND_BYTES,
@@ -240,6 +277,8 @@ module.exports = {
   decide,
   detach,
   formatApprovedCommand,
+  listDecided,
+  markMined,
   read,
   waitForDecision,
 };

package/core/cost-report.js

@@ -0,0 +1,140 @@
+"use strict";
+
+// C6: cost self-report. Aggregates the existing per-turn usage-history.jsonl
+// (ts, project, provider/model, token parts, costUsd) into a rolling 7-day
+// section for the dream summary: total spend + tokens, top burns by project,
+// week-over-week delta, and ONE concrete suggested cut picked by
+// deterministic heuristics. Pure arithmetic — no model call, no new logging
+// surface, nothing recorded at turn time beyond what already exists.
+
+const usageLog = require("./usage-log");
+
+const WINDOW_DAYS = 7;
+// Heuristic thresholds (exported for tests): concentration of spend in one
+// project, poor cache-hit ratio on a meaningful token volume, oversized
+// average context.
+const CONCENTRATION_SHARE = 0.6;
+const CONCENTRATION_MIN_USD = 1;
+const CACHE_RATIO_FLOOR = 0.5;
+const CACHE_MIN_INPUT_TOKENS = 1_000_000;
+const CONTEXT_AVG_CEILING = 120_000;
+
+function fmtTokens(n) {
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${Math.round(n / 1_000)}k`;
+  return String(n);
+}
+
+function inWindow(ts, from, to) {
+  const t = Date.parse(ts);
+  return Number.isFinite(t) && t >= from && t < to;
+}
+
+function aggregate(records) {
+  const agg = {
+    turns: 0, costUsd: 0, inputTokens: 0, outputTokens: 0,
+    cacheReadTokens: 0, contextTokenSum: 0, contextTurns: 0,
+    byProject: new Map(),
+  };
+  for (const r of records) {
+    agg.turns += 1;
+    const cost = Number(r.costUsd) || 0;
+    agg.costUsd += cost;
+    // session_total records carry cumulative token snapshots — counting them
+    // as a turn's tokens would double-bill. Their per-turn cost still counts.
+    if (r.usageScope !== "session_total") {
+      agg.inputTokens += Number(r.inputTokens) || 0;
+      agg.outputTokens += Number(r.outputTokens) || 0;
+      agg.cacheReadTokens += Number(r.cacheReadTokens) || 0;
+      const ctx = Number(r.billedContextTokens ?? r.contextTokens) || 0;
+      if (ctx > 0) { agg.contextTokenSum += ctx; agg.contextTurns += 1; }
+    }
+    const key = String(r.project || "(no project)");
+    const p = agg.byProject.get(key) || { costUsd: 0, turns: 0 };
+    p.costUsd += cost;
+    p.turns += 1;
+    agg.byProject.set(key, p);
+  }
+  return agg;
+}
+
+function topBurns(agg, n = 3) {
+  return [...agg.byProject.entries()]
+    .map(([project, v]) => ({ project, costUsd: v.costUsd, turns: v.turns }))
+    .sort((a, b) => b.costUsd - a.costUsd)
+    .slice(0, n);
+}
+
+// ONE concrete cut, first matching heuristic. Deterministic on purpose — a
+// suggestion the owner can check against the numbers shown next to it.
+function suggestCut(agg, burns) {
+  const top = burns[0];
+  if (top && agg.costUsd > 0 && top.costUsd / agg.costUsd > CONCENTRATION_SHARE && top.costUsd >= CONCENTRATION_MIN_USD) {
+    return `${Math.round((top.costUsd / agg.costUsd) * 100)}% of spend is "${top.project}" — review that channel's model tier and recall engine first.`;
+  }
+  const cacheDenom = agg.cacheReadTokens + agg.inputTokens;
+  if (cacheDenom >= CACHE_MIN_INPUT_TOKENS && agg.cacheReadTokens / cacheDenom < CACHE_RATIO_FLOOR) {
+    return `cache hit ratio is only ${Math.round((agg.cacheReadTokens / cacheDenom) * 100)}% — an unstable prompt head or long gaps between turns are re-billing the prefix; keeping the always-on head stable would cut input cost.`;
+  }
+  const avgCtx = agg.contextTurns ? Math.round(agg.contextTokenSum / agg.contextTurns) : 0;
+  if (avgCtx > CONTEXT_AVG_CEILING) {
+    return `average billed context is ${fmtTokens(avgCtx)} tokens/turn — earlier compaction or fewer injected packs would trim every turn.`;
+  }
+  return null;
+}
+
+function weeklyReport({ now = Date.now(), days = WINDOW_DAYS, history } = {}) {
+  const records = history || usageLog.loadUsageHistory();
+  const from = now - days * 86400000;
+  const prevFrom = from - days * 86400000;
+  const current = aggregate(records.filter((r) => inWindow(r.ts, from, now)));
+  const previous = aggregate(records.filter((r) => inWindow(r.ts, prevFrom, from)));
+  const burns = topBurns(current);
+  return {
+    days,
+    turns: current.turns,
+    costUsd: Math.round(current.costUsd * 100) / 100,
+    inputTokens: current.inputTokens,
+    outputTokens: current.outputTokens,
+    cacheReadTokens: current.cacheReadTokens,
+    cacheHitRatio: (current.cacheReadTokens + current.inputTokens) > 0
+      ? current.cacheReadTokens / (current.cacheReadTokens + current.inputTokens)
+      : null,
+    prevCostUsd: Math.round(previous.costUsd * 100) / 100,
+    deltaPct: previous.costUsd > 0 ? Math.round(((current.costUsd - previous.costUsd) / previous.costUsd) * 100) : null,
+    topBurns: burns,
+    suggestedCut: suggestCut(current, burns),
+  };
+}
+
+// Dream entry point: returns announce lines (empty when there is no usage in
+// the window — silence over noise).
+function reportLines(opts = {}) {
+  const r = weeklyReport(opts);
+  if (r.turns === 0) return { report: r, lines: [] };
+  const deltaTxt = r.deltaPct === null ? "" : ` · ${r.deltaPct >= 0 ? "+" : ""}${r.deltaPct}% vs prior week`;
+  const cacheTxt = r.cacheHitRatio === null ? "" : ` (cache ${Math.round(r.cacheHitRatio * 100)}%)`;
+  const burnsTxt = r.topBurns.length
+    ? ` Top: ${r.topBurns.map((b) => `${b.project} $${b.costUsd.toFixed(2)}`).join(" · ")}.`
+    : "";
+  const lines = [
+    `💸 Cost, last ${r.days}d: $${r.costUsd.toFixed(2)} · ${r.turns} turn${r.turns === 1 ? "" : "s"} · ${fmtTokens(r.inputTokens)} in / ${fmtTokens(r.outputTokens)} out${cacheTxt}${deltaTxt}.${burnsTxt}`,
+  ];
+  if (r.suggestedCut) lines.push(`💡 Cut: ${r.suggestedCut}`);
+  return { report: r, lines };
+}
+
+module.exports = {
+  WINDOW_DAYS,
+  CONCENTRATION_SHARE,
+  CONCENTRATION_MIN_USD,
+  CACHE_RATIO_FLOOR,
+  CACHE_MIN_INPUT_TOKENS,
+  CONTEXT_AVG_CEILING,
+  aggregate,
+  topBurns,
+  suggestCut,
+  weeklyReport,
+  reportLines,
+};