charness 0.0.0-stage → 3.1.0

package/dist/utils/limitEpisodeRecovery.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * @description Pure layer behind the boot recovery of a usage/session-limit
+ * episode that ENDED BEFORE the bot restarted.
+ *
+ * An ARMED retry survives a restart on its own (`state.json` `apiRetries`,
+ * re-armed after reattach). An UNRECOGNISED limit error leaves nothing behind —
+ * so a topic whose agent died on a limit before the detector understood that
+ * wording just sits there, and a bot update alone does not resume it. This module
+ * reads the evidence the json-stream Claude backend leaves on disk (the terminal
+ * `result` frame at the end of its `stdout.jsonl`) and decides whether the bot
+ * should arm the limit wait itself.
+ *
+ * V1 IS JSON-STREAM ONLY, by evidence availability: the tmux-scrape backend keeps
+ * its history only in a tmux pane (already repainted by adopt time) and OpenCode's
+ * error lives in a transient SSE event, so neither has a comparable on-disk tail
+ * to re-read. Those backends recover the normal way — the next live error fires
+ * the detector.
+ *
+ * Only the decisions live here; the fs read and the `handleApiError` call stay in
+ * `bot.ts` (the apiErrorRetry pure-layer / manager split).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitEpisodeMaxAgeMs = exports.limitEpisodeTailMaxBytes = void 0;
+exports.getLastTerminalErrorText = getLastTerminalErrorText;
+exports.decideLimitEpisodeRecovery = decideLimitEpisodeRecovery;
+const apiErrorRetry_1 = require("../apiErrorRetry");
+const claudeStreamJson_1 = require("./claudeStreamJson");
+/**
+ * How much of a session's `stdout.jsonl` to read when hunting the last terminal
+ * frame. The log holds a whole session's events and can reach hundreds of MB, so
+ * only the tail is read — the terminal `result` frame is by definition the last
+ * thing written. A torn first line is simply skipped by the NDJSON parser.
+ */
+exports.limitEpisodeTailMaxBytes = 64 * 1024;
+/**
+ * Max age of the stdout log for its trailing error to still count as "the episode
+ * the topic is stuck on". Older than this and the topic has moved on (or the limit
+ * window is long expired), so resurrecting it would push an unexpected prompt into
+ * a quiet topic.
+ */
+exports.limitEpisodeMaxAgeMs = 12 * 60 * 60 * 1000;
+/**
+ * @description The error text the session is PARKED on, read out of a stdout
+ * tail: the last terminal `result` frame's error, or `null` when the tail ends on
+ * a healthy turn, holds no terminal frame, or shows the session moving on after
+ * the error. Reuses the adapter's own NDJSON parse + message classifier, so "what
+ * counts as a terminal error and where its text lives" has exactly one definition.
+ *
+ * Anything real written AFTER the error — the echo of a message sent to the
+ * session, the agent's text, thinking or tool frames — clears the verdict, though
+ * the turn it belongs to has no terminal frame yet. That is what a limit resume
+ * leaves in the log: the bot's own "continue" nudge and the work on it. A topic
+ * with that tail is not stuck on the old error, and re-arming it at a restart
+ * in the middle of that turn would resume the same episode a second time.
+ *
+ * Only the PARENT session's frames count. A terminal `result` ends the parent
+ * turn, so the one thing that can still write after it without a resume is a
+ * background sub-agent finishing its own work (`parent_tool_use_id` set); a
+ * resume always starts with the parent's own frames (the nudge's echo first), so
+ * leaving the sub-agent's out loses nothing and keeps a parked topic parked.
+ */
+function getLastTerminalErrorText(tailText) {
+    let lastErrorText = null;
+    for (const line of tailText.split('\n')) {
+        const parsed = (0, claudeStreamJson_1.parseStreamJsonLine)(line);
+        if (!parsed)
+            continue; // blank, or the tail's torn first line
+        for (const action of (0, claudeStreamJson_1.classifyClaudeStreamMessage)(parsed)) {
+            if (action.kind === 'turnEnd') {
+                // A later healthy turn CLEARS the verdict — the session recovered.
+                lastErrorText = action.isError ? action.errorText : null;
+            }
+            else if (checkIsSessionActivity(action)) {
+                lastErrorText = null;
+            }
+        }
+    }
+    return lastErrorText;
+}
+/** Frames that only a running PARENT session writes (not the ambient rate-limit /
+ *  status ones, and not a sub-agent's — see {@link getLastTerminalErrorText}). */
+function checkIsSessionActivity(action) {
+    if (action.kind === 'userEcho')
+        return true;
+    if (action.kind === 'textDelta' || action.kind === 'thinkingDelta' || action.kind === 'toolUse' || action.kind === 'toolResult') {
+        return !action.isSubagent;
+    }
+    return false;
+}
+/**
+ * @description Whether this thread's trailing error is the one a previous boot
+ * already acted on: the log is byte-for-byte the same file, at the same mtime, as
+ * when the marker was written. Nothing has happened since, so re-arming would
+ * resurrect a wait that was already settled — skipped by «⏭ Skip once», by a user
+ * takeover, or by the retry giving up. Both fields must match; any real turn
+ * appends frames and changes them, so a genuinely NEW trailing error still arms.
+ * This matters on every code change, because hot mode reloads the bot.
+ */
+function checkIsSameHandledLog(handled, log) {
+    if (!handled)
+        return false;
+    return handled.sizeBytes === log.sizeBytes && handled.mtimeMs === log.mtimeMs;
+}
+/**
+ * @description Decide whether a session's trailing error should re-arm a limit
+ * wait at boot. Deliberately strict — every guard exists to keep a boot from
+ * pushing a surprise prompt into a topic:
+ *  - only when no persisted retry record already covers the thread (that one is
+ *    re-armed by the normal restore path — arming twice would double-notice);
+ *  - only when the log CHANGED since the episode a previous boot already handled
+ *    ({@link checkIsSameHandledLog});
+ *  - only the `usageLimit` class (a transient error is long past by restart time,
+ *    and an `auth` error needs a human, not a wait);
+ *  - only when the log is younger than {@link limitEpisodeMaxAgeMs}.
+ * A `resetAt` already in the past needs no special case: the retry plan clamps a
+ * negative delay to zero and the boot arming turns that into one prompt catch-up.
+ */
+function decideLimitEpisodeRecovery(input) {
+    if (input.hasArmedRetry)
+        return { action: 'skip', reason: 'alreadyArmed' };
+    if (checkIsSameHandledLog(input.handled, input.log))
+        return { action: 'skip', reason: 'alreadyHandled' };
+    if (!input.errorText)
+        return { action: 'skip', reason: 'noError' };
+    if (input.now - input.log.mtimeMs > exports.limitEpisodeMaxAgeMs)
+        return { action: 'skip', reason: 'stale' };
+    const cls = (0, apiErrorRetry_1.classifyAgentApiError)(input.errorText, input.now);
+    if (cls?.kind !== 'usageLimit')
+        return { action: 'skip', reason: 'notUsageLimit' };
+    return { action: 'arm', cls };
+}
+//# sourceMappingURL=limitEpisodeRecovery.js.map

