charness 0.0.0-stage → 3.1.0

package/dist/utils/paneResizeGuard.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resizeSettleMaxPolls = void 0;
+exports.parsePaneSize = parsePaneSize;
+exports.getPaneResizeGuardDecision = getPaneResizeGuardDecision;
+/** Shape of a valid `display-message -p '#{pane_width}x#{pane_height}'` reply. */
+const PANE_SIZE_RE = /^\d+x\d+$/;
+/**
+ * @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.
+ */
+exports.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).
+ */
+function parsePaneSize(raw) {
+    const trimmed = raw.trim();
+    return PANE_SIZE_RE.test(trimmed) ? trimmed : null;
+}
+const proceedDecision = {
+    action: 'proceed',
+    nextIsSettling: false,
+    nextSettlePolls: 0,
+};
+/**
+ * @description Decide whether this poll's capture is (part of) a resize
+ * repaint that must be swallowed. See the module JSDoc for the mechanism.
+ */
+function getPaneResizeGuardDecision(input) {
+    const { lastSize, currentSize, isSettling, settlePolls, isRawChanged } = input;
+    const nextSettlePolls = settlePolls + 1;
+    // The cap fires no matter which branch keeps the mode alive — a wedge-guard,
+    // not part of the normal exit.
+    const suppressDecision = nextSettlePolls >= exports.resizeSettleMaxPolls
+        ? proceedDecision
+        : { action: 'suppress', nextIsSettling: true, nextSettlePolls };
+    if (currentSize === null) {
+        // Size query failed — can't judge. Mid-settle the repaint may still be
+        // running, so stay suppressed (bounded by the cap); otherwise never
+        // suppress on missing data.
+        return isSettling ? suppressDecision : proceedDecision;
+    }
+    // First successful read of this session — a baseline, never a resize.
+    if (lastSize === null)
+        return proceedDecision;
+    if (currentSize !== lastSize)
+        return suppressDecision;
+    if (isSettling) {
+        // Size is stable again but the pane may still be repainting the re-wrapped
+        // scrollback — hold until a poll sees the capture unchanged.
+        return isRawChanged ? suppressDecision : proceedDecision;
+    }
+    return proceedDecision;
+}
+//# sourceMappingURL=paneResizeGuard.js.map

package/dist/utils/paneResizeGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paneResizeGuard.js","sourceRoot":"","sources":["../../src/utils/paneResizeGuard.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAmBH,sCAGC;AAgCD,gEA8BC;AAlFD,kFAAkF;AAClF,MAAM,YAAY,GAAG,WAAW,CAAC;AAEjC;;;;;;GAMG;AACU,QAAA,oBAAoB,GAAG,CAAC,CAAC;AAEtC;;;;GAIG;AACH,SAAgB,aAAa,CAAC,GAAW;IACvC,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3B,OAAO,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;AACrD,CAAC;AAsBD,MAAM,eAAe,GAA4B;IAC/C,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE,KAAK;IACrB,eAAe,EAAE,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,SAAgB,0BAA0B,CAAC,KAA2B;IACpE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC;IAE/E,MAAM,eAAe,GAAG,WAAW,GAAG,CAAC,CAAC;IACxC,6EAA6E;IAC7E,+BAA+B;IAC/B,MAAM,gBAAgB,GACpB,eAAe,IAAI,4BAAoB;QACrC,CAAC,CAAC,eAAe;QACjB,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IAEpE,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;QACzB,uEAAuE;QACvE,oEAAoE;QACpE,4BAA4B;QAC5B,OAAO,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,eAAe,CAAC;IACzD,CAAC;IAED,sEAAsE;IACtE,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,eAAe,CAAC;IAE9C,IAAI,WAAW,KAAK,QAAQ;QAAE,OAAO,gBAAgB,CAAC;IAEtD,IAAI,UAAU,EAAE,CAAC;QACf,2EAA2E;QAC3E,6DAA6D;QAC7D,OAAO,YAAY,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,eAAe,CAAC;IAC3D,CAAC;IAED,OAAO,eAAe,CAAC;AACzB,CAAC"}

package/dist/utils/persistAdapterSessionIds.d.ts

