charness 0.0.0-stage → 3.0.0

package/dist/utils/openCodeCompactPlugin.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @description The OpenCode plugin the bot installs so that a compaction OpenCode
+ * runs ON ITS OWN when the context overflows also tells the next session which
+ * skills to load again.
+ *
+ * WHY this exists: the loaded-skills guidance rides the bot's per-invocation
+ * `instruction` (`POST /session/:id/summarize`), which an overflow compaction
+ * never receives, and unlike D3 it is not baked into the fork's prompt. OpenCode
+ * runs the plugin hook `experimental.session.compacting` before EVERY compaction
+ * (manual and overflow) and appends the strings a plugin pushes into
+ * `output.context` to the compaction prompt. A plugin needs no fork rebuild.
+ *
+ * WHERE it lives: OpenCode's global plugin folder
+ * (`$XDG_CONFIG_HOME/opencode/plugins/`, scanned for `*.{ts,js}` whenever a
+ * project-folder instance is created), so every OpenCode on this account loads it
+ * — one the bot started, one it adopted, one run by hand. The bot owns that one
+ * file and rewrites it only when its content changed; the user's `opencode.json`
+ * is never touched.
+ *
+ * A RUNNING instance does not rescan: OpenCode loads plugins once per project
+ * folder. `POST /instance/dispose?directory=` makes the next request recreate the
+ * folder's instance, which then loads the plugin — no server restart, sessions
+ * stay on disk. Measured on the fork build: a plugin file added to a live folder
+ * did not load until that dispose, and its `server()` ran right after. Recreating
+ * drops the folder's runtime MCP registrations, so the bot reconciles its own MCP
+ * server right after. It only recreates an idle folder
+ * ({@link getCompactPluginActivation}).
+ *
+ * The hook only sees the session id, never the bot's per-invocation instruction,
+ * so it cannot skip a compaction that already carries the guidance. The bot
+ * therefore leaves the skills guidance out of its instruction when the folder's
+ * instance has this plugin ({@link checkHasOpenCodeCompactPlugin} over
+ * `GET /config`), and keeps it otherwise.
+ */
+/** File name of the plugin in OpenCode's plugin folder; also how the bot recognises it in `GET /config`. */
+export declare const openCodeCompactPluginFileName = "telegramcode-compaction.js";
+/** OpenCode requires a path plugin to export an id. */
+export declare const openCodeCompactPluginId = "telegramcode-compaction";
+/**
+ * @description The text the plugin adds to every compaction prompt. OpenCode
+ * appends it AFTER the bot's per-invocation instruction, which may end with the
+ * F2 closing-section directive ("write nothing after the end marker"), so the text
+ * says outright that the skills list belongs inside the summary.
+ */
+export declare function getOpenCodeCompactPluginContext(): string;
+/** @description The plugin module source: a v1 plugin (`default` export with `id` + `server`). */
+export declare function buildOpenCodeCompactPluginSource(context: string): string;
+/** @description OpenCode's global plugin folder, resolved the way OpenCode resolves it (XDG config home). */
+export declare function resolveOpenCodeGlobalPluginDir(env: NodeJS.ProcessEnv): string;
+/**
+ * @description Whether a `GET /config` `plugin` list contains the bot's plugin. A
+ * spec is a string or a `[spec, options]` tuple; OpenCode reports a path plugin as
+ * a `file://` URL.
+ */
+export declare function checkHasOpenCodeCompactPlugin(pluginSpecs: unknown): boolean;
+/**
+ * Boot decision for one project folder: its instance already has the plugin, it
+ * should be recreated to load it, or it is working and must not be disturbed.
+ */
+export type CompactPluginActivation = 'loaded' | 'recreate' | 'busy';
+/**
+ * @description Decide what to do with a folder's instance from its `GET /config`
+ * plugin list and its `GET /session/status` map. Recreating aborts whatever the
+ * folder is running, so ANY session that is not `idle` makes it `busy` — and so
+ * does a status the bot cannot read: never recreate on a guess.
+ */
+export declare function getCompactPluginActivation(input: {
+    pluginSpecs: unknown;
+    sessionStatus: unknown;
+}): CompactPluginActivation;
+/** Outcome of {@link installOpenCodeCompactPlugin}. */
+export type CompactPluginInstallResult = 'written' | 'unchanged' | 'failed';
+/**
+ * @description Put the plugin into OpenCode's global plugin folder. Idempotent:
+ * an identical file is left alone, a stale one is replaced atomically (a folder
+ * instance being created concurrently never reads half a file). Any failure is
+ * logged and returned — the plugin improves a summary, it must never block an
+ * OpenCode start or the bot's boot.
+ */
+export declare function installOpenCodeCompactPlugin(pluginDir?: string): CompactPluginInstallResult;
+//# sourceMappingURL=openCodeCompactPlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openCodeCompactPlugin.d.ts","sourceRoot":"","sources":["../../src/utils/openCodeCompactPlugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAOH,4GAA4G;AAC5G,eAAO,MAAM,6BAA6B,+BAA+B,CAAC;AAE1E,uDAAuD;AACvD,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AAEjE;;;;;GAKG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,CAExD;AAED,kGAAkG;AAClG,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcxE;AAED,6GAA6G;AAC7G,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAG7E;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,CAM3E;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;AAErE;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;CACxB,GAAG,uBAAuB,CAQ1B;AAED,uDAAuD;AACvD,MAAM,MAAM,0BAA0B,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE5E;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,GAAE,MAAoD,GAC9D,0BAA0B,CAmB5B"}

