charness 0.0.0-stage → 3.0.0

package/dist/apiRetryKick.d.ts

@@ -0,0 +1,148 @@
+import { type SessionKey } from './sessionKey';
+import type { UsageLimitWait } from './requests/limitWaitAnswer';
+import type { BufferedPromptSettled } from './startupPromptBuffer';
+import type { PromptDelivery } from './utils/promptDelivery';
+import type { AgentApiErrorClass, ApiRetryState } from './types';
+/**
+ * The retry kick and the boot restore of the API-error auto-retry (plan S4–S6),
+ * lifted out of `bot.ts` behind injected ports so the whole lifecycle — arm, fire,
+ * restart — runs in a test. `apiErrorRetry.ts` holds the pure decisions and
+ * `bot.ts` still arms and cancels a retry; this file owns what happens when its
+ * timer fires and when the bot comes back up.
+ */
+/**
+ * Catch-up delay for a retry whose `fireAt` is already in the past at boot.
+ * Small (not zero) so the kick is armed via `setTimeout` instead of firing
+ * synchronously in the adopt tick — a freshly-adopted Claude pane may still be
+ * repainting, and the Enter-verification in `sendInput` covers the residual race.
+ */
+export declare const apiRetryCatchUpDelayMs = 5000;
+/**
+ * @description One thread's live armed-retry timer + bookkeeping. The persisted
+ * twin lives in `state.json` (`ApiRetryState`); this in-memory entry additionally
+ * holds the actual `NodeJS.Timeout` (not serialisable) and `firedAt` (set when
+ * the timer fires) so `decideRetryAction` can tell a same-episode recurrence
+ * (escalate) from a fresh one (reset to attempt 1).
+ */
+export interface ApiRetryTimerEntry {
+    /** The armed timer, or `null` once it has fired (record kept until outcome known). */
+    timer: NodeJS.Timeout | null;
+    /** 1-based attempt the current/last timer was armed for. */
+    attempt: number;
+    /** Error class that armed it. */
+    kind: AgentApiErrorClass['kind'];
+    /** Epoch ms when the timer fired, or `null` while still pending. */
+    firedAt: number | null;
+    /** Epoch ms the timer is due (mirrors the persisted `fireAt`). It IDENTIFIES the
+     *  episode for the «skip once» button, whose stale keyboard must never cancel a
+     *  later one. */
+    fireAt: number;
+    /** How a usage-limit wait ends, for the limit answer of a request opened during it.
+     *  Absent for a record re-armed at boot (`state.json` keeps only the instant). */
+    limitWait?: UsageLimitWait;
+}
+/** What the kick needs to know of {@link ensureAgentSession}'s answer. */
+export type ApiRetryEnsureOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+    message: string;
+};
+/** A message the kick posts into a topic (Telegram only — a tracker issue has no topic, R6). */
+export type ApiRetryTopicNotice = {
+    kind: 'noSession';
+    message: string;
+} | {
+    kind: 'resuming';
+    retryKind: AgentApiErrorClass['kind'];
+};
+/**
+ * @name ApiRetryKickDeps
+ * @description The ports of {@link runApiRetryKick}: `entries` and `kicksInFlight`
+ * are the bot's own retry map and in-flight set (the wake-up probe reads the set);
+ * everything else acts on the world — the session, the topic, the request ledger.
+ */
+export interface ApiRetryKickDeps {
+    entries: Map<string, ApiRetryTimerEntry>;
+    /** Threads whose timer fired and whose "continue" nudge is not handed over yet. */
+    kicksInFlight: Set<string>;
+    now: () => number;
+    /** A session to nudge: the conversation's own, resumed when it sleeps (R26 for every platform, L-D4). */
+    ensureSession: (key: SessionKey) => Promise<ApiRetryEnsureOutcome>;
+    postTopicNotice: (key: SessionKey, notice: ApiRetryTopicNotice) => void;
+    /** The nudge, or the open request's own prompt the agent never took in (R21). */
+    getResumeMessage: (key: SessionKey, retryKind: AgentApiErrorClass['kind']) => {
+        text: string;
+        isRequestPrompt: boolean;
+    };
+    /** Through the startup buffer when another caller's start is still under way; a `buffered` nudge
+     *  tells `onBufferedSettled` how its wait ended. */
+    deliverNudge: (key: SessionKey, text: string, onBufferedSettled: BufferedPromptSettled) => Promise<PromptDelivery>;
+    trackContinuation: (key: SessionKey, options: {
+        isCountersReset: boolean;
+        isRequestPrompt: boolean;
+    }) => Promise<void>;
+    /** Drop the retry's saved twin (`state.json`). */
+    clearSavedRetry: (key: SessionKey) => void;
+}
+/**
+ * @description The retry kick (timer callback): make sure a session is up (after
+ * an OpenCode `session.error` it still is, so `ensureSession` is a no-op and the
+ * nudge lands in the SAME live session — context intact; a sleeping session is
+ * resumed by its id, and only one with nothing to resume is started fresh via the
+ * thread's last adapter), tell the topic we're resuming, then hand over a neutral
+ * "continue" nudge. With no session to resume
+ * the topic gets the reason instead and nothing is forwarded.
+ *
+ * The saved record means ARMED, so once the kick has run its course — the nudge
+ * forwarded to the session, no session to nudge, or a delivery that threw — the saved
+ * twin goes: left behind, every restart would restore it as armed and fire the kick
+ * again (a second "resuming" notice, a second nudge into the topic or the issue's
+ * session). A nudge that only waits in the startup buffer behind another caller's
+ * session start has NOT run its course: the buffer is in memory, a restart loses it,
+ * and a fresh spawn lays the session log out anew, so the boot recovery finds no error
+ * to resume from either — the saved record is the only thing that fires it again. It
+ * stays until the buffer settles the nudge: `replayed` (handed to the session — a
+ * failed forward counts, as a direct delivery that threw does) or `dropped` (the start
+ * failed, or the session is not up when the window closes — the same as "no session to
+ * nudge": the starter reported the failure, an open request is left to the wake-up
+ * engine, and a record kept for a start that failed would only fire the kick again at
+ * the next restart).
+ *
+ * It goes only if `entries` still holds THIS entry: a recurrence armed meanwhile (a
+ * newer entry and its own saved record) or a cancel / give-up (entry gone, record
+ * already cleared) must not be undone by an older kick. The in-memory entry itself is
+ * intentionally KEPT after firing (timer nulled, `firedAt` stamped): a recurrence
+ * within the grace window re-arms at attempt+1 — that memory is not persisted.
+ */
+export declare function runApiRetryKick(deps: ApiRetryKickDeps, key: SessionKey): Promise<void>;
+/**
+ * @name ApiRetryRestoreDeps
+ * @description The ports of {@link restoreApiRetryTimers}: the bot's retry map,
+ * a clock, the served-platform filter and what a due timer does.
+ */
+export interface ApiRetryRestoreDeps {
+    entries: Map<string, ApiRetryTimerEntry>;
+    now: () => number;
+    isServed: (key: SessionKey) => boolean;
+    /** A due timer: run the kick for `key`. */
+    fire: (key: SessionKey) => void;
+}
+/**
+ * @description Re-arm persisted API-error retries (S6) so a pending kick —
+ * especially a multi-hour usage-limit wait — survives a bot restart. The caller
+ * runs it AFTER the sessions are reattached, so each kick lands in a live session.
+ *
+ * For each record we re-populate `entries` and arm one unref'd timer at
+ * `fireAt - now` (clamped to `maxTimeoutMs`). A `fireAt` already in the past fires
+ * ONE catch-up after {@link apiRetryCatchUpDelayMs}. The arm notice is NOT re-posted
+ * (the user saw it before the restart); the `↻ resuming` notice fires when the
+ * timer fires.
+ *
+ * A retry of a platform this instance does not serve is neither armed nor dropped
+ * (Jira plan J3b, R10): its kick would start that conversation's session here,
+ * under this instance's environment and tmux server. Returns how many were re-armed.
+ */
+export declare function restoreApiRetryTimers(deps: ApiRetryRestoreDeps, records: Readonly<Record<string, ApiRetryState>>): number;
+//# sourceMappingURL=apiRetryKick.d.ts.map

