charness 0.0.0-stage → 3.0.0

package/dist/connectors/telegram/output/dmOutputTransport.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDmOutputTransport = createDmOutputTransport;
+const sessionKey_1 = require("../../../sessionKey");
+const sessionKeyCodec_1 = require("../sessionKeyCodec");
+const draftId_1 = require("../../../utils/draftId");
+const outputFlushPlan_1 = require("../outputFlushPlan");
+const draftPacer_1 = require("../../../utils/draftPacer");
+const draftFinalize_1 = require("../../../utils/draftFinalize");
+const sendErrorClassifier_1 = require("../../../sendErrorClassifier");
+/**
+ * @description The DM live-draft output transport — the relocated draft-cursor
+ * manager. In DM mode the LIVE phase of a streamed reply is shown as a native
+ * Telegram draft (the "bot is typing this message" animation) and FINALIZED to a
+ * permanent message at boundaries (idle / overflow / isFinal / new-response /
+ * teardown). The draft channel runs OFF the message rate-limiter so a draft 429
+ * can never delay a real send; every draft call is best-effort. Both streaming
+ * backends use the cursor ({@link DmOutputTransportDeps.checkSupportsDraft}
+ * gate): OpenCode marks its continuations, while the Claude scrape adapter emits
+ * each poll's prose delta with no meta, so the transport synthesises the
+ * continuation flag ({@link getDmDraftContinuation}) — the answer accumulates
+ * into ONE draft re-rendered as the full snapshot, with the same boundary set.
+ */
+function createDmOutputTransport(deps) {
+    const draftStreams = new Map();
+    function getDraftStreamState(key) {
+        const k = (0, sessionKey_1.keyToString)(key);
+        let s = draftStreams.get(k);
+        if (!s) {
+            s = {
+                draftId: 0,
+                accumulatedText: '',
+                lastSentText: null,
+                lastSentAtMs: null,
+                backoffUntilMs: 0,
+                pacerTimer: null,
+                idleFinalizeTimer: null,
+                lastFedAtMs: null,
+                active: false,
+            };
+            draftStreams.set(k, s);
+        }
+        return s;
+    }
+    /**
+     * @description Render the FULL accumulated draft text to HTML. The draft is the
+     * live "cursor" holding the entire current reply, so it renders the WHOLE
+     * `accumulatedText` — never a tail window. The overflow boundary keeps
+     * `accumulatedText` short enough that its render stays under the Telegram cap.
+     */
+    function renderDraftBody(accumulatedText) {
+        return deps.renderAgentHtml(accumulatedText);
+    }
+    /**
+     * @description Rendered-HTML length of `text` — the measure the overflow
+     * boundary compares against the cap. A body is sized by its RENDERED length
+     * (HTML escaping + tags inflate the source), so the overflow decision must
+     * measure the same way `renderDraftBody` / the persist splitter do.
+     */
+    function measureDraftRenderedLength(text) {
+        return deps.renderAgentHtml(text).length;
+    }
+    /** Clear both per-draft timers (pacer + idle-finalize) without touching state. */
+    function clearDraftTimers(draft) {
+        if (draft.pacerTimer) {
+            clearTimeout(draft.pacerTimer);
+            draft.pacerTimer = null;
+        }
+        if (draft.idleFinalizeTimer) {
+            clearTimeout(draft.idleFinalizeTimer);
+            draft.idleFinalizeTimer = null;
+        }
+    }
+    /**
+     * @description Fire ONE draft update for the thread's current accumulated text,
+     * reusing the turn's stable draft id. Best-effort: a 429 arms the draft-channel
+     * backoff (read from `retry_after` when present, else {@link
+     * DRAFT_DEFAULT_BACKOFF_MS}) and re-arms the pacer; any other failure is logged
+     * and dropped. Never throws, never touches the message rate-limiter.
+     */
+    async function sendDraftNow(key, draft) {
+        const text = renderDraftBody(draft.accumulatedText);
+        // The cursor invariant keeps `accumulatedText` under the cap; an over-cap
+        // render is the TRANSIENT pre-spill state at an overflow feed (the overflow
+        // boundary splits it into permanent messages on the same tick). Sending it
+        // would only earn `MESSAGE_TOO_LONG`, so skip — the spill carries the content.
+        if (text.length > deps.maxMessageLength)
+            return;
+        const payload = {
+            chat_id: (0, sessionKeyCodec_1.getTelegramChatId)(key),
+            draft_id: draft.draftId,
+            text,
+            parse_mode: 'HTML',
+        };
+        // Mirror `buildSendExtra`'s General handling: omit `message_thread_id` for the
+        // DM General thread (`DM_GENERAL_THREAD_ID = 0`).
+        if (!deps.checkIsGeneral(key))
+            payload.message_thread_id = (0, sessionKeyCodec_1.getTelegramThreadId)(key);
+        // Record what we are ABOUT to show + when, before the await, so a concurrent
+        // feed paces against this attempt (and a failure below only adjusts backoff).
+        draft.lastSentText = draft.accumulatedText;
+        draft.lastSentAtMs = Date.now();
+        try {
+            await deps.callSendMessageDraft('sendMessageDraft', payload);
+        }
+        catch (e) {
+            const code = (0, sendErrorClassifier_1.checkIsApiError)(e) ? (0, sendErrorClassifier_1.getErrorCode)(e) : undefined;
+            if (code === 429) {
+                const retryAfterSec = (0, sendErrorClassifier_1.checkIsApiError)(e) ? (0, sendErrorClassifier_1.getErrorRetryAfterSeconds)(e) : undefined;
+                const backoffMs = retryAfterSec ? retryAfterSec * 1000 : draftPacer_1.DRAFT_DEFAULT_BACKOFF_MS;
+                draft.backoffUntilMs = Date.now() + backoffMs;
+                console.warn(`[draft] ${(0, sessionKey_1.keyToString)(key)} draft 429 — backing off ${backoffMs}ms`);
+                armDraftPacerTimer(key, draft);
+                return;
+            }
+            console.warn(`[draft] ${(0, sessionKey_1.keyToString)(key)} draft update failed (best-effort, ignored):`, e instanceof Error ? e.message : e);
+        }
+    }
+    /**
+     * @description Arm (replacing any existing) the draft pacer timer. It fires
+     * after the soonest the pacer could next `send`: the later of the draft-channel
+     * backoff remainder and the min-interval remainder since the last send, then
+     * re-runs the pacer. The draft keepalive is gone (DM streaming v2): a draft is
+     * either updated within the idle window or FINALIZED at the idle boundary, so it
+     * never needs to survive the ~30s native ephemerality.
+     */
+    function armDraftPacerTimer(key, draft) {
+        if (draft.pacerTimer)
+            clearTimeout(draft.pacerTimer);
+        const now = Date.now();
+        const backoffRemainder = Math.max(0, draft.backoffUntilMs - now);
+        const intervalRemainder = draft.lastSentAtMs === null
+            ? 0
+            : Math.max(0, draft.lastSentAtMs + draftPacer_1.DRAFT_MIN_INTERVAL_MS - now);
+        // The pacer can only `send` once both the backoff and the interval clear.
+        const delay = Math.max(backoffRemainder, intervalRemainder);
+        draft.pacerTimer = setTimeout(() => {
+            draft.pacerTimer = null;
+            void runDraftPacer(key);
+        }, Math.max(delay, 0));
+        draft.pacerTimer.unref?.();
+    }
+    /**
+     * @description Re-evaluate the pacer for the thread's current accumulated text
+     * and act: `send` fires a draft now; `skip`/`defer` re-arm the timer. No-op once
+     * the turn is inactive (a teardown / finalize cleared it).
+     */
+    async function runDraftPacer(key) {
+        const draft = draftStreams.get((0, sessionKey_1.keyToString)(key));
+        if (!draft || !draft.active)
+            return;
+        const now = Date.now();
+        const action = (0, draftPacer_1.getDraftPaceAction)({
+            nextText: draft.accumulatedText,
+            lastSentText: draft.lastSentText,
+            nowMs: now,
+            lastSentAtMs: draft.lastSentAtMs,
+            minIntervalMs: draftPacer_1.DRAFT_MIN_INTERVAL_MS,
+            backoffUntilMs: draft.backoffUntilMs,
+        });
+        if (action === 'send') {
+            await sendDraftNow(key, draft);
+            return;
+        }
+        // `skip` / `defer` → re-arm for the remaining interval / backoff.
+        armDraftPacerTimer(key, draft);
+    }
+    /**
+     * @description Begin a fresh draft turn: allocate a new stable draft id (so this
+     * response animates separately from the previous one), reset the accumulator and
+     * pacing/idle state, and mark active. Called when a new response begins (a
+     * non-continuation output, or a forced new-message break) — the previous turn,
+     * if any, was finalized to a permanent message first.
+     *
+     * Opening the turn CONSUMES the `needsNewMessage` signal: the fresh draft IS the
+     * new message, so subsequent continuation tails extend it instead of being
+     * mis-read as another new response (in DM the draft path replaces the persist
+     * path that used to clear this flag on send).
+     */
+    function startDraftTurn(key) {
+        const draft = getDraftStreamState(key);
+        clearDraftTimers(draft);
+        draft.draftId = (0, draftId_1.nextDraftId)(draft.draftId);
+        draft.accumulatedText = '';
+        draft.lastSentText = null;
+        draft.lastSentAtMs = null;
+        draft.lastFedAtMs = null;
+        draft.backoffUntilMs = 0;
+        draft.active = true;
+        deps.getThreadMessageState(key).needsNewMessage = false;
+    }
+    /**
+     * @description Reset a draft turn to fully idle: clear timers + accumulator +
+     * pacing state and mark inactive. The shared tail of `finalizeDraft` (after the
+     * permanent message is sent) and of a defensive teardown.
+     */
+    function resetDraftState(draft) {
+        clearDraftTimers(draft);
+        draft.active = false;
+        draft.accumulatedText = '';
+        draft.lastSentText = null;
+        draft.lastSentAtMs = null;
+        draft.lastFedAtMs = null;
+        draft.backoffUntilMs = 0;
+    }
+    /**
+     * @description Arm (replacing any existing) the idle-finalize timer. It fires
+     * {@link FINALIZE_IDLE_MS} after this feed; if no newer output arrived in that
+     * window the accumulated draft is FINALIZED into a permanent message (a pause is
+     * a natural message boundary). Re-armed on every feed, so a steadily streaming
+     * reply never trips it.
+     */
+    function armIdleFinalizeTimer(key, draft) {
+        if (draft.idleFinalizeTimer)
+            clearTimeout(draft.idleFinalizeTimer);
+        draft.idleFinalizeTimer = setTimeout(() => {
+            draft.idleFinalizeTimer = null;
+            const live = draftStreams.get((0, sessionKey_1.keyToString)(key));
+            if (!live)
+                return;
+            if (!(0, draftFinalize_1.checkShouldFinalizeOnIdle)(Date.now(), live.lastFedAtMs, live.active, draftFinalize_1.FINALIZE_IDLE_MS)) {
+                return;
+            }
+            void finalizeDraft(key);
+        }, draftFinalize_1.FINALIZE_IDLE_MS);
+        draft.idleFinalizeTimer.unref?.();
+    }
+    /**
+     * @description Append `output` to the live draft's accumulator (S5 concat rule —
+     * mirroring what the eventual message holds), then pace the draft update and
+     * (re)arm the idle-finalize timer. The boundary router (`feedDraft`) calls this
+     * for the `append`/`overflow`-remainder/post-`finalizeThenStart` cases.
+     * `startsNewParagraph` (Claude only) upgrades a non-continuation join to a
+     * blank line so the live preview keeps the pane's paragraph structure.
+     */
+    function appendToDraft(key, output, isContinuation, startsNewParagraph = false) {
+        const draft = getDraftStreamState(key);
+        draft.accumulatedText = (0, outputFlushPlan_1.appendPendingOutput)(draft.accumulatedText === '' ? null : draft.accumulatedText, output, isContinuation, startsNewParagraph);
+        draft.lastFedAtMs = Date.now();
+        void runDraftPacer(key);
+        armIdleFinalizeTimer(key, draft);
+    }
+    /**
+     * @description Finalize the active draft into a PERMANENT message and reset the
+     * turn. The accumulated text is the live cursor's full body; by construction
+     * (overflow boundary) it renders within one Telegram message, but the
+     * render-aware splitter is reused defensively so an edge over the cap still
+     * lands every chunk. After the message(s) are sent the draft state is fully
+     * reset (inactive, empty, timers cleared) so the NEXT output opens a fresh
+     * draft → a new message. Best-effort + idempotent: nothing accumulated, or no
+     * draft at all, is a no-op.
+     */
+    async function finalizeDraft(key) {
+        const draft = draftStreams.get((0, sessionKey_1.keyToString)(key));
+        if (!draft)
+            return;
+        const text = draft.accumulatedText;
+        // Reset BEFORE the await so a concurrent feed opens a clean fresh turn rather
+        // than appending onto text we are about to ship as a permanent message.
+        resetDraftState(draft);
+        if (!text.trim())
+            return;
+        await deps.sendAgentChunks(key, deps.splitMessage(text, deps.maxMessageLength, measureDraftRenderedLength));
+    }
+    /**
+     * @description Spill an over-cap draft: split the accumulated text, finalize the
+     * leading chunk(s) as permanent message(s), and carry the LAST chunk (the
+     * remainder still under the cap) into a fresh draft so the live cursor continues
+     * below the finalized content. Called by `feedDraft` on the `overflow` boundary.
+     */
+    async function spillDraftOverflow(key) {
+        const draft = getDraftStreamState(key);
+        const chunks = deps.splitMessage(draft.accumulatedText, deps.maxMessageLength, measureDraftRenderedLength);
+        // A single chunk means the render fit after all (e.g. an un-splittable token
+        // the splitter emitted whole) — nothing to spill, just keep streaming it.
+        if (chunks.length <= 1) {
+            void runDraftPacer(key);
+            armIdleFinalizeTimer(key, draft);
+            return;
+        }
+        // Move the cursor to the remainder SYNCHRONOUSLY before shipping the leading
+        // chunk(s): `leadingChunks` is captured in a local and a fresh draft holds only
+        // the remainder, so a concurrently-dispatched continuation appends onto the
+        // remainder draft (never onto text already being shipped). Without this, a feed
+        // arriving during the send below would re-read the un-reset accumulator and
+        // re-spill the same leading chunk (duplicate send) or be wiped (lost text).
+        // Same invariant as feedDraft: no draft-state mutation AFTER the await.
+        const leadingChunks = chunks.slice(0, -1);
+        const remainder = chunks[chunks.length - 1];
+        startDraftTurn(key);
+        appendToDraft(key, remainder, /* isContinuation */ true);
+        await deps.sendAgentChunks(key, leadingChunks);
+    }
+    /**
+     * @description Feed the live draft with one `output` event and route it through
+     * the boundary decision ({@link getDraftFeedAction}):
+     *
+     *  - `finalizeThenStart` — a new response began while a draft was active:
+     *    finalize the previous draft to a permanent message, then open a fresh turn
+     *    for this output;
+     *  - `finalize` — the turn's last frame (`isFinal`): append, then finalize and do
+     *    NOT reopen a draft;
+     *  - `overflow` — appending makes the render cross the cap: append, then spill
+     *    the full chunk(s) to permanent message(s) and continue in a new draft;
+     *  - `append` — ordinary streaming tail: grow the draft, pace it, re-arm idle.
+     *
+     * Async because a boundary may send a permanent message; the caller calls it
+     * fire-and-forget. Lazily opens a turn if none is active.
+     */
+    async function feedDraft(key, output, isContinuation, isFinal, startsNewParagraph = false) {
+        const draft = getDraftStreamState(key);
+        const needsNewMessage = deps.getThreadMessageState(key).needsNewMessage;
+        // The text the draft WOULD hold after this output: for a continuation into a
+        // live draft it extends the accumulator (so the overflow check measures the
+        // real combined length); otherwise the new turn starts from just this output.
+        const isAppendingContinuation = draft.active && isContinuation && !needsNewMessage;
+        const prospective = isAppendingContinuation
+            ? (0, outputFlushPlan_1.appendPendingOutput)(draft.accumulatedText || null, output, true)
+            : output;
+        const action = (0, draftFinalize_1.getDraftFeedAction)({
+            isDraftActive: draft.active,
+            isContinuation,
+            needsNewMessage,
+            isFinal,
+            prospectiveRenderedLength: measureDraftRenderedLength(prospective),
+            renderedCap: deps.maxMessageLength,
+        });
+        if (action === 'finalizeThenStart') {
+            // SYNCHRONOUS reset→restart, no await between: finalizeDraft snapshots the old
+            // text and resets state synchronously BEFORE its network send (which then ships
+            // fire-and-forget, ordered by the per-thread send FIFO), so opening the new turn
+            // immediately runs in one stack. A concurrently-dispatched output event therefore
+            // cannot interleave at an await and be wiped by this startDraftTurn. Invariant for
+            // this whole family of functions: no draft-state mutation AFTER an await.
+            void finalizeDraft(key);
+            startDraftTurn(key);
+            appendToDraft(key, output, /* isContinuation */ false);
+            return;
+        }
+        if (!draft.active)
+            startDraftTurn(key);
+        if (action === 'finalize') {
+            appendToDraft(key, output, isContinuation, startsNewParagraph);
+            await finalizeDraft(key);
+            return;
+        }
+        appendToDraft(key, output, isContinuation, startsNewParagraph);
+        if (action === 'overflow')
+            await spillDraftOverflow(key);
+    }
+    /**
+     * @description Route one DM `output` event to its message path:
+     *  • streaming tail (not a one-shot, not a sub-agent) on a draft-capable
+     *    adapter → the draft manager is the SOLE output→message path;
+     *  • complete one-shot (`isComplete`) → finalize any live draft first (keeps
+     *    order), then post it straight as a permanent message (no draft animation);
+     *  • otherwise (e.g. Claude DM baseline) → the original `queueOutput` path.
+     */
+    function deliverOutput(key, output, meta) {
+        const isFinal = meta?.isFinal === true;
+        const isComplete = meta?.isComplete === true;
+        // Claude reports out-of-band that the pane had a paragraph break before this
+        // chunk; the draft / baseline join rebuilds the `\n\n` separator so the live
+        // preview matches the persisted message (ignored when starting a new turn).
+        const startsNewParagraph = meta?.startsNewParagraph === true;
+        // For a delta-emitting backend (Claude scrape) the meta carries no
+        // continuation, but each poll's prose delta continues the same answer — so
+        // accumulate it into the live draft. The real turn boundaries come from
+        // `needsNewMessage` / idle / overflow / isFinal, which `feedDraft` honours.
+        const isContinuation = (0, draftFinalize_1.getDmDraftContinuation)(meta?.isContinuation === true, deps.checkOutputsDeltas(key));
+        if ((0, draftPacer_1.checkShouldStreamAsDraft)(true, meta) && deps.checkSupportsDraft(key)) {
+            void feedDraft(key, output, isContinuation, isFinal, startsNewParagraph);
+        }
+        else if (isComplete) {
+            void (async () => {
+                await finalizeDraft(key);
+                await deps.sendAgentChunks(key, deps.splitMessage(output, deps.maxMessageLength, measureDraftRenderedLength));
+            })();
+        }
+        else {
+            deps.queueOutput(key, output, isContinuation, isFinal, isComplete, startsNewParagraph);
+        }
+    }
+    return {
+        deliverOutput,
+        finalizeInFlight: (key) => finalizeDraft(key),
+        disposeThread(key) {
+            // `finalizeInFlight` (the teardown convergence point) already finalized any
+            // accumulated draft text (synchronously capturing it + clearing the timers);
+            // drop the now-reset map entry so it doesn't leak across a rebind.
+            draftStreams.delete((0, sessionKey_1.keyToString)(key));
+        },
+        // Peek WITHOUT creating state: a thread with no draft is trivially not
+        // streaming. While `active`, the Claude liveness loop must stay noop so its
+        // heartbeat can't insert a status frame between prose deltas (which would
+        // trip `needsNewMessage` and finalize the draft mid-answer).
+        checkIsStreaming(key) {
+            return draftStreams.get((0, sessionKey_1.keyToString)(key))?.active === true;
+        },
+        // Threads with an active draft turn — the shutdown flush finalizes each so
+        // the live draft's accumulated text lands as a permanent message before exit.
+        getInFlightThreadKeys() {
+            const keys = [];
+            for (const [keyStr, draft] of draftStreams) {
+                if (draft.active)
+                    keys.push((0, sessionKey_1.keyFromString)(keyStr));
+            }
+            return keys;
+        },
+    };
+}
+//# sourceMappingURL=dmOutputTransport.js.map