@@ -0,0 +1,39 @@
+import type { SessionKey } from '../sessionKey';
+/**
+ * @description Minimal slice of a concrete adapter that session-id persistence
+ * reads: the backend-specific live session-id getter. Exactly one of the two
+ * getters exists per adapter class (Claude exposes its tmux/CLI UUID, OpenCode
+ * its server session id), so the persistence branch keys on method presence —
+ * the structural, stub-friendly equivalent of `instanceof ClaudeCliAdapter` /
+ * `instanceof OpenCodeAdapter`.
+ */
+export interface SessionIdSourceAdapter {
+    /** Unique adapter identifier, e.g. 'claude', 'opencode' (persisted as agent name). */
+    readonly name: string;
+    getClaudeSessionId?: (key: SessionKey) => string | null;
+    getOpenCodeSessionId?: (key: SessionKey) => string | null;
+}
+/**
+ * @description Minimal slice of `StateStore` that session-id persistence
+ * writes, so the helper is unit-testable with a recording stub.
+ */
+export interface SessionIdPersistenceStore {
+    setClaudeSessionId(key: SessionKey, uuid: string): Promise<void>;
+    setOpenCodeSessionId(key: SessionKey, id: string): Promise<void>;
+    setAgent(key: SessionKey, data: {
+        name: string;
+    }): Promise<void>;
+}
+/**
+ * @description Persist the adapter's CURRENT backend session id (+ the adapter
+ * name) so a bot restart re-attaches to the same session. Shared by the fresh
+ * start (`startAgentSession`) AND the user resume pick (`resumeSessionByIndex`)
+ * — before extraction only the fresh start persisted, so a `/sessions` pick
+ * was silently lost on the next restart and the thread fell back to an earlier
+ * session (live incident 2026-06-10).
+ *
+ * An adapter reporting no live id (getter returns `null`) keeps the previously
+ * persisted id untouched; the agent name is recorded unconditionally.
+ */
+export declare function persistAdapterSessionIds(key: SessionKey, adapter: SessionIdSourceAdapter, store: SessionIdPersistenceStore): Promise<void>;
+//# sourceMappingURL=persistAdapterSessionIds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persistAdapterSessionIds.d.ts","sourceRoot":"","sources":["../../src/utils/persistAdapterSessionIds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,MAAM,GAAG,IAAI,CAAC;IACxD,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,MAAM,GAAG,IAAI,CAAC;CAC3D;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,kBAAkB,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,oBAAoB,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,sBAAsB,EAC/B,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/utils/persistAdapterSessionIds.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistAdapterSessionIds = persistAdapterSessionIds;
+/**
+ * @description Persist the adapter's CURRENT backend session id (+ the adapter
+ * name) so a bot restart re-attaches to the same session. Shared by the fresh
+ * start (`startAgentSession`) AND the user resume pick (`resumeSessionByIndex`)
+ * — before extraction only the fresh start persisted, so a `/sessions` pick
+ * was silently lost on the next restart and the thread fell back to an earlier
+ * session (live incident 2026-06-10).
+ *
+ * An adapter reporting no live id (getter returns `null`) keeps the previously
+ * persisted id untouched; the agent name is recorded unconditionally.
+ */
+async function persistAdapterSessionIds(key, adapter, store) {
+    if (adapter.getClaudeSessionId) {
+        const uuid = adapter.getClaudeSessionId(key);
+        if (uuid)
+            await store.setClaudeSessionId(key, uuid);
+    }
+    else if (adapter.getOpenCodeSessionId) {
+        const sessionId = adapter.getOpenCodeSessionId(key);
+        if (sessionId)
+            await store.setOpenCodeSessionId(key, sessionId);
+    }
+    await store.setAgent(key, { name: adapter.name });
+}
+//# sourceMappingURL=persistAdapterSessionIds.js.map

package/dist/utils/persistAdapterSessionIds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistAdapterSessionIds.js","sourceRoot":"","sources":["../../src/utils/persistAdapterSessionIds.ts"],"names":[],"mappings":";;AAsCA,4DAaC;AAxBD;;;;;;;;;;GAUG;AACI,KAAK,UAAU,wBAAwB,CAC5C,GAAe,EACf,OAA+B,EAC/B,KAAgC;IAEhC,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,OAAO,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC7C,IAAI,IAAI;YAAE,MAAM,KAAK,CAAC,kBAAkB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACtD,CAAC;SAAM,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;QACxC,MAAM,SAAS,GAAG,OAAO,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;QACpD,IAAI,SAAS;YAAE,MAAM,KAAK,CAAC,oBAAoB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IAClE,CAAC;IACD,MAAM,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;AACpD,CAAC"}

