@nopeek/agent-bridge 0.7.14 → 0.7.16

package/dist/bot.d.ts

@@ -38,6 +38,7 @@ export declare class BotRunner {
     private channelModes;
     private mutedOff;
     private chains;
+    private turns;
     private cantPost;
     private log;
     private logErr;
@@ -102,6 +103,9 @@ export declare class BotRunner {
     /** Bounded dedupe so a redelivered frame is never answered twice. */
     private remember;
     private handleMessage;
+    private runBrainTurn;
+    private collectFollowups;
+    private ingestFollowup;
     /** A FORBIDDEN post (broadcast channel, bot not an operator) fails for every
      *  future message too — mute the channel so the brain stops running there. */
     private notePostFailure;

package/dist/bot.js

@@ -8,6 +8,7 @@ import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
 import { beginTurn, finishTurn, lastTurnFor } from "./last-turn.js";
 import { FileStore } from "./storage.js";
 import { TurnPublisher } from "./tool-progress.js";
+import { ChannelTurn, coalesceFollowups, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
 import { buildInboundPrompt, describeStructured, hasInboundWork, isControlType, parseAttachments, saveInboundFiles, } from "./inbound-files.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const MAX_BACKOFF_MS = 60_000;
@@ -74,6 +75,9 @@ export class BotRunner {
     // order, one at a time — concurrent brain runs against the same agent session
     // (e.g. one Hermes session per channel) deadlock or reply out of order.
     chains = new Map();
+    // Live brain turn per channel so a follow-up can abort Hermes immediately
+    // instead of waiting for the current 30-minute job to finish.
+    turns = new Map();
     // Channels the bot can't post to (e.g. broadcast, non-operator): after the
     // first FORBIDDEN, skip the brain entirely — replies there can never land.
     cantPost = new Set();
@@ -374,6 +378,12 @@ export class BotRunner {
         np.on("member.joined", onRosterChange);
         np.on("member.left", onRosterChange);
         np.on("message", ((m) => {
+            const live = this.turns.get(m.channelId);
+            if (live?.active) {
+                live.interrupt({ id: m.messageId, message: m });
+                this.log(`${m.channelId} mid-turn interrupt from ${m.senderUserId}: ${String(m.body && "text" in m.body ? m.body.text : "").slice(0, 80)}`);
+                return;
+            }
             const prev = this.chains.get(m.channelId) ?? Promise.resolve();
             const next = prev.then(() => this.handleMessage(m).catch((err) => {
                 this.notePostFailure(m.channelId, err);
@@ -560,79 +570,196 @@ export class BotRunner {
             return;
         this.log(`${m.channelId} <- ${m.senderUserId}: ${text.slice(0, 120)}`);
         ch.markRead(m.messageId).catch(() => { });
-        try {
-            ch.typing(true);
-        }
-        catch {
-            /* typing is best-effort */
-        }
-        // Resolve the brain PER MESSAGE: the NoPeek app can change it live over the
-        // local API (PUT /brains) and the very next message uses the new one.
-        const resolved = resolveBrain(this.cfg, this.info.handle);
-        this.brainKind = resolved.kind;
-        // Telegram-style turn: tool lines edit one live bubble; commentary
-        // between tool batches is posted in place; leftover recap goes last.
-        const stopTyping = () => {
+        await this.runBrainTurn({
+            ch,
+            channelId: m.channelId,
+            senderUserId: m.senderUserId,
+            text,
+            files,
+            interrupted: false,
+        });
+    }
+    async runBrainTurn(args) {
+        const { ch, channelId, senderUserId } = args;
+        let text = args.text;
+        let files = args.files;
+        let interrupted = args.interrupted;
+        while (true) {
+            if (!interrupted && isStopRequest(text)) {
+                this.log(`${channelId} stop with nothing running`);
+                try {
+                    await ch.send({ text: "Nothing is running." });
+                }
+                catch (err) {
+                    this.notePostFailure(channelId, err);
+                }
+                this.handled++;
+                return;
+            }
             try {
-                ch.typing(false);
+                ch.typing(true);
             }
             catch {
-                /* best-effort */
+                /* typing is best-effort */
             }
-        };
-        const published = new TurnPublisher({
-            stream: () => ch.stream(),
-            send: async (body) => {
-                await ch.send({ text: body });
-            },
-        }, {
-            stopTyping,
-            onStreamError: (err) => {
-                this.notePostFailure(m.channelId, err);
-                this.logErr(`stream open failed (falling back to a single send): ${err.message}`);
-            },
-        });
-        let reply = "";
-        const turn = beginTurn(this.info.handle, m.channelId, resolved.kind);
-        try {
-            reply = await resolved.brain(text, {
-                botHandle: this.info.handle,
-                botUserId: this.info.userId,
-                channelId: m.channelId,
-                senderUserId: m.senderUserId,
-                ...(files.length ? { files } : {}),
-            }, { onChunk: (delta) => published.onChunk(delta), onTool: (ev) => published.onTool(ev) });
-            const trimmed = reply.trim();
-            const timedOut = /went quiet for over \d+s/i.test(trimmed);
-            finishTurn(turn, {
-                ok: Boolean(trimmed) && !trimmed.startsWith("⚠️"),
-                chars: trimmed.length,
-                timedOut,
-                error: !trimmed ? "empty reply" : trimmed.startsWith("⚠️") ? trimmed.slice(0, 180) : null,
+            const resolved = resolveBrain(this.cfg, this.info.handle);
+            this.brainKind = resolved.kind;
+            const stopTyping = () => {
+                try {
+                    ch.typing(false);
+                }
+                catch {
+                    /* best-effort */
+                }
+            };
+            const published = new TurnPublisher({
+                stream: () => ch.stream(),
+                send: async (body) => {
+                    await ch.send({ text: body });
+                },
+            }, {
+                stopTyping,
+                onStreamError: (err) => {
+                    this.notePostFailure(channelId, err);
+                    this.logErr(`stream open failed (falling back to a single send): ${err.message}`);
+                },
             });
+            const live = new ChannelTurn();
+            this.turns.set(channelId, live);
+            const prompt = interrupted ? wrapInterruptedFollowup(text) : text;
+            let reply = "";
+            const stat = beginTurn(this.info.handle, channelId, resolved.kind);
+            try {
+                reply = await resolved.brain(prompt, {
+                    botHandle: this.info.handle,
+                    botUserId: this.info.userId,
+                    channelId,
+                    senderUserId,
+                    signal: live.abort.signal,
+                    ...(files.length ? { files } : {}),
+                }, { onChunk: (delta) => published.onChunk(delta), onTool: (ev) => published.onTool(ev) });
+                if (live.abort.signal.aborted) {
+                    finishTurn(stat, { ok: true, chars: 0, error: "interrupted" });
+                    await published.finish("").catch(() => { });
+                    const next = await this.collectFollowups(channelId, live, ch);
+                    if (!next)
+                        return;
+                    text = next.text;
+                    files = next.files;
+                    interrupted = true;
+                    continue;
+                }
+                const trimmed = reply.trim();
+                const timedOut = /went quiet for over \d+s/i.test(trimmed);
+                finishTurn(stat, {
+                    ok: Boolean(trimmed) && !trimmed.startsWith("⚠️"),
+                    chars: trimmed.length,
+                    timedOut,
+                    error: !trimmed ? "empty reply" : trimmed.startsWith("⚠️") ? trimmed.slice(0, 180) : null,
+                });
+            }
+            catch (err) {
+                finishTurn(stat, { ok: false, error: err.message, timedOut: false });
+                await published.fail(FALLBACK_REPLY).catch(() => { });
+                throw err;
+            }
+            finally {
+                if (this.turns.get(channelId) === live) {
+                    live.finish();
+                    this.turns.delete(channelId);
+                }
+                try {
+                    ch.typing(false);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            const how = await published.finish(reply.trim());
+            if (how === "empty") {
+                this.log(`brain returned empty reply — ignoring`);
+                return;
+            }
+            this.handled++;
+            this.log(`${channelId} -> ${how} reply (${reply.trim().length} chars, handled=${this.handled})`);
+            return;
         }
-        catch (err) {
-            finishTurn(turn, { ok: false, error: err.message, timedOut: false });
-            // Brain blew up mid-stream: finalize the partial bubble with an honest
-            // error line instead of leaving a forever-blinking cursor.
-            await published.fail(FALLBACK_REPLY).catch(() => { });
-            throw err;
+    }
+    async collectFollowups(channelId, live, ch) {
+        await new Promise((r) => setTimeout(r, 180));
+        const queued = live.takeIncoming();
+        live.finish();
+        if (this.turns.get(channelId) === live)
+            this.turns.delete(channelId);
+        const prepared = [];
+        for (const item of queued) {
+            const got = await this.ingestFollowup(item.message);
+            if (!got)
+                continue;
+            ch.markRead(item.message.messageId).catch(() => { });
+            prepared.push(got);
         }
-        finally {
+        if (!prepared.length) {
+            this.log(`${channelId} interrupted with no usable follow-up`);
+            return null;
+        }
+        const decision = coalesceFollowups(prepared.map((p) => p.text));
+        if (decision.action === "stop") {
+            this.log(`${channelId} stopped by user (${prepared.length} follow-up(s))`);
             try {
-                ch.typing(false);
+                await ch.send({ text: "Stopped." });
             }
-            catch {
-                /* best-effort */
+            catch (err) {
+                this.notePostFailure(channelId, err);
             }
+            this.handled++;
+            return null;
         }
-        const how = await published.finish(reply.trim());
-        if (how === "empty") {
-            this.log(`brain returned empty reply — ignoring`);
-            return;
+        this.log(`${channelId} folding ${prepared.length} follow-up(s) into the same session`);
+        return {
+            text: decision.text,
+            files: prepared.flatMap((p) => p.files),
+        };
+    }
+    async ingestFollowup(m) {
+        if (m.senderUserId === this.info.userId)
+            return null;
+        if (this.cantPost.has(m.channelId))
+            return null;
+        if (m.decryptionFailed)
+            return null;
+        if (!this.isAllowed(m.senderUserId))
+            return null;
+        const body = m.body;
+        if (!body || isControlType(body.type) || !hasInboundWork(body))
+            return null;
+        const attachments = parseAttachments(body);
+        let text = typeof body.text === "string" ? body.text : "";
+        let files = [];
+        const failures = [];
+        const previews = [];
+        if (attachments.length) {
+            try {
+                const ch = await this.getChannel(m.channelId);
+                const saved = await saveInboundFiles(async (att) => {
+                    const blob = await ch.fetchAttachment(att);
+                    return Buffer.from(await blob.arrayBuffer());
+                }, attachments, m.messageId);
+                files = saved.files;
+                failures.push(...saved.failures);
+                previews.push(...saved.previews);
+            }
+            catch (err) {
+                this.logErr(`follow-up ingest failed for ${m.messageId}: ${err.message}`);
+            }
         }
-        this.handled++;
-        this.log(`${m.channelId} -> ${how} reply (${reply.trim().length} chars, handled=${this.handled})`);
+        const structured = describeStructured(body);
+        text = buildInboundPrompt({ caption: text, files, structured, failures });
+        if (previews.length)
+            text = `${previews.join("\n\n")}\n\n${text}`;
+        if (!text.trim())
+            return null;
+        return { text, files };
     }
     /** A FORBIDDEN post (broadcast channel, bot not an operator) fails for every
      *  future message too — mute the channel so the brain stops running there. */

package/dist/brain.d.ts

@@ -15,6 +15,8 @@ export interface BrainContext {
     senderUserId: string;
     /** Local paths of photos / video / PDFs / any file the human just sent. */
     files?: BrainFile[];
+    /** Abort the in-flight brain when a later message interrupts this turn. */
+    signal?: AbortSignal;
 }
 /**
  * A brain answers one message. If it can stream, it calls `onChunk(delta)` as

package/dist/hermes-http.d.ts

@@ -10,6 +10,7 @@ export declare function lastHermesApiHealth(): HermesApiHealth | null;
 export declare function probeHermesApi(cfg: BridgeConfig, force?: boolean): Promise<HermesApiHealth>;
 /**
  * Stream one turn through Hermes' OpenAI-compatible chat completions.
- * Session continuity: X-Hermes-Session-Key = nopeek-<channelId> (stable per chat).
+ * Session continuity: X-Hermes-Session-Id + Key = nopeek-<channelId>
+ * so follow-ups share history instead of starting a blank api-* job.
  */
 export declare function hermesHttpBrain(cfg: BridgeConfig): Brain;

package/dist/hermes-http.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { asHooks } from "./brain.js";
+import { hermesSessionHeaders } from "./mid-turn.js";
 import { RECAP_HINT } from "./tool-progress.js";
 /** Skip data-URL vision parts above this so a gallery cannot blow the POST. */
 const MAX_IMAGE_DATA_URL_BYTES = 8 * 1024 * 1024;
@@ -59,7 +60,8 @@ export async function probeHermesApi(cfg, force = false) {
 }
 /**
  * Stream one turn through Hermes' OpenAI-compatible chat completions.
- * Session continuity: X-Hermes-Session-Key = nopeek-<channelId> (stable per chat).
+ * Session continuity: X-Hermes-Session-Id + Key = nopeek-<channelId>
+ * so follow-ups share history instead of starting a blank api-* job.
  */
 export function hermesHttpBrain(cfg) {
     return async (text, ctx, hooks) => {
@@ -69,17 +71,19 @@ export function hermesHttpBrain(cfg) {
         const url = cfg.hermesApiUrl.replace(/\/+$/, "");
         const headers = {
             "content-type": "application/json",
+            ...hermesSessionHeaders(cfg.hermesApiKey ?? "", ctx.channelId),
         };
-        // Hermes rejects X-Hermes-Session-Key with 403 unless API_SERVER_KEY is set.
-        // Without a key, skip the header so the turn still runs (no session memory).
-        if (cfg.hermesApiKey) {
-            headers.authorization = `Bearer ${cfg.hermesApiKey}`;
-            headers["X-Hermes-Session-Key"] = `nopeek-${ctx.channelId}`;
-        }
         // Idle abort — same rule as the CLI path. A wall-clock timeout on the
         // whole POST would kill a healthy 20-minute agentic turn. Any SSE byte
         // (token, keepalive, tool-progress) resets the idle timer.
+        // ctx.signal aborts immediately when the user sends a mid-turn follow-up.
         const controller = new AbortController();
+        if (ctx.signal) {
+            if (ctx.signal.aborted)
+                controller.abort();
+            else
+                ctx.signal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
         let idle;
         const armIdle = () => {
             clearTimeout(idle);
@@ -170,6 +174,8 @@ export function hermesHttpBrain(cfg) {
         catch (err) {
             const msg = err.message || "";
             if (controller.signal.aborted) {
+                if (ctx.signal?.aborted)
+                    return "";
                 return `⚠️ My brain went quiet for over ${Math.round(cfg.brainTimeoutMs / 1000)}s with no output and I had to give up on that turn — a long tool-use step or a very slow provider response can trigger this. Try messaging me again.`;
             }
             console.error(`${tag} stream error: ${msg}`);

package/dist/mid-turn.d.ts

@@ -0,0 +1,25 @@
+export type FollowupAction = "stop" | "continue";
+export interface FollowupDecision {
+    action: FollowupAction;
+    text: string;
+}
+export declare function isStopRequest(text: string): boolean;
+export declare function coalesceFollowups(texts: string[]): FollowupDecision;
+export declare function wrapInterruptedFollowup(text: string): string;
+export declare function hermesSessionId(channelId: string): string;
+export declare function hermesSessionHeaders(apiKey: string, channelId: string): Record<string, string>;
+export declare class ChannelTurn<T extends {
+    id: string;
+} = {
+    id: string;
+    text: string;
+}> {
+    readonly abort: AbortController;
+    active: boolean;
+    private incoming;
+    private seen;
+    interrupt(item: T): void;
+    consumed(id: string): boolean;
+    takeIncoming(): T[];
+    finish(): void;
+}

package/dist/mid-turn.js

@@ -0,0 +1,67 @@
+// Mid-turn interrupt policy for NoPeek → Hermes.
+//
+// Telegram can /stop a live agent immediately and fold the next message into
+// the same session. The HTTP brain used to serialize the whole turn, then
+// send each follow-up as a brand-new history=0 job — so "Stop" sat for 33
+// minutes and then replied "nothing to stop" three times.
+//
+// This module is the shared policy: detect stop, coalesce a burst, abort the
+// in-flight turn, and keep one stable Hermes session per channel.
+const STOP_RE = /^(?:\/)?(?:please\s+)?stop(?:\s+please)?[.!]?$/i;
+export function isStopRequest(text) {
+    return STOP_RE.test((text || "").trim());
+}
+export function coalesceFollowups(texts) {
+    const cleaned = texts.map((t) => (t || "").trim()).filter(Boolean);
+    if (cleaned.length === 0)
+        return { action: "continue", text: "" };
+    if (cleaned.every(isStopRequest))
+        return { action: "stop", text: cleaned[cleaned.length - 1] };
+    const kept = cleaned.filter((t) => !isStopRequest(t));
+    return { action: "continue", text: kept.join("\n\n") };
+}
+export function wrapInterruptedFollowup(text) {
+    return ("[System note: You were already working on a task. The user interrupted. " +
+        "Reassess the previous work together with this new message and continue as " +
+        "ONE combined task. Do not start a separate independent job. If the new " +
+        "message replaces the old task, switch to it.]\n\n" +
+        text);
+}
+export function hermesSessionId(channelId) {
+    return `nopeek-${channelId}`;
+}
+export function hermesSessionHeaders(apiKey, channelId) {
+    const headers = {};
+    if (!apiKey)
+        return headers;
+    const sid = hermesSessionId(channelId);
+    headers.authorization = `Bearer ${apiKey}`;
+    headers["X-Hermes-Session-Id"] = sid;
+    headers["X-Hermes-Session-Key"] = sid;
+    return headers;
+}
+export class ChannelTurn {
+    abort = new AbortController();
+    active = true;
+    incoming = [];
+    seen = new Set();
+    interrupt(item) {
+        if (!this.seen.has(item.id)) {
+            this.seen.add(item.id);
+            this.incoming.push(item);
+        }
+        if (!this.abort.signal.aborted)
+            this.abort.abort();
+    }
+    consumed(id) {
+        return this.seen.has(id);
+    }
+    takeIncoming() {
+        const items = this.incoming;
+        this.incoming = [];
+        return items;
+    }
+    finish() {
+        this.active = false;
+    }
+}

package/dist/tool-progress.d.ts

@@ -25,10 +25,21 @@ export type TurnPublisherOpts = {
     startDelayMs?: number;
     /** Start a fresh progress bubble after this many lines. */
     maxProgressLines?: number;
+    /** Split commentary/recap into a new bubble after this many chars. */
+    maxBubbleChars?: number;
+    /** If nothing arrives for this long, the next chunk is a new message. 0 = off. */
+    bubbleGapMs?: number;
 };
 export type TurnFinishKind = "streamed" | "sent" | "empty";
 /** Text in `full` that has not already been posted as commentary. */
 export declare function unpublishedTail(full: string, published: string): string;
+/** Unified diffs / `| review` dumps should never land in the chat. */
+export declare function isDumpLine(line: string): boolean;
+export declare function isToolDump(text: string): boolean;
+/** Drop dump lines from a live chunk without swallowing normal punctuation. */
+export declare function stripDumps(text: string): string;
+/** Split a reply into short chat bubbles. Drops tool-dump paragraphs. */
+export declare function splitBubbles(text: string, max?: number): string[];
 /**
  * One chat turn: live tool progress (edited in place) with commentary
  * messages in between tool batches, then any leftover recap below.
@@ -47,20 +58,27 @@ export declare class TurnPublisher {
     private published;
     private toolsUsed;
     private startTimer;
+    private gapTimer;
     private seen;
     private readonly startDelayMs;
     private readonly maxProgressLines;
+    private readonly maxBubbleChars;
+    private readonly bubbleGapMs;
     constructor(sink: TurnSink, opts: TurnPublisherOpts);
     onChunk(delta: string): void;
     onTool(ev: ToolProgressEvent): void;
     finish(reply: string): Promise<TurnFinishKind>;
     fail(text: string): Promise<void>;
     private cancelStart;
+    private cancelGap;
+    /** After `bubbleGapMs` of silence, seal the current bubble. Next text is new. */
+    private armGap;
     private enqueue;
     /** Open or append the current commentary/answer stream with this chunk only. */
     private appendCommentary;
     /** Finalize the current commentary so later tools land below it. */
     private commitText;
+    private sendBubbles;
     private addProgressLine;
     private closeProgress;
 }

package/dist/tool-progress.js

@@ -60,15 +60,125 @@ export function unpublishedTail(full, published) {
         return f;
     if (f === p)
         return "";
+    const nf = f.replace(/\s+/g, " ");
+    const np = p.replace(/\s+/g, " ");
+    if (nf === np || np.includes(nf))
+        return "";
     if (full.startsWith(published))
         return full.slice(published.length).trim();
     if (f.startsWith(p))
         return f.slice(p.length).trim();
+    if (nf.startsWith(np))
+        return "";
     const idx = f.indexOf(p);
     if (idx >= 0)
         return (f.slice(0, idx) + f.slice(idx + p.length)).trim();
     return f;
 }
+const DEFAULT_MAX_BUBBLE = 480;
+/** Unified diffs / `| review` dumps should never land in the chat. */
+export function isDumpLine(line) {
+    const l = line.trim();
+    if (!l)
+        return false;
+    if (/^review diff\b/i.test(l))
+        return true;
+    if (/^\|\s*(review|read|search|terminal|patch|write)\b/i.test(l))
+        return true;
+    if (/^@@\s+-/.test(l))
+        return true;
+    if (/^diff --git /.test(l))
+        return true;
+    if (/^\*\*\*\s+(Begin|Update|Add|Delete|End)\b/.test(l))
+        return true;
+    if (/^[ab]:?\/{1,2}Volumes\//.test(l))
+        return true;
+    if (/^index [0-9a-f]+\.\.[0-9a-f]+/.test(l))
+        return true;
+    return false;
+}
+export function isToolDump(text) {
+    const t = text.trim();
+    if (!t)
+        return false;
+    if (isDumpLine(t))
+        return true;
+    if (/^diff --git /m.test(t) && /^@@ /m.test(t))
+        return true;
+    const lines = t.split("\n");
+    if (lines.length >= 6) {
+        const dumpy = lines.filter((l) => isDumpLine(l) || /^(@@ |[+-](?![+-])|\| )/.test(l)).length;
+        if (dumpy / lines.length >= 0.4)
+            return true;
+    }
+    return false;
+}
+/** Drop dump lines from a live chunk without swallowing normal punctuation. */
+export function stripDumps(text) {
+    if (!text)
+        return text;
+    if (!text.includes("\n"))
+        return isDumpLine(text) ? "" : text;
+    if (isToolDump(text))
+        return "";
+    return text
+        .split("\n")
+        .filter((l) => !isDumpLine(l))
+        .join("\n");
+}
+/** Split a reply into short chat bubbles. Drops tool-dump paragraphs. */
+export function splitBubbles(text, max = DEFAULT_MAX_BUBBLE) {
+    const cleaned = text.replace(/\r\n/g, "\n").trim();
+    if (!cleaned)
+        return [];
+    const paras = cleaned.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+    const out = [];
+    for (const p of paras) {
+        if (isToolDump(p))
+            continue;
+        if (p.length <= max) {
+            out.push(p);
+            continue;
+        }
+        let buf = "";
+        for (const line of p.split("\n")) {
+            const next = buf ? `${buf}\n${line}` : line;
+            if (next.length > max && buf) {
+                out.push(buf);
+                buf = line.length > max ? "" : line;
+                if (line.length > max) {
+                    for (const piece of hardWrap(line, max))
+                        out.push(piece);
+                }
+            }
+            else if (next.length > max) {
+                for (const piece of hardWrap(next, max))
+                    out.push(piece);
+                buf = "";
+            }
+            else {
+                buf = next;
+            }
+        }
+        if (buf.trim())
+            out.push(buf.trim());
+    }
+    return out;
+}
+function hardWrap(s, max) {
+    const out = [];
+    let rest = s.trim();
+    while (rest.length > max) {
+        let at = rest.lastIndexOf(" ", max);
+        if (at < max * 0.5)
+            at = max;
+        out.push(rest.slice(0, at).trim());
+        rest = rest.slice(at).trim();
+    }
+    if (rest)
+        out.push(rest);
+    return out;
+}
 /**
  * One chat turn: live tool progress (edited in place) with commentary
  * messages in between tool batches, then any leftover recap below.
@@ -87,37 +197,44 @@ export class TurnPublisher {
     published = "";
     toolsUsed = false;
     startTimer = null;
+    gapTimer = null;
     seen = new Set();
     startDelayMs;
     maxProgressLines;
+    maxBubbleChars;
+    bubbleGapMs;
     constructor(sink, opts) {
         this.sink = sink;
         this.opts = opts;
         this.startDelayMs = opts.startDelayMs ?? 400;
-        this.maxProgressLines = opts.maxProgressLines ?? 16;
+        this.maxProgressLines = opts.maxProgressLines ?? 8;
+        this.maxBubbleChars = opts.maxBubbleChars ?? DEFAULT_MAX_BUBBLE;
+        this.bubbleGapMs = opts.bubbleGapMs ?? 2000;
     }
     onChunk(delta) {
-        if (!delta)
+        const chunk = stripDumps(delta);
+        if (!chunk)
             return;
+        this.armGap();
         if (this.toolsUsed) {
             this.cancelStart();
-            this.enqueue(() => this.appendCommentary(delta));
+            this.enqueue(() => this.appendCommentary(chunk));
             return;
         }
         if (this.textP) {
-            this.enqueue(() => this.appendCommentary(delta));
+            this.enqueue(() => this.appendCommentary(chunk));
             return;
         }
-        this.held += delta;
+        this.held += chunk;
         if (this.startTimer)
             return;
         this.startTimer = setTimeout(() => {
             this.startTimer = null;
             if (this.toolsUsed || this.textP || !this.held)
                 return;
-            const chunk = this.held;
+            const ready = this.held;
             this.held = "";
-            this.enqueue(() => this.appendCommentary(chunk));
+            this.enqueue(() => this.appendCommentary(ready));
         }, this.startDelayMs);
     }
     onTool(ev) {
@@ -130,40 +247,32 @@ export class TurnPublisher {
             return;
         this.seen.add(line);
         this.toolsUsed = true;
-        if (this.startTimer) {
-            clearTimeout(this.startTimer);
-            this.startTimer = null;
-        }
-        const pending = this.held;
-        this.held = "";
+        this.cancelStart();
+        this.cancelGap();
         this.enqueue(async () => {
+            const pending = this.held;
+            this.held = "";
             await this.commitText(pending);
             await this.addProgressLine(line);
         });
     }
     async finish(reply) {
         this.cancelStart();
+        this.cancelGap();
         await this.write;
         await this.closeProgress();
-        const trimmed = reply.trim();
-        if (this.textP && !this.toolsUsed) {
-            const s = await this.textP.catch(() => null);
-            this.textP = null;
-            if (s) {
-                await s.done(trimmed || undefined);
-                return trimmed ? "streamed" : "empty";
-            }
-        }
         await this.commitText(this.held);
-        const rest = unpublishedTail(trimmed, this.published);
+        this.held = "";
+        const rest = unpublishedTail(reply.trim(), this.published);
         if (!rest)
             return this.published.trim() ? "streamed" : "empty";
         this.opts.stopTyping();
-        await this.sink.send(rest);
-        return "sent";
+        const sent = await this.sendBubbles(rest);
+        return sent ? "sent" : this.published.trim() ? "streamed" : "empty";
     }
     async fail(text) {
         this.cancelStart();
+        this.cancelGap();
         await this.write;
         await this.closeProgress();
         if (this.textP) {
@@ -185,6 +294,26 @@ export class TurnPublisher {
         clearTimeout(this.startTimer);
         this.startTimer = null;
     }
+    cancelGap() {
+        if (!this.gapTimer)
+            return;
+        clearTimeout(this.gapTimer);
+        this.gapTimer = null;
+    }
+    /** After `bubbleGapMs` of silence, seal the current bubble. Next text is new. */
+    armGap() {
+        this.cancelGap();
+        if (this.bubbleGapMs <= 0)
+            return;
+        this.gapTimer = setTimeout(() => {
+            this.gapTimer = null;
+            this.enqueue(async () => {
+                const pending = this.held;
+                this.held = "";
+                await this.commitText(pending);
+            });
+        }, this.bubbleGapMs);
+    }
     enqueue(fn) {
         this.write = this.write.then(fn).catch((err) => {
             console.error(`[turn] ${err.message}`);
@@ -194,8 +323,24 @@ export class TurnPublisher {
     async appendCommentary(chunk) {
         if (!chunk)
             return;
-        if (this.toolsUsed)
+        if (this.toolsUsed) {
             await this.closeProgress();
+            this.held += chunk;
+            const cut = this.held.lastIndexOf("\n\n");
+            if (cut >= 0) {
+                const ready = this.held.slice(0, cut);
+                this.held = this.held.slice(cut + 2);
+                this.opts.stopTyping();
+                await this.sendBubbles(ready);
+            }
+            else if (this.held.length >= this.maxBubbleChars) {
+                const ready = this.held;
+                this.held = "";
+                this.opts.stopTyping();
+                await this.sendBubbles(ready);
+            }
+            return;
+        }
         this.opts.stopTyping();
         if (!this.textP) {
             this.textP = this.sink.stream();
@@ -236,22 +381,37 @@ export class TurnPublisher {
             if (s && final) {
                 if (extra)
                     s.append(extra);
-                await s.done(final).catch(() => { });
-                this.published += final;
+                const parts = splitBubbles(final, this.maxBubbleChars);
+                const first = parts[0] || final;
+                await s.done(first).catch(() => { });
+                this.published += first;
+                for (const more of parts.slice(1)) {
+                    this.opts.stopTyping();
+                    await this.sink.send(more);
+                    this.published += `\n\n${more}`;
+                }
                 return;
             }
             if (final.trim()) {
                 this.opts.stopTyping();
-                await this.sink.send(final).catch(() => { });
-                this.published += final;
+                await this.sendBubbles(final);
             }
             return;
         }
         if (!pending.trim())
             return;
         this.opts.stopTyping();
-        await this.sink.send(pending);
-        this.published += pending;
+        await this.sendBubbles(pending);
+    }
+    async sendBubbles(text) {
+        const parts = splitBubbles(text, this.maxBubbleChars);
+        if (!parts.length)
+            return false;
+        for (const part of parts) {
+            await this.sink.send(part);
+            this.published += this.published ? `\n\n${part}` : part;
+        }
+        return true;
     }
     async addProgressLine(line) {
         this.opts.stopTyping();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "description": "Run your own agents as E2EE NoPeek bots. Pairs with one-time codes (multiple accounts per computer), runs every bot each account owns, and pipes messages to any command or webhook.",
   "type": "module",
   "license": "MIT",
@@ -46,6 +46,6 @@
     "start": "node dist/cli.js",
     "dev": "tsx src/cli.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts"
+    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts src/mid-turn.test.ts"
   }
 }