charness 0.0.0-stage → 3.1.0

package/dist/utils/openCodeTurnActivity.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @description Pure decision for the OpenCode "prompt delivered but the agent
+ * never ran a turn" detector.
+ *
+ * OpenCode ALWAYS creates an assistant message when a turn genuinely starts
+ * (even a pure delegation emits the parent's text before spawning a sub-agent),
+ * so a healthy turn is always accompanied by assistant activity. A WEDGED
+ * session instead accepts the prompt (HTTP 204 from `prompt_async`), records the
+ * user message, and its agent loop exits IMMEDIATELY — no `message.updated`, no
+ * parts, no LLM call — so `session.idle` arrives with zero assistant activity
+ * and the topic looks silently hung.
+ *
+ * Live incident (2026-08-15, the my-news digest schedule): a bloated session
+ * (~648K tokens) accepted every scheduled/manual prompt but produced no output;
+ * three user messages piled up with no assistant reply and the topic looked
+ * dead with no explanation.
+ *
+ * Guards against false positives:
+ *  - a context compaction cycle legitimately idles with no assistant text;
+ *  - a still-pending provider-managed retry keeps the turn alive past this idle.
+ */
+export interface OpenCodeTurnActivityState {
+    /** A prompt was sent and this `session.idle` is the first one since it. */
+    awaitingResponse: boolean;
+    /** Any assistant message / part was observed for this turn (own or child). */
+    sawActivity: boolean;
+    /** A context compaction was in flight as the turn ended. */
+    wasCompacting: boolean;
+    /** A provider-managed retry was still pending as the turn ended. */
+    hadPendingProviderRetry: boolean;
+}
+/**
+ * @description `true` when a delivered prompt produced no turn at all — the
+ * caller should surface a notice instead of leaving the topic silently hung.
+ */
+export declare function checkIsWedgedTurn(state: OpenCodeTurnActivityState): boolean;
+/**
+ * @description State read when the bound on a post-provider-retry REPLACEMENT
+ * prompt's turn start elapses.
+ *
+ * `session.status` events carry no turn identifier, so after aborting a stale
+ * provider-managed retry the adapter marks a boundary and treats the next
+ * observed `busy` as the replacement turn's start. A WEDGED session accepts the
+ * replacement (HTTP 204) and never runs it, so that `busy` never arrives: the
+ * boundary would stay armed forever, swallowing every later idle, pinning the
+ * optimistic busy state, and leaving wedge detection disarmed — a permanently
+ * hung topic that nothing recovers.
+ */
+export interface OpenCodeReplacementTurnState {
+    /** The session is still live (not stopped / detached / replaced by a resume). */
+    isSessionActive: boolean;
+    /** The replacement boundary is still armed — no `busy` was ever observed. */
+    isAwaitingReplacementStart: boolean;
+    /** Any assistant activity was observed since the replacement prompt was sent. */
+    sawActivity: boolean;
+}
+/**
+ * @description `true` when the elapsed bound proves the replacement prompt never
+ * became a turn — the caller must end the abort episode and hand the thread to
+ * wedge recovery instead of waiting for a `busy` that will never come.
+ *
+ * Assistant activity releases the bound the same way {@link checkIsWedgedTurn}
+ * treats it: a turn that produced output genuinely started, even if its `busy`
+ * status was dropped, so reporting it would fire recovery on a working thread.
+ */
+export declare function checkIsReplacementTurnMissing(state: OpenCodeReplacementTurnState): boolean;
+//# sourceMappingURL=openCodeTurnActivity.d.ts.map

package/dist/utils/openCodeTurnActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeTurnActivity.d.ts","sourceRoot":"","sources":["../../src/utils/openCodeTurnActivity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,yBAAyB;IACxC,2EAA2E;IAC3E,gBAAgB,EAAE,OAAO,CAAC;IAC1B,8EAA8E;IAC9E,WAAW,EAAE,OAAO,CAAC;IACrB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAO3E;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,4BAA4B;IAC3C,iFAAiF;IACjF,eAAe,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,0BAA0B,EAAE,OAAO,CAAC;IACpC,iFAAiF;IACjF,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAE1F"}

package/dist/utils/openCodeTurnActivity.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIsWedgedTurn = checkIsWedgedTurn;
+exports.checkIsReplacementTurnMissing = checkIsReplacementTurnMissing;
+/**
+ * @description `true` when a delivered prompt produced no turn at all — the
+ * caller should surface a notice instead of leaving the topic silently hung.
+ */
+function checkIsWedgedTurn(state) {
+    return (state.awaitingResponse &&
+        !state.sawActivity &&
+        !state.wasCompacting &&
+        !state.hadPendingProviderRetry);
+}
+/**
+ * @description `true` when the elapsed bound proves the replacement prompt never
+ * became a turn — the caller must end the abort episode and hand the thread to
+ * wedge recovery instead of waiting for a `busy` that will never come.
+ *
+ * Assistant activity releases the bound the same way {@link checkIsWedgedTurn}
+ * treats it: a turn that produced output genuinely started, even if its `busy`
+ * status was dropped, so reporting it would fire recovery on a working thread.
+ */
+function checkIsReplacementTurnMissing(state) {
+    return state.isSessionActive && state.isAwaitingReplacementStart && !state.sawActivity;
+}
+//# sourceMappingURL=openCodeTurnActivity.js.map

package/dist/utils/openCodeTurnActivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeTurnActivity.js","sourceRoot":"","sources":["../../src/utils/openCodeTurnActivity.ts"],"names":[],"mappings":";;AAoCA,8CAOC;AAgCD,sEAEC;AA7CD;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,KAAgC;IAChE,OAAO,CACL,KAAK,CAAC,gBAAgB;QACtB,CAAC,KAAK,CAAC,WAAW;QAClB,CAAC,KAAK,CAAC,aAAa;QACpB,CAAC,KAAK,CAAC,uBAAuB,CAC/B,CAAC;AACJ,CAAC;AAuBD;;;;;;;;GAQG;AACH,SAAgB,6BAA6B,CAAC,KAAmC;IAC/E,OAAO,KAAK,CAAC,eAAe,IAAI,KAAK,CAAC,0BAA0B,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;AACzF,CAAC"}

package/dist/utils/outputDebounce.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @description The output-debounce constant, extracted as a pure helper so the
+ * value is unit-testable WITHOUT booting Telegraf.
+ *
+ * DM v2: the persist/`queueOutput` path runs in GROUP mode ONLY — DM streams its
+ * reply through the native-draft cursor (`bot.ts` draft manager) and finalizes
+ * at explicit boundaries, so it never debounces here. There is therefore one
+ * window left: the original group cadence. The function keeps a thin accessor
+ * shape so the regression test can assert the exact value against the same
+ * source `bot.ts` uses — no drift.
+ */
+/**
+ * Group-mode debounce (S2). Raised 1s → 3s so each topic coalesces its own
+ * stream to at most ~1 update / 3s: fewer, larger edits that compose with the
+ * global 1/2s send pacer instead of a trickle of tiny sends.
+ */
+export declare const OUTPUT_DEBOUNCE_MS = 3000;
+/**
+ * @description The output debounce window. Group-only now (DM finalizes the
+ * draft at boundaries instead of debouncing the persist), so there is a single
+ * value — the original group cadence.
+ */
+export declare function getOutputDebounceMs(): number;
+//# sourceMappingURL=outputDebounce.d.ts.map

package/dist/utils/outputDebounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputDebounce.d.ts","sourceRoot":"","sources":["../../src/utils/outputDebounce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/utils/outputDebounce.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @description The output-debounce constant, extracted as a pure helper so the
+ * value is unit-testable WITHOUT booting Telegraf.
+ *
+ * DM v2: the persist/`queueOutput` path runs in GROUP mode ONLY — DM streams its
+ * reply through the native-draft cursor (`bot.ts` draft manager) and finalizes
+ * at explicit boundaries, so it never debounces here. There is therefore one
+ * window left: the original group cadence. The function keeps a thin accessor
+ * shape so the regression test can assert the exact value against the same
+ * source `bot.ts` uses — no drift.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTPUT_DEBOUNCE_MS = void 0;
+exports.getOutputDebounceMs = getOutputDebounceMs;
+/**
+ * Group-mode debounce (S2). Raised 1s → 3s so each topic coalesces its own
+ * stream to at most ~1 update / 3s: fewer, larger edits that compose with the
+ * global 1/2s send pacer instead of a trickle of tiny sends.
+ */
+exports.OUTPUT_DEBOUNCE_MS = 3000;
+/**
+ * @description The output debounce window. Group-only now (DM finalizes the
+ * draft at boundaries instead of debouncing the persist), so there is a single
+ * value — the original group cadence.
+ */
+function getOutputDebounceMs() {
+    return exports.OUTPUT_DEBOUNCE_MS;
+}
+//# sourceMappingURL=outputDebounce.js.map

package/dist/utils/outputDebounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputDebounce.js","sourceRoot":"","sources":["../../src/utils/outputDebounce.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAcH,kDAEC;AAdD;;;;GAIG;AACU,QAAA,kBAAkB,GAAG,IAAI,CAAC;AAEvC;;;;GAIG;AACH,SAAgB,mBAAmB;IACjC,OAAO,0BAAkB,CAAC;AAC5B,CAAC"}

package/dist/utils/outputFlushTiming.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @description Pure decision for WHEN the per-thread output queue should flush
+ * a freshly-queued frame.
+ *
+ * Extracted from `bot.ts`'s `getOutputDelay` so the timing rule is
+ * unit-testable without the Telegraf / queue machinery (same pattern as
+ * {@link ../utils/statusFlushDecision.ts}). It governs only flush TIMING — the
+ * append/continuation semantics of the buffer are decided elsewhere.
+ *
+ * Three cases:
+ * - `isFinal` (the turn's last frame, emitted as the session goes idle) →
+ *   `'now'`: flush immediately, regardless of a 429 cooldown. A turn that just
+ *   ended must not look hung while its closing message sits out the stretched
+ *   debounce.
+ * - non-final + rate-limited → the stretched debounce, ADAPTIVELY scaled to the
+ *   live remaining cooldown (S3): while throttled, batch the whole cooldown into
+ *   one larger edit instead of a flat 5s, so a long 429 produces fewer, larger
+ *   API calls rather than a backlog of tiny ones. A short cooldown still gets at
+ *   least the 5s floor.
+ * - non-final + normal → the normal debounce.
+ */
+/**
+ * Stretched debounce FLOOR used while the chat is inside a Telegram 429 cooldown,
+ * so coalesced output is sent in larger, less-frequent batches instead of
+ * hammering an already-throttling API. The actual in-cooldown debounce scales UP
+ * to the live remaining cooldown when that is longer (S3).
+ */
+export declare const rateLimitedOutputDebounceMs = 5000;
+/** A flush that should fire immediately, bypassing the debounce. */
+export type ImmediateFlush = 'now';
+export interface OutputFlushTimingInput {
+    /** Is this the turn's final frame (emitted as the session goes idle)? */
+    isFinal: boolean;
+    /** Is the chat currently inside a Telegram 429 cooldown? */
+    isRateLimited: boolean;
+    /** The thread's normal debounce window, in ms. */
+    normalDebounceMs: number;
+    /**
+     * Live remaining 429 cooldown for the chat, in ms (0 / omitted when not
+     * limited). While rate-limited, the debounce scales to this so the flush
+     * batches the whole cooldown into one larger edit (S3) — fewer, bigger edits
+     * under a long 429. Ignored when not rate-limited.
+     */
+    remainingCooldownMs?: number;
+}
+/**
+ * @description Decide the flush timing for a queued output frame: either flush
+ * `'now'` (final frame) or after a debounce delay in ms. While rate-limited the
+ * delay is the LONGEST of the normal debounce, the 5s floor, and the live
+ * remaining cooldown — so a long cooldown coalesces into a single larger edit
+ * rather than a backlog of tiny ones (S3).
+ */
+export declare function getOutputFlushTiming(input: OutputFlushTimingInput): ImmediateFlush | number;
+//# sourceMappingURL=outputFlushTiming.d.ts.map

package/dist/utils/outputFlushTiming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputFlushTiming.d.ts","sourceRoot":"","sources":["../../src/utils/outputFlushTiming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC;AAEnC,MAAM,WAAW,sBAAsB;IACrC,yEAAyE;IACzE,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAC;IACvB,kDAAkD;IAClD,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,sBAAsB,GAAG,cAAc,GAAG,MAAM,CAU3F"}

package/dist/utils/outputFlushTiming.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * @description Pure decision for WHEN the per-thread output queue should flush
+ * a freshly-queued frame.
+ *
+ * Extracted from `bot.ts`'s `getOutputDelay` so the timing rule is
+ * unit-testable without the Telegraf / queue machinery (same pattern as
+ * {@link ../utils/statusFlushDecision.ts}). It governs only flush TIMING — the
+ * append/continuation semantics of the buffer are decided elsewhere.
+ *
+ * Three cases:
+ * - `isFinal` (the turn's last frame, emitted as the session goes idle) →
+ *   `'now'`: flush immediately, regardless of a 429 cooldown. A turn that just
+ *   ended must not look hung while its closing message sits out the stretched
+ *   debounce.
+ * - non-final + rate-limited → the stretched debounce, ADAPTIVELY scaled to the
+ *   live remaining cooldown (S3): while throttled, batch the whole cooldown into
+ *   one larger edit instead of a flat 5s, so a long 429 produces fewer, larger
+ *   API calls rather than a backlog of tiny ones. A short cooldown still gets at
+ *   least the 5s floor.
+ * - non-final + normal → the normal debounce.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimitedOutputDebounceMs = void 0;
+exports.getOutputFlushTiming = getOutputFlushTiming;
+/**
+ * Stretched debounce FLOOR used while the chat is inside a Telegram 429 cooldown,
+ * so coalesced output is sent in larger, less-frequent batches instead of
+ * hammering an already-throttling API. The actual in-cooldown debounce scales UP
+ * to the live remaining cooldown when that is longer (S3).
+ */
+exports.rateLimitedOutputDebounceMs = 5000;
+/**
+ * @description Decide the flush timing for a queued output frame: either flush
+ * `'now'` (final frame) or after a debounce delay in ms. While rate-limited the
+ * delay is the LONGEST of the normal debounce, the 5s floor, and the live
+ * remaining cooldown — so a long cooldown coalesces into a single larger edit
+ * rather than a backlog of tiny ones (S3).
+ */
+function getOutputFlushTiming(input) {
+    if (input.isFinal)
+        return 'now';
+    if (input.isRateLimited) {
+        return Math.max(input.normalDebounceMs, exports.rateLimitedOutputDebounceMs, input.remainingCooldownMs ?? 0);
+    }
+    return input.normalDebounceMs;
+}
+//# sourceMappingURL=outputFlushTiming.js.map

package/dist/utils/outputFlushTiming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputFlushTiming.js","sourceRoot":"","sources":["../../src/utils/outputFlushTiming.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAoCH,oDAUC;AA5CD;;;;;GAKG;AACU,QAAA,2BAA2B,GAAG,IAAI,CAAC;AAqBhD;;;;;;GAMG;AACH,SAAgB,oBAAoB,CAAC,KAA6B;IAChE,IAAI,KAAK,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAChC,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC,GAAG,CACb,KAAK,CAAC,gBAAgB,EACtB,mCAA2B,EAC3B,KAAK,CAAC,mBAAmB,IAAI,CAAC,CAC/B,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC,gBAAgB,CAAC;AAChC,CAAC"}

package/dist/utils/paginateList.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @description Generic pagination math shared by every inline-keyboard picker
+ * (`/bind` folders, `/model` models). Extracted from `paginateBindList` so the
+ * slice/clamp rules live in ONE place — a second picker must not re-derive
+ * them and drift (e.g. clamp a stale page to an empty slice instead of the
+ * last page).
+ */
+export interface PaginatedSlice<T> {
+    /** Entries visible on the resolved page. */
+    slice: T[];
+    /** `page` clamped to `[0, totalPages-1]` and floored to an integer. */
+    currentPage: number;
+    /** Total number of pages, ≥ 1 even for an empty list. */
+    totalPages: number;
+}
+/**
+ * @description Slice `items` into the page the caller asked for.
+ *
+ * `pageSize` must be a positive integer. Out-of-range `page` values are clamped
+ * silently rather than throwing — a stale callback (the underlying list shrank
+ * between rendering the keyboard and the tap) must land on the last available
+ * page, not blow up or render an empty body.
+ */
+export declare function paginateList<T>(items: readonly T[], page: number, pageSize: number): PaginatedSlice<T>;
+//# sourceMappingURL=paginateList.d.ts.map

package/dist/utils/paginateList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginateList.d.ts","sourceRoot":"","sources":["../../src/utils/paginateList.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,4CAA4C;IAC5C,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,cAAc,CAAC,CAAC,CAAC,CAYnB"}

package/dist/utils/paginateList.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @description Generic pagination math shared by every inline-keyboard picker
+ * (`/bind` folders, `/model` models). Extracted from `paginateBindList` so the
+ * slice/clamp rules live in ONE place — a second picker must not re-derive
+ * them and drift (e.g. clamp a stale page to an empty slice instead of the
+ * last page).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateList = paginateList;
+/**
+ * @description Slice `items` into the page the caller asked for.
+ *
+ * `pageSize` must be a positive integer. Out-of-range `page` values are clamped
+ * silently rather than throwing — a stale callback (the underlying list shrank
+ * between rendering the keyboard and the tap) must land on the last available
+ * page, not blow up or render an empty body.
+ */
+function paginateList(items, page, pageSize) {
+    if (!Number.isInteger(pageSize) || pageSize <= 0) {
+        throw new Error(`paginateList: pageSize must be a positive integer, got ${pageSize}`);
+    }
+    const totalPages = Math.max(1, Math.ceil(items.length / pageSize));
+    const clampedPage = Math.max(0, Math.min(Math.floor(page) || 0, totalPages - 1));
+    const start = clampedPage * pageSize;
+    return {
+        slice: items.slice(start, start + pageSize),
+        currentPage: clampedPage,
+        totalPages,
+    };
+}
+//# sourceMappingURL=paginateList.js.map

package/dist/utils/paginateList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginateList.js","sourceRoot":"","sources":["../../src/utils/paginateList.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAmBH,oCAgBC;AAxBD;;;;;;;GAOG;AACH,SAAgB,YAAY,CAC1B,KAAmB,EACnB,IAAY,EACZ,QAAgB;IAEhB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,0DAA0D,QAAQ,EAAE,CAAC,CAAC;IACxF,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC;IACnE,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC;IACjF,MAAM,KAAK,GAAG,WAAW,GAAG,QAAQ,CAAC;IACrC,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC;QAC3C,WAAW,EAAE,WAAW;QACxB,UAAU;KACX,CAAC;AACJ,CAAC"}

package/dist/utils/paneDiff.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @description Result of {@link getNewPaneContent}: the diffed NEW pane text
+ * plus an OUT-OF-BAND signal that the chunk's first new line was preceded by a
+ * paragraph break in the pane. The break is reported separately (not as a
+ * leading blank in `text`) because every downstream `.trim()` would strip a
+ * leading blank, and a fresh Telegram message must never start blank anyway —
+ * so the JOIN layer reconstructs the separator from this flag instead.
+ */
+export interface NewPaneContent {
+    /** The new pane lines, leading/trailing blanks trimmed (interior blanks kept). */
+    text: string;
+    /**
+     * True IFF a blank line immediately preceded the chunk's first new line AND
+     * there was content above that blank (so it is a real inter-paragraph break,
+     * not pane-top padding). Consumed only at the append JOIN, never at a message
+     * start. See {@link OutboundHints.startsNewParagraph}.
+     */
+    startsNewParagraph: boolean;
+}
+/**
+ * @description Diff a freshly-captured pane against the last one and return
+ * only the NEW lines, as a line-SET difference (positions ignored — Claude's
+ * TUI redraws the whole pane every poll, so a positional diff would re-emit
+ * everything that scrolled).
+ *
+ * Blank lines are NOT part of the matched set (they aren't unique), but a
+ * single blank that sat BETWEEN two runs of new content is preserved as a
+ * paragraph separator: the previous implementation `continue`d past every
+ * empty line, so multi-paragraph answers arrived in Telegram with every
+ * paragraph glued to the next (the `cleanOutput` C1 fix only kept blanks in
+ * the FULL pane; this delta path still dropped them). An INTERIOR blank (within
+ * this chunk) is kept inline in `text`; a LEADING blank (before the chunk's
+ * first new line) is instead reported via `startsNewParagraph` so the separator
+ * survives the pipeline's trims and is rebuilt only at the append join.
+ *
+ * Suppression is by SET membership, not multiset count (B10): a line that
+ * appeared in `oldContent` at all is suppressed for EVERY occurrence in
+ * `newContent`, not just the first `oldCount` of them. Why: typing a draft
+ * that wraps to several rows grows Claude's input box; the viewport is fixed
+ * height, so the transcript scrolls and tmux re-renders the lines straddling
+ * the scrollback↔visible boundary twice in one capture. The old multiset diff
+ * suppressed only as many copies as `oldContent` held, so the extra copy of an
+ * already-sent answer line counted as new and was re-emitted (a chunk of the
+ * previous answer reappeared before the next turn). Set membership errs toward
+ * DROPPING such a re-render duplicate — the locked tradeoff, since a re-send is
+ * the user-visible bug while a genuinely-new line that merely repeats an
+ * earlier transcript line is a rare, low-cost loss. (Note: `lastContent`
+ * advances to the full pane on every change in `pollOutput`, NOT only on emit,
+ * so a suppressed line does NOT self-heal next poll — hence we suppress only
+ * lines that were truly already present.)
+ *
+ * Exported + pure so the diff is unit-testable without booting tmux.
+ */
+export declare function getNewPaneContent(oldContent: string, newContent: string): NewPaneContent;
+//# sourceMappingURL=paneDiff.d.ts.map

package/dist/utils/paneDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paneDiff.d.ts","sourceRoot":"","sources":["../../src/utils/paneDiff.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAkDxF"}

package/dist/utils/paneDiff.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNewPaneContent = getNewPaneContent;
+const recentRelayWindow_1 = require("./recentRelayWindow");
+/**
+ * @description Diff a freshly-captured pane against the last one and return
+ * only the NEW lines, as a line-SET difference (positions ignored — Claude's
+ * TUI redraws the whole pane every poll, so a positional diff would re-emit
+ * everything that scrolled).
+ *
+ * Blank lines are NOT part of the matched set (they aren't unique), but a
+ * single blank that sat BETWEEN two runs of new content is preserved as a
+ * paragraph separator: the previous implementation `continue`d past every
+ * empty line, so multi-paragraph answers arrived in Telegram with every
+ * paragraph glued to the next (the `cleanOutput` C1 fix only kept blanks in
+ * the FULL pane; this delta path still dropped them). An INTERIOR blank (within
+ * this chunk) is kept inline in `text`; a LEADING blank (before the chunk's
+ * first new line) is instead reported via `startsNewParagraph` so the separator
+ * survives the pipeline's trims and is rebuilt only at the append join.
+ *
+ * Suppression is by SET membership, not multiset count (B10): a line that
+ * appeared in `oldContent` at all is suppressed for EVERY occurrence in
+ * `newContent`, not just the first `oldCount` of them. Why: typing a draft
+ * that wraps to several rows grows Claude's input box; the viewport is fixed
+ * height, so the transcript scrolls and tmux re-renders the lines straddling
+ * the scrollback↔visible boundary twice in one capture. The old multiset diff
+ * suppressed only as many copies as `oldContent` held, so the extra copy of an
+ * already-sent answer line counted as new and was re-emitted (a chunk of the
+ * previous answer reappeared before the next turn). Set membership errs toward
+ * DROPPING such a re-render duplicate — the locked tradeoff, since a re-send is
+ * the user-visible bug while a genuinely-new line that merely repeats an
+ * earlier transcript line is a rare, low-cost loss. (Note: `lastContent`
+ * advances to the full pane on every change in `pollOutput`, NOT only on emit,
+ * so a suppressed line does NOT self-heal next poll — hence we suppress only
+ * lines that were truly already present.)
+ *
+ * Exported + pure so the diff is unit-testable without booting tmux.
+ */
+function getNewPaneContent(oldContent, newContent) {
+    if (!oldContent)
+        return { text: newContent, startsNewParagraph: false };
+    if (oldContent === newContent)
+        return { text: '', startsNewParagraph: false };
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const oldLineSet = new Set();
+    for (const line of oldLines) {
+        const normalized = (0, recentRelayWindow_1.normalizeForComparison)(line);
+        if (normalized)
+            oldLineSet.add(normalized);
+    }
+    const newParts = [];
+    let pendingBlank = false;
+    // True once any content line (retained-old skipped OR new pushed) has been
+    // seen, so a blank that precedes the chunk's FIRST emitted new line counts as
+    // a real paragraph break only when there was content above it — pane-top
+    // padding (no content above) must not produce a leading separator.
+    let sawContent = false;
+    let startsNewParagraph = false;
+    for (const line of newLines) {
+        const normalized = (0, recentRelayWindow_1.normalizeForComparison)(line);
+        if (!normalized) {
+            pendingBlank = true;
+            continue;
+        }
+        if (oldLineSet.has(normalized)) {
+            pendingBlank = false;
+            sawContent = true;
+            continue;
+        }
+        if (newParts.length === 0) {
+            // First emitted new line: the leading blank is dropped from `text` (a
+            // fresh message must never start blank), but reported out-of-band so the
+            // JOIN can rebuild the separator — only when there was content above it.
+            if (pendingBlank && sawContent)
+                startsNewParagraph = true;
+        }
+        else if (pendingBlank) {
+            // Interior blank within this chunk — keep it inline as a separator.
+            newParts.push('');
+        }
+        newParts.push(line);
+        pendingBlank = false;
+        sawContent = true;
+    }
+    return { text: newParts.join('\n').trim(), startsNewParagraph };
+}
+//# sourceMappingURL=paneDiff.js.map

package/dist/utils/paneDiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paneDiff.js","sourceRoot":"","sources":["../../src/utils/paneDiff.ts"],"names":[],"mappings":";;AAwDA,8CAkDC;AA1GD,2DAA6D;AAsB7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,iBAAiB,CAAC,UAAkB,EAAE,UAAkB;IACtE,IAAI,CAAC,UAAU;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;IACxE,IAAI,UAAU,KAAK,UAAU;QAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;IAE9E,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAExC,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IACrC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,MAAM,UAAU,GAAG,IAAA,0CAAsB,EAAC,IAAI,CAAC,CAAC;QAChD,IAAI,UAAU;YAAE,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,2EAA2E;IAC3E,8EAA8E;IAC9E,yEAAyE;IACzE,mEAAmE;IACnE,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,kBAAkB,GAAG,KAAK,CAAC;IAE/B,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,MAAM,UAAU,GAAG,IAAA,0CAAsB,EAAC,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,YAAY,GAAG,IAAI,CAAC;YACpB,SAAS;QACX,CAAC;QAED,IAAI,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YAC/B,YAAY,GAAG,KAAK,CAAC;YACrB,UAAU,GAAG,IAAI,CAAC;YAClB,SAAS;QACX,CAAC;QAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,sEAAsE;YACtE,yEAAyE;YACzE,yEAAyE;YACzE,IAAI,YAAY,IAAI,UAAU;gBAAE,kBAAkB,GAAG,IAAI,CAAC;QAC5D,CAAC;aAAM,IAAI,YAAY,EAAE,CAAC;YACxB,oEAAoE;YACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACpB,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,YAAY,GAAG,KAAK,CAAC;QACrB,UAAU,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,kBAAkB,EAAE,CAAC;AAClE,CAAC"}

package/dist/utils/paneResizeGuard.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @description Pure decision logic for the Claude scrape pane-RESIZE guard.
+ *
+ * WHY it exists (live incident 2026-07-02): an interactive
+ * `tmux attach` from a normal-width terminal resizes the tmux window to the
+ * client's size (and back to the `-x/-y` default on detach). tmux re-wraps the
+ * WHOLE scrollback at the new width, so every physical line becomes a
+ * different string: the per-poll line-SET diff (`getNewPaneContent`) sees
+ * ~everything as "new" (69k-char diffs), and the long-horizon relay window
+ * can't match re-wrapped lines either — its 16-char minimum deliberately
+ * exempts short lines, so clusters of short old lines (JSON fragments, code
+ * snippets, list numbers) leaked into the topic as ragged messages on EVERY
+ * width flap, and captures taken mid-repaint leaked broken ANSI prefixes as
+ * status frames.
+ *
+ * The guard: the poll loop queries `#{pane_width}x#{pane_height}` AFTER each
+ * capture (same-poll order matters — a resize landing between the two calls is
+ * then detected on THIS poll, never after the giant diff already shipped). On
+ * a size change it emits NOTHING and re-seeds the diff baseline from the fresh
+ * capture, then stays in a short "settling" mode until a poll sees the capture
+ * unchanged (the TUI's own SIGWINCH repaint may lag tmux's mechanical re-wrap
+ * by a poll or two). {@link resizeSettleMaxPolls} caps the mode so a busy,
+ * constantly-streaming pane can never be wedged into permanent silence —
+ * same shape as the resume-seeding cap.
+ *
+ * Locked tradeoff (same direction as `getNewPaneContent` and
+ * `recentRelayWindow`): err toward DROPPING output. Real output produced
+ * during the few settling polls is swallowed with the repaint; a resize flood
+ * is the user-visible bug, a ~1-2s hole in a streamed answer mid-resize is a
+ * low-cost loss.
+ */
+/**
+ * @description Hard cap on consecutive suppressed settling polls. The normal
+ * exit is "same size and the capture stopped changing"; a pane that streams
+ * real output non-stop never goes quiet, so without the cap a mid-turn resize
+ * would suppress the rest of the answer. ~6 polls at base cadence ≈ 2s —
+ * comfortably covers tmux's re-wrap + the TUI's SIGWINCH repaint.
+ */
+export declare const resizeSettleMaxPolls = 6;
+/**
+ * @description Parse the raw `display-message` reply into a canonical
+ * `<width>x<height>` size string, or `null` when the query failed or returned
+ * something unexpected (never guess a size from garbage).
+ */
+export declare function parsePaneSize(raw: string): string | null;
+export interface PaneResizeGuardInput {
+    /** Last known pane size (`null` before the first successful query). */
+    lastSize: string | null;
+    /** This poll's parsed size (`null` = the query failed this poll). */
+    currentSize: string | null;
+    /** Whether the previous poll left the session in settling mode. */
+    isSettling: boolean;
+    /** Consecutive suppressed polls already spent settling. */
+    settlePolls: number;
+    /** Whether this poll's raw capture differs from the previous poll's. */
+    isRawChanged: boolean;
+}
+export interface PaneResizeGuardDecision {
+    /** `suppress` = emit nothing this poll and re-seed the diff baseline. */
+    action: 'proceed' | 'suppress';
+    nextIsSettling: boolean;
+    nextSettlePolls: number;
+}
+/**
+ * @description Decide whether this poll's capture is (part of) a resize
+ * repaint that must be swallowed. See the module JSDoc for the mechanism.
+ */
+export declare function getPaneResizeGuardDecision(input: PaneResizeGuardInput): PaneResizeGuardDecision;
+//# sourceMappingURL=paneResizeGuard.d.ts.map

package/dist/utils/paneResizeGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paneResizeGuard.d.ts","sourceRoot":"","sources":["../../src/utils/paneResizeGuard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGxD;AAED,MAAM,WAAW,oBAAoB;IACnC,uEAAuE;IACvE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,qEAAqE;IACrE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAC;IACpB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,yEAAyE;IACzE,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC;IAC/B,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AAQD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,oBAAoB,GAAG,uBAAuB,CA8B/F"}