@inetafrica/open-claudia 3.0.0 → 3.0.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v3.0.2 — honest context numbers, dream summaries that arrive
+
+- **The context warning counts the window again, not the bill.** The v3.0.0 provider rewrite computed the live context number from the provider's *cumulative* turn usage — every tool round-trip re-counted the cached prompt prefix, so a normal turn read as 347k+ "context" (crossing 1M on busy turns), spooked the usage alert, and could prematurely force-compact sessions whose real window was fine. The number now tracks the **peak single API call** in the turn (`peakContextTokens` over per-call usage events) — true window occupancy, the same semantics v2 reported (~160k on a heavy turn). Billing is untouched: ledger records keep the cumulative figure in `billedContextTokens`, and API-reported spend was never affected (v3 bills the same or less than v2 — the display was wrong, not the meter). The usage alert says "Context this turn" whenever the peak is available.
+- **Nightly dream summaries reach the chat again.** Dreams ran every night at 04:00 — and for over a week every summary died with Telegram's `400: message is too long` (the report outgrew the 4,096-char hard cap and the adapter had no chunking), so consolidation happened invisibly. Two fixes: the Telegram adapter now splits any oversized message on paragraph → line → word boundaries and sends the chunks in order (reply anchor on the first, buttons on the last, per-chunk HTML→plain fallback preserved), and the dream's tool-health note caps long lists (unused tools, drifted docs) to a short digest in chat while the full lists still land in the on-disk dream log (`~/.open-claudia/dreams/<date>.md`).
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. New hermetic assertions: peak-vs-cumulative derivation in `test-usage-accounting.js`, chunk-size and content-preservation in `test-delivery-contract.js`.
+
+## v3.0.1 — streaming restored, /stop queue survival, boot resilience
+
+- **Live streaming is back, and the final message stays clean.** The v3.0.0 provider rewrite dropped the in-chat streaming feel: no live progress while a run worked, and the settled reply concatenated every text block into one blob. Now an active run edits a throttled preview message in place with the agent's narration (and its thinking, when `/verbose` is on — new command + button toggle), and when the run settles only the **last** text segment is delivered as the final answer; earlier pre-tool text is preserved as narration instead of being glued onto the reply. Providers emit a normalized `thinking` event (Claude thinking blocks, Codex reasoning items) that feeds the preview but can never leak into settled output. On success the preview becomes the narration record (or is deleted when there was none); on failure or cancel the partial preview is kept so you can see how far the run got. Preview edits are channel-guarded, so a bubble minted on one channel is never edited from another.
+- **`/stop` no longer throws away your queued messages.** Cancelling killed the current turn *and* silently emptied the message queue — every turn you'd typed behind the running one vanished. `/stop` now cancels only the current turn (including a pre-spawn abort checkpoint for runs still building their prompt), keeps the queue intact, and tells you how many queued messages will run next. Cancelled runs unwind quietly instead of delivering an error-shaped reply.
+- **The Codex model menu now offers the GPT-5.6 generation.** The retired `gpt-5.1-codex` trio is replaced by `gpt-5.6-sol` / `gpt-5.6-terra` / `gpt-5.6-luna`; effort tiers map low→luna and medium→terra so utility work stays cheap, with sol as the default.
+- **One 409 doesn't kill the bot anymore.** A single Telegram 409 Conflict (another poller on the same token — usually a ghost poll from a restarting predecessor) used to `exit(1)` immediately, which is how one stray poll became a restart storm. The poller now rides out a conflict streak: pause 15s and retry, clear the streak after 45s of quiet, and only exit if the conflict persists beyond 2 minutes (a real second instance). The watchdog defers restarts during a streak.
+- **A single-instance lock refuses double-boots.** Boot now claims `bot.lock` in the config dir (pid, start time, entrypoint); a second bot pointed at the same config refuses to start while the holder is alive, claims a stale or corrupt lock safely, and release never deletes a successor's lock. Combined with the 409 grace this makes accidental duplicate launches self-identifying and harmless.
+- **Startup polling stalls recover on their own.** A Telegram long-poll that went silent right after boot (dead socket, no error) is now detected and restarted instead of leaving a deaf bot.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. New hermetic tests (`test-streaming-split.js`, `test-telegram-409-grace.js`, `test-single-instance.js`, `test-telegram-poll-recovery.js`) wired into `npm test`; CI test commands now carry the fake-agent env explicitly so the suite is hermetic on runners with no provider CLIs.
+
 ## v3.0.0 — provider parity and Cursor removal
 
 - **The runtime is now a provider-agnostic coding-agent harness.** Claude Code and OpenAI Codex implement one registry contract for prompts, immutable run admission, normalized events, native sessions, capability reporting, utility work, and pre-tool safety policy. Setup, web configuration, status, and doctor work with either, both, or neither provider installed; only model turns require a compatible authenticated provider.

package/bot.js

@@ -16,6 +16,21 @@ const {
   ensureRuntimeDirectories,
 } = require("./core/config");
 ensureRuntimeDirectories();