package/dist/utils/pinnedBannerSkipDecision.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @description Pure decision for the pinned-banner refresh in
+ * `updatePinnedStatus`: given the freshly-computed banner text, the in-memory
+ * dedup cache, and the text persisted in `state.json`, decide whether the
+ * `editMessageText` API call can be skipped because nothing changed.
+ *
+ * Extracted from `bot.ts` so the rule is unit-testable without the Telegraf /
+ * state machinery (same pattern as `statusFlushDecision.ts`). The persisted
+ * fallback is the B8 fix: the in-memory cache is empty on every restart, so the
+ * boot-time refresh wave used to re-edit every banner with identical text,
+ * each call earning a wasted `400 "message is not modified"` that burns the
+ * chat-wide send budget. Seeding the decision with the persisted text lets the
+ * wave skip those edits entirely.
+ *
+ * @name PinnedBannerSkipDecision
+ * @description
+ * - `skip`        — computed text equals what is already displayed; no API
+ *   call. The in-memory cache already matched.
+ * - `seedAndSkip` — cache miss, but the persisted text equals the computed
+ *   text (the on-disk banner is already current after a restart): seed the
+ *   in-memory cache from it and skip the API call.
+ * - `send`        — text differs (or there is no known prior text at all): the
+ *   banner must be edited/sent.
+ */
+export type PinnedBannerSkipDecision = 'skip' | 'seedAndSkip' | 'send';
+export interface PinnedBannerSkipInput {
+    /** Banner text just computed from live adapter + state. */
+    computedText: string;
+    /** In-memory dedup cache value for this thread, or undefined on a miss. */
+    cachedText: string | undefined;
+    /** Banner text persisted in state.json for this thread, or undefined. */
+    persistedText: string | undefined;
+}
+/**
+ * @description Decide whether the pinned-banner edit can be skipped.
+ *
+ * In-memory cache wins first (hot path during a busy turn); on a miss we fall
+ * back to the persisted text so a restart's refresh wave skips identical
+ * banners. A stale persisted text must never suppress a needed edit, so callers
+ * clear `persistedText` whenever the banner message id is nulled / unpinned —
+ * once cleared, `persistedText` is undefined and this returns `send`.
+ */
+export declare function getPinnedBannerSkipDecision(input: PinnedBannerSkipInput): PinnedBannerSkipDecision;
+//# sourceMappingURL=pinnedBannerSkipDecision.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pinnedBannerSkipDecision.d.ts","sourceRoot":"","sources":["../../src/utils/pinnedBannerSkipDecision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,aAAa,GAAG,MAAM,CAAC;AAEvE,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,yEAAyE;IACzE,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,qBAAqB,GAC3B,wBAAwB,CAI1B"}

package/dist/utils/pinnedBannerSkipDecision.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPinnedBannerSkipDecision = getPinnedBannerSkipDecision;
+/**
+ * @description Decide whether the pinned-banner edit can be skipped.
+ *
+ * In-memory cache wins first (hot path during a busy turn); on a miss we fall
+ * back to the persisted text so a restart's refresh wave skips identical
+ * banners. A stale persisted text must never suppress a needed edit, so callers
+ * clear `persistedText` whenever the banner message id is nulled / unpinned —
+ * once cleared, `persistedText` is undefined and this returns `send`.
+ */
+function getPinnedBannerSkipDecision(input) {
+    if (input.cachedText === input.computedText)
+        return 'skip';
+    if (input.persistedText === input.computedText)
+        return 'seedAndSkip';
+    return 'send';
+}
+//# sourceMappingURL=pinnedBannerSkipDecision.js.map