package/dist/connectors/telegram/output/dmOutputTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dmOutputTransport.js","sourceRoot":"","sources":["../../../../src/connectors/telegram/output/dmOutputTransport.ts"],"names":[],"mappings":"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"}

package/dist/connectors/telegram/outputBacklogGlue.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @description Pure backlog-glue for the per-topic send queue (S2b).
+ *
+ * When a topic BACKS UP — the global 1/2s send pacer (S1) leaves ≥3 messages
+ * waiting to send for one topic — a per-2s trickle reads badly. This collapses
+ * that backlog into ONE message (frames joined by a blank line, `\n\n`) so the
+ * burst drains in a single send. 1–2 pending frames stay separate (snappy).
+ *
+ * The join+threshold is a pure, Telegraf-free helper (mirrors
+ * `utils/outputFlushPlan.ts` / `utils/groupFinalizePlan.ts`): input = ordered
+ * pending frames, output = the fewest messages that fit, each ≤ the cap, frames
+ * joined by `\n\n`. Per-topic only — cross-topic messages carry distinct
+ * `message_thread_id`s and can never merge, so "in one chat" ⇒ "in one topic's
+ * queue".
+ *
+ * Splitting reuses {@link splitMessage}: it already emits the fewest chunks that
+ * fit, preferring newline boundaries (so a glued block breaks on the `\n\n`
+ * frame boundaries, never mid-line) and honouring the rendered-length cap when a
+ * measure is supplied.
+ */
+/**
+ * @description Glue threshold: a topic's pending-send backlog collapses only at
+ * this many frames or more. Below it, frames stay separate for snappiness.
+ */
+export declare const backlogGlueThreshold = 3;
+/**
+ * @description Collapse a topic's ordered pending frames into the fewest
+ * `\n\n`-joined messages when the backlog is ≥ {@link backlogGlueThreshold};
+ * otherwise return the frames unchanged (1–2 stay separate).
+ *
+ * @param frames Ordered pending frames (each already a would-be single message).
+ * @param maxLen Per-message source-length cap (default {@link MAX_MESSAGE_LEN}).
+ * @param measureRendered Optional rendered-length measure; when supplied the
+ *   split also keeps each message's RENDERED length within Telegram's cap (same
+ *   contract as {@link splitMessage}). Omit for plain source-length splitting.
+ */
+export declare function glueBacklogFrames(frames: string[], maxLen?: number, measureRendered?: (chunk: string) => number): string[];
+//# sourceMappingURL=outputBacklogGlue.d.ts.map