package/dist/utils/limitEpisodeRecovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitEpisodeRecovery.js","sourceRoot":"","sources":["../../src/utils/limitEpisodeRecovery.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AA0CH,4DAeC;AA8CD,gEAgBC;AArHD,oDAAyD;AACzD,yDAA+G;AAG/G;;;;;GAKG;AACU,QAAA,wBAAwB,GAAG,EAAE,GAAG,IAAI,CAAC;AAElD;;;;;GAKG;AACU,QAAA,oBAAoB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,wBAAwB,CAAC,QAAgB;IACvD,IAAI,aAAa,GAAkB,IAAI,CAAC;IACxC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,MAAM,MAAM,GAAG,IAAA,sCAAmB,EAAC,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC,MAAM;YAAE,SAAS,CAAC,uCAAuC;QAC9D,KAAK,MAAM,MAAM,IAAI,IAAA,8CAA2B,EAAC,MAAM,CAAC,EAAE,CAAC;YACzD,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC9B,mEAAmE;gBACnE,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;YAC3D,CAAC;iBAAM,IAAI,sBAAsB,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC1C,aAAa,GAAG,IAAI,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;kFACkF;AAClF,SAAS,sBAAsB,CAAC,MAA0B;IACxD,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW,IAAI,MAAM,CAAC,IAAI,KAAK,eAAe,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QAChI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC;IAC5B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAQD;;;;;;;;GAQG;AACH,SAAS,qBAAqB,CAAC,OAAuC,EAAE,GAAuB;IAC7F,IAAI,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAC3B,OAAO,OAAO,CAAC,SAAS,KAAK,GAAG,CAAC,SAAS,IAAI,OAAO,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,0BAA0B,CAAC,KAQ1C;IACC,IAAI,KAAK,CAAC,aAAa;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;IAC3E,IAAI,qBAAqB,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;IACzG,IAAI,CAAC,KAAK,CAAC,SAAS;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IACnE,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,4BAAoB;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IACrG,MAAM,GAAG,GAAG,IAAA,qCAAqB,EAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAC9D,IAAI,GAAG,EAAE,IAAI,KAAK,YAAY;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IACnF,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;AAChC,CAAC"}