package/dist/utils/pinnedBannerSkipDecision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinnedBannerSkipDecision.js","sourceRoot":"","sources":["../../src/utils/pinnedBannerSkipDecision.ts"],"names":[],"mappings":";;AA4CA,kEAMC;AAfD;;;;;;;;GAQG;AACH,SAAgB,2BAA2B,CACzC,KAA4B;IAE5B,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,YAAY;QAAE,OAAO,MAAM,CAAC;IAC3D,IAAI,KAAK,CAAC,aAAa,KAAK,KAAK,CAAC,YAAY;QAAE,OAAO,aAAa,CAAC;IACrE,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/utils/pollBackoff.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @description Base poll cadence: how fast the Claude pane is captured + parsed
+ * while a session is actively streaming. Mirrors the historical fixed interval.
+ */
+export declare const basePollIntervalMs = 300;
+/**
+ * @description Ceiling the adaptive backoff may slow an idle pane down to. An
+ * idle session capped here still re-checks the pane ~every 1.5s, so it wakes
+ * promptly when the agent resumes on its own (background tool finishing, etc.).
+ */
+export declare const maxPollIntervalMs = 1500;
+/**
+ * @description How many consecutive unchanged polls must elapse before we start
+ * backing off. Kept above the resume-seeding exit (~2 unchanged polls) so
+ * seeding always runs at base cadence and is never slowed by the backoff.
+ */
+export declare const backoffAfterUnchangedPolls = 10;
+interface PollBackoffInput {
+    /** Whether the raw capture changed since the previous poll (S1 raw compare). */
+    isChanged: boolean;
+    /** Delay used for the poll that just ran. */
+    currentDelayMs: number;
+    /** Consecutive unchanged polls observed BEFORE this one. */
+    unchangedStreak: number;
+}
+interface PollBackoffResult {
+    /** Delay to arm the next poll timer with. */
+    delayMs: number;
+    /** Updated consecutive-unchanged-poll counter. */
+    unchangedStreak: number;
+}
+/**
+ * @description Decide the next Claude poll delay from the latest poll's outcome.
+ *
+ * WHY: a fixed 300ms cadence burns a full `tmux capture-pane` + `cleanOutput`
+ * (~15 regex passes over up to ~600KB) per session even when the pane is idle,
+ * starving the event loop when several sessions stream in parallel. An idle
+ * pane carries no information, so we double the delay (capped) once it has been
+ * unchanged for {@link backoffAfterUnchangedPolls} polls. Any change — or an
+ * explicit write that snaps the cadence back — returns to base immediately, so
+ * user-visible latency after a prompt is unaffected.
+ */
+export declare function getNextPollDelay(input: PollBackoffInput): PollBackoffResult;
+export {};
+//# sourceMappingURL=pollBackoff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pollBackoff.d.ts","sourceRoot":"","sources":["../../src/utils/pollBackoff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,UAAU,gBAAgB;IACxB,gFAAgF;IAChF,SAAS,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,cAAc,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,iBAAiB;IACzB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,iBAAiB,CAY3E"}

package/dist/utils/pollBackoff.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backoffAfterUnchangedPolls = exports.maxPollIntervalMs = exports.basePollIntervalMs = void 0;
+exports.getNextPollDelay = getNextPollDelay;
+/**
+ * @description Base poll cadence: how fast the Claude pane is captured + parsed
+ * while a session is actively streaming. Mirrors the historical fixed interval.
+ */
+exports.basePollIntervalMs = 300;
+/**
+ * @description Ceiling the adaptive backoff may slow an idle pane down to. An
+ * idle session capped here still re-checks the pane ~every 1.5s, so it wakes
+ * promptly when the agent resumes on its own (background tool finishing, etc.).
+ */
+exports.maxPollIntervalMs = 1500;
+/**
+ * @description How many consecutive unchanged polls must elapse before we start
+ * backing off. Kept above the resume-seeding exit (~2 unchanged polls) so
+ * seeding always runs at base cadence and is never slowed by the backoff.
+ */
+exports.backoffAfterUnchangedPolls = 10;
+/**
+ * @description Decide the next Claude poll delay from the latest poll's outcome.
+ *
+ * WHY: a fixed 300ms cadence burns a full `tmux capture-pane` + `cleanOutput`
+ * (~15 regex passes over up to ~600KB) per session even when the pane is idle,
+ * starving the event loop when several sessions stream in parallel. An idle
+ * pane carries no information, so we double the delay (capped) once it has been
+ * unchanged for {@link backoffAfterUnchangedPolls} polls. Any change — or an
+ * explicit write that snaps the cadence back — returns to base immediately, so
+ * user-visible latency after a prompt is unaffected.
+ */
+function getNextPollDelay(input) {
+    if (input.isChanged) {
+        return { delayMs: exports.basePollIntervalMs, unchangedStreak: 0 };
+    }
+    const unchangedStreak = input.unchangedStreak + 1;
+    if (unchangedStreak < exports.backoffAfterUnchangedPolls) {
+        return { delayMs: exports.basePollIntervalMs, unchangedStreak };
+    }
+    const delayMs = Math.min(input.currentDelayMs * 2, exports.maxPollIntervalMs);
+    return { delayMs, unchangedStreak };
+}
+//# sourceMappingURL=pollBackoff.js.map