package/dist/connectors/telegram/outputBacklogGlue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputBacklogGlue.d.ts","sourceRoot":"","sources":["../../../src/connectors/telegram/outputBacklogGlue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH;;;GAGG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAKtC;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,GAAE,MAAwB,EAChC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAC1C,MAAM,EAAE,CAGV"}

package/dist/connectors/telegram/outputBacklogGlue.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * @description Pure backlog-glue for the per-topic send queue (S2b).
+ *
+ * When a topic BACKS UP — the global 1/2s send pacer (S1) leaves ≥3 messages
+ * waiting to send for one topic — a per-2s trickle reads badly. This collapses
+ * that backlog into ONE message (frames joined by a blank line, `\n\n`) so the
+ * burst drains in a single send. 1–2 pending frames stay separate (snappy).
+ *
+ * The join+threshold is a pure, Telegraf-free helper (mirrors
+ * `utils/outputFlushPlan.ts` / `utils/groupFinalizePlan.ts`): input = ordered
+ * pending frames, output = the fewest messages that fit, each ≤ the cap, frames
+ * joined by `\n\n`. Per-topic only — cross-topic messages carry distinct
+ * `message_thread_id`s and can never merge, so "in one chat" ⇒ "in one topic's
+ * queue".
+ *
+ * Splitting reuses {@link splitMessage}: it already emits the fewest chunks that
+ * fit, preferring newline boundaries (so a glued block breaks on the `\n\n`
+ * frame boundaries, never mid-line) and honouring the rendered-length cap when a
+ * measure is supplied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backlogGlueThreshold = void 0;
+exports.glueBacklogFrames = glueBacklogFrames;
+const messageSplit_1 = require("./messageSplit");
+/**
+ * @description Glue threshold: a topic's pending-send backlog collapses only at
+ * this many frames or more. Below it, frames stay separate for snappiness.
+ */
+exports.backlogGlueThreshold = 3;
+/** Blank-line separator between glued frames. */
+const frameSeparator = '\n\n';
+/**
+ * @description Collapse a topic's ordered pending frames into the fewest
+ * `\n\n`-joined messages when the backlog is ≥ {@link backlogGlueThreshold};
+ * otherwise return the frames unchanged (1–2 stay separate).
+ *
+ * @param frames Ordered pending frames (each already a would-be single message).
+ * @param maxLen Per-message source-length cap (default {@link MAX_MESSAGE_LEN}).
+ * @param measureRendered Optional rendered-length measure; when supplied the
+ *   split also keeps each message's RENDERED length within Telegram's cap (same
+ *   contract as {@link splitMessage}). Omit for plain source-length splitting.
+ */
+function glueBacklogFrames(frames, maxLen = messageSplit_1.MAX_MESSAGE_LEN, measureRendered) {
+    if (frames.length < exports.backlogGlueThreshold)
+        return frames;
+    return (0, messageSplit_1.splitMessage)(frames.join(frameSeparator), maxLen, measureRendered);
+}
+//# sourceMappingURL=outputBacklogGlue.js.map