package/dist/utils/limitHeldPromptQueue.d.ts

@@ -0,0 +1,48 @@
+import { type SessionKey } from '../sessionKey';
+import { type LimitHeldPrompt } from './limitHeldPrompts';
+/**
+ * @name LimitHeldPromptStore
+ * @description Where held prompts live — `state.json`, per conversation, apart
+ * from the retry record: the wait can end without its resume (the operator
+ * writes, skips or disables it, the session ends) and the prompts must outlive it.
+ * Both calls are synchronous, so a take is atomic within one turn of the loop.
+ */
+export interface LimitHeldPromptStore {
+    getLimitHeldPrompts: (key: SessionKey) => LimitHeldPrompt[];
+    setLimitHeldPrompts: (key: SessionKey, prompts: readonly LimitHeldPrompt[]) => void;
+}
+/**
+ * @name LimitHeldPromptQueueDeps
+ * @description `checkIsLimitWaitArmed` — whether `key` waits out an ARMED usage
+ * limit right now (a fired record is history, not a wait).
+ */
+export interface LimitHeldPromptQueueDeps {
+    store: LimitHeldPromptStore;
+    checkIsLimitWaitArmed: (key: SessionKey) => boolean;
+}
+/**
+ * @description The held prompts of usage-limit waits (Jira plan R23): held
+ * while a wait is armed, released — never dropped — once none is: after the
+ * next prompt forwarded to the conversation's session (the resume's, the
+ * operator's next message, a later post), or on their own when a session starts.
+ */
+export declare class LimitHeldPromptQueue {
+    private readonly deps;
+    constructor(deps: LimitHeldPromptQueueDeps);
+    /**
+     * @description Hold `text` while a usage-limit wait is armed; `false` — none is,
+     * post as usual. `heldText` is what it says when it arrives late (R27), when that
+     * differs; the run itself is identified by `text`.
+     */
+    holdPrompt(key: SessionKey, text: string, heldText?: string): boolean;
+    /**
+     * @description `text` about to be forwarded to the session, with the held
+     * prompts after it — and they are no longer held. Unchanged while a wait is
+     * still armed or nothing is held.
+     */
+    releaseWithForward(key: SessionKey, text: string): string;
+    /** @description The held prompts as one message for a session that has nothing else to forward; `null` — none, or still held. */
+    releaseAll(key: SessionKey): string | null;
+    private takeHeldPrompts;
+}
+//# sourceMappingURL=limitHeldPromptQueue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"limitHeldPromptQueue.d.ts","sourceRoot":"","sources":["../../src/utils/limitHeldPromptQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAuF,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE/I;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,eAAe,EAAE,CAAC;IAC5D,mBAAmB,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,CAAC;CACrF;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,oBAAoB,CAAC;IAC5B,qBAAqB,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC;CACrD;AAED;;;;;GAKG;AACH,qBAAa,oBAAoB;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,wBAAwB;IAE3D;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO;IAYrE;;;;OAIG;IACH,kBAAkB,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAKzD,iIAAiI;IACjI,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI;IAI1C,OAAO,CAAC,eAAe;CAQxB"}

package/dist/utils/limitHeldPromptQueue.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitHeldPromptQueue = void 0;
+const sessionKey_1 = require("../sessionKey");
+const limitHeldPrompts_1 = require("./limitHeldPrompts");
+/**
+ * @description The held prompts of usage-limit waits (Jira plan R23): held
+ * while a wait is armed, released — never dropped — once none is: after the
+ * next prompt forwarded to the conversation's session (the resume's, the
+ * operator's next message, a later post), or on their own when a session starts.
+ */
+class LimitHeldPromptQueue {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * @description Hold `text` while a usage-limit wait is armed; `false` — none is,
+     * post as usual. `heldText` is what it says when it arrives late (R27), when that
+     * differs; the run itself is identified by `text`.
+     */
+    holdPrompt(key, text, heldText) {
+        if (!this.deps.checkIsLimitWaitArmed(key))
+            return false;
+        const prompt = heldText === undefined || heldText === text ? { text } : { text, heldText };
+        const { held, droppedCount } = (0, limitHeldPrompts_1.getHeldPromptsWith)(this.deps.store.getLimitHeldPrompts(key), prompt);
+        if (droppedCount > 0) {
+            console.warn(`[limitHeld] ${(0, sessionKey_1.keyToString)(key)}: ${droppedCount} oldest held prompt(s) dropped (at most ${limitHeldPrompts_1.limitHeldPromptsMax})`);
+        }
+        this.deps.store.setLimitHeldPrompts(key, held);
+        console.log(`[limitHeld] ${(0, sessionKey_1.keyToString)(key)}: prompt held until the usage-limit wait ends (${held.length} held)`);
+        return true;
+    }
+    /**
+     * @description `text` about to be forwarded to the session, with the held
+     * prompts after it — and they are no longer held. Unchanged while a wait is
+     * still armed or nothing is held.
+     */
+    releaseWithForward(key, text) {
+        const held = this.takeHeldPrompts(key);
+        return held.length > 0 ? (0, limitHeldPrompts_1.getTextWithHeldPrompts)(text, held) : text;
+    }
+    /** @description The held prompts as one message for a session that has nothing else to forward; `null` — none, or still held. */
+    releaseAll(key) {
+        return (0, limitHeldPrompts_1.getHeldPromptsText)(this.takeHeldPrompts(key));
+    }
+    takeHeldPrompts(key) {
+        if (this.deps.checkIsLimitWaitArmed(key))
+            return [];
+        const held = this.deps.store.getLimitHeldPrompts(key);
+        if (held.length === 0)
+            return [];
+        this.deps.store.setLimitHeldPrompts(key, []);
+        console.log(`[limitHeld] ${(0, sessionKey_1.keyToString)(key)}: ${held.length} held prompt(s) released`);
+        return held;
+    }
+}
+exports.LimitHeldPromptQueue = LimitHeldPromptQueue;
+//# sourceMappingURL=limitHeldPromptQueue.js.map