+
+// Refuse to double-boot: a second process on this CONFIG_DIR shares the same
+// channel tokens and 409-wars the running service (see core/single-instance).
+const { acquireSingleInstanceLock } = require("./core/single-instance");
+const instanceLock = acquireSingleInstanceLock({ configDir: CONFIG_DIR });
+if (!instanceLock.acquired) {
+  const h = instanceLock.holder;
+  console.error(
+    `Another Open Claudia instance already owns ${CONFIG_DIR} ` +
+    `(pid ${h.pid}, started ${h.startedAt || "?"}, ${h.entrypoint || "unknown entrypoint"}). Exiting. ` +
+    "Stop it first (launchctl stop com.claude-telegram-bot), or give a dev run its own OPEN_CLAUDIA_CONFIG_DIR."
+  );
+  process.exit(1);
+}
+
 const { defaultMigrationSources, ensureMigrationSnapshot } = require("./core/migration-backup");
 const migrationSources = defaultMigrationSources({
   configDir: CONFIG_DIR,

package/channels/telegram/adapter.js

@@ -10,7 +10,7 @@ const TelegramBot = require("node-telegram-bot-api");
 const { TEMP_DIR, FILES_DIR, CONFIG_DIR } = require("../../core/config");
 const { canonicalForChannel } = require("../../core/identity");
 const { portableToInlineKeyboard } = require("../types");
-const { telegramHtml, htmlToPlain } = require("./format");
+const { telegramHtml, htmlToPlain, splitMessage } = require("./format");
 
 class TelegramAdapter {
   constructor({ id = "telegram", token, ownerChatId, chatIds }) {
@@ -36,6 +36,11 @@ class TelegramAdapter {
     this._wedgedSince = 0;       // start of the current unrecovered error streak
     this._lastHiccupLog = 0;     // throttle the transient-error log (1/min)
     this._healBackoff = 0;       // grows per consecutive heal, capped
+    this._pollWatchdogTimer = null; // detects a silent first/active getUpdates stall
+    this._pollStartedAt = 0;
+    this._conflictSince = 0;         // start of the current 409 streak
+    this._conflictTimer = null;      // pending paused retry after a 409
+    this._conflictClearTimer = null; // quiet after a retry ⇒ streak over
     this._wireInbound();
   }
 
@@ -53,12 +58,33 @@ class TelegramAdapter {
   }
 
   async start() {
-    await this.bot.startPolling();
+    // node-telegram-bot-api resolves startPolling() only after the current
+    // getUpdates request settles. Awaiting it can therefore pin the entire bot
+    // boot sequence behind a half-open first poll. Start the loop, return so the
+    // remaining adapters can boot, and let the independent watchdog recover a
+    // poll that never completes and emits no polling_error.
+    this._pollStartedAt = Date.now();
+    Promise.resolve(this.bot.startPolling()).catch((error) => {
+      this._onPollingHiccup(error?.message || "Telegram polling failed to start");
+    });
+    if (!this._pollWatchdogTimer) {
+      this._pollWatchdogTimer = setInterval(() => this._checkPollingHealth(), 15000);
+    }
+  }
+
+  _checkPollingHealth() {
+    if (this._conflictTimer || this._conflictSince) return; // 409 backoff owns recovery
+    const lastCompletedPoll = this.bot?._polling?._lastUpdate || this._pollStartedAt;
+    if (!lastCompletedPoll || Date.now() - lastCompletedPoll <= 75000) return;
+    this._onPollingHiccup("poll watchdog: no completed getUpdates request in 75s");
   }
 
   async stop() {
+    if (this._pollWatchdogTimer) { clearInterval(this._pollWatchdogTimer); this._pollWatchdogTimer = null; }
     if (this._healTimer) { clearTimeout(this._healTimer); this._healTimer = null; }
     if (this._healthyTimer) { clearTimeout(this._healthyTimer); this._healthyTimer = null; }
+    if (this._conflictTimer) { clearTimeout(this._conflictTimer); this._conflictTimer = null; }
+    if (this._conflictClearTimer) { clearTimeout(this._conflictClearTimer); this._conflictClearTimer = null; }
     try { await this.bot.stopPolling(); } catch (e) {}
   }
 
@@ -116,13 +142,42 @@ class TelegramAdapter {
     }, 30000);
   }
 
+  // Telegram 409s a getUpdates call while ANOTHER one holds the token. Two
+  // causes: a ghost long-poll left by an uncleanly-killed predecessor (clears
+  // within its ≤30s poll timeout), or a genuinely running second instance.
+  // Exiting on the first 409 turned the ghost case into a KeepAlive respawn
+  // storm (7 boot→409→die cycles on 2026-07-12). So: pause, retry inside a
+  // grace window, and exit only if the conflict outlives it — that really is
+  // a second instance, and the supervisor's throttled respawns pace the rest.
+  _on409Conflict() {
+    const now = Date.now();
+    if (!this._conflictSince) this._conflictSince = now;
+    if (this._conflictClearTimer) { clearTimeout(this._conflictClearTimer); this._conflictClearTimer = null; }
+    if (now - this._conflictSince > 120000) {
+      console.error("Another instance is polling (409 persisted >2min). Exiting.");
+      process.exit(1);
+    }
+    if (this._conflictTimer) return; // a paused retry is already queued
+    console.error("409 Conflict: another poller holds this token — pausing 15s (ghost polls clear in <1min; exiting only if this persists >2min).");
+    // Stop hammering now; the timer below dials back in.
+    Promise.resolve(this.bot.stopPolling({ cancel: true, reason: "409 conflict backoff" })).catch(() => {});
+    this._conflictTimer = setTimeout(async () => {
+      this._conflictTimer = null;
+      try { await this.bot.startPolling(); } catch (e) {}
+      // No further 409 for 45s ⇒ the other poller is gone; end the streak.
+      this._conflictClearTimer = setTimeout(() => {
+        this._conflictClearTimer = null;
+        this._conflictSince = 0;
+      }, 45000);
+    }, 15000);
+  }
+
   _wireInbound() {
     this.bot.on("polling_error", (err) => {
       const msg = err.message || "";
       if (msg.includes("409 Conflict")) {
-        // Two pollers can't share one token — this one must bow out.
-        console.error("Another instance is polling. Exiting.");
-        process.exit(1);
+        this._on409Conflict();
+        return;
       }
       if (/ETIMEDOUT|ECONNRESET|ENOTFOUND|ENETUNREACH|EAI_AGAIN|EFATAL|socket hang up/i.test(msg)) {
         this._onPollingHiccup(msg); // transient — heal quietly, never exit
@@ -261,13 +316,23 @@ class TelegramAdapter {
   }
 
   async send(channelId, text, opts = {}) {
-    const o = {};
-    let body = opts.parseMode === "HTML" ? telegramHtml(text) : text;
-    if (opts.parseMode) o.parse_mode = opts.parseMode;
+    const body = opts.parseMode === "HTML" ? telegramHtml(text) : text;
     const kb = this._normalizeKeyboard(opts.keyboard);
-    if (kb) o.reply_markup = kb;
-    if (opts.replyTo) o.reply_to_message_id = opts.replyTo;
+    const chunks = splitMessage(body);
+    let lastId = null;
+    for (let i = 0; i < chunks.length; i++) {
+      const o = {};
+      if (opts.parseMode) o.parse_mode = opts.parseMode;
+      // Reply anchor goes on the first chunk; buttons belong on the last.
+      if (opts.replyTo && i === 0) o.reply_to_message_id = opts.replyTo;
+      if (kb && i === chunks.length - 1) o.reply_markup = kb;
+      const id = await this._sendChunk(channelId, chunks[i], o, opts);
+      if (id !== null) lastId = id;
+    }
+    return lastId;
+  }
 
+  async _sendChunk(channelId, body, o, opts = {}) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
         const msg = await this.bot.sendMessage(channelId, body, o);

package/channels/telegram/format.js

@@ -139,4 +139,26 @@ function htmlToPlain(html) {
     .replace(/&/g, "&");
 }
 
-module.exports = { escapeHtml, stripMarkdown, telegramHtml, htmlToPlain };
+// Telegram rejects messages over 4096 chars outright ("message is too long"),
+// which silently killed long sends like the nightly dream summary. Split on
+// paragraph > line > word boundaries, with margin for entity accounting.
+function splitMessage(text, limit = 4000) {
+  const body = String(text ?? "");
+  if (body.length <= limit) return [body];
+  const chunks = [];
+  let rest = body;
+  while (rest.length > limit) {
+    const window = rest.slice(0, limit);
+    let cut = window.lastIndexOf("\n\n");
+    if (cut < limit * 0.5) cut = window.lastIndexOf("\n");
+    if (cut < limit * 0.5) cut = window.lastIndexOf(" ");
+    if (cut <= 0) cut = limit;
+    const chunk = rest.slice(0, cut).trimEnd();
+    if (chunk) chunks.push(chunk);
+    rest = rest.slice(cut).replace(/^\s+/, "");
+  }
+  if (rest) chunks.push(rest);
+  return chunks.length ? chunks : [""];
+}
+
+module.exports = { escapeHtml, stripMarkdown, telegramHtml, htmlToPlain, splitMessage };

package/core/actions.js

@@ -516,6 +516,12 @@ async function handleAction(envelope) {
     await send(`Tool trace: ${state.settings.showToolTrace ? "on" : "off"}`);
     return;
   }
+  if (d.startsWith("vb:")) {
+    state.settings.showThinking = d.slice(3) === "on";
+    saveState();
+    await send(`Verbose thinking: ${state.settings.showThinking ? "on" : "off"}`);
+    return;
+  }
   if (d.startsWith("cw:")) {
     const v = d.slice(3);
     if (v === "default") state.settings.compactWindow = null;

package/core/dream.js

@@ -1246,17 +1246,29 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
     // Read-only toward the tools themselves — a tool is never auto-deleted (that's
     // destructive); we just surface the breakage for the user to re-link or remove.
     let toolNote = "";
+    let toolNoteFull = "";
     try {
       const toolsLib = require("./tools");
       const tg = require("./tool-graph").tend(toolsLib, { packsLib: packs });
+      // Two variants: `bits` keeps full lists for the on-disk dream log;
+      // `chatBits` caps the long ones so the chat digest stays readable.
       const bits = [];
+      const chatBits = [];
+      const push = (full, chat = full) => { bits.push(full); chatBits.push(chat); };
+      const capList = (items, sep = ", ", max = 5) => (items.length <= max
+        ? items.join(sep)
+        : `${items.slice(0, max).join(sep)} …and ${items.length - max} more (full list in the dream log)`);
       if (tg.edges || tg.decayed || tg.pruned) {
-        bits.push(`🔧 Tool graph: ${tg.edges} edges / ${tg.nodes} nodes (decayed ${tg.decayed}, pruned ${tg.pruned}).`);
+        push(`🔧 Tool graph: ${tg.edges} edges / ${tg.nodes} nodes (decayed ${tg.decayed}, pruned ${tg.pruned}).`);
       }
       const allTools = toolsLib.listTools();
       const dangling = allTools.filter((t) => t.pack && !packs.readPack(t.pack));
       if (dangling.length) {
-        bits.push(`🔗 ${dangling.length} tool(s) link a missing skill pack: ${dangling.map((t) => `${t.name}→${t.pack}`).join(", ")} — re-link with --pack or remove.`);
+        const names = dangling.map((t) => `${t.name}→${t.pack}`);
+        push(
+          `🔗 ${dangling.length} tool(s) link a missing skill pack: ${names.join(", ")} — re-link with --pack or remove.`,
+          `🔗 ${dangling.length} tool(s) link a missing skill pack: ${capList(names)} — re-link with --pack or remove.`,
+        );
       }
       // Zero-run tools: created but never run and gone cold. Telemetry runCount
       // is authoritative; createdAt measures "how long since it was made" (a body
@@ -1271,7 +1283,11 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
         try { return fs.statSync(t.file).mtimeMs < cutoff; } catch (e) { return false; }
       });
       if (coldUnused.length) {
-        bits.push(`🗃️ ${coldUnused.length} tool(s) created but never run in ${STALE_DAYS}+ days: ${coldUnused.map((t) => t.name).join(", ")} — keep, fold into another, or remove.`);
+        const names = coldUnused.map((t) => t.name);
+        push(
+          `🗃️ ${coldUnused.length} tool(s) created but never run in ${STALE_DAYS}+ days: ${names.join(", ")} — keep, fold into another, or remove.`,
+          `🗃️ ${coldUnused.length} tool(s) created but never run in ${STALE_DAYS}+ days: ${capList(names)} — keep, fold into another, or remove.`,
+        );
       }
       // Near-duplicate pairs: two tools whose name+description overlap strongly,
       // a sign one should have been a subcommand of the other. Dedupe by sorted
@@ -1284,7 +1300,11 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
         for (const m of near) dupPairs.add([t.name, m.name].sort().join(" ↔ "));
       }
       if (dupPairs.size) {
-        bits.push(`👯 ${dupPairs.size} near-duplicate tool pair(s): ${[...dupPairs].join(", ")} — consider merging into one tool with subcommands.`);
+        const pairs = [...dupPairs];
+        push(
+          `👯 ${pairs.length} near-duplicate tool pair(s): ${pairs.join(", ")} — consider merging into one tool with subcommands.`,
+          `👯 ${pairs.length} near-duplicate tool pair(s): ${capList(pairs)} — consider merging into one tool with subcommands.`,
+        );
       }
       // Doc/code drift: source edited after TOOL.md, or verbs in real use that
       // the docs never mention. Flag only — the fix is a tool note.
@@ -1292,7 +1312,10 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
         .map((t) => { const d = toolsLib.docDrift(t); return d ? `${t.name} (${d})` : null; })
         .filter(Boolean);
       if (drifted.length) {
-        bits.push(`📝 ${drifted.length} tool(s) with doc/code drift: ${drifted.join("; ")} — refresh the docs with tool note.`);
+        push(
+          `📝 ${drifted.length} tool(s) with doc/code drift: ${drifted.join("; ")} — refresh the docs with tool note.`,
+          `📝 ${drifted.length} tool(s) with doc/code drift: ${capList(drifted, "; ")} — refresh the docs with tool note.`,
+        );
       }
       // 5c usage KPI: what fraction of operational actions went through the
       // authorised channel, computed from telemetry stamps (state.json run
@@ -1319,10 +1342,11 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
           }
           if (g.denies.length) kpiBits.push(`${g.denies.length} denied by the gate`);
           if (r.failures) kpiBits.push(`${r.failures} failed run(s) at use: ${r.failedTools.join(", ")}`);
-          bits.push(`📈 Tool usage since last dream: ${kpiBits.join(" · ")}.`);
+          push(`📈 Tool usage since last dream: ${kpiBits.join(" · ")}.`);
         }
       } catch (e) { /* KPI is best-effort */ }
-      toolNote = bits.join("\n");
+      toolNoteFull = bits.join("\n");
+      toolNote = chatBits.join("\n");
     } catch (e) { /* tool graph is best-effort (old node) */ }
 
     const staleNote = staleTaskReport();
@@ -1396,7 +1420,7 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
       trigger,
       consolidation: { report: decision.report, lines: consolidationLines },
       introspection: { report: introReport, lines: introApplied, proposed: introProposed },
-      healthNote, graphNote, episodicNote, toolNote, staleNote, backupRoot,
+      healthNote, graphNote, episodicNote, toolNote: toolNoteFull || toolNote, staleNote, backupRoot,
     });
 
     // Richer chat summary: consolidation + introspection narrative + what