package/dist/apiRetryKick.d.ts.map

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

package/dist/apiRetryKick.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRetryCatchUpDelayMs = void 0;
+exports.runApiRetryKick = runApiRetryKick;
+exports.restoreApiRetryTimers = restoreApiRetryTimers;
+const sessionKey_1 = require("./sessionKey");
+const sessionKeyCodec_1 = require("./connectors/telegram/sessionKeyCodec");
+const engine_1 = require("./scheduler/engine");
+/**
+ * The retry kick and the boot restore of the API-error auto-retry (plan S4–S6),
+ * lifted out of `bot.ts` behind injected ports so the whole lifecycle — arm, fire,
+ * restart — runs in a test. `apiErrorRetry.ts` holds the pure decisions and
+ * `bot.ts` still arms and cancels a retry; this file owns what happens when its
+ * timer fires and when the bot comes back up.
+ */
+/**
+ * Catch-up delay for a retry whose `fireAt` is already in the past at boot.
+ * Small (not zero) so the kick is armed via `setTimeout` instead of firing
+ * synchronously in the adopt tick — a freshly-adopted Claude pane may still be
+ * repainting, and the Enter-verification in `sendInput` covers the residual race.
+ */
+exports.apiRetryCatchUpDelayMs = 5_000;
+/**
+ * @description The retry kick (timer callback): make sure a session is up (after
+ * an OpenCode `session.error` it still is, so `ensureSession` is a no-op and the
+ * nudge lands in the SAME live session — context intact; a sleeping session is
+ * resumed by its id, and only one with nothing to resume is started fresh via the
+ * thread's last adapter), tell the topic we're resuming, then hand over a neutral
+ * "continue" nudge. With no session to resume
+ * the topic gets the reason instead and nothing is forwarded.
+ *
+ * The saved record means ARMED, so once the kick has run its course — the nudge
+ * forwarded to the session, no session to nudge, or a delivery that threw — the saved
+ * twin goes: left behind, every restart would restore it as armed and fire the kick
+ * again (a second "resuming" notice, a second nudge into the topic or the issue's
+ * session). A nudge that only waits in the startup buffer behind another caller's
+ * session start has NOT run its course: the buffer is in memory, a restart loses it,
+ * and a fresh spawn lays the session log out anew, so the boot recovery finds no error
+ * to resume from either — the saved record is the only thing that fires it again. It
+ * stays until the buffer settles the nudge: `replayed` (handed to the session — a
+ * failed forward counts, as a direct delivery that threw does) or `dropped` (the start
+ * failed, or the session is not up when the window closes — the same as "no session to
+ * nudge": the starter reported the failure, an open request is left to the wake-up
+ * engine, and a record kept for a start that failed would only fire the kick again at
+ * the next restart).
+ *
+ * It goes only if `entries` still holds THIS entry: a recurrence armed meanwhile (a
+ * newer entry and its own saved record) or a cancel / give-up (entry gone, record
+ * already cleared) must not be undone by an older kick. The in-memory entry itself is
+ * intentionally KEPT after firing (timer nulled, `firedAt` stamped): a recurrence
+ * within the grace window re-arms at attempt+1 — that memory is not persisted.
+ */
+async function runApiRetryKick(deps, key) {
+    const k = (0, sessionKey_1.keyToString)(key);
+    const entry = deps.entries.get(k);
+    if (!entry)
+        return;
+    // Claimed in the same tick the retry stops being armed (see `kicksInFlight`).
+    deps.kicksInFlight.add(k);
+    entry.timer = null;
+    entry.firedAt = deps.now();
+    const clearSavedRetryIfLive = () => {
+        if (deps.entries.get(k) === entry)
+            deps.clearSavedRetry(key);
+    };
+    let isNudgeBuffered = false;
+    try {
+        // R26: the conversation the limit interrupted is the one resumed — the ensure brings a sleeping
+        // session back by its id, for a topic as for a tracker issue (a fresh session would not know the work).
+        const ensured = await deps.ensureSession(key);
+        if (!ensured.ok) {
+            // No session to nudge (unbound, no adapter, a start that failed): a forward would hit a dead adapter, and
+            // watching a turn that never started would only mislead the wake-ups. The open request, if any, stays
+            // open for the wake-up engine (its backstop / retries); what was held stays held for the next session.
+            console.warn(`[apiRetry] not resuming ${k}: no session (${ensured.reason}); an open request is left to the wake-up engine`);
+            // A topic is told why nothing resumed — it waits for the operator's next message now (R6: not a tracker issue).
+            if ((0, sessionKeyCodec_1.checkIsTelegramKey)(key))
+                deps.postTopicNotice(key, { kind: 'noSession', message: ensured.message });
+            return;
+        }
+        // Announced only once there is a session to resume: a pinned "resuming" over a start that failed would
+        // read as work under way. The notices are topic messages (a pin among them): a tracker issue hears about
+        // the wait from the request's own answer, and has no topic for the rest (R6).
+        if ((0, sessionKeyCodec_1.checkIsTelegramKey)(key))
+            deps.postTopicNotice(key, { kind: 'resuming', retryKind: entry.kind });
+        // The nudge is NOT a request: the open request (if any) continues under it. A
+        // request whose prompt never reached the agent — the wait held it (R23) — gets
+        // that prompt instead (R21). Prompts held during the wait ride whichever it is.
+        const resume = deps.getResumeMessage(key, entry.kind);
+        const delivery = await deps.deliverNudge(key, resume.text, (outcome) => {
+            if (outcome === 'dropped') {
+                console.warn(`[apiRetry] nudge for ${k} dropped: the session did not come up; the retry is spent and an open request is left to the wake-up engine`);
+            }
+            clearSavedRetryIfLive();
+        });
+        isNudgeBuffered = delivery === 'buffered';
+        await deps.trackContinuation(key, {
+            isCountersReset: entry.kind === 'usageLimit',
+            isRequestPrompt: resume.isRequestPrompt,
+        });
+    }
+    catch (e) {
+        console.error('[apiRetry] kick failed:', e instanceof Error ? e.message : e);
+    }
+    finally {
+        deps.kicksInFlight.delete(k);
+        // A buffered nudge keeps the record: the buffer's settle callback clears it.
+        if (!isNudgeBuffered)
+            clearSavedRetryIfLive();
+    }
+}
+/**
+ * @description Re-arm persisted API-error retries (S6) so a pending kick —
+ * especially a multi-hour usage-limit wait — survives a bot restart. The caller
+ * runs it AFTER the sessions are reattached, so each kick lands in a live session.
+ *
+ * For each record we re-populate `entries` and arm one unref'd timer at
+ * `fireAt - now` (clamped to `maxTimeoutMs`). A `fireAt` already in the past fires
+ * ONE catch-up after {@link apiRetryCatchUpDelayMs}. The arm notice is NOT re-posted
+ * (the user saw it before the restart); the `↻ resuming` notice fires when the
+ * timer fires.
+ *
+ * A retry of a platform this instance does not serve is neither armed nor dropped
+ * (Jira plan J3b, R10): its kick would start that conversation's session here,
+ * under this instance's environment and tmux server. Returns how many were re-armed.
+ */
+function restoreApiRetryTimers(deps, records) {
+    let restored = 0;
+    for (const [keyStr, record] of Object.entries(records)) {
+        let key;
+        try {
+            key = (0, sessionKey_1.keyFromString)(keyStr);
+        }
+        catch {
+            // Hand-edited / corrupt key (can't come from `keyToString`): skip it,
+            // keep booting. Tolerated-and-skipped, like restorePendingQuestions.
+            continue;
+        }
+        if (!deps.isServed(key))
+            continue;
+        const dueInMs = record.fireAt - deps.now();
+        const delayMs = dueInMs > 0 ? Math.min(dueInMs, engine_1.maxTimeoutMs) : exports.apiRetryCatchUpDelayMs;
+        const timer = setTimeout(() => {
+            deps.fire(key);
+        }, delayMs);
+        timer.unref?.();
+        deps.entries.set(keyStr, {
+            timer,
+            attempt: record.attempt,
+            kind: record.kind,
+            firedAt: null,
+            fireAt: record.fireAt,
+        });
+        restored += 1;
+    }
+    return restored;
+}
+//# sourceMappingURL=apiRetryKick.js.map