package/dist/utils/limitHeldPromptQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitHeldPromptQueue.js","sourceRoot":"","sources":["../../src/utils/limitHeldPromptQueue.ts"],"names":[],"mappings":";;;AAAA,8CAA6D;AAC7D,yDAA+I;AAwB/I;;;;;GAKG;AACH,MAAa,oBAAoB;IACF;IAA7B,YAA6B,IAA8B;QAA9B,SAAI,GAAJ,IAAI,CAA0B;IAAG,CAAC;IAE/D;;;;OAIG;IACH,UAAU,CAAC,GAAe,EAAE,IAAY,EAAE,QAAiB;QACzD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QACxD,MAAM,MAAM,GAAoB,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC5G,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,IAAA,qCAAkB,EAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QACpG,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,eAAe,IAAA,wBAAW,EAAC,GAAG,CAAC,KAAK,YAAY,2CAA2C,sCAAmB,GAAG,CAAC,CAAC;QAClI,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC/C,OAAO,CAAC,GAAG,CAAC,eAAe,IAAA,wBAAW,EAAC,GAAG,CAAC,kDAAkD,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC;QAClH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,GAAe,EAAE,IAAY;QAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAA,yCAAsB,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACrE,CAAC;IAED,iIAAiI;IACjI,UAAU,CAAC,GAAe;QACxB,OAAO,IAAA,qCAAkB,EAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;IAEO,eAAe,CAAC,GAAe;QACrC,IAAI,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC;YAAE,OAAO,EAAE,CAAC;QACpD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;QACtD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC7C,OAAO,CAAC,GAAG,CAAC,eAAe,IAAA,wBAAW,EAAC,GAAG,CAAC,KAAK,IAAI,CAAC,MAAM,0BAA0B,CAAC,CAAC;QACvF,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AA3CD,oDA2CC"}