package/core/handlers.js

@@ -371,7 +371,7 @@ register({
     if (!authorized(env)) return;
     send([
       "Session: /session /sessions /projects /continue /status /stop /end",
-      "Settings: /model /effort /budget /plan /compact /compactwindow /worktree /mode /engine /recall /tooltrace /toolmode",
+      "Settings: /model /effort /budget /plan /compact /compactwindow /worktree /mode /engine /recall /tooltrace /toolmode /verbose",
       "Identity: /whoami /link",
       "Team: /people /intros /auth (owner)",
       "Automation: /cron /vault /soul /dreamsummary",
@@ -1077,6 +1077,29 @@ register({
   },
 });
 
+register({
+  name: "verbose", description: "Stream thinking into the live preview (on/off)", args: "[on|off]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const { settings } = currentState();
+    if (tail) {
+      const v = tail.trim().toLowerCase();
+      if (v === "on" || v === "true") settings.showThinking = true;
+      else if (v === "off" || v === "false") settings.showThinking = false;
+      else return send(`Usage: /verbose [on|off]. Currently ${settings.showThinking ? "on" : "off"}.`);
+      saveState();
+      return send(`Verbose thinking: ${settings.showThinking ? "on" : "off"}`);
+    }
+    send(
+      `Verbose thinking: ${settings.showThinking ? "on" : "off"}\n\n` +
+      "When on, the live status preview also streams my thinking (reasoning) in italics as it happens. Narration and the clean final answer are unaffected. Off by default.",
+      { keyboard: { inline_keyboard: [
+        [{ text: "On", callback_data: "vb:on" }, { text: "Off", callback_data: "vb:off" }],
+      ] } },
+    );
+  },
+});
+
 register({
   name: "budget", description: "Set max spend for next task", args: "[$N]",
   handler: async (env, { tail }) => {
@@ -1303,25 +1326,34 @@ register({
     if (!authorized(env)) return;
     const state = currentState();
     const sideCancellation = require("./side-chat").sideChatCoordinator.cancel(state.userId);
+    // /stop cancels the CURRENT turn only. Messages queued behind it stay
+    // queued — the cancelled run's unwind drains them as usual.
+    const queuedNote = () => {
+      const n = Array.isArray(state.messageQueue) ? state.messageQueue.length : 0;
+      return n ? ` ${n} queued message${n === 1 ? "" : "s"} will run next.` : "";
+    };
     if (state.runningProcess) {
       const pid = state.runningProcess.pid;
       const { killProcessTree } = require("./process-tree");
+      // Quiet unwind: deliverForegroundResult consumes this flag to suppress
+      // the "run failed" diagnostic the SIGTERM exit would otherwise emit.
+      state.cancelRequested = true;
       killProcessTree(pid, "SIGTERM");
       setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
       state.runningProcess = null;
-      if (state.streamInterval) clearTimeout(state.streamInterval);
+      // Stop pending preview flushes but keep statusMessageId/Channel: the
+      // killed run's delivery unwind edits the preview to drop its footer.
+      if (state.streamInterval) { clearTimeout(state.streamInterval); state.streamInterval = null; }
       if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
-      state.messageQueue = [];
       await sideCancellation;
-      await send("Cancelled.");
+      await send(`Cancelled.${queuedNote()}`);
     } else if (state.preparingRun) {
-      // Turn is mid-recall/compaction — no process to kill yet. Flag it so
-      // runAgent bails at its pre-spawn checkpoint, and stop typing now.
+      // Turn is mid-recall/prompt-build — no process to kill yet. Flag it so
+      // the runner's pre-spawn shouldAbort checkpoint bails before spawning.
       state.cancelRequested = true;
-      state.messageQueue = [];
       if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
       await sideCancellation;
-      await send("Cancelled.");
+      await send(`Cancelled.${queuedNote()}`);
     } else if (await sideCancellation) await send("Cancelled side response.");
     else await send("Nothing running.");
   },

package/core/providers/claude-events.js

@@ -55,6 +55,10 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
       if (block?.type === "text" && typeof block.text === "string" && block.text) {
         state.sawText = true;
         events.push({ type: "text_final", text: block.text });
+      } else if (block?.type === "thinking" && typeof block.thinking === "string" && block.thinking) {
+        // Deliberately does not set sawText: thinking is never answer text,
+        // so the result-event fallback semantics stay unchanged.
+        events.push({ type: "thinking", text: block.thinking });
       } else if (block?.type === "tool_use" && block.id && block.name) {
         state.tools.set(block.id, block.name);
         events.push({

package/core/providers/codex-events.js

@@ -80,6 +80,10 @@ function normalizeCodexEvent(rawEvent, state = createCodexParserState()) {
       state.sawText = true;
       return [{ type: "text_final", text: item.text }];
     }
+    if (item.type === "reasoning" && typeof item.text === "string" && item.text) {
+      // Deliberately does not set sawText: reasoning is never answer text.
+      return [{ type: "thinking", text: item.text }];
+    }
     const info = toolInfo(item);
     if (!info) return [];
     const exitCode = Number.isInteger(item.exit_code)

package/core/providers/codex.js

@@ -6,7 +6,7 @@ const { createJsonlDecoder } = require("./events");
 const { createCodexParserState, normalizeCodexEvent } = require("./codex-events");
 const { createCodexHookTransport } = require("./codex-hook");
 
-const CODEX_MODELS = Object.freeze(["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex"]);
+const CODEX_MODELS = Object.freeze(["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]);
 const CODEX_EFFORT_VALUES = Object.freeze(["minimal", "low", "medium", "high", "xhigh"]);
 const REQUIRED_EXEC_HELP_FLAGS = Object.freeze(["--config", "--json", "--sandbox", "--image", "--model", "--skip-git-repo-check"]);
 const REQUIRED_RESUME_HELP_FLAGS = Object.freeze(["--config", "--json", "--image", "--model", "--skip-git-repo-check"]);
@@ -264,9 +264,9 @@ function createCodexProvider(options = {}) {
     },
     nativeToolsNote: "Codex exposes its native exec tools; Open Claudia capability checks and approval policy remain authoritative.",
     tierModel(tier) {
-      if (tier === "low") return "gpt-5.4-mini";
-      if (tier === "medium") return "gpt-5.3-codex";
-      return defaultModel || "gpt-5.5";
+      if (tier === "low") return "gpt-5.6-luna";
+      if (tier === "medium") return "gpt-5.6-terra";
+      return defaultModel || "gpt-5.6-sol";
     },
   };
 

package/core/providers/events.js

@@ -4,6 +4,7 @@ const NORMALIZED_EVENT_TYPES = Object.freeze([
   "session",
   "text_delta",
   "text_final",
+  "thinking",
   "tool_start",
   "tool_end",
   "usage",

package/core/runner.js

@@ -29,7 +29,7 @@ const {
 } = require("./run-context");
 const { redactSensitive } = require("./redact");
 const { createSideChatPromptBuilder, sideChatCoordinator } = require("./side-chat");
-const { send, sendVoice, sendVoiceEnd, splitMessage } = require("./io");
+const { send, sendVoice, sendVoiceEnd, splitMessage, editMessage, deleteMessage } = require("./io");
 const { textToVoice, splitSentences, synthSentenceMp3 } = require("./media");
 const { killProcessTree, waitForPidsExit } = require("./process-tree");
 const {
@@ -84,6 +84,19 @@ function usageParts(usage, backend) {
   };
 }
 
+// The provider's final "turn" usage sums every API call's prefix, re-counting
+// the cached prefix once per tool round-trip. True window occupancy is the
+// largest single call, so track the peak across per-call usage events.
+function peakContextTokens(usageEvents, backend) {
+  let peak = 0;
+  for (const event of usageEvents || []) {
+    if (event?.scope !== "provider_call" || !event.usage) continue;
+    const context = usageParts(event.usage, backend).context;
+    if (context > peak) peak = context;
+  }
+  return peak > 0 ? peak : null;
+}
+
 function clampUsageDelta(current, previous) {
   if (!previous) return current;
   return {
@@ -192,7 +205,7 @@ function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
     if (announce && usageOwnerOnly) {
       const baseline = result.trend?.baselineAvgContextTokens || 0;
       const rate = result.trend?.latestRate || 0;
-      const contextLabel = usageScope === "turn_delta" ? "Context this turn" : "Session context total";
+      const contextLabel = hasPeak || usageScope === "turn_delta" ? "Context this turn" : "Session context total";
       announce([
         "Token usage alert:",
         `${contextLabel}: ${fmtTokens(record.contextTokens)}`,
@@ -258,6 +271,11 @@ async function executeProviderInvocation(options = {}) {
   const tools = [];
   const textDeltas = [];
   const textFinals = [];
+  // Text blocks grouped by the tool runs between them. The last segment is
+  // the provider's actual answer; everything before it is interim narration
+  // ("Let me check X…" written before a tool call). Kept separate so chat
+  // delivery can split them while result.text keeps the full transcript.
+  const textSegments = [[]];
   let resultText = "";
   let sessionId = runContext?.sessionId || null;
   let terminalSeen = false;
@@ -327,8 +345,13 @@ async function executeProviderInvocation(options = {}) {
     if (!event || typeof event !== "object") return;
     if (event.type === "session" && event.sessionId) sessionId = event.sessionId;
     else if (event.type === "text_delta" && typeof event.text === "string") textDeltas.push(event.text);
-    else if (event.type === "text_final" && typeof event.text === "string") textFinals.push(event.text);
-    else if (event.type === "tool_start" || event.type === "tool_end") tools.push(event);
+    else if (event.type === "text_final" && typeof event.text === "string") {
+      textFinals.push(event.text);
+      textSegments[textSegments.length - 1].push(event.text);
+    } else if (event.type === "tool_start" || event.type === "tool_end") {
+      if (event.type === "tool_start" && textSegments[textSegments.length - 1].length) textSegments.push([]);
+      tools.push(event);
+    }
     else if (event.type === "usage") usageEvents.push(event);
     else if (event.type === "result") {
       terminalSeen = true;
@@ -487,6 +510,9 @@ async function executeProviderInvocation(options = {}) {
     finalText: textFinals.join(""),
     deltaText: textDeltas.join(""),
   });
+  const segmentTexts = textSegments.map((blocks) => blocks.join("")).filter((t) => t.trim());
+  const finalAnswerText = segmentTexts.length ? segmentTexts[segmentTexts.length - 1] : "";
+  const narrationText = segmentTexts.slice(0, -1).join("\n\n");
   let failure = null;
   if (spawnError) failure = stableRunError(spawnError.message, "PROVIDER_SPAWN_FAILED");
   else if (timedOut) failure = stableRunError(
@@ -511,6 +537,8 @@ async function executeProviderInvocation(options = {}) {
     sessionId,
     purpose: runContext?.purpose || "foreground",
     text: redactSensitive(String(text || "").trim()),
+    finalAnswerText: redactSensitive(String(finalAnswerText || "").trim()),
+    narrationText: redactSensitive(String(narrationText || "")),
     usage: finalUsage?.usage || null,
     usageScope: finalUsage?.scope || null,
     usageEvents,
@@ -631,6 +659,15 @@ function preflightFailureResult(runContext, provider, failure) {
   };
 }
 
+function cancelledRunResult(runContext, provider) {
+  const result = preflightFailureResult(runContext, provider, {
+    code: "RUN_CANCELLED",
+    message: "Cancelled by /stop before the provider started",
+  });
+  result.status = "cancelled";
+  return result;
+}
+
 async function settleImmediateRunResult(result, runContext, dependencies, capture) {
   for (const [name, hook] of [
     ["transcript", dependencies.persistTranscript],
@@ -738,6 +775,15 @@ function createRunnerService(dependencies = {}) {
       return immediateFailure(provider, error);
     }
 
+    // Pre-spawn cancel checkpoint: /stop during recall/prompt-build sets a
+    // flag instead of killing a process (there is none yet). Honour it here,
+    // after the slow prompt build and before anything spawns. Persistence
+    // still settles (the transcript records the cancelled turn); delivery is
+    // suppressed downstream via the RUN_CANCELLED code.
+    if (dependencies.shouldAbort && dependencies.shouldAbort(runContext, { capture })) {
+      return settleImmediateRunResult(cancelledRunResult(runContext, provider), runContext, dependencies, capture);
+    }
+
     const result = await executeProviderInvocation({
       runContext,
       provider,
@@ -1387,7 +1433,8 @@ async function persistForegroundUsage(result, runContext, state = currentState()
     let usage = result.usage;
     let usageScope = result.usageScope || "turn_delta";
     let rawUsage = usage;
-    let liveContextTokens = usageParts(usage, runContext.provider).context;
+    let liveContextTokens = peakContextTokens(result.usageEvents, runContext.provider)
+      ?? usageParts(usage, runContext.provider).context;
     const usageSessionId = result.sessionId || runContext.sessionId;
     const usageProject = runContext.project?.name || null;
     if (runContext.provider === "codex") {
@@ -1469,11 +1516,49 @@ async function persistForegroundSession(result, runContext, state = currentState
   result.sessionAttached = attach;
 }
 
+// Settle the streamed preview message before the final answer goes out.
+// Success with narration → the preview becomes the narration record (footer
+// dropped). Success without narration → the preview only ever showed the
+// streamed answer itself; delete it so the final message isn't a duplicate.
+// Failure/cancel → keep the partial text but drop the lying "working" footer.
+async function finalizeStreamPreview(state, result) {
+  if (state.streamInterval) { clearTimeout(state.streamInterval); state.streamInterval = null; }
+  const id = state.statusMessageId;
+  const channel = state.statusMessageChannel;
+  const buffer = String(state.streamBuffer || "").trim();
+  state.statusMessageId = null;
+  state.statusMessageChannel = null;
+  state.streamBuffer = "";
+  if (typeof id !== "string") return;
+  // A message id is only valid on the channel that minted it; a foreign-
+  // channel preview is left as an orphan rather than edited cross-transport.
+  if (!channel || String(channel) !== String(currentChannelId())) return;
+  try {
+    if (!result || !result.ok) {
+      if (buffer) await editMessage(id, buffer.slice(-4000), telegramHtmlOpts({ streaming: true }));
+      return;
+    }
+    const narration = String(result.narrationText || "").trim();
+    if (narration) await editMessage(id, narration.slice(-4000), telegramHtmlOpts({ streaming: true }));
+    else await deleteMessage(id);
+  } catch (_) { /* preview cleanup is best-effort; the final answer still goes out */ }
+}
+
 async function deliverForegroundResult(result, runContext, state = currentState()) {
   if (runContext.lastInputWasVoice) state.lastInputWasVoice = false;
+  await finalizeStreamPreview(state, result);
+  // /stop unwind: the SIGTERM (or pre-spawn abort) that follows a user cancel
+  // is not a failure worth announcing — /stop already replied "Cancelled.".
+  // The flag is consumed here (and re-cleared on the run's unwind) so it can
+  // never suppress a later run's genuine failure.
+  if (!result.ok && (state.cancelRequested || result.error?.code === "RUN_CANCELLED")) {
+    state.cancelRequested = false;
+    return { ok: true, suppressed: "cancelled" };
+  }
   const diagnostic = providerRunDiagnostic(result, runContext);
   if (diagnostic) result.diagnostic = diagnostic;
-  let finalText = result.ok ? (result.text || "(no output)") : (diagnostic || result.diagnostic || "Provider run failed");
+  const cleanAnswer = String(result.finalAnswerText || "").trim();
+  let finalText = result.ok ? (cleanAnswer || result.text || "(no output)") : (diagnostic || result.diagnostic || "Provider run failed");
 
   if (result.ok) {
     let guarded = false;
@@ -1596,8 +1681,73 @@ function settleImmediateEffects(result, runContext, { state, store, capture }) {
   })();
 }
 
+const STREAM_PREVIEW_THROTTLE_MS = 2500;
+const STREAM_PREVIEW_FOOTER = "\n\n⏳ working — /stop to cancel";
+
+// Edited-in-place interim preview: each completed text block the provider
+// emits mid-run is appended to one throttled status message, so the user sees
+// the narration as it happens instead of silence. finalizeStreamPreview
+// settles the message when the run ends.
+function createStreamPreview({ state, store }) {
+  let enabled = !!store && (store?.adapter?.type || "") !== "voice";
+  if (enabled) {
+    // Interim text is NOT vetted by guardOutboundReply (only the final answer
+    // is), so it must never reach a guarded external speaker. Fail closed if
+    // classification is unavailable.
+    try { enabled = chatContext.run(store, () => !require("./relationship").isCurrentSpeakerGuarded()); }
+    catch (_) { enabled = false; }
+  }
+  const channelId = store?.channelId || null;
+
+  const flush = () => {
+    state.streamInterval = null;
+    if (!enabled || state.cancelRequested) return;
+    const body = String(state.streamBuffer || "").trim();
+    if (!body) return;
+    const display = body.slice(-3800) + STREAM_PREVIEW_FOOTER;
+    // Event callbacks arrive off the provider's stdout stream, outside the
+    // chat AsyncLocalStorage context — rebind before any send/edit.
+    chatContext.run(store, async () => {
+      try {
+        if (typeof state.statusMessageId === "string" && String(state.statusMessageChannel) === String(channelId)) {
+          await editMessage(state.statusMessageId, display, telegramHtmlOpts({ streaming: true }));
+          return;
+        }
+        if (state.statusMessageId === true) return; // sent but not editable — leave the single notice alone
+        const sent = await send(display, telegramHtmlOpts());
+        state.statusMessageId = sent.editable ? sent.messageId : (sent.ok ? true : null);
+        state.statusMessageChannel = sent.ok ? channelId : null;
+      } catch (_) { /* preview is best-effort */ }
+    }).catch(() => {});
+  };
+
+  const appendChunk = (chunk, runContext) => {
+    if (!enabled || runContext?.purpose !== "foreground" || state.cancelRequested) return;
+    state.streamBuffer = state.streamBuffer ? `${state.streamBuffer}\n\n${chunk}` : chunk;
+    if (state.streamBuffer.length > 20000) state.streamBuffer = state.streamBuffer.slice(-16000);
+    if (!state.streamInterval) state.streamInterval = setTimeout(flush, STREAM_PREVIEW_THROTTLE_MS);
+  };
+
+  return {
+    append(text, runContext) {
+      appendChunk(text, runContext);
+    },
+    // Thinking/reasoning is interim-only display: it rides the preview buffer
+    // under /verbose but never enters narrationText or the final answer, so
+    // a successful run's settled messages carry no reasoning residue.
+    appendThinking(text, runContext) {
+      if (!state.settings?.showThinking) return;
+      const summary = String(text).trim();
+      if (!summary) return;
+      const clipped = summary.length > 900 ? `${summary.slice(0, 900)}…` : summary;
+      appendChunk(`<i>🧠 ${clipped}</i>`, runContext);
+    },
+  };
+}
+
 function createForegroundService({ state, store, stopTyping, capture, ownsAdmissionLock, persistCapture = true }) {
   const persistEffects = !capture || persistCapture;
+  const preview = capture ? null : createStreamPreview({ state, store });
   return createRunnerService({
     getState: () => state,
     getStore: () => store,
@@ -1618,12 +1768,24 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
       state.runningProcess = proc;
       if (ownsAdmissionLock) state.preparingRun = false;
     },
-    onEvent(event) {
+    shouldAbort(runContext, { capture: isCapture } = {}) {
+      if (isCapture || !ownsAdmissionLock) return false;
+      if (!state.cancelRequested) return false;
+      state.cancelRequested = false;
+      return true;
+    },
+    onEvent(event, runContext) {
       if (["text_delta", "text_final", "tool_start", "result", "error"].includes(event.type)) state.thinkingPhase = false;
       if (event.type === "tool_start" && ["Shell", "Bash"].includes(event.name)) {
         const command = typeof event.detail === "string" ? event.detail : event.detail?.command;
         if (command) { try { require("./tool-guard").noteRawOp(command); } catch (_) {} }
       }
+      if (preview && event.type === "text_final" && typeof event.text === "string" && event.text) {
+        preview.append(event.text, runContext);
+      }
+      if (preview && event.type === "thinking" && typeof event.text === "string" && event.text) {
+        preview.appendThinking(event.text, runContext);
+      }
     },
     onInvocationWarning(warning) {
       return send(`⚠️ ${warning.message}`);
@@ -1701,6 +1863,10 @@ async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissi
   } finally {
     if (tracksMainRun && state.runningProcess) state.runningProcess = null;
     if (ownsAdmissionLock) state.preparingRun = false;
+    // A cancel flag that survived this run (e.g. /stop raced a run that
+    // finished successfully anyway) must not leak into the next turn, where
+    // it would falsely abort a queued run or mute a genuine failure.
+    if (ownsAdmissionLock) state.cancelRequested = false;
     if (tracksMainRun && state.activeRunContext === runContext) state.activeRunContext = null;
     stopTyping();
   }
@@ -1889,6 +2055,7 @@ module.exports = {
   shouldAutoCompact,
   effectiveCompactThreshold,
   usageParts,
+  peakContextTokens,
   clampUsageDelta,
   normalizeCodexUsage,
   applyUsageToState,

package/core/single-instance.js

@@ -0,0 +1,46 @@
+// Single-instance lock on the config dir. Two bot processes sharing one
+// CONFIG_DIR share one Telegram token; Telegram then 409-terminates their
+// getUpdates polls in turns and each side keeps exiting/respawning — the
+// 2026-07-12 restart storm, where a debugger-run dev checkout fought the
+// launchd service copy all morning. Whoever boots second must refuse to
+// start BEFORE touching any channel.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (e) { return e.code === "EPERM"; } // EPERM: alive, different owner
+}
+
+function acquireSingleInstanceLock({ configDir, name = "bot" }) {
+  const lockPath = path.join(configDir, `${name}.lock`);
+  try {
+    const prev = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    if (prev && prev.pid && prev.pid !== process.pid && pidAlive(prev.pid)) {
+      return { acquired: false, holder: prev, lockPath };
+    }
+    // Missing, corrupt, own-pid, or dead-pid (stale after SIGKILL): claim it.
+  } catch (e) {}
+  fs.writeFileSync(lockPath, JSON.stringify({
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    entrypoint: process.argv[1] || "",
+  }));
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    try {
+      const cur = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+      // Never delete a lock a successor already owns.
+      if (cur && cur.pid === process.pid) fs.unlinkSync(lockPath);
+    } catch (e) {}
+  };
+  process.on("exit", release);
+  return { acquired: true, lockPath, release };
+}
+
+module.exports = { acquireSingleInstanceLock, pidAlive };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
@@ -10,7 +10,7 @@
     "setup": "node setup.js",
     "start": "node bot.js",
     "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js",
-    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-runner-watchdog-static.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-nesting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-unified-identity.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-queue-routing.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-packs.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-speaker-persona.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-pipeline.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-relationship-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-relationship.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-enforcer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-identity-prune.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-kazee-message-id.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-delivery-contract.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-run-lock.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-web-sessions.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-poll-recovery.js"
+    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-runner-watchdog-static.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-nesting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-unified-identity.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-queue-routing.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-packs.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-speaker-persona.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-pipeline.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-relationship-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-relationship.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-enforcer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-identity-prune.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-kazee-message-id.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-delivery-contract.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-run-lock.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-web-sessions.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-poll-recovery.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-409-grace.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-single-instance.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-streaming-split.js"
   },
   "files": [
     "bot.js",

package/test-cursor-removal.js

@@ -306,8 +306,11 @@ function semanticStaticProbe() {
   assert.match(fs.readFileSync(path.join(root, "test-provider-registry.js"), "utf8"), /provider\("cursor"\)/);
 
   const changelog = fs.readFileSync(path.join(root, "CHANGELOG.md"), "utf8");
-  assert.match(changelog.slice(0, 2500), /active Cursor Agent runtime support has been removed/i);
-  assert.match(changelog.slice(0, 2500), /rollback/i);
+  const removalStart = changelog.indexOf("## v3.0.0");
+  assert.ok(removalStart !== -1, "the v3.0.0 removal section must remain in the changelog");
+  const removalNotes = changelog.slice(removalStart, removalStart + 2500);
+  assert.match(removalNotes, /active Cursor Agent runtime support has been removed/i);
+  assert.match(removalNotes, /rollback/i);
 }
 
 async function main() {

package/test-delivery-contract.js

@@ -84,5 +84,33 @@ const inChat = (adapter, fn) => runInChat({ adapter, channelId: "chan-1", transp
   assert.deepStrictEqual(io.normalizeSendResult(null), { ok: false, messageId: null, editable: false });
   assert.deepStrictEqual(io.normalizeSendResult(99), { ok: true, messageId: "99", editable: true });
 
+  // 7. Telegram splitMessage: messages over the 4096 hard cap must be chunked
+  //    instead of dying with "message is too long" (the silent dream-summary
+  //    failure). Chunks stay under the margin and preserve all content.
+  {
+    const { splitMessage } = require("./channels/telegram/format");
+
+    assert.deepStrictEqual(splitMessage("short message"), ["short message"], "under limit → single chunk untouched");
+    assert.deepStrictEqual(splitMessage(""), [""], "empty stays a single empty chunk");
+
+    const paragraphs = [];
+    for (let i = 0; i < 40; i++) paragraphs.push(`Paragraph ${i} ${"x".repeat(180)}`);
+    const longText = paragraphs.join("\n\n");
+    const chunks = splitMessage(longText);
+    assert.ok(chunks.length > 1, "long multi-paragraph text is chunked");
+    for (const c of chunks) assert.ok(c.length <= 4000, "every chunk fits Telegram's limit with margin");
+    assert.strictEqual(
+      chunks.join("\n\n").replace(/\s+/g, " "),
+      longText.replace(/\s+/g, " "),
+      "no content lost across paragraph-boundary splits",
+    );
+
+    const unbroken = "y".repeat(9500);
+    const hardChunks = splitMessage(unbroken);
+    assert.ok(hardChunks.length >= 3, "giant unbroken string hard-splits");
+    for (const c of hardChunks) assert.ok(c.length <= 4000, "hard-split chunks also fit");
+    assert.strictEqual(hardChunks.join(""), unbroken, "hard split loses nothing");
+  }
+
   console.log("delivery-contract OK");
 })().catch((e) => { console.error(e); process.exit(1); });

package/test-fixtures/fake-agent-cli.js

@@ -267,6 +267,26 @@ function claudeEvents(sessionId) {
   }
 
   const events = [init];
+  if (process.env.FAKE_AGENT_THINKING) {
+    events.push({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "thinking", thinking: process.env.FAKE_AGENT_THINKING, signature: "fixture-sig" }],
+      },
+      session_id: sessionId,
+    });
+  }
+  if (process.env.FAKE_AGENT_NARRATION) {
+    events.push({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "text", text: process.env.FAKE_AGENT_NARRATION }],
+      },
+      session_id: sessionId,
+    });
+  }
   if (boolControl("FAKE_AGENT_TOOL")) {
     events.push({
       type: "assistant",
@@ -321,6 +341,18 @@ function codexEvents(sessionId) {
   }
 
   const events = [started, { type: "turn.started" }];
+  if (process.env.FAKE_AGENT_THINKING) {
+    events.push({
+      type: "item.completed",
+      item: { id: "item-think", type: "reasoning", text: process.env.FAKE_AGENT_THINKING },
+    });
+  }
+  if (process.env.FAKE_AGENT_NARRATION) {
+    events.push({
+      type: "item.completed",
+      item: { id: "item-narration", type: "agent_message", text: process.env.FAKE_AGENT_NARRATION },
+    });
+  }
   if (boolControl("FAKE_AGENT_TOOL")) {
     const command = {
       id: "item-1",

package/test-provider-capabilities.js

@@ -158,8 +158,8 @@ async function commandProbe() {
 
   await dispatch("/model");
   const modelControls = callbacks(sent.at(-1).options.keyboard.inline_keyboard);
-  assert.ok(modelControls.includes("mb:codex:gpt-5.4"));
-  assert.ok(modelControls.includes("mb:codex:gpt-5.4-mini"));
+  assert.ok(modelControls.includes("mb:codex:gpt-5.6-sol"));
+  assert.ok(modelControls.includes("mb:codex:gpt-5.6-luna"));
   assert.ok(!modelControls.includes("mb:codex:o4-mini"));
   assert.ok(modelControls.includes("mb:claude:claude-sonnet-4-6"));
 }

package/test-provider-codex.js

@@ -46,7 +46,7 @@ assert.strictEqual(provider.label, "OpenAI Codex");
 assert.strictEqual(provider.isAvailable(), true);
 assert.strictEqual(provider.executable(), "/fixture/codex");
 assert.strictEqual(provider.defaultModel(), "gpt-5-codex");
-assert.ok(provider.modelChoices().includes("gpt-5.4-mini"));
+assert.deepStrictEqual(provider.modelChoices(), ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]);
 assert.ok(!provider.modelChoices().includes("o4-mini"));
 assert.deepStrictEqual(provider.compatibilityStatus(), {
   state: "compatible",
@@ -180,7 +180,7 @@ const utility = validateInvocation(provider.buildUtilityInvocation(deepFreeze({
   outputSchemaPath: "/fixture/schema.json",
 })));
 assert.ok(utility.args.includes("--ephemeral"));
-assert.strictEqual(utility.args[utility.args.indexOf("--model") + 1], "gpt-5.4-mini");
+assert.strictEqual(utility.args[utility.args.indexOf("--model") + 1], "gpt-5.6-luna");
 assert.strictEqual(utility.args[utility.args.indexOf("--output-schema") + 1], "/fixture/schema.json");
 assert.deepStrictEqual(
   utility.args.slice(utility.args.indexOf("--sandbox"), utility.args.indexOf("--sandbox") + 2),

package/test-provider-events.js

@@ -20,6 +20,7 @@ assert.deepStrictEqual([...NORMALIZED_EVENT_TYPES].sort(), [
   "session",
   "text_delta",
   "text_final",
+  "thinking",
   "tool_end",
   "tool_start",
   "usage",
@@ -76,6 +77,28 @@ assert.strictEqual(selectTerminalText({
   finalText: "```json\n{\"status\":\"ok\"}\n```",
 }), '{"status":"ok"}', "structured terminal output overrides presentation text");
 
+const claudeThinkingState = createClaudeParserState();
+assert.deepStrictEqual(normalizeClaudeEvent({
+  type: "assistant",
+  message: { content: [
+    { type: "thinking", thinking: "Weighing the fixture options…", signature: "sig-1" },
+    { type: "text", text: "answer" },
+  ] },
+}, claudeThinkingState), [
+  { type: "thinking", text: "Weighing the fixture options…" },
+  { type: "text_final", text: "answer" },
+]);
+const claudeThinkingOnly = createClaudeParserState();
+normalizeClaudeEvent({
+  type: "assistant",
+  message: { content: [{ type: "thinking", thinking: "only thoughts" }] },
+}, claudeThinkingOnly);
+assert.deepStrictEqual(
+  normalizeClaudeEvent(samples.claude.result, claudeThinkingOnly).at(-1),
+  { type: "result", text: "Hello world", sessionId: "claude-session-1" },
+  "thinking alone must not mark sawText — the result fallback text still applies",
+);
+
 const usageOnly = { type: "assistant", message: { usage: { input_tokens: 1, output_tokens: 1 }, content: [] } };
 const usageState = createClaudeParserState();
 assert.strictEqual(normalizeClaudeEvent(usageOnly, usageState).filter((event) => event.type === "usage").length, 1);
@@ -114,6 +137,13 @@ assert.deepStrictEqual(normalizeCodexEvent(samples.codex.result, codexState), [
 ]);
 assert.deepStrictEqual(normalizeCodexEvent(samples.codex.result, codexState), [], "duplicate Codex terminal and usage settle once");
 
+assert.deepStrictEqual(normalizeCodexEvent({
+  type: "item.completed",
+  item: { id: "item-think", type: "reasoning", text: "Weighing options…" },
+}, createCodexParserState()), [
+  { type: "thinking", text: "Weighing options…" },
+]);
+
 const codexAuth = normalizeCodexEvent({ type: "turn.failed", error: { message: "401 Unauthorized" } }, createCodexParserState());
 assert.deepStrictEqual(codexAuth, [{
   type: "error",

package/test-provider-language.js

@@ -32,9 +32,10 @@ assert.doesNotMatch(setup, /Your Claude Code bot is connected|Description=Claude
 
 const pkg = JSON.parse(read("package.json"));
 assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
-// 3.0.0 approved by Sumeet 2026-07-10 (provider-parity release; CHANGELOG
-// already documents it as v3.0.0).
-assert.strictEqual(pkg.version, "3.0.0", "release version must remain unchanged without explicit approval");
+// 3.0.2 approved by Sumeet 2026-07-12 ("Yeh do it and push it out" — peak
+// context metric restored, Telegram long-message chunking so dream summaries
+// deliver; CHANGELOG documents it as v3.0.2).
+assert.strictEqual(pkg.version, "3.0.2", "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-telegram-poll-recovery.js

@@ -3,6 +3,42 @@
 const assert = require("assert");
 const { TelegramAdapter } = require("./channels/telegram/adapter");
 
+async function testStartDoesNotWaitForFirstLongPollAndArmsStallWatchdog() {
+  const adapter = Object.create(TelegramAdapter.prototype);
+  adapter._pollWatchdogTimer = null;
+  adapter._pollStartedAt = 0;
+  adapter.bot = {
+    _polling: { _lastUpdate: null },
+    startPolling() { return new Promise(() => {}); },
+  };
+  const hiccups = [];
+  adapter._onPollingHiccup = (message) => hiccups.push(message);
+
+  let watchdog;
+  const realSetInterval = global.setInterval;
+  const realClearInterval = global.clearInterval;
+  const realNow = Date.now;
+  global.setInterval = (fn) => { watchdog = fn; return { watchdog: true }; };
+  global.clearInterval = () => {};
+
+  try {
+    const outcome = await Promise.race([
+      adapter.start().then(() => "started"),
+      new Promise((resolve) => setTimeout(() => resolve("blocked"), 25)),
+    ]);
+    assert.strictEqual(outcome, "started", "adapter startup must not wait for Telegram's first long-poll request to settle");
+    assert.strictEqual(typeof watchdog, "function", "adapter startup must arm an independent poll-stall watchdog");
+
+    Date.now = () => adapter._pollStartedAt + 120000;
+    watchdog();
+    assert.match(hiccups[0] || "", /no completed getUpdates/i, "watchdog must recover a silent first-poll stall");
+  } finally {
+    Date.now = realNow;
+    global.setInterval = realSetInterval;
+    global.clearInterval = realClearInterval;
+  }
+}
+
 async function testHealCancelsWedgedLongPollBeforeRestarting() {
   const calls = [];
   let stopOptions;
@@ -48,6 +84,7 @@ async function testHealCancelsWedgedLongPollBeforeRestarting() {
 }
 
 (async () => {
+  await testStartDoesNotWaitForFirstLongPollAndArmsStallWatchdog();
   await testHealCancelsWedgedLongPollBeforeRestarting();
   console.log("telegram poll recovery OK");
 })().catch((err) => {

package/test-usage-accounting.js

@@ -9,6 +9,7 @@ const {
   normalizeCodexUsage,
   applyUsageToState,
   shouldAutoCompact,
+  peakContextTokens,
 } = require("./core/runner");
 const stateApi = require("./core/state");
 const { normalizeUsageRecord, loadUsageHistory, USAGE_HISTORY_FILE } = require("./core/usage-log");
@@ -152,5 +153,28 @@ assert.strictEqual(shouldAutoCompact(state({
   sessionUsage: { liveContextTokens: 250, lastInputTokens: 250, lastCompactedAt: Date.now() },
 })), true);
 
+// peakContextTokens: the live context number must be the LARGEST single API
+// call, not the turn-cumulative sum (the v3.0.0 347k-vs-160k regression).
+assert.strictEqual(peakContextTokens([
+  { type: "usage", scope: "provider_call", usage: { input_tokens: 1000, cache_read_input_tokens: 150000, cache_creation_input_tokens: 2000 } },
+  { type: "usage", scope: "provider_call", usage: { input_tokens: 500, cache_read_input_tokens: 158000, cache_creation_input_tokens: 1500 } },
+  { type: "usage", scope: "provider_call", usage: { input_tokens: 200, cache_read_input_tokens: 120000 } },
+], "claude"), 160000, "peak is the max single provider_call context");
+assert.strictEqual(peakContextTokens([
+  { type: "usage", scope: "provider_call", usage: { input_tokens: 100, cache_read_input_tokens: 50 } },
+  { type: "usage", scope: "turn", usage: { input_tokens: 999999, cache_read_input_tokens: 999999 } },
+], "claude"), 150, "turn-scope cumulative usage never wins over per-call peak");
+assert.strictEqual(peakContextTokens([], "claude"), null, "no events → null so callers fall back");
+assert.strictEqual(peakContextTokens([
+  { type: "usage", scope: "turn", usage: { input_tokens: 10 } },
+], "claude"), null, "only turn-scope events → null");
+assert.strictEqual(peakContextTokens([
+  { type: "usage", scope: "provider_call", usage: { output_tokens: 40 } },
+], "claude"), null, "zero-context calls → null");
+assert.strictEqual(peakContextTokens(null, "claude"), null, "missing events list tolerated");
+assert.strictEqual(peakContextTokens([
+  { type: "usage", scope: "provider_call", usage: { input_tokens: 70, cached_input_tokens: 30, output_tokens: 5 } },
+], "codex"), 70, "codex context counts input only, matching usageParts");
+
 fs.rmSync(configDir, { recursive: true, force: true });
 console.log("usage accounting OK");