charness 0.0.0-stage → 3.0.0

package/dist/postToSession.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * @description Post a prompt into a conversation's agent session (Jira connector
+ * plan J5, D21): make sure a session is ready — the ensure resumes the
+ * conversation's own sleeping session, else starts one if needed — let a
+ * BUSY session finish its turn (up to {@link waitIdleTimeoutMs} — live work is
+ * never interrupted on purpose; after the bound the forward takes the normal
+ * interrupt path), then forward — unless an armed usage-limit wait holds the
+ * prompt, checked before the session is touched and again right before the
+ * forward (R23). The scheduler's fire (steps 3–4) and the Jira
+ * connector's requests share it. Every side effect is injected, so the wait
+ * loop runs on a fake clock in tests.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitIdleTimeoutMs = exports.busyPollIntervalMs = void 0;
+exports.postToSession = postToSession;
+/** Poll cadence for the wait-for-idle loop: re-check the busy probe every 5s. */
+exports.busyPollIntervalMs = 5000;
+/**
+ * Upper bound on waiting for a busy session to go idle before forwarding anyway
+ * (10 min). The forward then takes the normal interrupt path, so a wedged turn
+ * never blocks a post forever.
+ */
+exports.waitIdleTimeoutMs = 10 * 60 * 1000;
+async function waitForIdle(deps, conversationKey) {
+    const deadline = deps.now() + exports.waitIdleTimeoutMs;
+    while (deps.checkBusy(conversationKey)) {
+        if (deps.now() >= deadline)
+            return;
+        await deps.sleep(exports.busyPollIntervalMs);
+    }
+}
+async function postToSession(deps, conversationKey, prompt, fallbackAdapterName, options = {}) {
+    // What is held is read only once the wait is over: a caller may say when it was due (R27).
+    const { heldText } = options;
+    const text = typeof prompt === 'string' ? prompt : prompt.fullText;
+    // Checked first: no session is started or resumed into a limit.
+    if (deps.holdForLimitResume?.(conversationKey, text, heldText))
+        return { ok: true, isHeld: true };
+    const session = await deps.ensureSession(conversationKey, fallbackAdapterName);
+    if (!session.ok)
+        return { ok: false, reason: session.reason };
+    if (deps.checkBusy(conversationKey))
+        await waitForIdle(deps, conversationKey);
+    // Again: the turn waited out above may itself have hit the limit and armed a wait.
+    if (deps.holdForLimitResume?.(conversationKey, text, heldText))
+        return { ok: true, isHeld: true };
+    try {
+        await deps.forwardPrompt(conversationKey, typeof prompt === 'string' ? prompt : prompt.buildText({ isFresh: session.isFresh }));
+    }
+    catch (error) {
+        return { ok: false, reason: 'forward-failed', error: error instanceof Error ? error.message : String(error) };
+    }
+    return { ok: true, isHeld: false };
+}
+//# sourceMappingURL=postToSession.js.map

package/dist/postToSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postToSession.js","sourceRoot":"","sources":["../src/postToSession.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAgFH,sCAuBC;AArGD,iFAAiF;AACpE,QAAA,kBAAkB,GAAG,IAAI,CAAC;AAEvC;;;;GAIG;AACU,QAAA,iBAAiB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AA8DhD,KAAK,UAAU,WAAW,CAAC,IAAuB,EAAE,eAAuB;IACzE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,yBAAiB,CAAC;IAChD,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,EAAE,CAAC;QACvC,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,QAAQ;YAAE,OAAO;QACnC,MAAM,IAAI,CAAC,KAAK,CAAC,0BAAkB,CAAC,CAAC;IACvC,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,aAAa,CACjC,IAAuB,EACvB,eAAuB,EACvB,MAAkC,EAClC,mBAA4B,EAC5B,UAAiC,EAAE;IAEnC,2FAA2F;IAC3F,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAC7B,MAAM,IAAI,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACnE,gEAAgE;IAChE,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC,eAAe,EAAE,IAAI,EAAE,QAAQ,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAClG,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;IAC/E,IAAI,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;IAC9D,IAAI,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC;QAAE,MAAM,WAAW,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IAC9E,mFAAmF;IACnF,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC,eAAe,EAAE,IAAI,EAAE,QAAQ,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAClG,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAClI,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IAChH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;AACrC,CAAC"}