package/dist/utils/limitHeldPrompts.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @description Prompts that arrived during an armed usage-limit wait (Jira plan
+ * R23): posting them would only run into the limit again, so they are HELD and
+ * delivered once nothing holds them any more. They are never dropped: they ride
+ * the first prompt forwarded after the wait — its resume, the operator's next
+ * message, a later post — or, when a new session starts with nothing to
+ * forward, go to it on their own. The scheduler's fire and a tracker's request
+ * share the hold through `postToSession`.
+ */
+/** Held per conversation at most; a scheduler firing all through a long wait must not flood the resume. */
+export declare const limitHeldPromptsMax = 10;
+/**
+ * @name LimitHeldPrompt
+ * @description A prompt held over a usage-limit wait. `text` is the prompt as it
+ * is posted at once — two holds of the same `text` are the same run; `heldText`,
+ * when it differs, is what the prompt says once it arrives late (R27: a scheduled
+ * run names when it was due).
+ */
+export interface LimitHeldPrompt {
+    text: string;
+    heldText?: string;
+}
+/**
+ * @description `held` with `prompt` added, the oldest dropped past {@link limitHeldPromptsMax}.
+ * A prompt whose `text` is already held is not added again — a recurring job
+ * firing all through a long wait runs once after it, like the scheduler's one
+ * catch-up for missed runs, and says when it was FIRST due, as the catch-up does.
+ */
+export declare function getHeldPromptsWith(held: readonly LimitHeldPrompt[], prompt: LimitHeldPrompt): {
+    held: LimitHeldPrompt[];
+    droppedCount: number;
+};
+/**
+ * @description The forwarded `text` with the held prompts after it, in arrival
+ * order — one message, so nothing can slip between them. A held copy of `text`
+ * itself is not repeated: it is being delivered right now.
+ */
+export declare function getTextWithHeldPrompts(text: string, held: readonly LimitHeldPrompt[]): string;
+/**
+ * @description The held prompts as one message, for a session that starts with
+ * nothing else to forward; `null` when nothing is held.
+ */
+export declare function getHeldPromptsText(held: readonly LimitHeldPrompt[]): string | null;
+/**
+ * @description What the resume of a usage-limit wait forwards: the open
+ * request's prompt when the agent never took it in (R21 — it arrived during the
+ * wait, or its post failed), else the "continue" nudge, which resumes the turn
+ * the limit interrupted. Held prompts are not part of it: they ride whichever is
+ * forwarded. `isRequestPrompt` — the turn carries the request's prompt.
+ */
+export declare function getLimitResumeMessage(input: {
+    continueNudge: string;
+    untakenRequestPrompt: string | undefined;
+}): {
+    text: string;
+    isRequestPrompt: boolean;
+};
+//# sourceMappingURL=limitHeldPrompts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"limitHeldPrompts.d.ts","sourceRoot":"","sources":["../../src/utils/limitHeldPrompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,2GAA2G;AAC3G,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAItC;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAOD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,eAAe,EAAE,EAChC,MAAM,EAAE,eAAe,GACtB;IAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAKnD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM,CAE7F;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM,GAAG,IAAI,CAElF;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAI7C"}

package/dist/utils/limitHeldPrompts.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * @description Prompts that arrived during an armed usage-limit wait (Jira plan
+ * R23): posting them would only run into the limit again, so they are HELD and
+ * delivered once nothing holds them any more. They are never dropped: they ride
+ * the first prompt forwarded after the wait — its resume, the operator's next
+ * message, a later post — or, when a new session starts with nothing to
+ * forward, go to it on their own. The scheduler's fire and a tracker's request
+ * share the hold through `postToSession`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitHeldPromptsMax = void 0;
+exports.getHeldPromptsWith = getHeldPromptsWith;
+exports.getTextWithHeldPrompts = getTextWithHeldPrompts;
+exports.getHeldPromptsText = getHeldPromptsText;
+exports.getLimitResumeMessage = getLimitResumeMessage;
+/** Held per conversation at most; a scheduler firing all through a long wait must not flood the resume. */
+exports.limitHeldPromptsMax = 10;
+/** Between two prompts delivered as one: each carries its own header. */
+const heldPromptSeparator = '\n\n';
+/** What a held prompt says when it is finally delivered. */
+function getDeliveredText(prompt) {
+    return prompt.heldText ?? prompt.text;
+}
+/**
+ * @description `held` with `prompt` added, the oldest dropped past {@link limitHeldPromptsMax}.
+ * A prompt whose `text` is already held is not added again — a recurring job
+ * firing all through a long wait runs once after it, like the scheduler's one
+ * catch-up for missed runs, and says when it was FIRST due, as the catch-up does.
+ */
+function getHeldPromptsWith(held, prompt) {
+    if (held.some((heldPrompt) => heldPrompt.text === prompt.text))
+        return { held: [...held], droppedCount: 0 };
+    const next = [...held, prompt];
+    const droppedCount = Math.max(0, next.length - exports.limitHeldPromptsMax);
+    return { held: next.slice(droppedCount), droppedCount };
+}
+/**
+ * @description The forwarded `text` with the held prompts after it, in arrival
+ * order — one message, so nothing can slip between them. A held copy of `text`
+ * itself is not repeated: it is being delivered right now.
+ */
+function getTextWithHeldPrompts(text, held) {
+    return [text, ...held.filter((prompt) => prompt.text !== text).map(getDeliveredText)].join(heldPromptSeparator);
+}
+/**
+ * @description The held prompts as one message, for a session that starts with
+ * nothing else to forward; `null` when nothing is held.
+ */
+function getHeldPromptsText(held) {
+    return held.length > 0 ? held.map(getDeliveredText).join(heldPromptSeparator) : null;
+}
+/**
+ * @description What the resume of a usage-limit wait forwards: the open
+ * request's prompt when the agent never took it in (R21 — it arrived during the
+ * wait, or its post failed), else the "continue" nudge, which resumes the turn
+ * the limit interrupted. Held prompts are not part of it: they ride whichever is
+ * forwarded. `isRequestPrompt` — the turn carries the request's prompt.
+ */
+function getLimitResumeMessage(input) {
+    return input.untakenRequestPrompt === undefined
+        ? { text: input.continueNudge, isRequestPrompt: false }
+        : { text: input.untakenRequestPrompt, isRequestPrompt: true };
+}
+//# sourceMappingURL=limitHeldPrompts.js.map

