charness 0.0.0-stage → 3.0.0

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"}

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"}