package/dist/utils/pollBackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollBackoff.js","sourceRoot":"","sources":["../../src/utils/pollBackoff.ts"],"names":[],"mappings":";;;AA+CA,4CAYC;AA3DD;;;GAGG;AACU,QAAA,kBAAkB,GAAG,GAAG,CAAC;AAEtC;;;;GAIG;AACU,QAAA,iBAAiB,GAAG,IAAI,CAAC;AAEtC;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAkB7C;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB,CAAC,KAAuB;IACtD,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACpB,OAAO,EAAE,OAAO,EAAE,0BAAkB,EAAE,eAAe,EAAE,CAAC,EAAE,CAAC;IAC7D,CAAC;IAED,MAAM,eAAe,GAAG,KAAK,CAAC,eAAe,GAAG,CAAC,CAAC;IAClD,IAAI,eAAe,GAAG,kCAA0B,EAAE,CAAC;QACjD,OAAO,EAAE,OAAO,EAAE,0BAAkB,EAAE,eAAe,EAAE,CAAC;IAC1D,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,EAAE,yBAAiB,CAAC,CAAC;IACtE,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;AACtC,CAAC"}

package/dist/utils/promptDelivery.d.ts

@@ -0,0 +1,46 @@
+import { type SessionKey } from '../sessionKey';
+import type { BufferedPromptSettled, StartupPromptBuffer } from '../startupPromptBuffer';
+/**
+ * @name PromptDeliveryDeps
+ * @description What {@link deliverPromptOrBuffer} acts through. `announceQueued`
+ * tells the person their prompt waits for the session to come up — a topic
+ * message, so it is only called for a Telegram conversation.
+ */
+export interface PromptDeliveryDeps {
+    startupBuffer: Pick<StartupPromptBuffer, 'addPrompt'>;
+    forwardPrompt: (key: SessionKey, text: string) => Promise<void>;
+    announceQueued: (key: SessionKey) => Promise<void>;
+}
+/**
+ * @name PromptDelivery
+ * @description Where {@link deliverPromptOrBuffer} put the prompt: `forwarded` to the
+ * session (done), or `buffered` behind a session start (it waits in memory until the
+ * start ends — see `onBufferedSettled`).
+ */
+export type PromptDelivery = 'forwarded' | 'buffered';
+/**
+ * @description Deliver `text` to a conversation's agent while honouring the startup
+ * window: mid-startup the prompt is buffered (it replays in order once the session
+ * is up, exactly like a text typed during boot); otherwise it is forwarded at once.
+ * The one "buffer-or-forward" unit shared by the text and voice handlers' mid-startup
+ * buffering, file/album intake, `/schedule`, the Jira connector's posts and an
+ * API-error retry's "continue" nudge — the last two reach it with a session another
+ * caller's start may still be bringing up, where a direct forward would hit an
+ * adapter that is not there yet.
+ *
+ * `isStarting` is passed in (not read here) because the album collector captures
+ * it AT FLUSH TIME — a session that finished booting mid-burst must forward, not
+ * buffer.
+ *
+ * The "queued while starting" notice is posted once per startup window, and only
+ * for a Telegram conversation: a tracker issue has no topic to say it in (R6).
+ *
+ * A buffered prompt lives in memory, so a restart before the start ends loses it.
+ * A caller that must know how the wait ended — to keep what would re-send the prompt
+ * until it reached a session — passes `onBufferedSettled`; it is called once, only
+ * for a prompt that was buffered (a forwarded one is already done when this resolves).
+ * A failed "queued" notice is logged and does not change the answer: the prompt was
+ * buffered before the notice went out.
+ */
+export declare function deliverPromptOrBuffer(deps: PromptDeliveryDeps, key: SessionKey, text: string, isStarting: boolean, onBufferedSettled?: BufferedPromptSettled): Promise<PromptDelivery>;
+//# sourceMappingURL=promptDelivery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promptDelivery.d.ts","sourceRoot":"","sources":["../../src/utils/promptDelivery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAEzF;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,CAAC;IACtD,aAAa,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,cAAc,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,OAAO,EACnB,iBAAiB,CAAC,EAAE,qBAAqB,GACxC,OAAO,CAAC,cAAc,CAAC,CAiBzB"}

