charness 0.0.0-stage → 3.0.0

package/dist/utils/recentRelayWindow.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * @description Rolling window of recently-RELAYED Claude pane lines — the
+ * long-horizon companion to the per-poll line-set diff (`getNewPaneContent`
+ * in `adapters/claudeCliAdapter.ts`).
+ *
+ * WHY it exists (live incident 2026-06-10, plan
+ * `agent/tasks/actual/2026-06-10-claude-stale-rescrape-dedup.md`): the
+ * per-poll diff only knows the immediately-previous pane capture. When the
+ * Claude TUI re-renders hours-old scrollback (full repaint, scroll-through,
+ * resize), the redrawn lines are absent from that previous capture, so the
+ * diff classifies them as "new" and re-relays them — chunked and overlapping
+ * as the pane scrolls (a topic was flooded with ~12 chunks of a stale ~1400
+ * line diff). This window remembers what was actually RELAYED to the topic,
+ * so a re-render of already-sent content is suppressed regardless of WHAT
+ * triggered the redraw.
+ *
+ * Locked tradeoff — the SAME direction as the per-poll set diff (see
+ * `getNewPaneContent`'s JSDoc): err toward DROPPING a re-render duplicate. A
+ * re-send flood is the user-visible bug; a rare suppressed legit repeat (e.g.
+ * re-running an identical long command within the window horizon) is a
+ * low-cost loss. Like `lastContent`, the window does not self-heal a
+ * wrongly-suppressed line within its horizon. Two guards bound the damage:
+ * only SUBSTANTIAL lines (≥ {@link relayDedupMinLineLength} after
+ * normalization) are ever recorded or suppressed — short lines ("yes",
+ * "done", list bullets) repeat legitimately all the time and always pass —
+ * and the FIFO bound means old lines eventually evict as new content is
+ * relayed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayBlockSignatureMax = exports.relayWindowMaxLines = exports.relayDedupMinLineLength = void 0;
+exports.normalizeForComparison = normalizeForComparison;
+exports.normalizeForRelayDedup = normalizeForRelayDedup;
+exports.buildRelayBlockSignature = buildRelayBlockSignature;
+exports.createRecentRelayWindow = createRecentRelayWindow;
+exports.seedRelayWindowFromPane = seedRelayWindowFromPane;
+exports.getRelayDedupedChunk = getRelayDedupedChunk;
+const claudeScrapeShapes_1 = require("./claudeScrapeShapes");
+const progressLine_1 = require("../progressLine");
+/**
+ * @description Minimum NORMALIZED line length for the window to record or
+ * suppress a line. Shorter lines repeat legitimately too often (confirmations,
+ * bullets, numbers) to ever be treated as re-render duplicates.
+ */
+exports.relayDedupMinLineLength = 16;
+/**
+ * @description Whether a NORMALIZED line is the short `NN +` diff-gutter shape
+ * that bypasses the length gate (record + suppress on re-appearance).
+ *
+ * WHY a targeted bypass (live leak 2026-06-24, topic my-health): a short `NN +`
+ * gutter scrolled off, was RE-SCRAPED on a later poll, re-emitted as fresh
+ * output, and prepended onto the next real message. Being under the 16-char gate
+ * it bypassed the dedup entirely. The gutter shape — a leading line number, then
+ * a literal `+` change marker — is never legitimate short prose ("done", "yes",
+ * "+1 done", "3 lines changed" all fail it), so suppressing its RE-render is
+ * safe. Strictly `+` (additions); `-` deletion gutters and everything else stay
+ * outside this bypass and keep the normal length gate. Reuses the single
+ * source-of-truth shape {@link DIFF_CHANGE_GUTTER_RE} (called on the same
+ * coarse-normalized form `record`/`checkHasLine` key on, so gate and key agree).
+ */
+function checkIsDiffChangeGutter(normalizedLine) {
+    return claudeScrapeShapes_1.DIFF_CHANGE_GUTTER_RE.test(normalizedLine);
+}
+/**
+ * @description Window capacity in lines. Sized to cover the incident-scale
+ * re-render (a ~1400-line stale diff) with headroom, while keeping the memory
+ * bound trivial and letting truly old content evict.
+ */
+exports.relayWindowMaxLines = 1500;
+/**
+ * @description Capacity of the block-signature FIFO behind
+ * {@link RecentRelayWindow.checkBlockAlreadyRelayed}. A block is one emitted
+ * chunk (a table, a prose paragraph) recorded as a SINGLE joined signature, so
+ * far fewer entries than the per-line window need bounding. Sized to remember a
+ * good run of recent emitted blocks (covers a looped table re-printed many times
+ * within a turn) while keeping the memory bound trivial.
+ */
+exports.relayBlockSignatureMax = 200;
+/**
+ * @description Leading-glyph strip for line-identity comparison: the ANIMATED
+ * spinner/tick set (shared {@link spinnerGlyphClass}, so it never drifts from
+ * `PROGRESS_LINE_RE`) PLUS the bullet/tool STATE glyphs `⏺ ⏳ ✓` (`⏺` U+23FA is
+ * the real assistant-output bullet in Claude v2.1.177). The animated glyphs
+ * (`✻ ✽ ✶ ✢ · *`) rotate every frame, so without stripping them a stable line
+ * re-animated to another frame (`✻X` vs `✽X`) looks NEW to the diff and re-emits;
+ * the state glyphs let a tool header match regardless of its `⏳`/`✓` state.
+ */
+const LEADING_COMPARISON_GLYPH_RE = new RegExp(`^[${progressLine_1.spinnerGlyphClass}⏺⏳✓]\\s*`);
+/**
+ * @description Normalise a pane line for line-identity comparison: trim, then
+ * drop a single leading spinner/state glyph ({@link LEADING_COMPARISON_GLYPH_RE}).
+ *
+ * Single source of truth for BOTH dedup layers — the per-poll set diff
+ * (`getNewPaneContent`) and this relay window — which MUST share one
+ * normalization domain: the window stores the same normalized forms the pane
+ * diff compares, otherwise a redraw would slip past one layer or the other.
+ * Comparison-ONLY: this shapes equality/dedup keys, never the text emitted.
+ */
+function normalizeForComparison(line) {
+    return line.trim().replace(LEADING_COMPARISON_GLYPH_RE, '');
+}
+/**
+ * @description COARSER normalization for the LONG-HORIZON relay-window dedup
+ * (record + suppress). Builds on {@link normalizeForComparison} and ADDITIONALLY
+ * strips markdown emphasis/code markers (`*`, `_`, `` ` ``, `~`) and collapses
+ * whitespace runs.
+ *
+ * WHY a second, coarser form (live re-emit 2026-06-15): a line that scrolled off
+ * and was re-rendered comes back with the SAME text but different emphasis spans
+ * — `the Claude *liveness loop* …` one capture, `the Claude *liveness* *loop* …`
+ * the next — or shifted padding/wrapping. The per-poll diff's plain
+ * normalization left those as DIFFERENT strings, so the window failed to
+ * recognise the re-render and re-emitted it. Stripping the volatile markup makes
+ * the re-render match.
+ *
+ * It is a strict COARSENING of {@link normalizeForComparison} (only further
+ * transforms its output), so the window still recognises every line the per-poll
+ * diff emitted (it can only match MORE, never fewer) — the "no redraw slips past
+ * one layer" guarantee holds, WITHOUT touching the per-poll core diff (and group
+ * mode), where over-suppression would risk dropping genuinely-new content.
+ */
+function normalizeForRelayDedup(line) {
+    return normalizeForComparison(line)
+        .replace(/[*_`~]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * @description Build a single normalized signature for a WHOLE block (a table,
+ * a paragraph) so a fully-duplicate block can be recognised even when its
+ * individual lines are too short to clear the per-line {@link
+ * relayDedupMinLineLength} gate — table border rows (`├──┤`) and tiny cells
+ * (`│ ✅ │`) are exactly that case. Drops blank lines, normalizes each surviving
+ * line in the SAME coarse domain {@link normalizeForRelayDedup} uses, and joins
+ * with `\n`. Returns `''` for a block with no substantial content (so a
+ * whitespace-only block is never treated as a relayed block).
+ */
+function buildRelayBlockSignature(blockText) {
+    const normalizedLines = blockText
+        .split('\n')
+        .map(normalizeForRelayDedup)
+        .filter(line => line.length > 0);
+    return normalizedLines.join('\n');
+}
+/**
+ * @description Create an empty relay window holding up to `maxLines`
+ * normalized lines; the oldest line is evicted first once full.
+ */
+function createRecentRelayWindow(maxLines = exports.relayWindowMaxLines) {
+    /** Insertion-ordered normalized lines — defines eviction order. */
+    const lineFifo = [];
+    /** Same lines as `lineFifo`, for O(1) membership checks. */
+    const lineSet = new Set();
+    /** Insertion-ordered joined block signatures — defines block eviction order. */
+    const blockSignatureFifo = [];
+    /** Same signatures as `blockSignatureFifo`, for O(1) membership checks. */
+    const blockSignatureSet = new Set();
+    return {
+        record(chunkText) {
+            for (const line of chunkText.split('\n')) {
+                const normalized = normalizeForRelayDedup(line);
+                // A short `NN +` diff gutter is recorded too (it re-renders and leaks);
+                // every other short line stays out of the window (legit repeats).
+                if (normalized.length < exports.relayDedupMinLineLength && !checkIsDiffChangeGutter(normalized))
+                    continue;
+                // A line repeated within one chunk must occupy ONE slot, or the FIFO
+                // and the Set would desync on eviction.
+                if (lineSet.has(normalized))
+                    continue;
+                lineFifo.push(normalized);
+                lineSet.add(normalized);
+                if (lineFifo.length > maxLines) {
+                    const evictedLine = lineFifo.shift();
+                    if (evictedLine !== undefined)
+                        lineSet.delete(evictedLine);
+                }
+            }
+            // Also record the chunk's whole-block signature so a fully-duplicate
+            // block (a re-printed table whose individual lines are too short for the
+            // per-line gate) is recognised by `checkBlockAlreadyRelayed`.
+            const blockSignature = buildRelayBlockSignature(chunkText);
+            if (blockSignature && !blockSignatureSet.has(blockSignature)) {
+                blockSignatureFifo.push(blockSignature);
+                blockSignatureSet.add(blockSignature);
+                if (blockSignatureFifo.length > exports.relayBlockSignatureMax) {
+                    const evictedSignature = blockSignatureFifo.shift();
+                    if (evictedSignature !== undefined)
+                        blockSignatureSet.delete(evictedSignature);
+                }
+            }
+        },
+        checkHasLine(line) {
+            const normalized = normalizeForRelayDedup(line);
+            // Same bypass as `record`: a short `NN +` diff gutter is eligible for
+            // suppression (only on RE-appearance — it had to be recorded first); any
+            // other short line is never suppressed.
+            if (normalized.length < exports.relayDedupMinLineLength && !checkIsDiffChangeGutter(normalized))
+                return false;
+            return lineSet.has(normalized);
+        },
+        checkBlockAlreadyRelayed(blockText) {
+            const blockSignature = buildRelayBlockSignature(blockText);
+            if (!blockSignature)
+                return false;
+            return blockSignatureSet.has(blockSignature);
+        },
+        reset() {
+            lineFifo.length = 0;
+            lineSet.clear();
+            blockSignatureFifo.length = 0;
+            blockSignatureSet.clear();
+        },
+    };
+}
+/**
+ * @description Seed a FRESH relay window from a full pane snapshot so a re-render
+ * of content ALREADY ON the pane is recognised as already-relayed on the very
+ * first poll — never re-emitted.
+ *
+ * WHY (live incident 2026-06-24): on adopt/re-attach the bot already
+ * seeds the pane-diff baseline (`lastContent`), which suppresses re-appearing
+ * PROSE. But a SETTLED table already on the pane is deduped ONLY at the BLOCK
+ * level ({@link RecentRelayWindow.checkBlockAlreadyRelayed} in
+ * `emitStabilizedTable`) — its border rows and tiny cells fall under the per-line
+ * gate. Adopt did NOT seed this window, so the first post-adopt poll saw the
+ * table's block signature as unknown and RE-EMITTED the whole table once per
+ * restart (~1100 chars). Recording the pane (per-line + whole-pane block) AND the
+ * settled table's OWN block signature here makes that first re-render hit
+ * `checkBlockAlreadyRelayed === true` and be suppressed.
+ *
+ * `getTableBlock` is injected (the adapter passes its `getLastSharpTableBlock`)
+ * to keep this module free of an adapter import — the adapter already imports
+ * from here, so the reverse would be a cycle. Pure (no I/O); the `record` calls
+ * are byte-identical to the ones the live emit path makes, so the window's
+ * domains agree.
+ */
+function seedRelayWindowFromPane(window, paneText, getTableBlock) {
+    if (!paneText)
+        return;
+    // Records the pane's substantial lines (per-line dedup) AND a whole-pane block
+    // signature so a long-horizon re-render of the same pane is recognised.
+    window.record(paneText);
+    // Record the settled table's OWN block signature in the SAME domain
+    // `emitStabilizedTable` records/checks, so the first post-adopt table re-emit
+    // is suppressed.
+    const seedTable = getTableBlock(paneText);
+    if (seedTable)
+        window.record(seedTable);
+}
+/**
+ * @description Filter a pane-diff chunk against the window: drop every line
+ * whose normalized form was already relayed (substantial lines only — short
+ * lines always pass). Returns `''` when nothing survives, so the caller can
+ * skip the poll's emit entirely (no empty messages).
+ *
+ * Blank-line shaping mirrors `getNewPaneContent`'s pending-blank exactly: a
+ * single blank that sat BETWEEN two surviving lines is preserved as a
+ * paragraph separator; leading/trailing blanks and blanks adjacent to dropped
+ * lines never leak out. An already-shaped chunk passes through an empty
+ * window byte-identical — fresh output is never altered.
+ */
+function getRelayDedupedChunk(relayWindow, chunkText) {
+    if (!chunkText)
+        return '';
+    const keptParts = [];
+    let pendingBlank = false;
+    for (const line of chunkText.split('\n')) {
+        const normalized = normalizeForComparison(line);
+        if (!normalized) {
+            pendingBlank = true;
+            continue;
+        }
+        if (relayWindow.checkHasLine(line)) {
+            pendingBlank = false;
+            continue;
+        }
+        if (pendingBlank && keptParts.length > 0)
+            keptParts.push('');
+        keptParts.push(line);
+        pendingBlank = false;
+    }
+    return keptParts.join('\n').trim();
+}
+//# sourceMappingURL=recentRelayWindow.js.map

package/dist/utils/recentRelayWindow.js.map

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

package/dist/utils/recvPreviewRedaction.d.ts

@@ -0,0 +1,23 @@
+/** Recorded instead of a pasted provider API key while `/connect` is pending. */
+export declare const redactedConnectKeyPreview = "[redacted: provider API key]";
+/** Recorded instead of a `/connect …` invocation — its arguments may carry the key inline. */
+export declare const redactedConnectCommandPreview = "/connect <redacted>";
+/**
+ * @description Is `rawText` a `/connect` command invocation (any argument
+ * shape, `@botmention` tolerated)? Shared by the command wrapper (a re-issued
+ * `/connect` keeps the pending state without a "cancelled" notice) and the
+ * recv-trace redaction below.
+ */
+export declare function checkIsConnectCommandText(rawText: string): boolean;
+/**
+ * @description Decide what the output-trace `recv` preview may show for an
+ * incoming text message. Security: a provider API key must never land in the
+ * on-disk trace log. Mirrors the text handler's own routing: while the thread
+ * is in the pending `/connect` state, the next non-command text IS the pasted
+ * key → the preview is fully redacted (a command text cancels the flow instead,
+ * so it is not a secret). Independently of the pending state, an inline
+ * `/connect <key>` carries the key in its arguments → only a fixed command
+ * marker is recorded. Everything else records unchanged.
+ */
+export declare function getRecvTracePreview(messageText: string, isThreadPendingProviderConnect: boolean): string;
+//# sourceMappingURL=recvPreviewRedaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recvPreviewRedaction.d.ts","sourceRoot":"","sources":["../../src/utils/recvPreviewRedaction.ts"],"names":[],"mappings":"AAEA,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,iCAAiC,CAAC;AAExE,8FAA8F;AAC9F,eAAO,MAAM,6BAA6B,wBAAwB,CAAC;AAEnE;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGlE;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,8BAA8B,EAAE,OAAO,GACtC,MAAM,CAMR"}

package/dist/utils/recvPreviewRedaction.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactedConnectCommandPreview = exports.redactedConnectKeyPreview = void 0;
+exports.checkIsConnectCommandText = checkIsConnectCommandText;
+exports.getRecvTracePreview = getRecvTracePreview;
+const utils_1 = require("../utils");
+/** Recorded instead of a pasted provider API key while `/connect` is pending. */
+exports.redactedConnectKeyPreview = '[redacted: provider API key]';
+/** Recorded instead of a `/connect …` invocation — its arguments may carry the key inline. */
+exports.redactedConnectCommandPreview = '/connect <redacted>';
+/**
+ * @description Is `rawText` a `/connect` command invocation (any argument
+ * shape, `@botmention` tolerated)? Shared by the command wrapper (a re-issued
+ * `/connect` keeps the pending state without a "cancelled" notice) and the
+ * recv-trace redaction below.
+ */
+function checkIsConnectCommandText(rawText) {
+    const [commandName = ''] = (0, utils_1.stripCommandBotMention)(rawText.trim()).split(/\s+/, 1);
+    return commandName === '/connect';
+}
+/**
+ * @description Decide what the output-trace `recv` preview may show for an
+ * incoming text message. Security: a provider API key must never land in the
+ * on-disk trace log. Mirrors the text handler's own routing: while the thread
+ * is in the pending `/connect` state, the next non-command text IS the pasted
+ * key → the preview is fully redacted (a command text cancels the flow instead,
+ * so it is not a secret). Independently of the pending state, an inline
+ * `/connect <key>` carries the key in its arguments → only a fixed command
+ * marker is recorded. Everything else records unchanged.
+ */
+function getRecvTracePreview(messageText, isThreadPendingProviderConnect) {
+    if (checkIsConnectCommandText(messageText))
+        return exports.redactedConnectCommandPreview;
+    if (isThreadPendingProviderConnect && !messageText.trim().startsWith('/')) {
+        return exports.redactedConnectKeyPreview;
+    }
+    return messageText;
+}
+//# sourceMappingURL=recvPreviewRedaction.js.map

package/dist/utils/recvPreviewRedaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recvPreviewRedaction.js","sourceRoot":"","sources":["../../src/utils/recvPreviewRedaction.ts"],"names":[],"mappings":";;;AAcA,8DAGC;AAYD,kDASC;AAtCD,oCAAkD;AAElD,iFAAiF;AACpE,QAAA,yBAAyB,GAAG,8BAA8B,CAAC;AAExE,8FAA8F;AACjF,QAAA,6BAA6B,GAAG,qBAAqB,CAAC;AAEnE;;;;;GAKG;AACH,SAAgB,yBAAyB,CAAC,OAAe;IACvD,MAAM,CAAC,WAAW,GAAG,EAAE,CAAC,GAAG,IAAA,8BAAsB,EAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAClF,OAAO,WAAW,KAAK,UAAU,CAAC;AACpC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,mBAAmB,CACjC,WAAmB,EACnB,8BAAuC;IAEvC,IAAI,yBAAyB,CAAC,WAAW,CAAC;QAAE,OAAO,qCAA6B,CAAC;IACjF,IAAI,8BAA8B,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1E,OAAO,iCAAyB,CAAC;IACnC,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/utils/reminderFlow.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @description The `/reminders` decisions that live OUTSIDE the pure wizard
+ * module because they depend on the bot's own surroundings rather than on the
+ * wizard's step machine: which hub screen to draw (a function of the scheduler's
+ * per-thread reminder cap), whether a step-4 text wait has expired or is already
+ * claimed by another inbound message, whether the captured text is short enough
+ * to keep, whether the wait survives a given wizard transition at all, and
+ * whether a tapped wizard button belongs to the wizard that is live right now.
+ *
+ * They are here rather than in `bot.ts` for the usual reason: `bot.ts` cannot be
+ * imported by a test (its module-scope `parseEnv()` exits the process), and each
+ * of these is a rule whose failure is silent — a hub that offers «add» at the cap
+ * is a dead end, an unexpired text wait swallows an ordinary message that should
+ * have reached the agent, an unclaimed one creates two reminders from one wizard,
+ * and a mis-routed stale tap feeds picks into the wrong wizard.
+ */
+import { type ReminderWizardTransition } from './reminderWizard';
+/**
+ * How long step 4 keeps waiting for the reminder text. The wait INTERCEPTS every
+ * plain message in the topic, so it must expire: an abandoned wizard would
+ * otherwise swallow, hours later, a message the operator meant for the agent.
+ * 15 minutes is long enough to finish typing and short enough that nobody has
+ * forgotten what they were doing.
+ */
+export declare const reminderTextWaitMs: number;
+/**
+ * @name ReminderHubBody
+ * @description Which line the hub prints under its title.
+ *  - `empty`   — nothing scheduled yet.
+ *  - `active`  — the count.
+ *  - `atLimit` — the count PLUS "delete one to add another", because the «add»
+ *                button is gone and the operator needs to know why.
+ */
+export type ReminderHubBody = 'empty' | 'active' | 'atLimit';
+/** The hub screen's two decisions: what the body says, and whether «add» is drawn. */
+export interface ReminderHubPlan {
+    body: ReminderHubBody;
+    isAddOffered: boolean;
+}
+/**
+ * @description Decide the hub screen. At (or past) the per-thread REMINDER cap
+ * the «add» button is NOT offered: the create would be rejected by the store, so
+ * a button that can only fail is worse than no button — provided the screen says
+ * why, which is what the `atLimit` body is for.
+ *
+ * The comparison must be the one `createScheduleForThread` makes, or the hub walks
+ * the operator through all four steps and only then hits a rejection. That store
+ * counts a reminder against the REMINDER cap alone, so the topic's agent-prompt
+ * jobs are irrelevant here — a topic full of `/schedule` jobs still has room for
+ * reminders.
+ *
+ * A non-positive cap is treated as "at the limit" rather than special-cased: it
+ * is the same user-visible truth (nothing more can be created).
+ */
+export declare function getReminderHubPlan(input: {
+    reminderCount: number;
+    maxReminders: number;
+}): ReminderHubPlan;
+/**
+ * @name ReminderTextCaptureRoute
+ * @description What an inbound message in the topic means for a reminder wizard.
+ *  - `notArmed` — no wizard is waiting for text; handle the message normally.
+ *  - `capture`  — this message IS the reminder text.
+ *  - `claimed`  — a wizard is waiting, but another message got there first: handle
+ *                 this one normally, because the wait it would have filled is
+ *                 already being consumed.
+ *  - `expired`  — a wizard was waiting but the window closed: retire it AND let
+ *                 the message fall through to normal handling (swallowing it
+ *                 would lose a prompt the operator meant for the agent).
+ */
+export type ReminderTextCaptureRoute = 'notArmed' | 'capture' | 'claimed' | 'expired';
+/**
+ * @description Route an inbound message against the step-4 wait. `armedAtMs` is
+ * `null` whenever no wizard is on the text step (never armed, already finished,
+ * cancelled). Takes the instant as an argument so the window is testable without
+ * a clock.
+ *
+ * `isClaimed` is what makes the wait single-use. Telegraf handles updates
+ * CONCURRENTLY and only the voice path is serialized per thread, so two messages
+ * arriving together would both route `capture` and create two reminders from one
+ * wizard; the caller claims the wait synchronously before its first `await`, and
+ * the loser lands here as `claimed`.
+ *
+ * `claimed` is checked BEFORE the window: a claim means the winner is already
+ * turning that wizard's message into the created card, so reporting `expired`
+ * underneath it would retire the wizard and relabel the very message being
+ * finished.
+ */
+export declare function getReminderTextCaptureRoute(input: {
+    armedAtMs: number | null;
+    isClaimed: boolean;
+    nowMs: number;
+}): ReminderTextCaptureRoute;
+/**
+ * @name ReminderTextAcceptance
+ * @description Whether a captured reminder text can be kept.
+ *  - `accept`  — within {@link reminderTextMaxLength}; create the reminder.
+ *  - `tooLong` — over it: nothing is saved, step 4 re-renders with the reason and
+ *                the wait stays armed for a shorter retry.
+ */
+export type ReminderTextAcceptance = 'accept' | 'tooLong';
+/**
+ * @description Bound the captured reminder text — the ONE gate both text sources
+ * (a typed message and a transcribed voice note) pass, since a transcript carries
+ * no length bound of its own.
+ *
+ * An over-long text is REJECTED, never truncated. Truncating would silently ship a
+ * reminder whose words are not the operator's, while accepting it breaks three
+ * screens at once: the "created" edit fails, so they still see step 4 and believe
+ * nothing happened; the card cannot be opened, which is the only place a delete
+ * button lives; and at fire time the announcement send fails while the run is
+ * still recorded as delivered.
+ */
+export declare function getReminderTextAcceptance(text: string): ReminderTextAcceptance;
+/**
+ * @description Whether a wizard transition leaves the step-4 text wait ARMED.
+ * Only the two outcomes that end ON the text step do; every other outcome moves
+ * the wizard off step 4 and must disarm it.
+ *
+ * Load-bearing for «‹ Back» out of the text step: the screen then asks for a TIME
+ * again, so a wait left armed would capture the operator's next ordinary message
+ * and create the reminder from the very picks they went back to change — and that
+ * message never reaches the agent it was meant for.
+ */
+export declare function checkIsReminderTextWaitKept(transitionKind: ReminderWizardTransition['kind']): boolean;
+/**
+ * @name ReminderWizardTapRoute
+ * @description Where a tapped wizard button is routed.
+ *  - `foreign` — it belongs to no live wizard (a different wizard's id, or none
+ *                is live at all): answer "out of date" and strip THAT message's
+ *                keyboard, since the screen it came from is dead.
+ *  - `apply`   — it belongs to the live wizard: hand it to
+ *                `applyReminderWizardCallback`, which owns the remaining guard
+ *                (an action that does not belong to the step now on screen).
+ */
+export type ReminderWizardTapRoute = 'foreign' | 'apply';
+/**
+ * @description Split "this tap is from a dead screen" from "this tap is for the
+ * live wizard". The distinction is load-bearing for the recovery action, not just
+ * the message: stripping the keyboard is right for a dead screen and WRONG for
+ * the live wizard (a tap on a stale VIEW of the live wizard would otherwise leave
+ * the operator staring at a keyboard-less, unfinishable wizard).
+ */
+export declare function getReminderWizardTapRoute(input: {
+    liveWizardId: string | null;
+    callbackData: string;
+}): ReminderWizardTapRoute;
+//# sourceMappingURL=reminderFlow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reminderFlow.d.ts","sourceRoot":"","sources":["../../src/utils/reminderFlow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,kBAAkB,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAiB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE7D,sFAAsF;AACtF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,eAAe,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,eAAe,CAIlB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,wBAAwB,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,wBAAwB,CAI3B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAE9E;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,wBAAwB,CAAC,MAAM,CAAC,GAC/C,OAAO,CAET;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,OAAO,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,sBAAsB,CAKzB"}

package/dist/utils/reminderFlow.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * @description The `/reminders` decisions that live OUTSIDE the pure wizard
+ * module because they depend on the bot's own surroundings rather than on the
+ * wizard's step machine: which hub screen to draw (a function of the scheduler's
+ * per-thread reminder cap), whether a step-4 text wait has expired or is already
+ * claimed by another inbound message, whether the captured text is short enough
+ * to keep, whether the wait survives a given wizard transition at all, and
+ * whether a tapped wizard button belongs to the wizard that is live right now.
+ *
+ * They are here rather than in `bot.ts` for the usual reason: `bot.ts` cannot be
+ * imported by a test (its module-scope `parseEnv()` exits the process), and each
+ * of these is a rule whose failure is silent — a hub that offers «add» at the cap
+ * is a dead end, an unexpired text wait swallows an ordinary message that should
+ * have reached the agent, an unclaimed one creates two reminders from one wizard,
+ * and a mis-routed stale tap feeds picks into the wrong wizard.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reminderTextWaitMs = void 0;
+exports.getReminderHubPlan = getReminderHubPlan;
+exports.getReminderTextCaptureRoute = getReminderTextCaptureRoute;
+exports.getReminderTextAcceptance = getReminderTextAcceptance;
+exports.checkIsReminderTextWaitKept = checkIsReminderTextWaitKept;
+exports.getReminderWizardTapRoute = getReminderWizardTapRoute;
+const reminderWizard_1 = require("./reminderWizard");
+/**
+ * How long step 4 keeps waiting for the reminder text. The wait INTERCEPTS every
+ * plain message in the topic, so it must expire: an abandoned wizard would
+ * otherwise swallow, hours later, a message the operator meant for the agent.
+ * 15 minutes is long enough to finish typing and short enough that nobody has
+ * forgotten what they were doing.
+ */
+exports.reminderTextWaitMs = 15 * 60 * 1000;
+/**
+ * @description Decide the hub screen. At (or past) the per-thread REMINDER cap
+ * the «add» button is NOT offered: the create would be rejected by the store, so
+ * a button that can only fail is worse than no button — provided the screen says
+ * why, which is what the `atLimit` body is for.
+ *
+ * The comparison must be the one `createScheduleForThread` makes, or the hub walks
+ * the operator through all four steps and only then hits a rejection. That store
+ * counts a reminder against the REMINDER cap alone, so the topic's agent-prompt
+ * jobs are irrelevant here — a topic full of `/schedule` jobs still has room for
+ * reminders.
+ *
+ * A non-positive cap is treated as "at the limit" rather than special-cased: it
+ * is the same user-visible truth (nothing more can be created).
+ */
+function getReminderHubPlan(input) {
+    const isAtLimit = input.reminderCount >= input.maxReminders;
+    if (isAtLimit)
+        return { body: 'atLimit', isAddOffered: false };
+    return { body: input.reminderCount === 0 ? 'empty' : 'active', isAddOffered: true };
+}
+/**
+ * @description Route an inbound message against the step-4 wait. `armedAtMs` is
+ * `null` whenever no wizard is on the text step (never armed, already finished,
+ * cancelled). Takes the instant as an argument so the window is testable without
+ * a clock.
+ *
+ * `isClaimed` is what makes the wait single-use. Telegraf handles updates
+ * CONCURRENTLY and only the voice path is serialized per thread, so two messages
+ * arriving together would both route `capture` and create two reminders from one
+ * wizard; the caller claims the wait synchronously before its first `await`, and
+ * the loser lands here as `claimed`.
+ *
+ * `claimed` is checked BEFORE the window: a claim means the winner is already
+ * turning that wizard's message into the created card, so reporting `expired`
+ * underneath it would retire the wizard and relabel the very message being
+ * finished.
+ */
+function getReminderTextCaptureRoute(input) {
+    if (input.armedAtMs === null)
+        return 'notArmed';
+    if (input.isClaimed)
+        return 'claimed';
+    return input.nowMs - input.armedAtMs >= exports.reminderTextWaitMs ? 'expired' : 'capture';
+}
+/**
+ * @description Bound the captured reminder text — the ONE gate both text sources
+ * (a typed message and a transcribed voice note) pass, since a transcript carries
+ * no length bound of its own.
+ *
+ * An over-long text is REJECTED, never truncated. Truncating would silently ship a
+ * reminder whose words are not the operator's, while accepting it breaks three
+ * screens at once: the "created" edit fails, so they still see step 4 and believe
+ * nothing happened; the card cannot be opened, which is the only place a delete
+ * button lives; and at fire time the announcement send fails while the run is
+ * still recorded as delivered.
+ */
+function getReminderTextAcceptance(text) {
+    return text.length > reminderWizard_1.reminderTextMaxLength ? 'tooLong' : 'accept';
+}
+/**
+ * @description Whether a wizard transition leaves the step-4 text wait ARMED.
+ * Only the two outcomes that end ON the text step do; every other outcome moves
+ * the wizard off step 4 and must disarm it.
+ *
+ * Load-bearing for «‹ Back» out of the text step: the screen then asks for a TIME
+ * again, so a wait left armed would capture the operator's next ordinary message
+ * and create the reminder from the very picks they went back to change — and that
+ * message never reaches the agent it was meant for.
+ */
+function checkIsReminderTextWaitKept(transitionKind) {
+    return transitionKind === 'awaitText' || transitionKind === 'createNow';
+}
+/**
+ * @description Split "this tap is from a dead screen" from "this tap is for the
+ * live wizard". The distinction is load-bearing for the recovery action, not just
+ * the message: stripping the keyboard is right for a dead screen and WRONG for
+ * the live wizard (a tap on a stale VIEW of the live wizard would otherwise leave
+ * the operator staring at a keyboard-less, unfinishable wizard).
+ */
+function getReminderWizardTapRoute(input) {
+    if (input.liveWizardId === null)
+        return 'foreign';
+    const parsed = (0, reminderWizard_1.parseReminderWizardCallback)(input.callbackData);
+    if (parsed === null || parsed.wizardId !== input.liveWizardId)
+        return 'foreign';
+    return 'apply';
+}
+//# sourceMappingURL=reminderFlow.js.map

package/dist/utils/reminderFlow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reminderFlow.js","sourceRoot":"","sources":["../../src/utils/reminderFlow.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAgDH,gDAOC;AAiCD,kEAQC;AAuBD,8DAEC;AAYD,kEAIC;AAqBD,8DAQC;AApKD,qDAI0B;AAE1B;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAkBjD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,kBAAkB,CAAC,KAGlC;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,YAAY,CAAC;IAC5D,IAAI,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;IAC/D,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,aAAa,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;AACtF,CAAC;AAgBD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,2BAA2B,CAAC,KAI3C;IACC,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI;QAAE,OAAO,UAAU,CAAC;IAChD,IAAI,KAAK,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IACtC,OAAO,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,IAAI,0BAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AACrF,CAAC;AAWD;;;;;;;;;;;GAWG;AACH,SAAgB,yBAAyB,CAAC,IAAY;IACpD,OAAO,IAAI,CAAC,MAAM,GAAG,sCAAqB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;AACpE,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,2BAA2B,CACzC,cAAgD;IAEhD,OAAO,cAAc,KAAK,WAAW,IAAI,cAAc,KAAK,WAAW,CAAC;AAC1E,CAAC;AAcD;;;;;;GAMG;AACH,SAAgB,yBAAyB,CAAC,KAGzC;IACC,IAAI,KAAK,CAAC,YAAY,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAClD,MAAM,MAAM,GAAG,IAAA,4CAA2B,EAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAC/D,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,CAAC,YAAY;QAAE,OAAO,SAAS,CAAC;IAChF,OAAO,OAAO,CAAC;AACjB,CAAC"}