package/dist/utils/limitHeldPrompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitHeldPrompts.js","sourceRoot":"","sources":["../../src/utils/limitHeldPrompts.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA8BH,gDAQC;AAOD,wDAEC;AAMD,gDAEC;AASD,sDAOC;AArED,2GAA2G;AAC9F,QAAA,mBAAmB,GAAG,EAAE,CAAC;AACtC,yEAAyE;AACzE,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAcnC,4DAA4D;AAC5D,SAAS,gBAAgB,CAAC,MAAuB;IAC/C,OAAO,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC;AACxC,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAChC,IAAgC,EAChC,MAAuB;IAEvB,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IAC5G,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;IAC/B,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,2BAAmB,CAAC,CAAC;IACpE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC;AAC1D,CAAC;AAED;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,IAAY,EAAE,IAAgC;IACnF,OAAO,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;AAClH,CAAC;AAED;;;GAGG;AACH,SAAgB,kBAAkB,CAAC,IAAgC;IACjE,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACvF,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,qBAAqB,CAAC,KAGrC;IACC,OAAO,KAAK,CAAC,oBAAoB,KAAK,SAAS;QAC7C,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,aAAa,EAAE,eAAe,EAAE,KAAK,EAAE;QACvD,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,oBAAoB,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;AAClE,CAAC"}

package/dist/utils/linkPreviewSuppression.d.ts

@@ -0,0 +1,18 @@
+import type { CallApiHost } from '../outputTrace';
+/**
+ * @description Default a text-message API payload to NO link preview by
+ * injecting `link_preview_options: { is_disabled: true }`. Pure — returns the
+ * payload to send. A caller that already set `link_preview_options` (or the
+ * legacy `disable_web_page_preview`) wins; we only supply the default when
+ * neither is present, and leave non-text methods untouched.
+ */
+export declare function applyLinkPreviewSuppression(method: string, payload: object): object;
+/**
+ * @description Wrap `telegram.callApi` so every text message / edit the bot
+ * sends defaults to NO link preview. Operator complaint: each agent message
+ * containing a URL expanded into a large preview card, one per message, in the
+ * muted topic. Installed once at boot alongside `installCallApiTrace`, and
+ * OUTSIDE it (installed after) so the trace records the payload actually sent.
+ */
+export declare function installLinkPreviewSuppression(host: CallApiHost): void;
+//# sourceMappingURL=linkPreviewSuppression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linkPreviewSuppression.d.ts","sourceRoot":"","sources":["../../src/utils/linkPreviewSuppression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AASlD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAKnF;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAIrE"}

package/dist/utils/linkPreviewSuppression.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyLinkPreviewSuppression = applyLinkPreviewSuppression;
+exports.installLinkPreviewSuppression = installLinkPreviewSuppression;
+/**
+ * Bot API methods whose payload can carry `link_preview_options`. A media send
+ * (`sendPhoto`/`sendVideo`/…) does not expand a standalone URL preview card, so
+ * only the text-message methods are rewritten.
+ */
+const linkPreviewMethods = new Set(['sendMessage', 'editMessageText']);
+/**
+ * @description Default a text-message API payload to NO link preview by
+ * injecting `link_preview_options: { is_disabled: true }`. Pure — returns the
+ * payload to send. A caller that already set `link_preview_options` (or the
+ * legacy `disable_web_page_preview`) wins; we only supply the default when
+ * neither is present, and leave non-text methods untouched.
+ */
+function applyLinkPreviewSuppression(method, payload) {
+    if (!linkPreviewMethods.has(method))
+        return payload;
+    const base = payload;
+    if ('link_preview_options' in base || 'disable_web_page_preview' in base)
+        return payload;
+    return { ...base, link_preview_options: { is_disabled: true } };
+}
+/**
+ * @description Wrap `telegram.callApi` so every text message / edit the bot
+ * sends defaults to NO link preview. Operator complaint: each agent message
+ * containing a URL expanded into a large preview card, one per message, in the
+ * muted topic. Installed once at boot alongside `installCallApiTrace`, and
+ * OUTSIDE it (installed after) so the trace records the payload actually sent.
+ */
+function installLinkPreviewSuppression(host) {
+    const originalCallApi = host.callApi.bind(host);
+    host.callApi = (method, payload, options) => originalCallApi(method, applyLinkPreviewSuppression(method, payload), options);
+}
+//# sourceMappingURL=linkPreviewSuppression.js.map

