@inetafrica/open-claudia 3.0.0 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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

@@ -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

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/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 {
@@ -258,6 +258,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 +332,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 +497,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 +524,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 +646,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 +762,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,
@@ -1469,11 +1502,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 +1667,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 +1754,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 +1849,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();
   }

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.1",
   "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-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,9 @@ 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.1 approved by Sumeet 2026-07-12 ("Push v3.0.1" — streaming restored,
+// /stop queue survival, boot resilience; CHANGELOG documents it as v3.0.1).
+assert.strictEqual(pkg.version, "3.0.1", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }

package/test-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) => {