charness 0.0.0-stage → 3.1.0

package/dist/utils/transcribeAudio.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * @description Voice-note transcription against a Whisper-compatible HTTP API
+ * (Groq when its key is set, else OpenAI), with automatic retries on transient
+ * failures.
+ *
+ * Extracted from `bot.ts` so it is side-effect-free and testable against a
+ * local HTTP server (importing `bot.ts` would construct a Telegraf instance and
+ * read ENV at module load) — the same reasoning as `./download`.
+ *
+ * Why retries: Groq normally answers in well under a second, yet a request
+ * occasionally stalls past the timeout. Without a retry that voice note was
+ * simply lost and the user had to re-record it. A timeout, a network error, an
+ * HTTP 408 / 409 and a 5xx are retried after a pause (5 s, then 15 s); a 429
+ * waits at least as long as the provider's `Retry-After`; any other 4xx fails
+ * at once, since resending the same request would fail the same way.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcribeRetryDelaysMs = void 0;
+exports.getTranscriptionEndpoint = getTranscriptionEndpoint;
+exports.getTranscribeFailureKind = getTranscribeFailureKind;
+exports.getTranscribeRetryDelayMs = getTranscribeRetryDelayMs;
+exports.transcribeAudio = transcribeAudio;
+const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const retryAfterHeader_1 = require("./retryAfterHeader");
+/** Pauses before the automatic retries: the 1st after 5 s, the 2nd after 15 s. */
+exports.transcribeRetryDelaysMs = [5_000, 15_000];
+const groqTranscriptionUrl = 'https://api.groq.com/openai/v1/audio/transcriptions';
+const openAiTranscriptionUrl = 'https://api.openai.com/v1/audio/transcriptions';
+const groqTranscriptionModel = 'whisper-large-v3';
+const openAiTranscriptionModel = 'whisper-1';
+const tooManyRequestsStatus = 429;
+const firstServerErrorStatus = 500;
+/**
+ * 408 Request Timeout and 409 Conflict pass on a resend — the same set the
+ * official OpenAI / Groq SDKs retry besides 429 and 5xx.
+ */
+const retryableClientErrorStatuses = new Set([408, 409]);
+const errorBodyPreviewLength = 500;
+/**
+ * @description Pick the transcription provider from the configured API keys:
+ * Groq wins when both are set; `null` when neither is.
+ */
+function getTranscriptionEndpoint(apiKeys) {
+    if (apiKeys.groqApiKey) {
+        return { url: groqTranscriptionUrl, apiKey: apiKeys.groqApiKey, model: groqTranscriptionModel };
+    }
+    if (apiKeys.openaiApiKey) {
+        return { url: openAiTranscriptionUrl, apiKey: apiKeys.openaiApiKey, model: openAiTranscriptionModel };
+    }
+    return null;
+}
+/**
+ * @description Classify a non-2xx HTTP status of the transcription API.
+ */
+function getTranscribeFailureKind(status) {
+    if (status === tooManyRequestsStatus)
+        return 'rateLimited';
+    if (status >= firstServerErrorStatus || retryableClientErrorStatuses.has(status))
+        return 'transient';
+    return 'permanent';
+}
+/**
+ * @description Pause before retry number `retryIndex` (0-based), or `null`
+ * when the failure must not be retried (permanent, or the schedule is used
+ * up). A 429 never retries sooner than the schedule NOR sooner than the
+ * provider's `Retry-After` asks.
+ */
+function getTranscribeRetryDelayMs(input) {
+    if (input.failureKind === 'permanent')
+        return null;
+    const scheduledDelayMs = (input.retryDelaysMs ?? exports.transcribeRetryDelaysMs)[input.retryIndex];
+    if (scheduledDelayMs === undefined)
+        return null;
+    if (input.failureKind === 'rateLimited' && input.retryAfterSec !== undefined) {
+        return Math.max(input.retryAfterSec * 1000, scheduledDelayMs);
+    }
+    return scheduledDelayMs;
+}
+function parseRetryAfterSec(header) {
+    const waitMs = (0, retryAfterHeader_1.getRetryAfterHeaderMs)(Array.isArray(header) ? header[0] : header, Date.now());
+    return waitMs ? Math.ceil(waitMs / 1000) : undefined;
+}
+function getApiErrorMessage(body) {
+    const bodyPreview = body.slice(0, errorBodyPreviewLength);
+    try {
+        const errorJson = JSON.parse(body);
+        const apiMessage = errorJson?.error?.message ?? errorJson?.error;
+        return typeof apiMessage === 'string' ? apiMessage : bodyPreview;
+    }
+    catch {
+        return bodyPreview;
+    }
+}
+/**
+ * @description One transcription request. Never rejects: every failure comes
+ * back classified so {@link transcribeAudio} can decide whether to retry.
+ */
+async function transcribeAudioOnce(filePath, endpoint, timeoutMs) {
+    // Detect a 0-byte download up-front: previously this would still be sent
+    // to Whisper, which replies 400 with a generic "file is empty" body that
+    // the old error path swallowed silently. Failing here gives the operator
+    // a concrete cause (download produced no bytes) without the round-trip.
+    let fileSize = 0;
+    try {
+        fileSize = (await fs_1.promises.stat(filePath)).size;
+    }
+    catch (e) {
+        return { ok: false, error: `stat failed: ${e instanceof Error ? e.message : e}`, failureKind: 'permanent' };
+    }
+    if (fileSize === 0)
+        return { ok: false, error: 'downloaded audio is empty', failureKind: 'permanent' };
+    const form = new form_data_1.default();
+    // Explicit filename + content-type: form-data's auto-detection from the
+    // ReadStream's path usually works, but some intermediaries strip
+    // path-based hints. Setting both makes the multipart upload deterministic.
+    form.append('file', fs.createReadStream(filePath), {
+        filename: path.basename(filePath),
+        contentType: 'audio/ogg',
+    });
+    form.append('model', endpoint.model);
+    const url = new URL(endpoint.url);
+    const client = url.protocol === 'https:' ? https : http;
+    return new Promise((resolve) => {
+        // Audit S14 / #33: install the error handler before piping the form
+        // so a socket error during the initial handshake can't escape. Also
+        // add a hard timeout so a hung Groq/OpenAI response can't block the
+        // voice-message path indefinitely.
+        const req = client.request(url, {
+            method: 'POST',
+            headers: { ...form.getHeaders(), Authorization: `Bearer ${endpoint.apiKey}` },
+        }, (res) => {
+            // Decode across chunk boundaries: per-chunk `toString()` garbled a
+            // multi-byte character (e.g. Cyrillic) split between two chunks.
+            res.setEncoding('utf8');
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            // A connection reset mid-body destroys only the RESPONSE: `end` never
+            // fires and the request emits no `error`, so without this the attempt
+            // would hang forever and stall the thread's voice queue.
+            res.on('error', (e) => {
+                resolve({ ok: false, error: e.message, failureKind: 'transient' });
+            });
+            res.on('end', () => {
+                const status = res.statusCode ?? 0;
+                if (status < 200 || status >= 300) {
+                    resolve({
+                        ok: false,
+                        error: `HTTP ${status}: ${getApiErrorMessage(body)}`,
+                        failureKind: getTranscribeFailureKind(status),
+                        retryAfterSec: parseRetryAfterSec(res.headers['retry-after']),
+                    });
+                    return;
+                }
+                try {
+                    const json = JSON.parse(body);
+                    if (typeof json.text === 'string' && json.text.length > 0) {
+                        resolve({ ok: true, text: json.text });
+                        return;
+                    }
+                    resolve({ ok: false, error: 'transcription returned empty text', failureKind: 'permanent' });
+                }
+                catch {
+                    resolve({
+                        ok: false,
+                        error: `malformed response from Whisper API: ${body.slice(0, errorBodyPreviewLength)}`,
+                        failureKind: 'permanent',
+                    });
+                }
+            });
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error('transcription timed out'));
+        });
+        req.on('error', (e) => {
+            resolve({ ok: false, error: e instanceof Error ? e.message : String(e), failureKind: 'transient' });
+        });
+        form.pipe(req);
+    });
+}
+/**
+ * @description Transcribe a voice note, retrying transient failures on the
+ * {@link transcribeRetryDelaysMs} schedule. Resolves with the text, or with
+ * the LAST error (annotated with the attempt count once a retry happened).
+ */
+async function transcribeAudio(filePath, endpoint, options) {
+    for (let retryIndex = 0;; retryIndex++) {
+        const attempt = await transcribeAudioOnce(filePath, endpoint, options.timeoutMs);
+        if (attempt.ok)
+            return attempt;
+        const delayMs = getTranscribeRetryDelayMs({
+            failureKind: attempt.failureKind,
+            retryIndex,
+            retryAfterSec: attempt.retryAfterSec,
+            retryDelaysMs: options.retryDelaysMs,
+        });
+        const attemptCount = retryIndex + 1;
+        if (delayMs === null) {
+            return {
+                ok: false,
+                error: attemptCount > 1 ? `${attempt.error} (after ${attemptCount} attempts)` : attempt.error,
+            };
+        }
+        options.onRetry?.({ attemptNumber: attemptCount, error: attempt.error, delayMs });
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+}
+//# sourceMappingURL=transcribeAudio.js.map

package/dist/utils/transcribeAudio.js.map

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

package/dist/utils/transientFrames.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @description Pure collector for a thread's TRANSIENT status-frame message ids
+ * — the three SEPARATE bot messages the turn lifecycle creates-then-deletes:
+ *
+ *   - `statusMessageId`          — the "✽ working…" liveness/spinner frame
+ *   - `thinkingMessageId`        — the live "☁️ thinking …" chain-of-thought frame
+ *   - `subagentStatusMessageId`  — the dedicated "🤖 sub-agent …" delegation frame
+ *
+ * Returns only the non-null ones, in that fixed order, so the graceful-shutdown
+ * sweep and the boot reconciliation can delete exactly the frames currently on
+ * screen. These ids live ONLY in volatile in-memory `ThreadMessageState`, so a
+ * restart that doesn't clean them up orphans the messages forever in the topic.
+ *
+ * Deliberately absent: the pinned status banner (`pinnedStatusMessageId`, a
+ * persistent-by-design message) and the native typing loader (a
+ * `sendChatAction('typing')` with no message of its own) — neither is a
+ * transient frame.
+ */
+export interface TransientFrameState {
+    statusMessageId: number | null;
+    thinkingMessageId: number | null;
+    subagentStatusMessageId: number | null;
+}
+export declare function getTransientFrameIds(state: TransientFrameState): number[];
+/**
+ * The frame-generation guards a shutdown sweep must bump. Both are captured by
+ * an in-flight `sendStatusFrame` / thinking-frame create BEFORE its `await` and
+ * re-checked after (`getStatusFrameStoreDecision`) to decide store-vs-discard.
+ */
+export interface ShutdownFrameState extends TransientFrameState {
+    statusFrameGeneration: number;
+    thinkingFrameGeneration: number;
+}
+/**
+ * @description Graceful-shutdown clear of a thread's transient frames: returns the
+ * ids currently on screen (for the caller to delete), then bumps BOTH frame
+ * generations and nulls all three ids.
+ *
+ * The generation bump is the load-bearing part, and the reason this must run for
+ * EVERY tracked thread — including one whose ids are all null right now. A
+ * `sendStatusFrame` / thinking-frame create that is mid-`await` when the sweep
+ * runs has NOT yet stored its id (so {@link getTransientFrameIds} is empty here),
+ * but it captured the pre-bump generation and re-checks it after the await
+ * (`getStatusFrameStoreDecision`). Bumping makes that racing create DISCARD
+ * (delete) its just-sent message instead of storing an orphan that outlives the
+ * restart — the leftover "🔧 <tool>…" / "✽ working…" frame stranded as a topic's
+ * last message. Mirrors the bump `deleteStatusMessage` already does for the
+ * mid-session delete; the shutdown path previously nulled the ids WITHOUT bumping,
+ * so it sat outside that race protection.
+ */
+export declare function clearTransientFramesForShutdown(state: ShutdownFrameState): number[];
+//# sourceMappingURL=transientFrames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transientFrames.d.ts","sourceRoot":"","sources":["../../src/utils/transientFrames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAMzE;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,EAAE,CAQnF"}

package/dist/utils/transientFrames.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransientFrameIds = getTransientFrameIds;
+exports.clearTransientFramesForShutdown = clearTransientFramesForShutdown;
+function getTransientFrameIds(state) {
+    const ids = [];
+    if (state.statusMessageId !== null)
+        ids.push(state.statusMessageId);
+    if (state.thinkingMessageId !== null)
+        ids.push(state.thinkingMessageId);
+    if (state.subagentStatusMessageId !== null)
+        ids.push(state.subagentStatusMessageId);
+    return ids;
+}
+/**
+ * @description Graceful-shutdown clear of a thread's transient frames: returns the
+ * ids currently on screen (for the caller to delete), then bumps BOTH frame
+ * generations and nulls all three ids.
+ *
+ * The generation bump is the load-bearing part, and the reason this must run for
+ * EVERY tracked thread — including one whose ids are all null right now. A
+ * `sendStatusFrame` / thinking-frame create that is mid-`await` when the sweep
+ * runs has NOT yet stored its id (so {@link getTransientFrameIds} is empty here),
+ * but it captured the pre-bump generation and re-checks it after the await
+ * (`getStatusFrameStoreDecision`). Bumping makes that racing create DISCARD
+ * (delete) its just-sent message instead of storing an orphan that outlives the
+ * restart — the leftover "🔧 <tool>…" / "✽ working…" frame stranded as a topic's
+ * last message. Mirrors the bump `deleteStatusMessage` already does for the
+ * mid-session delete; the shutdown path previously nulled the ids WITHOUT bumping,
+ * so it sat outside that race protection.
+ */
+function clearTransientFramesForShutdown(state) {
+    const ids = getTransientFrameIds(state);
+    state.statusFrameGeneration += 1;
+    state.thinkingFrameGeneration += 1;
+    state.statusMessageId = null;
+    state.thinkingMessageId = null;
+    state.subagentStatusMessageId = null;
+    return ids;
+}
+//# sourceMappingURL=transientFrames.js.map

package/dist/utils/transientFrames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transientFrames.js","sourceRoot":"","sources":["../../src/utils/transientFrames.ts"],"names":[],"mappings":";;AAwBA,oDAMC;AA6BD,0EAQC;AA3CD,SAAgB,oBAAoB,CAAC,KAA0B;IAC7D,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,KAAK,CAAC,eAAe,KAAK,IAAI;QAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACpE,IAAI,KAAK,CAAC,iBAAiB,KAAK,IAAI;QAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACxE,IAAI,KAAK,CAAC,uBAAuB,KAAK,IAAI;QAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACpF,OAAO,GAAG,CAAC;AACb,CAAC;AAYD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,+BAA+B,CAAC,KAAyB;IACvE,MAAM,GAAG,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACxC,KAAK,CAAC,qBAAqB,IAAI,CAAC,CAAC;IACjC,KAAK,CAAC,uBAAuB,IAAI,CAAC,CAAC;IACnC,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC;IAC7B,KAAK,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAC/B,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC;IACrC,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/utils/typingActive.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @description Pure decision for whether the native "agent is typing" state
+ * should keep showing for a topic (S3).
+ *
+ * The typing indicator persists while a topic has anything still to show OR its
+ * agent is still working — and clears only when the topic is truly drained AND
+ * idle. Extracted so the rule is unit-testable without the Telegraf / adapter
+ * machinery; `bot.ts` supplies the two live readings (output-queue streaming and
+ * adapter busy).
+ */
+export interface TypingActiveInput {
+    /** Is real agent output mid-flight (queued / debouncing / sending / drafting)? */
+    isOutputStreaming: boolean;
+    /** Is the thread's adapter still working (its `checkIsBusy`)? */
+    isAdapterBusy: boolean;
+    /**
+     * Is a BOT-ISSUED compaction in flight for this thread (`/compact`, the idle
+     * watchdog, or the agent's `compact_conversation`)?
+     *
+     * A third input is needed because the other two are BOTH false during a
+     * compaction on at least one backend: OpenCode sets no busy flag for its
+     * `summarize` turn, and neither backend streams output while summarising. A
+     * compaction measured at 43 s (and up to 3+ minutes on a large context) would
+     * therefore leave the topic showing nothing at all — the silence this input
+     * exists to remove.
+     */
+    isCompacting: boolean;
+}
+/**
+ * @description Keep the typing indicator alive while output is streaming, the
+ * agent is busy, OR a bot-issued compaction is running; stop only when ALL three
+ * are false (drained + idle + not compacting).
+ */
+export declare function checkShouldKeepTyping(input: TypingActiveInput): boolean;
+//# sourceMappingURL=typingActive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typingActive.d.ts","sourceRoot":"","sources":["../../src/utils/typingActive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,iBAAiB,EAAE,OAAO,CAAC;IAC3B,iEAAiE;IACjE,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;;;;;;OAUG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAEvE"}

package/dist/utils/typingActive.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @description Pure decision for whether the native "agent is typing" state
+ * should keep showing for a topic (S3).
+ *
+ * The typing indicator persists while a topic has anything still to show OR its
+ * agent is still working — and clears only when the topic is truly drained AND
+ * idle. Extracted so the rule is unit-testable without the Telegraf / adapter
+ * machinery; `bot.ts` supplies the two live readings (output-queue streaming and
+ * adapter busy).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkShouldKeepTyping = checkShouldKeepTyping;
+/**
+ * @description Keep the typing indicator alive while output is streaming, the
+ * agent is busy, OR a bot-issued compaction is running; stop only when ALL three
+ * are false (drained + idle + not compacting).
+ */
+function checkShouldKeepTyping(input) {
+    return input.isOutputStreaming || input.isAdapterBusy || input.isCompacting;
+}
+//# sourceMappingURL=typingActive.js.map

package/dist/utils/typingActive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typingActive.js","sourceRoot":"","sources":["../../src/utils/typingActive.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AA0BH,sDAEC;AAPD;;;;GAIG;AACH,SAAgB,qBAAqB,CAAC,KAAwB;IAC5D,OAAO,KAAK,CAAC,iBAAiB,IAAI,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,YAAY,CAAC;AAC9E,CAAC"}

package/dist/utils/typingLoopBackstop.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @description Loop-level backstop for the native "agent is typing…" indicator —
+ * a bounded safety net that force-stops the typing loader when it is being kept
+ * alive by a PROVABLY-INCONSISTENT state, never by a legitimately long turn.
+ *
+ * ROOT-CAUSE CONTEXT. The typing loop self-stops only when
+ * `checkShouldKeepTyping` (`isOutputStreaming || isAdapterBusy`) goes false, and
+ * has NO absolute bound. `jsonStreamBusyWatchdog` already covers a stuck
+ * `isBusy` (a missed terminal `result`). This backstop covers the OTHER input:
+ * `isOutputStreaming`, which reads `q.pendingOutput !== null || q.isProcessing ||
+ * q.debounceTimer !== null`. A leaked non-null `debounceTimer` (the `isFinal`
+ * fast-path in `queueOutput` cleared the timer but left the handle set) pins
+ * `isOutputStreaming` true forever → the indicator hangs unbounded even though
+ * the output queue is empty (live 2026-07-19, a json-stream group topic firing
+ * `sendChatAction('typing')` every 4s for an hour+ after a clean turn end).
+ *
+ * WHY THIS CAN'T CUT A LEGIT LONG (SILENT) TURN. The backstop fires ONLY on a
+ * contradiction that a working agent can never produce:
+ *  - a genuinely-working agent keeps `isAdapterBusy` TRUE (a long silent
+ *    Bash/Task tool, a sub-agent, an unanswered question all hold busy) → vetoed;
+ *  - a bot-issued compaction (`isCompacting`) is work the bot is itself awaiting,
+ *    and on OpenCode it sets no busy flag at all → vetoed;
+ *  - a live DM draft is a real stream (`isTransportStreaming`) → vetoed;
+ *  - real text waiting to send (`hasPendingOutput`) or an in-flight send
+ *    (`isProcessing`, which may legitimately be a slow API call) → vetoed.
+ * Only when the adapter is idle, nothing is drafting, the queue is empty AND an
+ * un-fired debounce handle lingers does it fire. A LIVE debounce is ALWAYS armed
+ * WITH pending text (both `queueOutput` and `processOutputQueue` arm it only when
+ * `pendingOutput` is set, nulling it the instant it fires), so "debounce armed +
+ * empty queue" can only be the dead/stale handle from the leak — never a real
+ * in-flight turn. The decision is therefore safe by construction: it truncates a
+ * leak, never work.
+ */
+export interface TypingLoopBackstopInput {
+    /** The adapter's genuine busy signal — a real long/silent tool turn holds it. */
+    isAdapterBusy: boolean;
+    /**
+     * A BOT-ISSUED compaction is in flight for this thread. A VETO, because during
+     * a compaction the "leak" pattern below is LEGITIMATE: the adapter reports idle
+     * (OpenCode sets no busy flag for `summarize`), nothing is queued, and a stale
+     * debounce handle may well be sitting there from the turn that just ended — and
+     * force-stopping on that combination would kill precisely the indicator that
+     * covers the compaction.
+     */
+    isCompacting: boolean;
+    /** The output transport (DM draft cursor) reports an active live stream. */
+    isTransportStreaming: boolean;
+    /** `q.pendingOutput !== null` — real agent text still waiting to be sent. */
+    hasPendingOutput: boolean;
+    /** `q.isProcessing` — a flush is actively awaiting a send (possibly slow). */
+    isProcessing: boolean;
+    /** `q.debounceTimer !== null` — a debounce timer HANDLE is present. */
+    hasDebounceTimer: boolean;
+}
+/**
+ * @description True iff the typing loop is being kept alive PURELY by a leaked
+ * output-queue state — an armed debounce handle over an otherwise-empty queue
+ * while the adapter is idle. This is a provable inconsistency (a live debounce
+ * never coexists with an empty queue), so force-stopping here can only clear a
+ * leak, never truncate a genuinely long turn. Every "genuinely in flight" signal
+ * (adapter busy / DM draft / pending text / active send) VETOES the decision.
+ */
+export declare function checkIsTypingStuckByLeak(input: TypingLoopBackstopInput): boolean;
+//# sourceMappingURL=typingLoopBackstop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typingLoopBackstop.d.ts","sourceRoot":"","sources":["../../src/utils/typingLoopBackstop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,MAAM,WAAW,uBAAuB;IACtC,iFAAiF;IACjF,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;;;OAOG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,4EAA4E;IAC5E,oBAAoB,EAAE,OAAO,CAAC;IAC9B,6EAA6E;IAC7E,gBAAgB,EAAE,OAAO,CAAC;IAC1B,8EAA8E;IAC9E,YAAY,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAiBhF"}

package/dist/utils/typingLoopBackstop.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * @description Loop-level backstop for the native "agent is typing…" indicator —
+ * a bounded safety net that force-stops the typing loader when it is being kept
+ * alive by a PROVABLY-INCONSISTENT state, never by a legitimately long turn.
+ *
+ * ROOT-CAUSE CONTEXT. The typing loop self-stops only when
+ * `checkShouldKeepTyping` (`isOutputStreaming || isAdapterBusy`) goes false, and
+ * has NO absolute bound. `jsonStreamBusyWatchdog` already covers a stuck
+ * `isBusy` (a missed terminal `result`). This backstop covers the OTHER input:
+ * `isOutputStreaming`, which reads `q.pendingOutput !== null || q.isProcessing ||
+ * q.debounceTimer !== null`. A leaked non-null `debounceTimer` (the `isFinal`
+ * fast-path in `queueOutput` cleared the timer but left the handle set) pins
+ * `isOutputStreaming` true forever → the indicator hangs unbounded even though
+ * the output queue is empty (live 2026-07-19, a json-stream group topic firing
+ * `sendChatAction('typing')` every 4s for an hour+ after a clean turn end).
+ *
+ * WHY THIS CAN'T CUT A LEGIT LONG (SILENT) TURN. The backstop fires ONLY on a
+ * contradiction that a working agent can never produce:
+ *  - a genuinely-working agent keeps `isAdapterBusy` TRUE (a long silent
+ *    Bash/Task tool, a sub-agent, an unanswered question all hold busy) → vetoed;
+ *  - a bot-issued compaction (`isCompacting`) is work the bot is itself awaiting,
+ *    and on OpenCode it sets no busy flag at all → vetoed;
+ *  - a live DM draft is a real stream (`isTransportStreaming`) → vetoed;
+ *  - real text waiting to send (`hasPendingOutput`) or an in-flight send
+ *    (`isProcessing`, which may legitimately be a slow API call) → vetoed.
+ * Only when the adapter is idle, nothing is drafting, the queue is empty AND an
+ * un-fired debounce handle lingers does it fire. A LIVE debounce is ALWAYS armed
+ * WITH pending text (both `queueOutput` and `processOutputQueue` arm it only when
+ * `pendingOutput` is set, nulling it the instant it fires), so "debounce armed +
+ * empty queue" can only be the dead/stale handle from the leak — never a real
+ * in-flight turn. The decision is therefore safe by construction: it truncates a
+ * leak, never work.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIsTypingStuckByLeak = checkIsTypingStuckByLeak;
+/**
+ * @description True iff the typing loop is being kept alive PURELY by a leaked
+ * output-queue state — an armed debounce handle over an otherwise-empty queue
+ * while the adapter is idle. This is a provable inconsistency (a live debounce
+ * never coexists with an empty queue), so force-stopping here can only clear a
+ * leak, never truncate a genuinely long turn. Every "genuinely in flight" signal
+ * (adapter busy / DM draft / pending text / active send) VETOES the decision.
+ */
+function checkIsTypingStuckByLeak(input) {
+    // A genuinely working agent (long/silent tool, sub-agent, mid-turn, unanswered
+    // question) keeps this true — never a leak, never cut.
+    if (input.isAdapterBusy)
+        return false;
+    // A bot-issued compaction is real work the bot itself is awaiting, even though
+    // it looks exactly like the leak from the output queue's side.
+    if (input.isCompacting)
+        return false;
+    // A live DM draft cursor is a legitimate stream, not this leak.
+    if (input.isTransportStreaming)
+        return false;
+    // Real text queued → genuinely streaming.
+    if (input.hasPendingOutput)
+        return false;
+    // An in-flight send may just be a slow API call, not a leak — leave it be.
+    if (input.isProcessing)
+        return false;
+    // Nothing is genuinely in flight, yet a debounce timer handle lingers. A live
+    // debounce is ALWAYS paired with pending text, so a handle over an empty queue
+    // can only be the dead/stale one left by the `isFinal` fast-path → a leak.
+    return input.hasDebounceTimer;
+}
+//# sourceMappingURL=typingLoopBackstop.js.map

package/dist/utils/typingLoopBackstop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typingLoopBackstop.js","sourceRoot":"","sources":["../../src/utils/typingLoopBackstop.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;AAgCH,4DAiBC;AAzBD;;;;;;;GAOG;AACH,SAAgB,wBAAwB,CAAC,KAA8B;IACrE,+EAA+E;IAC/E,uDAAuD;IACvD,IAAI,KAAK,CAAC,aAAa;QAAE,OAAO,KAAK,CAAC;IACtC,+EAA+E;IAC/E,+DAA+D;IAC/D,IAAI,KAAK,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IACrC,gEAAgE;IAChE,IAAI,KAAK,CAAC,oBAAoB;QAAE,OAAO,KAAK,CAAC;IAC7C,0CAA0C;IAC1C,IAAI,KAAK,CAAC,gBAAgB;QAAE,OAAO,KAAK,CAAC;IACzC,2EAA2E;IAC3E,IAAI,KAAK,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IACrC,8EAA8E;IAC9E,+EAA+E;IAC/E,2EAA2E;IAC3E,OAAO,KAAK,CAAC,gBAAgB,CAAC;AAChC,CAAC"}

package/dist/utils/verbosityRender.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @description Pure decision helper for the `/verbosity` umbrella command
+ * (plan 2026-06-11 S2). The macro itself just writes the same per-pref store
+ * the individual commands (`/thinking`, `/tool_results`, `/subagent`) write —
+ * last write per pref wins — so the only /verbosity-specific logic is this
+ * read-side question: "do all three prefs currently agree on one level?",
+ * which drives the picker's ✓ marker and the "custom" (mixed) rendering.
+ */
+import type { DisplayVerbosityMode, ResolvedThreadDisplayPrefs } from '../types';
+/**
+ * @description The single level all three display prefs (thinking,
+ * toolResults, subagent) currently share, or `null` when they are mixed.
+ * The `/verbosity` picker puts ✓ on an exact match ONLY — a mixed state shows
+ * no marker anywhere and is rendered as "custom" with the three values
+ * spelled out.
+ */
+export declare function getUniformVerbosityLevel(prefs: ResolvedThreadDisplayPrefs): DisplayVerbosityMode | null;
+//# sourceMappingURL=verbosityRender.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verbosityRender.d.ts","sourceRoot":"","sources":["../../src/utils/verbosityRender.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAEjF;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,0BAA0B,GAAG,oBAAoB,GAAG,IAAI,CAKvG"}

package/dist/utils/verbosityRender.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniformVerbosityLevel = getUniformVerbosityLevel;
+/**
+ * @description The single level all three display prefs (thinking,
+ * toolResults, subagent) currently share, or `null` when they are mixed.
+ * The `/verbosity` picker puts ✓ on an exact match ONLY — a mixed state shows
+ * no marker anywhere and is rendered as "custom" with the three values
+ * spelled out.
+ */
+function getUniformVerbosityLevel(prefs) {
+    if (prefs.thinking === prefs.toolResults && prefs.toolResults === prefs.subagent) {
+        return prefs.thinking;
+    }
+    return null;
+}
+//# sourceMappingURL=verbosityRender.js.map

package/dist/utils/verbosityRender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verbosityRender.js","sourceRoot":"","sources":["../../src/utils/verbosityRender.ts"],"names":[],"mappings":";;AAiBA,4DAKC;AAZD;;;;;;GAMG;AACH,SAAgB,wBAAwB,CAAC,KAAiC;IACxE,IAAI,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjF,OAAO,KAAK,CAAC,QAAQ,CAAC;IACxB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}