package/dist/utils/linkPreviewSuppression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkPreviewSuppression.js","sourceRoot":"","sources":["../../src/utils/linkPreviewSuppression.ts"],"names":[],"mappings":";;AAgBA,kEAKC;AASD,sEAIC;AAhCD;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,SAAgB,2BAA2B,CAAC,MAAc,EAAE,OAAe;IACzE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC;QAAE,OAAO,OAAO,CAAC;IACpD,MAAM,IAAI,GAAG,OAAkC,CAAC;IAChD,IAAI,sBAAsB,IAAI,IAAI,IAAI,0BAA0B,IAAI,IAAI;QAAE,OAAO,OAAO,CAAC;IACzF,OAAO,EAAE,GAAG,IAAI,EAAE,oBAAoB,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC;AAClE,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,6BAA6B,CAAC,IAAiB;IAC7D,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChD,IAAI,CAAC,OAAO,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CAC1C,eAAe,CAAC,MAAM,EAAE,2BAA2B,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AACnF,CAAC"}

package/dist/utils/localClock.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description The instance-local clock of an instant, for bot notices. "Local"
+ * is the process timezone, which `/timezone` sets for the whole instance.
+ */
+/** `HH:MM` of an epoch-ms instant. */
+export declare function formatLocalClock(epochMs: number): string;
+/**
+ * @description `HH:MM` when the instant falls on today's local calendar date,
+ * else `YYYY-MM-DD HH:MM`: a usage-limit reset days away must not read as a time
+ * later today.
+ */
+export declare function formatLocalClockWithDateIfNotToday(epochMs: number, nowMs: number): string;
+/** `YYYY-MM-DD HH:MM` of an instant — for a text read at an unknown later time. */
+export declare function formatLocalDateAndClock(epochMs: number): string;
+//# sourceMappingURL=localClock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localClock.d.ts","sourceRoot":"","sources":["../../src/utils/localClock.ts"],"names":[],"mappings":"AAEA;;;GAGG;AAEH,sCAAsC;AACtC,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGzF;AAED,mFAAmF;AACnF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D"}

package/dist/utils/localClock.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLocalClock = formatLocalClock;
+exports.formatLocalClockWithDateIfNotToday = formatLocalClockWithDateIfNotToday;
+exports.formatLocalDateAndClock = formatLocalDateAndClock;
+const reminderWizard_1 = require("./reminderWizard");
+/**
+ * @description The instance-local clock of an instant, for bot notices. "Local"
+ * is the process timezone, which `/timezone` sets for the whole instance.
+ */
+/** `HH:MM` of an epoch-ms instant. */
+function formatLocalClock(epochMs) {
+    const at = new Date(epochMs);
+    return (0, reminderWizard_1.formatReminderTime)({ hour: at.getHours(), minute: at.getMinutes() });
+}
+/**
+ * @description `HH:MM` when the instant falls on today's local calendar date,
+ * else `YYYY-MM-DD HH:MM`: a usage-limit reset days away must not read as a time
+ * later today.
+ */
+function formatLocalClockWithDateIfNotToday(epochMs, nowMs) {
+    const dateIso = (0, reminderWizard_1.formatReminderDateIso)(new Date(epochMs));
+    return dateIso === (0, reminderWizard_1.formatReminderDateIso)((0, reminderWizard_1.getLocalDateAtDayOffset)(nowMs, 0)) ? formatLocalClock(epochMs) : formatLocalDateAndClock(epochMs);
+}
+/** `YYYY-MM-DD HH:MM` of an instant — for a text read at an unknown later time. */
+function formatLocalDateAndClock(epochMs) {
+    return `${(0, reminderWizard_1.formatReminderDateIso)(new Date(epochMs))} ${formatLocalClock(epochMs)}`;
+}
+//# sourceMappingURL=localClock.js.map

package/dist/utils/localClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localClock.js","sourceRoot":"","sources":["../../src/utils/localClock.ts"],"names":[],"mappings":";;AAQA,4CAGC;AAOD,gFAGC;AAGD,0DAEC;AA1BD,qDAAsG;AAEtG;;;GAGG;AAEH,sCAAsC;AACtC,SAAgB,gBAAgB,CAAC,OAAe;IAC9C,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,OAAO,IAAA,mCAAkB,EAAC,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;AAC9E,CAAC;AAED;;;;GAIG;AACH,SAAgB,kCAAkC,CAAC,OAAe,EAAE,KAAa;IAC/E,MAAM,OAAO,GAAG,IAAA,sCAAqB,EAAC,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACzD,OAAO,OAAO,KAAK,IAAA,sCAAqB,EAAC,IAAA,wCAAuB,EAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAC7I,CAAC;AAED,mFAAmF;AACnF,SAAgB,uBAAuB,CAAC,OAAe;IACrD,OAAO,GAAG,IAAA,sCAAqB,EAAC,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;AACpF,CAAC"}