package/dist/apiRetryKick.js.map

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

package/dist/bootClassifier.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @description Pure helper that decides whether a fresh `startBot()` call is
+ * a **hot reload** (nodemon swapped the process; agents and Telegram
+ * backlog should be treated as still-connected) or a **cold start** (the
+ * bot was actually down — reconnect notices are appropriate; stale
+ * Telegram backlog should be dropped).
+ *
+ * Decision is based on the gap between `now` and the last persisted
+ * heartbeat stamp (`StateStore.getDowntimeMs`):
+ *
+ *   - unknown (no stamp at all) → cold start.
+ *     Fresh install or a pre-heartbeat state file. Conservative default —
+ *     "I don't know how long I was down, assume long".
+ *   - `< HOT_RELOAD_THRESHOLD_MS` → hot reload.
+ *     Old PID exited and new PID started within the threshold — basically
+ *     a nodemon swap or a `kill -HUP` followed by an immediate respawn.
+ *   - `≥ threshold` → cold start.
+ *     Operator manually stopped the bot and restarted it later; stale
+ *     pending updates are probably no longer interesting.
+ *
+ * The threshold is generous (60s) so an unusually slow tsc build during a
+ * hot reload still classifies correctly. Tightening it later is safe;
+ * loosening would only widen the window where we'd quietly resubscribe to
+ * a long-dead session.
+ */
+/** Cap (ms) below which a boot is treated as a hot reload, not a cold start. */
+export declare const HOT_RELOAD_THRESHOLD_MS = 60000;
+export interface BootClassification {
+    /** True iff the gap since the last heartbeat is below the threshold. */
+    isHotReload: boolean;
+    /**
+     * Whether `bot.launch({ dropPendingUpdates: ... })` should drop the
+     * Telegram backlog. Inverse of {@link isHotReload}: hot reload keeps
+     * messages typed during the ~1s reload gap so they reach the live
+     * agents; cold start discards stale updates that piled up while the bot
+     * was actually down.
+     */
+    dropPendingUpdates: boolean;
+}
+/**
+ * @description Map a measured downtime (in ms, or `null` for unknown) to
+ * the boot-mode flags consumed by `startBot()`. Pure / synchronous — easy
+ * to unit-test without touching state or telegraf.
+ */
+export declare function classifyBoot(downtimeMs: number | null, thresholdMs?: number): BootClassification;
+//# sourceMappingURL=bootClassifier.d.ts.map