package/dist/utils/promptDelivery.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverPromptOrBuffer = deliverPromptOrBuffer;
+const sessionKey_1 = require("../sessionKey");
+const sessionKeyCodec_1 = require("../connectors/telegram/sessionKeyCodec");
+/**
+ * @description Deliver `text` to a conversation's agent while honouring the startup
+ * window: mid-startup the prompt is buffered (it replays in order once the session
+ * is up, exactly like a text typed during boot); otherwise it is forwarded at once.
+ * The one "buffer-or-forward" unit shared by the text and voice handlers' mid-startup
+ * buffering, file/album intake, `/schedule`, the Jira connector's posts and an
+ * API-error retry's "continue" nudge — the last two reach it with a session another
+ * caller's start may still be bringing up, where a direct forward would hit an
+ * adapter that is not there yet.
+ *
+ * `isStarting` is passed in (not read here) because the album collector captures
+ * it AT FLUSH TIME — a session that finished booting mid-burst must forward, not
+ * buffer.
+ *
+ * The "queued while starting" notice is posted once per startup window, and only
+ * for a Telegram conversation: a tracker issue has no topic to say it in (R6).
+ *
+ * A buffered prompt lives in memory, so a restart before the start ends loses it.
+ * A caller that must know how the wait ended — to keep what would re-send the prompt
+ * until it reached a session — passes `onBufferedSettled`; it is called once, only
+ * for a prompt that was buffered (a forwarded one is already done when this resolves).
+ * A failed "queued" notice is logged and does not change the answer: the prompt was
+ * buffered before the notice went out.
+ */
+async function deliverPromptOrBuffer(deps, key, text, isStarting, onBufferedSettled) {
+    if (!isStarting) {
+        await deps.forwardPrompt(key, text);
+        return 'forwarded';
+    }
+    const isFirstBuffered = deps.startupBuffer.addPrompt((0, sessionKey_1.keyToString)(key), text, onBufferedSettled);
+    if (isFirstBuffered && (0, sessionKeyCodec_1.checkIsTelegramKey)(key)) {
+        // The prompt IS buffered by now (and its settle callback registered), so a notice that fails must not
+        // read as a delivery that failed: a caller keeping something until the prompt reached a session would
+        // otherwise treat the buffered prompt as spent.
+        try {
+            await deps.announceQueued(key);
+        }
+        catch (err) {
+            console.error(`[promptDelivery] queued notice for ${(0, sessionKey_1.keyToString)(key)} failed:`, err);
+        }
+    }
+    return 'buffered';
+}
+//# sourceMappingURL=promptDelivery.js.map