package/dist/progressLine.d.ts

@@ -0,0 +1,180 @@
+/**
+ * @description Detect Claude-CLI "thinking" progress lines so the bot can
+ * collapse a long burst of them into a single edited Telegram message
+ * instead of flooding the topic with one message per poll tick.
+ *
+ * Claude's TUI redraws a spinner roughly every 300 ms while the agent is
+ * thinking. The line looks like:
+ *
+ *     <glyph> <Activity>… (Xm Ys · ↑/↓ X.Xk tokens [ · <thinking-note>])
+ *
+ * where `<glyph>` rotates through `✻ ✽ ✶ ✢ · *` (plus `●/○` for bullet
+ * states), `<Activity>` is one of Claude's activity words (Smooshing,
+ * Actioning, …) or the active task title ("Fixing streaming output
+ * overwrite…"), and the trailing parenthesis updates time / tokens /
+ * thinking-mode every tick (seconds-only right after the turn starts).
+ *
+ * The bot already routes adapter `status` events through a coalescer
+ * that edits one message in place; the gap was that long bursts of
+ * progress lines (≥ 4 lines per poll diff, or any line that pushes
+ * the chunk over the adapter's `checkIsStatusOutput` length / line
+ * heuristic) were misclassified as substantive `output` and flooded
+ * the thread. {@link checkIsProgressChunk} is the adapter-agnostic
+ * safety net: every non-empty line in the chunk must match the regex,
+ * so mixed chunks with real prose still fall back to the normal
+ * output path with no regression.
+ *
+ * Verb transitions (`Newspapering` → `Coalescing` → `Booping`) all match
+ * the same regex and therefore stay in the same coalesced message — the
+ * user sees the latest verb on the rolling line, never a stream of
+ * separate "Now Newspapering" / "Now Coalescing" messages.
+ *
+ * The same applies to `/compact` (and the automatic context compaction),
+ * whose progress is a different shape — a `Compacting conversation…` verb
+ * line (with or without a `(Xs)` / `(Xs · ↑ X.Xk tokens)` stats parenthesis)
+ * optionally accompanied by a `▰▰▱▱` bar line — caught by {@link
+ * COMPACT_LINE_RE} + {@link PROGRESS_BAR_LINE_RE}. The verb line is anchored
+ * on the literal `Compacting conversation` phrase, so a bar line is no longer
+ * required to admit it (auto-compaction frequently redraws the verb line on
+ * its own, with no bar in the diff). {@link collapseProgressChunk} then trims
+ * a redraw burst down to its latest frame so the rolling message shows only
+ * the current state, not every intermediate one.
+ *
+ * A third transient shape is the **sub-agent task panel**: while a Task
+ * sub-agent runs, Claude redraws a `◯ <type>  <title>  <elapsed> · ↓ <tokens>`
+ * line every tick (the trailing time/tokens change each second, so the diff
+ * sees every tick as new and the topic floods). {@link
+ * SUBAGENT_PROGRESS_LINE_RE} catches it (anchored on the `◯` U+25EF
+ * sub-agent glyph, distinct from the `○` spinner / `●` bullet glyphs), and
+ * {@link collapseProgressChunk} keeps only the latest frame of each distinct
+ * task (a fan-out shows several `◯` lines at once), squeezing the TUI
+ * right-alignment padding down to single spaces.
+ *
+ * Kept in its own module (not inlined in `bot.ts`) so the regex is the
+ * single source of truth shared with `progressLine.test.ts`, and so the
+ * detection logic can be reused by future adapters (OpenCode, etc.)
+ * without exporting bot-internal helpers.
+ */
+/**
+ * @description The animated spinner / bullet glyph set Claude's TUI rotates
+ * through at the head of a progress line (`✻ ✽ ✶ ✢ · *`) plus the `● ○` bullet
+ * states. THE single source of the class used by {@link PROGRESS_LINE_RE} below
+ * AND by `normalizeForComparison` (utils/recentRelayWindow), so the line-SET
+ * diff dedups a re-animating-but-stable line and the progress detector accept
+ * the SAME glyph set — the two must never drift. A drift-lock test asserts
+ * `PROGRESS_LINE_RE.source` still carries exactly `[${spinnerGlyphClass}]`.
+ */
+export declare const spinnerGlyphClass = "\u273B\u273D\u2736\u2722\u00B7*\u25CF\u25CB";
+/**
+ * @description Single-line regex for one Claude-CLI progress tick.
+ *
+ * Structure (each group commented):
+ *
+ *   ^\s*                              leading whitespace (TUI indent)
+ *   [✻✽✶✢·*●○]                       spinner glyph (full observed set)
+ *   \s+\S(?:[^()\n]|\([^()\n]*\))*?…  the activity text ending in U+2026
+ *                                     ellipsis. Originally a single verb
+ *                                     token ("Smooshing…"), then the active
+ *                                     task title too ("Fixing streaming
+ *                                     output overwrite…"), and the TUI now
+ *                                     also puts parenthesised bits inside it
+ *                                     ("Fixing relations add flow
+ *                                     (sub-agent)…" — live flood 2026-06-11;
+ *                                     a task title can carry its own parens
+ *                                     too), so single-level `(…)` segments
+ *                                     are allowed; the end-anchored stats
+ *                                     group below stays the real anchor
+ *   \s*\(                             stats parenthesis opens
+ *   (?:\d+h\s+)?(?:\d+m\s+)?\d+s      elapsed time — "13s", "4m 35s",
+ *                                     "1h 2m 3s" (a fresh tick has no
+ *                                     minutes yet; the old `\d+m \d+s`
+ *                                     requirement made second-only ticks
+ *                                     flood the topic)
+ *   \s*·\s*[↑↓]\s*[\d.]+k?\s*tokens   token counter, e.g. "↑ 4.4k tokens",
+ *                                     "↓ 176 tokens"
+ *   (?:\s*·[^()]*)?                   optional thinking-note suffix
+ *                                     ("thought for 9s", "thinking with
+ *                                     xhigh effort", "still thinking
+ *                                     with xhigh effort", "thinking
+ *                                     more with xhigh effort"). `[^()]*`
+ *                                     refuses nested parens so a real
+ *                                     prose sentence with parentheses
+ *                                     cannot be mistaken for a tick.
+ *   \)\s*$                            stats parenthesis closes; line ends
+ *
+ * The activity text deliberately has no verb whitelist — Claude has shipped
+ * Smooshing / Actioning / Coalescing / … then task titles, then parenthesised
+ * suffixes like "(sub-agent)" inside the title; the trailing end-anchored
+ * `(time · tokens)` stats parenthesis is specific enough to carry the match
+ * on its own — the same safety argument that admitted multi-word titles
+ * (2026-06-05) covers the paren widening (2026-06-11).
+ */
+export declare const PROGRESS_LINE_RE: RegExp;
+/**
+ * @description Verb line of Claude's `/compact` (and automatic context
+ * compaction) progress. Observed shapes:
+ *   `✶ Compacting conversation…`                          (before the timer)
+ *   `✻ Compacting conversation… (1m 22s)`                 (elapsed time only)
+ *   `· Compacting conversation… (48s · ↑ 3.1k tokens)`    (time + token stats)
+ *
+ * Anchored on the literal `Compacting conversation` phrase, followed by the
+ * ellipsis and an OPTIONAL `(…)` stats parenthesis (`[^()]*` so a real prose
+ * sentence with nested parens can't stretch the match). The phrase anchor is
+ * specific enough that this line on its own is safe to treat as progress —
+ * unlike a broad `\S.*…` body, it can never collide with a real `●`-prefixed
+ * answer, so {@link checkIsProgressChunk} no longer needs a bar line to admit
+ * it (auto-compaction redraws the verb line with no bar in the diff).
+ */
+export declare const COMPACT_LINE_RE: RegExp;
+/**
+ * @description Sub-agent task line of Claude's TUI, redrawn every tick while a
+ * Task sub-agent runs, e.g.
+ *   `◯ general-purpose  Move styles into solClientKit          6m 50s · ↓ 120.2k tokens`
+ * optionally prefixed with the `❯` selection cursor, optionally without the
+ * trailing stats (right after the sub-agent starts, before its timer shows).
+ *
+ * Anchored on the `◯` (U+25EF) sub-agent glyph — deliberately distinct from
+ * the `○` (U+25CB) thinking spinner and the `●` (U+25CF) tool/result bullet,
+ * so a `● Bash(…)` tool call or a `○ Thinking…` tick is never mistaken for a
+ * sub-agent frame. The trailing time/token counter changes each second, which
+ * is exactly why the pane diff sees every tick as a new line and the topic
+ * floods without collapsing.
+ */
+export declare const SUBAGENT_PROGRESS_LINE_RE: RegExp;
+/**
+ * @description Progress-bar line of Claude's `/compact`, e.g.
+ * `▰▰▰▰▰▰▱▱▱▱▱▱ 15%`. A run of filled/empty bar cells (U+25B0 `▰` /
+ * U+25B1 `▱`) optionally followed by a percentage.
+ *
+ * The percentage is optional because a terminal-redraw scrape can clip the
+ * trailing `N%` mid-frame; such a fragment must still count as progress (so
+ * it never floods the topic) and {@link collapseProgressChunk} falls back to
+ * the filled-cell count for ordering it. The `{4,}` cell run is a high-signal
+ * anchor (bar cells never appear in real prose), so a bar line on its own is
+ * always treated as progress; {@link COMPACT_LINE_RE} carries its own phrase
+ * anchor and no longer relies on a bar being present.
+ */
+export declare const PROGRESS_BAR_LINE_RE: RegExp;
+export declare function checkIsProgressChunk(text: string): boolean;
+/**
+ * @description Reduce a progress chunk (see {@link checkIsProgressChunk}) to
+ * the single most-recent frame, so the coalesced status message rolls in
+ * place instead of stacking every intermediate tick/percentage.
+ *
+ * - sub-agent frames (may be interleaved with any other shape) → the latest
+ *   frame of EACH distinct task (grouped by {@link getSubagentTaskIdentity},
+ *   first-seen order preserved), so a parallel fan-out shows one rolling line
+ *   per sub-agent, padding squeezed. Rendered first — mirroring the TUI,
+ *   which draws the task panel above the main spinner.
+ * - thinking-spinner lines → the last tick line (time only grows, scrape is
+ *   in order, so "last" is "latest").
+ * - compaction lines with a bar → the highest-percentage bar line (a redraw
+ *   scrape can arrive out of order, and `%` only grows, so max is the true
+ *   latest) prefixed with the most recent `Compacting conversation…` verb
+ *   line for context. The pair mirrors Claude's own two-line frame.
+ * - compaction lines with no bar (verb lines only) → the last verb line.
+ *
+ * Must only be called on a chunk that {@link checkIsProgressChunk} accepted.
+ */
+export declare function collapseProgressChunk(text: string): string;
+//# sourceMappingURL=progressLine.d.ts.map