package/dist/bootClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootClassifier.d.ts","sourceRoot":"","sources":["../src/bootClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,gFAAgF;AAChF,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,WAAW,EAAE,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,WAAW,GAAE,MAAgC,GAC5C,kBAAkB,CAKpB"}

package/dist/bootClassifier.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @description Pure helper that decides whether a fresh `startBot()` call is
+ * a **hot reload** (nodemon swapped the process; agents and Telegram
+ * backlog should be treated as still-connected) or a **cold start** (the
+ * bot was actually down — reconnect notices are appropriate; stale
+ * Telegram backlog should be dropped).
+ *
+ * Decision is based on the gap between `now` and the last persisted
+ * heartbeat stamp (`StateStore.getDowntimeMs`):
+ *
+ *   - unknown (no stamp at all) → cold start.
+ *     Fresh install or a pre-heartbeat state file. Conservative default —
+ *     "I don't know how long I was down, assume long".
+ *   - `< HOT_RELOAD_THRESHOLD_MS` → hot reload.
+ *     Old PID exited and new PID started within the threshold — basically
+ *     a nodemon swap or a `kill -HUP` followed by an immediate respawn.
+ *   - `≥ threshold` → cold start.
+ *     Operator manually stopped the bot and restarted it later; stale
+ *     pending updates are probably no longer interesting.
+ *
+ * The threshold is generous (60s) so an unusually slow tsc build during a
+ * hot reload still classifies correctly. Tightening it later is safe;
+ * loosening would only widen the window where we'd quietly resubscribe to
+ * a long-dead session.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOT_RELOAD_THRESHOLD_MS = void 0;
+exports.classifyBoot = classifyBoot;
+/** Cap (ms) below which a boot is treated as a hot reload, not a cold start. */
+exports.HOT_RELOAD_THRESHOLD_MS = 60_000;
+/**
+ * @description Map a measured downtime (in ms, or `null` for unknown) to
+ * the boot-mode flags consumed by `startBot()`. Pure / synchronous — easy
+ * to unit-test without touching state or telegraf.
+ */
+function classifyBoot(downtimeMs, thresholdMs = exports.HOT_RELOAD_THRESHOLD_MS) {
+    if (downtimeMs === null || downtimeMs >= thresholdMs) {
+        return { isHotReload: false, dropPendingUpdates: true };
+    }
+    return { isHotReload: true, dropPendingUpdates: false };
+}
+//# sourceMappingURL=bootClassifier.js.map