package/dist/utils/markdownTableRender.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @description Pure pre-processing pass that turns raw GitHub-flavored
+ * markdown tables (`| a | b |` …) into a readable Telegram form.
+ *
+ * Why this exists: OpenCode replies often contain GFM tables as plain pipe
+ * text, which is unreadable on a phone. This module detects those blocks and
+ * rewrites each one to a HYBRID rendering chosen by width:
+ *  - narrow table (aligned form fits {@link tableMaxMonospaceWidth}) → a
+ *    column-aligned box-drawing frame WRAPPED in a ``` fence, so the shared
+ *    `renderAgentHtml` fence machinery turns it into a `<pre>` (monospace).
+ *  - wide table → per-row "field: value" blocks as plain markdown lines, which
+ *    flow through the normal bold/inline passes.
+ *
+ * It is wired as step 0.5 of `renderAgentHtml` (after the control-char strip,
+ * before the fence regex) and therefore runs on EVERY agent output for BOTH
+ * backends. Two safety invariants follow from that:
+ *  1. it is FENCE-AWARE — lines inside an existing ```-delimited region are
+ *     never scanned for tables (a code block full of pipes must survive);
+ *  2. it leaves all non-table text byte-for-byte identical.
+ *
+ * The detector is narrow on purpose (header pipe row + GFM separator row +
+ * ≥1 body rows), so ordinary prose containing a stray `|` never matches.
+ */
+/**
+ * Width budget (in monospace code points) for the aligned form. If the widest
+ * line of the box-drawing render exceeds this, the renderer falls back to the
+ * "field: value" form instead. Chosen so an aligned table still fits a typical
+ * phone without horizontal scroll. Tunable — the main agent confirms/adjusts
+ * the exact value via live verification.
+ */
+export declare const tableMaxMonospaceWidth = 42;
+/** A contiguous block of source lines that form one GFM table. */
+export interface TableLineRange {
+    startLine: number;
+    endLineExclusive: number;
+}
+/** A parsed table: header cells + body rows (each row already padded to the
+ *  header width). */
+export interface ParsedTable {
+    headers: string[];
+    rows: string[][];
+}
+/**
+ * Find every GFM table block in `text`, returning their line ranges. A block
+ * is a header pipe row, a separator row directly below it, then ≥1 consecutive
+ * pipe body rows. Lines inside an existing ```-fenced region are skipped, so a
+ * code block containing pipes never matches.
+ */
+export declare function detectTables(text: string): TableLineRange[];
+/**
+ * Parse a table block (the raw lines of one detected range, joined by `\n`)
+ * into headers + rows. Ragged rows shorter than the header are padded with
+ * `''`; rows longer than the header keep their extra cells (so nothing is
+ * silently lost — the aligned form widens to fit).
+ */
+export declare function parseTable(block: string): ParsedTable;
+/**
+ * Render the table as a monospace, column-aligned box-drawing frame. The
+ * caller wraps the result in a ``` fence so the HTML layer makes it a `<pre>`.
+ */
+export declare function renderAligned(table: ParsedTable): string;
+/**
+ * Render the table as per-row "field: value" blocks for the wide case. The
+ * first column is the key cell (after `▸`); remaining columns become
+ * `  <header>: <cell>` lines. Inline markdown in cell text is kept — the HTML
+ * layer renders it. When there is only one column (no obvious key/value split)
+ * the rows are numbered instead.
+ */
+export declare function renderFieldValue(table: ParsedTable): string;
+/**
+ * Pick the rendering for one table: aligned (fenced) if its widest line fits
+ * {@link tableMaxMonospaceWidth}, else the field-value form. Returns the text
+ * already wrapped for the HTML layer (``` fence for aligned, plain lines for
+ * field-value).
+ */
+export declare function renderTable(table: ParsedTable): string;
+/**
+ * Replace every detected GFM table block in `text` with its chosen rendering,
+ * in place. Non-table text and fenced regions are returned byte-for-byte
+ * unchanged. This is the single entry point wired into `renderAgentHtml`.
+ */
+export declare function renderMarkdownTables(text: string): string;
+//# sourceMappingURL=markdownTableRender.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTableRender.d.ts","sourceRoot":"","sources":["../../src/utils/markdownTableRender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,kEAAkE;AAClE,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;qBACqB;AACrB,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;CAClB;AAmED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAwD3D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAWrD;AAqDD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CASxD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAgB3D;AAOD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAMtD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAuBzD"}