package/dist/progressLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressLine.d.ts","sourceRoot":"","sources":["../src/progressLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,gDAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,gBAAgB,QAC0G,CAAC;AAExI;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,QACuC,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,QAA2B,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,QAAyC,CAAC;AA0C3E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAI1D;AAuCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAuC1D"}

package/dist/progressLine.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * @description Detect Claude-CLI "thinking" progress lines so the bot can
+ * collapse a long burst of them into a single edited Telegram message
+ * instead of flooding the topic with one message per poll tick.
+ *
+ * Claude's TUI redraws a spinner roughly every 300 ms while the agent is
+ * thinking. The line looks like:
+ *
+ *     <glyph> <Activity>… (Xm Ys · ↑/↓ X.Xk tokens [ · <thinking-note>])
+ *
+ * where `<glyph>` rotates through `✻ ✽ ✶ ✢ · *` (plus `●/○` for bullet
+ * states), `<Activity>` is one of Claude's activity words (Smooshing,
+ * Actioning, …) or the active task title ("Fixing streaming output
+ * overwrite…"), and the trailing parenthesis updates time / tokens /
+ * thinking-mode every tick (seconds-only right after the turn starts).
+ *
+ * The bot already routes adapter `status` events through a coalescer
+ * that edits one message in place; the gap was that long bursts of
+ * progress lines (≥ 4 lines per poll diff, or any line that pushes
+ * the chunk over the adapter's `checkIsStatusOutput` length / line
+ * heuristic) were misclassified as substantive `output` and flooded
+ * the thread. {@link checkIsProgressChunk} is the adapter-agnostic
+ * safety net: every non-empty line in the chunk must match the regex,
+ * so mixed chunks with real prose still fall back to the normal
+ * output path with no regression.
+ *
+ * Verb transitions (`Newspapering` → `Coalescing` → `Booping`) all match
+ * the same regex and therefore stay in the same coalesced message — the
+ * user sees the latest verb on the rolling line, never a stream of
+ * separate "Now Newspapering" / "Now Coalescing" messages.
+ *
+ * The same applies to `/compact` (and the automatic context compaction),
+ * whose progress is a different shape — a `Compacting conversation…` verb
+ * line (with or without a `(Xs)` / `(Xs · ↑ X.Xk tokens)` stats parenthesis)
+ * optionally accompanied by a `▰▰▱▱` bar line — caught by {@link
+ * COMPACT_LINE_RE} + {@link PROGRESS_BAR_LINE_RE}. The verb line is anchored
+ * on the literal `Compacting conversation` phrase, so a bar line is no longer
+ * required to admit it (auto-compaction frequently redraws the verb line on
+ * its own, with no bar in the diff). {@link collapseProgressChunk} then trims
+ * a redraw burst down to its latest frame so the rolling message shows only
+ * the current state, not every intermediate one.
+ *
+ * A third transient shape is the **sub-agent task panel**: while a Task
+ * sub-agent runs, Claude redraws a `◯ <type>  <title>  <elapsed> · ↓ <tokens>`
+ * line every tick (the trailing time/tokens change each second, so the diff
+ * sees every tick as new and the topic floods). {@link
+ * SUBAGENT_PROGRESS_LINE_RE} catches it (anchored on the `◯` U+25EF
+ * sub-agent glyph, distinct from the `○` spinner / `●` bullet glyphs), and
+ * {@link collapseProgressChunk} keeps only the latest frame of each distinct
+ * task (a fan-out shows several `◯` lines at once), squeezing the TUI
+ * right-alignment padding down to single spaces.
+ *
+ * Kept in its own module (not inlined in `bot.ts`) so the regex is the
+ * single source of truth shared with `progressLine.test.ts`, and so the
+ * detection logic can be reused by future adapters (OpenCode, etc.)
+ * without exporting bot-internal helpers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROGRESS_BAR_LINE_RE = exports.SUBAGENT_PROGRESS_LINE_RE = exports.COMPACT_LINE_RE = exports.PROGRESS_LINE_RE = exports.spinnerGlyphClass = void 0;
+exports.checkIsProgressChunk = checkIsProgressChunk;
+exports.collapseProgressChunk = collapseProgressChunk;
+/**
+ * @description The animated spinner / bullet glyph set Claude's TUI rotates
+ * through at the head of a progress line (`✻ ✽ ✶ ✢ · *`) plus the `● ○` bullet
+ * states. THE single source of the class used by {@link PROGRESS_LINE_RE} below
+ * AND by `normalizeForComparison` (utils/recentRelayWindow), so the line-SET
+ * diff dedups a re-animating-but-stable line and the progress detector accept
+ * the SAME glyph set — the two must never drift. A drift-lock test asserts
+ * `PROGRESS_LINE_RE.source` still carries exactly `[${spinnerGlyphClass}]`.
+ */
+exports.spinnerGlyphClass = '✻✽✶✢·*●○';
+/**
+ * @description Single-line regex for one Claude-CLI progress tick.
+ *
+ * Structure (each group commented):
+ *
+ *   ^\s*                              leading whitespace (TUI indent)
+ *   [✻✽✶✢·*●○]                       spinner glyph (full observed set)
+ *   \s+\S(?:[^()\n]|\([^()\n]*\))*?…  the activity text ending in U+2026
+ *                                     ellipsis. Originally a single verb
+ *                                     token ("Smooshing…"), then the active
+ *                                     task title too ("Fixing streaming
+ *                                     output overwrite…"), and the TUI now
+ *                                     also puts parenthesised bits inside it
+ *                                     ("Fixing relations add flow
+ *                                     (sub-agent)…" — live flood 2026-06-11;
+ *                                     a task title can carry its own parens
+ *                                     too), so single-level `(…)` segments
+ *                                     are allowed; the end-anchored stats
+ *                                     group below stays the real anchor
+ *   \s*\(                             stats parenthesis opens
+ *   (?:\d+h\s+)?(?:\d+m\s+)?\d+s      elapsed time — "13s", "4m 35s",
+ *                                     "1h 2m 3s" (a fresh tick has no
+ *                                     minutes yet; the old `\d+m \d+s`
+ *                                     requirement made second-only ticks
+ *                                     flood the topic)
+ *   \s*·\s*[↑↓]\s*[\d.]+k?\s*tokens   token counter, e.g. "↑ 4.4k tokens",
+ *                                     "↓ 176 tokens"
+ *   (?:\s*·[^()]*)?                   optional thinking-note suffix
+ *                                     ("thought for 9s", "thinking with
+ *                                     xhigh effort", "still thinking
+ *                                     with xhigh effort", "thinking
+ *                                     more with xhigh effort"). `[^()]*`
+ *                                     refuses nested parens so a real
+ *                                     prose sentence with parentheses
+ *                                     cannot be mistaken for a tick.
+ *   \)\s*$                            stats parenthesis closes; line ends
+ *
+ * The activity text deliberately has no verb whitelist — Claude has shipped
+ * Smooshing / Actioning / Coalescing / … then task titles, then parenthesised
+ * suffixes like "(sub-agent)" inside the title; the trailing end-anchored
+ * `(time · tokens)` stats parenthesis is specific enough to carry the match
+ * on its own — the same safety argument that admitted multi-word titles
+ * (2026-06-05) covers the paren widening (2026-06-11).
+ */
+exports.PROGRESS_LINE_RE = /^\s*[✻✽✶✢·*●○]\s+\S(?:[^()\n]|\([^()\n]*\))*?…\s*\((?:\d+h\s+)?(?:\d+m\s+)?\d+s\s*·\s*[↑↓]\s*[\d.]+k?\s*tokens(?:\s*·[^()]*)?\)\s*$/;
+/**
+ * @description Verb line of Claude's `/compact` (and automatic context
+ * compaction) progress. Observed shapes:
+ *   `✶ Compacting conversation…`                          (before the timer)
+ *   `✻ Compacting conversation… (1m 22s)`                 (elapsed time only)
+ *   `· Compacting conversation… (48s · ↑ 3.1k tokens)`    (time + token stats)
+ *
+ * Anchored on the literal `Compacting conversation` phrase, followed by the
+ * ellipsis and an OPTIONAL `(…)` stats parenthesis (`[^()]*` so a real prose
+ * sentence with nested parens can't stretch the match). The phrase anchor is
+ * specific enough that this line on its own is safe to treat as progress —
+ * unlike a broad `\S.*…` body, it can never collide with a real `●`-prefixed
+ * answer, so {@link checkIsProgressChunk} no longer needs a bar line to admit
+ * it (auto-compaction redraws the verb line with no bar in the diff).
+ */
+exports.COMPACT_LINE_RE = /^\s*[✻✽✶✢·*●○]\s+Compacting conversation…\s*(?:\([^()]*\))?\s*$/;
+/**
+ * @description Sub-agent task line of Claude's TUI, redrawn every tick while a
+ * Task sub-agent runs, e.g.
+ *   `◯ general-purpose  Move styles into solClientKit          6m 50s · ↓ 120.2k tokens`
+ * optionally prefixed with the `❯` selection cursor, optionally without the
+ * trailing stats (right after the sub-agent starts, before its timer shows).
+ *
+ * Anchored on the `◯` (U+25EF) sub-agent glyph — deliberately distinct from
+ * the `○` (U+25CB) thinking spinner and the `●` (U+25CF) tool/result bullet,
+ * so a `● Bash(…)` tool call or a `○ Thinking…` tick is never mistaken for a
+ * sub-agent frame. The trailing time/token counter changes each second, which
+ * is exactly why the pane diff sees every tick as a new line and the topic
+ * floods without collapsing.
+ */
+exports.SUBAGENT_PROGRESS_LINE_RE = /^\s*(?:❯\s+)?◯\s+\S.*$/;
+/**
+ * @description Progress-bar line of Claude's `/compact`, e.g.
+ * `▰▰▰▰▰▰▱▱▱▱▱▱ 15%`. A run of filled/empty bar cells (U+25B0 `▰` /
+ * U+25B1 `▱`) optionally followed by a percentage.
+ *
+ * The percentage is optional because a terminal-redraw scrape can clip the
+ * trailing `N%` mid-frame; such a fragment must still count as progress (so
+ * it never floods the topic) and {@link collapseProgressChunk} falls back to
+ * the filled-cell count for ordering it. The `{4,}` cell run is a high-signal
+ * anchor (bar cells never appear in real prose), so a bar line on its own is
+ * always treated as progress; {@link COMPACT_LINE_RE} carries its own phrase
+ * anchor and no longer relies on a bar being present.
+ */
+exports.PROGRESS_BAR_LINE_RE = /^\s*[▰▱]{4,}(?:\s*\d{1,3}\s*%?)?\s*$/;
+/**
+ * @description Return `true` iff `text` consists exclusively of Claude
+ * progress lines.
+ *
+ * Splits on `\n`, drops empty / whitespace-only lines, and requires that
+ * the remaining array is non-empty **and every line matches**
+ * {@link PROGRESS_LINE_RE}. This means:
+ *
+ *  - a single tick line → `true`
+ *  - a 4-line burst of ticks (one verb, time advancing) → `true`
+ *  - a verb-transition burst (Newspapering → Coalescing → Booping) →
+ *    `true`, because every individual line still matches
+ *  - a chunk that mixes a tick line with real prose → `false`, so the
+ *    chunk reaches the normal output pipeline unchanged
+ *  - empty string → `false` (nothing to collapse)
+ *
+ * @example
+ *   checkIsProgressChunk('✽ Smooshing… (1m 49s · ↑ 3.3k tokens)') // true
+ *   checkIsProgressChunk('Sure, here is the answer…')             // false
+ */
+/**
+ * @description One line of ANY recognised progress shape — thinking tick,
+ * sub-agent task frame, compaction verb, or compaction bar.
+ *
+ * A single predicate (not per-shape branches) because a scrape diff freely
+ * interleaves shapes: while a Task sub-agent runs, every redraw carries a
+ * `◯ <type> <title> <elapsed>` frame AND a spinner tick — the old
+ * one-shape-per-chunk branches rejected that mix, so the whole burst was
+ * misrouted as substantive output and flooded the topic (live repro
+ * 2026-06-05, thread relay of a review sub-agent).
+ */
+function checkIsProgressLine(line) {
+    return (exports.PROGRESS_LINE_RE.test(line) ||
+        exports.SUBAGENT_PROGRESS_LINE_RE.test(line) ||
+        exports.COMPACT_LINE_RE.test(line) ||
+        exports.PROGRESS_BAR_LINE_RE.test(line));
+}
+function checkIsProgressChunk(text) {
+    const lines = text.split('\n').filter(l => l.trim().length > 0);
+    if (lines.length === 0)
+        return false;
+    return lines.every(checkIsProgressLine);
+}
+/**
+ * @description Parse the percentage a `/compact` bar line represents, used to
+ * pick the latest frame out of a jumbled scrape burst.
+ *
+ * Prefers the explicit trailing `N%`; falls back to counting filled bar
+ * cells (`▰`) when the percentage text was clipped from the diff.
+ */
+function getProgressBarPercent(line) {
+    const percentMatch = line.match(/(\d{1,3})\s*%/);
+    if (percentMatch)
+        return Number(percentMatch[1]);
+    return (line.match(/▰/g) ?? []).length;
+}
+/**
+ * @description Collapse runs of 2+ whitespace (Claude's TUI right-alignment
+ * padding) down to a single space and trim — turns a heavily-padded scrape
+ * line into a compact one-liner for Telegram.
+ */
+function squeezeWhitespace(line) {
+    return line.replace(/\s{2,}/g, ' ').trim();
+}
+/**
+ * @description Identity of a sub-agent task line, stable across ticks: the
+ * `◯ <type>  <title>` prefix with the trailing `<pad><elapsed> · ↓ <tokens>`
+ * stats removed. The pad+stats always begin with 2+ spaces followed by a
+ * digit, which the single-spaced title never contains — so cutting at the
+ * first such run drops the changing tail without touching the title.
+ *
+ * The leading `❯` selection cursor is stripped first: it hops on/off a task
+ * as the user navigates the panel, so keeping it would split one task into
+ * two rolling lines (cursored vs not) within a single burst.
+ */
+function getSubagentTaskIdentity(line) {
+    return squeezeWhitespace(line.replace(/^\s*❯\s+/, '').replace(/\s{2,}\d.*$/, ''));
+}
+/**
+ * @description Reduce a progress chunk (see {@link checkIsProgressChunk}) to
+ * the single most-recent frame, so the coalesced status message rolls in
+ * place instead of stacking every intermediate tick/percentage.
+ *
+ * - sub-agent frames (may be interleaved with any other shape) → the latest
+ *   frame of EACH distinct task (grouped by {@link getSubagentTaskIdentity},
+ *   first-seen order preserved), so a parallel fan-out shows one rolling line
+ *   per sub-agent, padding squeezed. Rendered first — mirroring the TUI,
+ *   which draws the task panel above the main spinner.
+ * - thinking-spinner lines → the last tick line (time only grows, scrape is
+ *   in order, so "last" is "latest").
+ * - compaction lines with a bar → the highest-percentage bar line (a redraw
+ *   scrape can arrive out of order, and `%` only grows, so max is the true
+ *   latest) prefixed with the most recent `Compacting conversation…` verb
+ *   line for context. The pair mirrors Claude's own two-line frame.
+ * - compaction lines with no bar (verb lines only) → the last verb line.
+ *
+ * Must only be called on a chunk that {@link checkIsProgressChunk} accepted.
+ */
+function collapseProgressChunk(text) {
+    const lines = text.split('\n').filter(l => l.trim().length > 0);
+    const collapsedParts = [];
+    // Sub-agent panel: keep the latest frame of each distinct task. A Map keyed
+    // by task identity, last write wins, preserves insertion (first-seen) order.
+    // The `❯` selection cursor is dropped from both the key and the rendered
+    // line so a task reads identically whether or not it's currently selected.
+    const subagentLines = lines.filter(line => exports.SUBAGENT_PROGRESS_LINE_RE.test(line));
+    if (subagentLines.length > 0) {
+        const latestFrameByTask = new Map();
+        for (const line of subagentLines) {
+            const frame = squeezeWhitespace(line.replace(/^\s*❯\s+/, ''));
+            latestFrameByTask.set(getSubagentTaskIdentity(line), frame);
+        }
+        collapsedParts.push(...latestFrameByTask.values());
+    }
+    // Remaining (non-sub-agent) lines: spinner ticks and/or compaction frames.
+    const spinnerAndCompactLines = lines.filter(line => !exports.SUBAGENT_PROGRESS_LINE_RE.test(line));
+    if (spinnerAndCompactLines.length > 0) {
+        const barLines = spinnerAndCompactLines.filter(line => exports.PROGRESS_BAR_LINE_RE.test(line));
+        if (barLines.length === 0) {
+            collapsedParts.push(spinnerAndCompactLines[spinnerAndCompactLines.length - 1].trim());
+        }
+        else {
+            const latestBar = barLines.reduce((best, line) => getProgressBarPercent(line) >= getProgressBarPercent(best) ? line : best);
+            const verbLines = spinnerAndCompactLines.filter(line => exports.COMPACT_LINE_RE.test(line) && !exports.PROGRESS_BAR_LINE_RE.test(line));
+            const latestVerb = verbLines.length > 0 ? verbLines[verbLines.length - 1].trim() : null;
+            collapsedParts.push(latestVerb ? `${latestVerb}\n${latestBar.trim()}` : latestBar.trim());
+        }
+    }
+    return collapsedParts.join('\n');
+}
+//# sourceMappingURL=progressLine.js.map

package/dist/progressLine.js.map

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