package/dist/connectors/telegram/outputBacklogGlue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputBacklogGlue.js","sourceRoot":"","sources":["../../../src/connectors/telegram/outputBacklogGlue.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAwBH,8CAOC;AA7BD,iDAA+D;AAE/D;;;GAGG;AACU,QAAA,oBAAoB,GAAG,CAAC,CAAC;AAEtC,iDAAiD;AACjD,MAAM,cAAc,GAAG,MAAM,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,SAAgB,iBAAiB,CAC/B,MAAgB,EAChB,SAAiB,8BAAe,EAChC,eAA2C;IAE3C,IAAI,MAAM,CAAC,MAAM,GAAG,4BAAoB;QAAE,OAAO,MAAM,CAAC;IACxD,OAAO,IAAA,2BAAY,EAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC;AAC5E,CAAC"}

package/dist/connectors/telegram/outputFlushPlan.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @description Pure planning logic for flushing agent `output` to Telegram —
+ * extracted from `bot.ts` so the streaming-append decision is unit-testable
+ * without booting Telegraf.
+ *
+ * Live repro 2026-06-05: OpenCode emits a long reply
+ * as incremental tails, and the bot edited the SAME message with only the
+ * newest batch each flush — every edit replaced everything before it, so the
+ * user could read only the last tail. The fix: a continuation tail is
+ * appended to the text already rendered into the last message and the FULL
+ * combined text is re-rendered (also re-pairing markdown tokens that straddle
+ * two flushes), spilling into new messages when it outgrows the Telegram cap.
+ */
+export interface OutputFlushInput {
+    /** The batch of output text to flush (already debounce-coalesced). */
+    output: string;
+    /** True when `output` continues the text already sent to `lastMessageId`. */
+    isContinuation: boolean;
+    /** Thread flag: next output must start a new message (user prompt, etc.). */
+    needsNewMessage: boolean;
+    /** Id of the last agent message in the thread, if editable. */
+    lastMessageId: number | null;
+    /** Source (pre-render) text currently shown in `lastMessageId`. */
+    lastMessageText: string | null;
+}
+export interface OutputFlushPlan {
+    /** Telegram-sized chunks covering the full (possibly combined) text. */
+    chunks: string[];
+    /**
+     * True → `chunks[0]` re-edits `lastMessageId` in place (append semantics);
+     * remaining chunks send as new messages. False → every chunk sends new.
+     */
+    shouldEditFirstChunk: boolean;
+}
+/**
+ * @description Decide how a flush lands in Telegram. Append-edit is possible
+ * only when the batch is a continuation AND the last message is still
+ * editable (id + source text known, no forced break since).
+ */
+export declare function getOutputFlushPlan(input: OutputFlushInput): OutputFlushPlan;
+/**
+ * @description The effective continuation flag the GROUP output path should use
+ * for an incoming `output`, accounting for adapters that stream WITHOUT marking
+ * continuations (the Claude scrape adapter).
+ *
+ * OpenCode marks every tail except a response's first with `meta.isContinuation`,
+ * so the group edit-in-place path already knows which outputs extend the last
+ * message; for it (`outputsDeltas === false`) the meta flag passes through
+ * unchanged. The Claude scrape adapter emits each poll's prose delta with NO
+ * meta even though every delta CONTINUES the same block — treating those as
+ * non-continuations made `getOutputFlushPlan` start a new message per poll flush
+ * (the one-message-per-scrape flood, and every re-flowed table width its own
+ * message).
+ *
+ * For a delta-emitting adapter a poll delta is therefore a CONTINUATION (it
+ * edits the growing message in place) UNLESS the pane had a real block boundary
+ * before it — a blank-line paragraph break or a distinct block (a settled
+ * table), both surfaced out-of-band as `startsNewParagraph`. At such a boundary
+ * the delta starts a NEW message (the locked boundary rule: a new message begins
+ * only at a paragraph/section, a distinct block, or a fresh turn — the last via
+ * `needsNewMessage`, which `getOutputFlushPlan` already honours). Unlike the DM
+ * cursor (one accumulating draft → everything is a continuation,
+ * {@link getDmDraftContinuation}), group renders discrete messages, so a
+ * paragraph/block boundary must break the message, not glue onto it.
+ */
+export declare function getGroupDeltaContinuation(metaIsContinuation: boolean, outputsDeltas: boolean, startsNewParagraph: boolean): boolean;
+/**
+ * @description Coalesce a new output batch into the pending (not yet flushed)
+ * buffer. Continuation tails concatenate as-is — they may be cut mid-word, a
+ * `\n` would split the word across lines. DISTINCT standalone outputs join with
+ * a single `\n` by default, UPGRADED to a BLANK LINE (`\n\n`) only when
+ * `startsNewParagraph` is set — the Claude scrape adapter reports out-of-band
+ * (`OutboundHints.startsNewParagraph`) when the pane had a real paragraph
+ * break before the chunk, so multi-paragraph answers keep their structure while
+ * a single wrapped paragraph spanning two polls is NOT split by a blank.
+ */
+export declare function appendPendingOutput(pending: string | null, output: string, isContinuation: boolean, startsNewParagraph?: boolean): string;
+/**
+ * @description Compute the text that must be RE-ENQUEUED after a flush where one
+ * or more chunks failed to send (live incident 2026-06-11, plan
+ * `2026-06-11-claude-wide-table-content-loss` S2: `replyChunkWithFallback`
+ * returns `null` when a chunk is dropped on a 429 after the rate-limit queue
+ * gives up; the buffer was already cleared, so the chunk was permanently lost).
+ *
+ * `sentCount` is the number of chunks that landed, counting from the FRONT of
+ * `chunks` (sends are in order, so a failure stops the run and everything from
+ * the first failure onward is un-sent). Returns the rejoined un-sent remainder,
+ * or `null` when everything landed. Idempotent: re-flushing the remainder never
+ * re-sends a landed chunk because those are excluded here. Pure + exported for
+ * unit tests.
+ */
+export declare function getUnsentRemainder(chunks: string[], sentCount: number): string | null;
+//# sourceMappingURL=outputFlushPlan.d.ts.map

package/dist/connectors/telegram/outputFlushPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputFlushPlan.d.ts","sourceRoot":"","sources":["../../../src/connectors/telegram/outputFlushPlan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAUH,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,cAAc,EAAE,OAAO,CAAC;IACxB,6EAA6E;IAC7E,eAAe,EAAE,OAAO,CAAC;IACzB,+DAA+D;IAC/D,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,mEAAmE;IACnE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,wEAAwE;IACxE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;OAGG;IACH,oBAAoB,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,eAAe,CAgB3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,yBAAyB,CACvC,kBAAkB,EAAE,OAAO,EAC3B,aAAa,EAAE,OAAO,EACtB,kBAAkB,EAAE,OAAO,GAC1B,OAAO,CAGT;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,OAAO,EACvB,kBAAkB,UAAQ,GACzB,MAAM,CAIR;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKrF"}