package/dist/bootClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootClassifier.js","sourceRoot":"","sources":["../src/bootClassifier.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAuBH,oCAQC;AA7BD,gFAAgF;AACnE,QAAA,uBAAuB,GAAG,MAAM,CAAC;AAe9C;;;;GAIG;AACH,SAAgB,YAAY,CAC1B,UAAyB,EACzB,cAAsB,+BAAuB;IAE7C,IAAI,UAAU,KAAK,IAAI,IAAI,UAAU,IAAI,WAAW,EAAE,CAAC;QACrD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;IAC1D,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;AAC1D,CAAC"}

package/dist/bot.d.ts

@@ -0,0 +1,207 @@
+import { Markup } from 'telegraf';
+import type { Message } from 'telegraf/typings/core/types/typegram';
+import type { AgentAdapter, SeenWatermark } from './types';
+import type { SessionKey } from './sessionKey';
+import './connectors/jira/sessionKeyCodec';
+import type { InboundCommand } from './platform/inbound';
+import type { InlineKeyboardMarkup } from 'telegraf/typings/core/types/typegram';
+import type { CommandContext } from './connectors/telegram/commands/botCore';
+/**
+ * @description The Telegram connector's inbound side: the membership lookup the
+ * access policy needs, and the normalization step that hands the core
+ * platform-neutral events.
+ */
+declare const telegramInbound: import("./connectors/telegram/inbound").TelegramConnectorInbound;
+export declare function buildBindKeyboard(subdirs: readonly string[], page?: number, pageSize?: number, isBound?: boolean): Markup.Markup<InlineKeyboardMarkup>;
+export declare function getStartReadyMessage(adapter: AgentAdapter, subdir: string, args: string | undefined, model: string | null, effort: string | null): string;
+/**
+ * @name EnsureAgentSessionResult
+ * @description Outcome of {@link ensureAgentSession}. `ok` means a session is
+ * ready to receive prompts NOW — either it was already active, it is in its
+ * async startup window (prompts get buffered + replayed on ready), or it was
+ * just started. `message` is the localized text the caller MAY surface (the
+ * `agent.ready` notice on a fresh start, empty when nothing user-facing
+ * happened). On failure, `reason` distinguishes a missing binding (`unbound`),
+ * a bound topic that has never picked an agent and none was supplied
+ * (`no-adapter` — refuse rather than silently launch a default), and a start
+ * that threw (`start-failed`); `message` carries the matching localized text.
+ */
+export type EnsureAgentSessionResult = {
+    ok: true;
+    message: string;
+    isFresh: boolean;
+} | {
+    ok: false;
+    reason: EnsureAgentSessionFailureReason;
+    message: string;
+};
+/**
+ * `unbound` / `no-adapter` / `start-failed` as before; `nothing-to-resume` and
+ * `resume-failed` only for a resume-only caller (no fresh start allowed).
+ */
+export type EnsureAgentSessionFailureReason = 'unbound' | 'no-adapter' | 'start-failed' | 'nothing-to-resume' | 'resume-failed';
+/**
+ * @name EnsureAgentSessionOptions
+ * @description Tuning for {@link ensureAgentSession}.
+ *  - `preferredAdapterName` — an EXPLICIT user choice that outranks every
+ *    resolved name (the natural-language-start path passes the matched
+ *    `/claude` vs `/opencode` adapter here).
+ *  - `fallbackAdapterName` — the LAST resort when nothing else resolves (the
+ *    scheduler passes a job's `lastAdapterName` snapshot for a start after a
+ *    rebind, where the thread has no live or persisted adapter). When it too is
+ *    absent and nothing resolved, `ensureAgentSession` fails with `no-adapter`
+ *    rather than silently launching a default backend.
+ *  - `args` — forwarded to `startAgentSession` (e.g. the natural-language
+ *    start phrase's trailing args).
+ */
+export interface EnsureAgentSessionOptions {
+    preferredAdapterName?: string;
+    fallbackAdapterName?: string;
+    args?: string;
+    /**
+     * Resume a sleeping session but never start a fresh one — a wake-up reminder or
+     * a topic's retry has nothing to say to a session that does not know the work.
+     */
+    isResumeOnly?: boolean;
+}
+/**
+ * @description True iff the neutral router owns `name`, i.e. a `/name` message
+ * is claimed by the routed-command trigger instead of falling through.
+ *
+ * Exported so the fall-through contract can be asserted against the REAL
+ * registration table: `pair` must stay OFF it (it is a raw `bot.command` that
+ * has to run in a not-yet-paired group, which authorisation would reject).
+ */
+export declare function checkIsRoutedCommand(name: string): boolean;
+/**
+ * @description Collaborators of {@link handleRoutedCommandMessage}, injected so
+ * the trigger's guard ORDER is provable without a live Telegraf instance, a
+ * paired group or an admin-cache round trip.
+ */
+export interface RoutedCommandTriggerDeps<TContext> {
+    /** Telegraf's own command recognition, re-implemented in `getTelegramCommand`. */
+    getCommand: (message: Message.TextMessage) => InboundCommand | null;
+    /** Is the name on the neutral router's table? `false` ⇒ fall through. */
+    checkIsRegistered: (name: string) => boolean;
+    /** Resolve + gate the sender. `null` ⇒ not allowed here: drop, no fall-through. */
+    authorise: (ctx: TContext) => Promise<SessionKey | null>;
+    /** Clear the single-purpose input modes an earlier command armed. */
+    exitPendingInputModes: (key: SessionKey, messageText: string) => Promise<void>;
+    /** Reset the compact-on-idle watchdog (F2) — any command is thread activity. */
+    noteActivity: (key: SessionKey) => void;
+    /** Normalize through the connector and hand the event to the core's router. */
+    deliverInbound: (ctx: TContext, key: SessionKey) => Promise<void>;
+}
+/**
+ * @description The single Telegram trigger for every routed command, replacing
+ * the per-command `bot.command(...)` registrations.
+ *
+ * Recognition is telegraf's own rule, re-implemented in
+ * {@link getTelegramCommand}, so WHICH messages count as commands is unchanged
+ * — including `/name@otherbot` falling through.
+ *
+ * The guard ORDER is load-bearing in both directions and is what this function
+ * exists (separately from its `bot.on` registration) to make testable:
+ *  - an unrouted name calls `next()` BEFORE authorisation, so a raw
+ *    `bot.command` further down the middleware chain — `/pair`, which must work
+ *    in a group the bot is not paired with yet — still receives it;
+ *  - a rejected sender returns WITHOUT `next()`, so the update stops at the
+ *    first gate that refused it. The generic text handler below re-authorises,
+ *    so a stray `next()` would not actually leak the command; it would spend a
+ *    second admin-cache round trip and log the same refusal twice, which is how
+ *    a real leak would be missed in the noise.
+ */
+export declare function handleRoutedCommandMessage<TContext extends {
+    message: Message.TextMessage;
+}>(ctx: TContext, next: () => Promise<void>, deps: RoutedCommandTriggerDeps<TContext>): Promise<void>;
+/**
+ * @description Hand a routed command to the connector for normalization.
+ *
+ * Normalization goes through the connector rather than a second inline
+ * `getInboundEvent` call so exactly one place decides what lands on the event.
+ *
+ * The event's `raw` is the telegraf CONTEXT, not `ctx.message` — load-bearing,
+ * and it shipped wrong once (fixed in `c9b1da4`): the not-yet-relocated command
+ * handlers read Telegram fields off the context, so one reading
+ * `ctx.message.message_id` finds `undefined` when `raw` is the bare message.
+ * `ConnectorInbound.deliver` types `raw` as `unknown`, so only a test can hold
+ * this line honest.
+ */
+export declare function deliverRoutedCommand<TContext extends {
+    message: Message.TextMessage;
+}>(ctx: TContext, key: SessionKey): Promise<void>;
+/**
+ * Registered at the position the first command used to occupy, so middleware
+ * order relative to `bot.command('pair')` and the text handler is preserved.
+ */
+export declare const routedCommandTriggerDeps: RoutedCommandTriggerDeps<CommandContext>;
+/** The connector the routed-command trigger and the core's dispatcher share. */
+export { telegramInbound };
+export declare const COMMANDS_MENU: {
+    command: string;
+    description: string;
+}[];
+/**
+ * @description Post the silent-reattach recap for one thread after a successful
+ * re-adopt: how many AGENT messages were produced while the bot was down (vs the
+ * persisted watermark) plus the last few turns. The anti-spam gate
+ * ({@link checkShouldPostReattachRecap}) lives in the recap module: post when
+ * `missedCount > 0` (real missed output, ANY boot mode) OR — only on a COLD start
+ * (`isColdStart`) — the watermark-unknown fallback. The fallback is cold-start
+ * gated precisely so a watermark-less session (first run after ship, pruned
+ * transcript) does NOT re-spam every active topic on every hot rebuild.
+ *
+ * Adapters without `getReattachRecap` (Terminal) are skipped. Best-effort: a
+ * read/format failure logs and posts nothing — it never blocks the reattach
+ * scan or crashes boot.
+ *
+ * `watermark` is the PRE-adopt snapshot read by the caller BEFORE `adopt/resume`
+ * (S1-wiring): the concurrent live-advance (Claude's idle-poll tracker / OpenCode's
+ * `session.idle`) starts running the instant the session polls, so re-reading the
+ * watermark here could see it already moved to the tail and silently suppress a
+ * genuine recap. Taking the snapshot before adopt freezes the recap baseline.
+ *
+ * Idempotency: after the recap is computed the persisted watermark is ALWAYS
+ * advanced to the session's current head (`recap.headWatermark`) — whether or not
+ * a recap posted, and even on `missedCount === 0` — so the same gap can never
+ * re-report on the next reattach. Skipped only when the head is unknown (the
+ * record read failed) → retry on the next reattach. The collaborators are
+ * injectable (`deps`) so the orchestration is unit-testable; production uses the
+ * real {@link replyToThread} / {@link StateStore.setSeenWatermark}.
+ */
+interface PostReattachRecapDeps {
+    reply: (key: SessionKey, text: string) => Promise<unknown>;
+    advanceWatermark: (key: SessionKey, watermark: SeenWatermark) => void;
+}
+export declare function postReattachRecap(key: SessionKey, adapter: Pick<AgentAdapter, 'getReattachRecap'>, workDir: string, sessionId: string, watermark: SeenWatermark | null, isColdStart: boolean, deps?: PostReattachRecapDeps): Promise<void>;
+/**
+ * @description Injected collaborators for {@link reconcileTransientFrames}, so the
+ * boot reconciliation is unit-testable without a live Telegram client or
+ * StateStore (mirrors the `deps` seam {@link postReattachRecap} uses). Defaults
+ * wire the real bot client + the persist choke point.
+ */
+export interface ReconcileTransientFramesDeps {
+    /** Best-effort delete of one Telegram message (Telegraf resolves `true`). */
+    deleteMessage: (chatId: number, messageId: number) => Promise<boolean>;
+    /** Re-sync disk to the thread's LIVE in-memory frame ids after the stale deletes. */
+    persistFrames: (key: SessionKey) => void;
+}
+/**
+ * @description Delete transient status frames left on screen by an UNGRACEFUL
+ * exit (crash / SIGKILL — the graceful shutdown sweep never ran), so a
+ * "✽ working…" / thinking / sub-agent frame doesn't stick forever in a topic
+ * (S2, the crash safety net behind S1). Deletes every id in the `orphaned`
+ * snapshot best-effort (swallowing "message not found" / too-old). The snapshot
+ * MUST be captured BEFORE reattach (see {@link startBot}): a reattached
+ * session's frame setters persist the fresh in-memory state and would clobber
+ * the live persisted set first. Every snapshot id is stale by definition (the
+ * fresh process holds no handle to it; a still-busy reattached session repaints
+ * its OWN fresh frame), so deleting is always safe. After deleting, re-persist
+ * the CURRENT live frame ids per thread so disk reflects post-reattach truth
+ * (the repainted frame's id, or empty) instead of the consumed stale ids. A
+ * graceful exit already cleared the set in its sweep, so this is normally a
+ * no-op.
+ */
+export declare function reconcileTransientFrames(orphaned: Record<string, number[]>, deps?: ReconcileTransientFramesDeps): number;
+export declare function startBot(): Promise<void>;
+//# sourceMappingURL=bot.d.ts.map

package/dist/bot.d.ts.map

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