package/dist/utils/openCodeCompactPlugin.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * @description The OpenCode plugin the bot installs so that a compaction OpenCode
+ * runs ON ITS OWN when the context overflows also tells the next session which
+ * skills to load again.
+ *
+ * WHY this exists: the loaded-skills guidance rides the bot's per-invocation
+ * `instruction` (`POST /session/:id/summarize`), which an overflow compaction
+ * never receives, and unlike D3 it is not baked into the fork's prompt. OpenCode
+ * runs the plugin hook `experimental.session.compacting` before EVERY compaction
+ * (manual and overflow) and appends the strings a plugin pushes into
+ * `output.context` to the compaction prompt. A plugin needs no fork rebuild.
+ *
+ * WHERE it lives: OpenCode's global plugin folder
+ * (`$XDG_CONFIG_HOME/opencode/plugins/`, scanned for `*.{ts,js}` whenever a
+ * project-folder instance is created), so every OpenCode on this account loads it
+ * — one the bot started, one it adopted, one run by hand. The bot owns that one
+ * file and rewrites it only when its content changed; the user's `opencode.json`
+ * is never touched.
+ *
+ * A RUNNING instance does not rescan: OpenCode loads plugins once per project
+ * folder. `POST /instance/dispose?directory=` makes the next request recreate the
+ * folder's instance, which then loads the plugin — no server restart, sessions
+ * stay on disk. Measured on the fork build: a plugin file added to a live folder
+ * did not load until that dispose, and its `server()` ran right after. Recreating
+ * drops the folder's runtime MCP registrations, so the bot reconciles its own MCP
+ * server right after. It only recreates an idle folder
+ * ({@link getCompactPluginActivation}).
+ *
+ * The hook only sees the session id, never the bot's per-invocation instruction,
+ * so it cannot skip a compaction that already carries the guidance. The bot
+ * therefore leaves the skills guidance out of its instruction when the folder's
+ * instance has this plugin ({@link checkHasOpenCodeCompactPlugin} over
+ * `GET /config`), and keeps it otherwise.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openCodeCompactPluginId = exports.openCodeCompactPluginFileName = void 0;
+exports.getOpenCodeCompactPluginContext = getOpenCodeCompactPluginContext;
+exports.buildOpenCodeCompactPluginSource = buildOpenCodeCompactPluginSource;
+exports.resolveOpenCodeGlobalPluginDir = resolveOpenCodeGlobalPluginDir;
+exports.checkHasOpenCodeCompactPlugin = checkHasOpenCodeCompactPlugin;
+exports.getCompactPluginActivation = getCompactPluginActivation;
+exports.installOpenCodeCompactPlugin = installOpenCodeCompactPlugin;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const compactOnIdle_1 = require("./compactOnIdle");
+/** File name of the plugin in OpenCode's plugin folder; also how the bot recognises it in `GET /config`. */
+exports.openCodeCompactPluginFileName = 'telegramcode-compaction.js';
+/** OpenCode requires a path plugin to export an id. */
+exports.openCodeCompactPluginId = 'telegramcode-compaction';
+/**
+ * @description The text the plugin adds to every compaction prompt. OpenCode
+ * appends it AFTER the bot's per-invocation instruction, which may end with the
+ * F2 closing-section directive ("write nothing after the end marker"), so the text
+ * says outright that the skills list belongs inside the summary.
+ */
+function getOpenCodeCompactPluginContext() {
+    return `Additional instruction for the summary itself (put it inside the summary, never after a closing section the instructions above require): ${compactOnIdle_1.compactionSkillsGuidance}`;
+}
+/** @description The plugin module source: a v1 plugin (`default` export with `id` + `server`). */
+function buildOpenCodeCompactPluginSource(context) {
+    return [
+        '// Installed by Charness, which rewrites it when its content changes. Do not edit.',
+        `const context = ${JSON.stringify(context)};`,
+        'export default {',
+        `  id: ${JSON.stringify(exports.openCodeCompactPluginId)},`,
+        '  server: async () => ({',
+        '    "experimental.session.compacting": async (_input, output) => {',
+        '      output.context.push(context);',
+        '    },',
+        '  }),',
+        '};',
+        '',
+    ].join('\n');
+}
+/** @description OpenCode's global plugin folder, resolved the way OpenCode resolves it (XDG config home). */
+function resolveOpenCodeGlobalPluginDir(env) {
+    const configHome = env.XDG_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), '.config');
+    return path_1.default.join(configHome, 'opencode', 'plugins');
+}
+/**
+ * @description Whether a `GET /config` `plugin` list contains the bot's plugin. A
+ * spec is a string or a `[spec, options]` tuple; OpenCode reports a path plugin as
+ * a `file://` URL.
+ */
+function checkHasOpenCodeCompactPlugin(pluginSpecs) {
+    if (!Array.isArray(pluginSpecs))
+        return false;
+    return pluginSpecs.some((entry) => {
+        const spec = Array.isArray(entry) ? entry[0] : entry;
+        return typeof spec === 'string' && spec.endsWith(`/${exports.openCodeCompactPluginFileName}`);
+    });
+}
+/**
+ * @description Decide what to do with a folder's instance from its `GET /config`
+ * plugin list and its `GET /session/status` map. Recreating aborts whatever the
+ * folder is running, so ANY session that is not `idle` makes it `busy` — and so
+ * does a status the bot cannot read: never recreate on a guess.
+ */
+function getCompactPluginActivation(input) {
+    if (checkHasOpenCodeCompactPlugin(input.pluginSpecs))
+        return 'loaded';
+    const status = input.sessionStatus;
+    if (!status || typeof status !== 'object' || Array.isArray(status))
+        return 'busy';
+    const isAnyBusy = Object.values(status).some((entry) => !entry || typeof entry !== 'object' || entry.type !== 'idle');
+    return isAnyBusy ? 'busy' : 'recreate';
+}
+/**
+ * @description Put the plugin into OpenCode's global plugin folder. Idempotent:
+ * an identical file is left alone, a stale one is replaced atomically (a folder
+ * instance being created concurrently never reads half a file). Any failure is
+ * logged and returned — the plugin improves a summary, it must never block an
+ * OpenCode start or the bot's boot.
+ */
+function installOpenCodeCompactPlugin(pluginDir = resolveOpenCodeGlobalPluginDir(process.env)) {
+    const pluginPath = path_1.default.join(pluginDir, exports.openCodeCompactPluginFileName);
+    const source = buildOpenCodeCompactPluginSource(getOpenCodeCompactPluginContext());
+    try {
+        if (fs_1.default.readFileSync(pluginPath, 'utf-8') === source)
+            return 'unchanged';
+    }
+    catch {
+        // Missing or unreadable: (re)write below.
+    }
+    const tmpPath = `${pluginPath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs_1.default.mkdirSync(pluginDir, { recursive: true });
+        fs_1.default.writeFileSync(tmpPath, source);
+        fs_1.default.renameSync(tmpPath, pluginPath);
+    }
+    catch (e) {
+        console.warn(`[compact-plugin] cannot write ${pluginPath}:`, e);
+        try {
+            fs_1.default.unlinkSync(tmpPath);
+        }
+        catch { /* never written */ }
+        return 'failed';
+    }
+    return 'written';
+}
+//# sourceMappingURL=openCodeCompactPlugin.js.map

package/dist/utils/openCodeCompactPlugin.js.map

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

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