package/dist/utils/promptDelivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptDelivery.js","sourceRoot":"","sources":["../../src/utils/promptDelivery.ts"],"names":[],"mappings":";;AAgDA,sDAuBC;AAvED,8CAA6D;AAC7D,4EAA4E;AAuB5E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACI,KAAK,UAAU,qBAAqB,CACzC,IAAwB,EACxB,GAAe,EACf,IAAY,EACZ,UAAmB,EACnB,iBAAyC;IAEzC,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACpC,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAA,wBAAW,EAAC,GAAG,CAAC,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC;IAChG,IAAI,eAAe,IAAI,IAAA,oCAAkB,EAAC,GAAG,CAAC,EAAE,CAAC;QAC/C,sGAAsG;QACtG,sGAAsG;QACtG,gDAAgD;QAChD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,sCAAsC,IAAA,wBAAW,EAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/utils/providerDisconnectPlan.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @description Pure decision layer behind `/disconnect`: what did deleting a
+ * provider's stored credentials actually achieve?
+ *
+ * `DELETE /auth/:id` only removes what OpenCode keeps in its own auth store. A
+ * provider it enables from an ENVIRONMENT VARIABLE (`openrouter` ←
+ * `OPENROUTER_API_KEY`) stays fully active afterwards — reporting "disconnected"
+ * there would be a lie, and it is exactly the case that motivated the
+ * bot-side "hide provider" toggle in `/model`. So the adapter re-reads the live
+ * provider config after the delete and asks this helper what to tell the user.
+ */
+/**
+ * @name ProviderDisconnectOutcome
+ * @description
+ * - `removed` — the provider is gone from the live catalog: a clean disconnect.
+ * - `stillActiveViaEnv` — credentials were removed but the provider is still
+ *   listed, i.e. it comes from an environment variable the bot cannot unset.
+ */
+export type ProviderDisconnectOutcome = 'removed' | 'stillActiveViaEnv';
+/** Anchored matcher for `bot.action(...)`, kept beside the builder so the wire
+ *  format has one definition. */
+export declare const disconnectProviderCallbackRe: RegExp;
+/**
+ * @description Callback id for one row of the bare-`/disconnect` provider
+ * picker. Index-based like `connm_<idx>` / `resume_<idx>`: Telegram caps
+ * `callback_data` at 64 bytes, so the tapped entry is resolved against the
+ * per-thread snapshot the picker stored rather than carried by name.
+ */
+export declare function buildDisconnectProviderCallback(providerIndex: number): string;
+export declare function parseDisconnectProviderCallback(callbackData: string): number | null;
+/**
+ * @description How many picker snapshots the bot keeps before evicting the
+ * oldest. Each is a handful of short provider ids, and an operator realistically
+ * opens a couple of pickers — the cap only exists so a long-lived process can
+ * never accumulate them without bound.
+ */
+export declare const disconnectPickerSnapshotLimit = 50;
+/**
+ * @description Snapshot key for ONE picker message.
+ *
+ * Keying by thread alone is a destructive bug: a second `/disconnect`
+ * overwrites the thread's snapshot while the FIRST picker's buttons stay
+ * tappable forever, so tapping "openai" (index 1) on the old message resolves
+ * index 1 against the NEW list and deletes a different provider's credentials.
+ * The message id makes each keyboard resolve only against the list it was
+ * rendered from.
+ */
+export declare function buildDisconnectPickerKey(threadKeyString: string, messageId: number): string;
+/**
+ * @description Every snapshot key belonging to `threadKeyString` — the thread
+ * teardown sweep, which must drop ALL of a thread's picker snapshots, not just
+ * one.
+ *
+ * The trailing-digits check is load-bearing: a bare `startsWith` on the thread
+ * key would make thread `-100:1` claim thread `-100:12`'s snapshots
+ * (`"-100:12:5".startsWith("-100:1")` is true), wiping a live sibling topic's
+ * picker.
+ */
+export declare function getDisconnectPickerKeysForThread(pickerKeys: Iterable<string>, threadKeyString: string): string[];
+/**
+ * @description Keys to evict so the snapshot store stays bounded — the oldest
+ * first (`Map` preserves insertion order), keeping at most `limit` entries.
+ */
+export declare function getEvictedDisconnectPickerKeys(pickerKeys: Iterable<string>, limit?: number): string[];
+/**
+ * @description Resolve a tapped `dscp_<idx>` button against the snapshot of the
+ * message it sits on.
+ *
+ * Returns `null` — never another message's provider — when the tap carries no
+ * message id, when that message's snapshot is gone (an old picker after a
+ * restart or an eviction), or when the index is out of range. The caller turns
+ * `null` into the "this menu expired" toast.
+ */
+export declare function getDisconnectPickerProviderAt(snapshots: ReadonlyMap<string, readonly string[]>, threadKeyString: string, messageId: number | null, index: number): string | null;
+/**
+ * @description Classify a finished disconnect from the provider ids still
+ * active after the delete. Comparison is trim+lowercase so a differently-cased
+ * catalog entry is never mistaken for a removed provider (which would report a
+ * clean disconnect for a provider that is still serving models).
+ */
+export declare function getProviderDisconnectOutcome(providerId: string, activeProviderIdsAfterDelete: readonly string[]): ProviderDisconnectOutcome;
+//# sourceMappingURL=providerDisconnectPlan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"providerDisconnectPlan.d.ts","sourceRoot":"","sources":["../../src/utils/providerDisconnectPlan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,mBAAmB,CAAC;AAIxE;iCACiC;AACjC,eAAO,MAAM,4BAA4B,QAAiB,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGnF;AAED;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3F;AAED;;;;;;;;;GASG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC5B,eAAe,EAAE,MAAM,GACtB,MAAM,EAAE,CAKV;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC5B,KAAK,GAAE,MAAsC,GAC5C,MAAM,EAAE,CAGV;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EACjD,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,KAAK,EAAE,MAAM,GACZ,MAAM,GAAG,IAAI,CAIf;AAMD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,4BAA4B,EAAE,SAAS,MAAM,EAAE,GAC9C,yBAAyB,CAM3B"}