charness 0.0.0-stage → 3.0.0

package/dist/utils/claudeScrapeShapes.d.ts

@@ -0,0 +1,256 @@
+/**
+ * @description Single source of truth for the LINE-SHAPE regexes/predicates of
+ * a scraped, ANSI-cleaned Claude TUI pane. These were originally private to
+ * `adapters/claudeCliAdapter.ts`; they were lifted here so BOTH the adapter
+ * (`stripTuiElementsWithContext` / `fenceToolResultBodies`) and the chunk
+ * classifier (`utils/claudeChunkClassifier.ts`) consume ONE definition per
+ * shape — never a copy. The rationale comments live with each shape below.
+ *
+ * Exception: {@link checkIsClaudeChromeLine} is a DELIBERATE parallel of the
+ * adapter's inline chrome filters (the adapter drops those lines mid-strip and
+ * is NOT yet rewired to this predicate — that wiring is a behavior change
+ * deferred to S4–S6). Keep the two in sync until then; unify when the relay
+ * starts consuming the classifier.
+ *
+ * Pure module: regexes + small line predicates only, no I/O, no state. Whole-
+ * block detectors that need parsing state (question/survey extraction, input-
+ * echo) stay in the adapter and are imported there, not here.
+ */
+/**
+ * @description The full set of leading spinner / bullet glyphs the Claude TUI
+ * (and the bot's own rotating liveness frame, `CLAUDE_LIVENESS_GLYPHS =
+ * ['✻','✽','✶','✢']`) may prepend to a status/activity line, anchored at the
+ * line start with its trailing whitespace. Stripping it yields a
+ * GLYPH-INSENSITIVE signature so a frame that changed only its animation glyph
+ * dedups as identical. ONE definition for every call site that strips the lead
+ * glyph (status dedup, the liveness frame, the adapter's status dedup).
+ */
+export declare const LEADING_SPINNER_GLYPH_RE: RegExp;
+/** Strip a single leading spinner/bullet glyph (+ trailing ws) from a line. */
+export declare function stripLeadingSpinnerGlyph(line: string): string;
+/**
+ * @description Active spinner tick, per-line shape used by Claude's TUI
+ * while it is thinking or running a tool. Examples:
+ *   `✽ Doing… (4s · ↓ 14 tokens)`
+ *   `* Brewing… (1m 30s · ↑ 88 tokens · thought for 17s)`
+ *   `· Working… (7s · ↓ 222 tokens)`
+ *
+ * Plan §2026-05-28 tg-output-readability / S4 (N1.b). Why a SECOND
+ * regex on top of `PROGRESS_LINE_RE` (in `progressLine.ts`): different
+ * job — this one strips tick lines that ride INSIDE a chunk that also
+ * carries real output, while `PROGRESS_LINE_RE` classifies whole
+ * pure-progress chunks bot-side. This regex does not require the token
+ * counter (`(5s)` alone matches), `PROGRESS_LINE_RE` does. Both accept
+ * a multi-word activity text since 2026-06-05 — the TUI now shows the
+ * active task title there ("Fixing streaming output overwrite…"), and
+ * the single-token `\S+…` let those ticks leak into permanent messages
+ * (adapter side) / flood the topic (bot side). Since 2026-06-11 both
+ * also accept single-level parenthesised segments inside the title —
+ * the TUI appends bits like "(sub-agent)" while a Task sub-agent runs
+ * ("Fixing relations add flow (sub-agent)…", the live topic flood), and
+ * a task title can carry its own parens. The trailing end-anchored
+ * `(<elapsed>[ · …])` parenthesis stays the load-bearing anchor — the
+ * same safety argument as the multi-word widening.
+ *
+ * The required text-with-ellipsis disambiguates this from a tool-call
+ * header (`● Bash(ls -la)`), which starts with the same `●` glyph but
+ * has no ellipsis.
+ */
+export declare const SPINNER_TICK_RE: RegExp;
+/**
+ * @description Post-thinking trailer line that Claude's TUI prints
+ * AFTER it has finished thinking (just before resuming the prompt
+ * area). Examples observed in the live ExampleGroup debug session:
+ *   `✻ Cooked for 27s`
+ *   `✻ Cogitated for 20s`
+ *   `✻ Crunched for 7s`
+ *   `✻ Baked for 10s`
+ *   `✻ Churned for 20s`       (V3 iteration 1, 2026-05-28)
+ *   `✻ Sautéed for 20s`       (V3 iteration 2, 2026-05-28)
+ *
+ * Plan §2026-05-28 tg-output-readability / S3 (N1.a). The trailer
+ * carries zero novel info — the same time was already streaming in
+ * the active spinner that preceded it — so we drop it.
+ *
+ * Verb match is `\S+`, not an explicit list. The original plan called
+ * for an explicit list of `-ed` forms (Cooked|Cogitated|...) on the
+ * theory that a future Claude verb that IS real prose (e.g.
+ * `✻ Ready for input`) could be silently swallowed. Two live V3
+ * iterations on 2026-05-28 demonstrated the opposite failure mode:
+ * Claude ships new spinner verbs faster than we'd realistically
+ * extend the list (`Churned` and `Sautéed` both slipped through on
+ * first encounter). The triple anchor `<glyph> <verb> for <N>s` is
+ * shape-specific enough that real prose almost cannot satisfy it:
+ *   - line must START with a spinner glyph (`✻✽✶✢·*●○`) — outside
+ *     transient TUI status, Claude never emits these as the first
+ *     non-whitespace char of a prose line;
+ *   - line must END with `for \d+(?:m\s+\d+)?s` — a time literal,
+ *     not a generic noun;
+ *   - line has no other content (anchored `$`).
+ * `\S+` is the minimal relaxation: one non-whitespace token between
+ * the glyph and ` for `. Accepts `Sautéed`, `Churned`, future verbs,
+ * and rejects anything containing whitespace or extra structure.
+ */
+export declare const POST_THINKING_TRAILER_RE: RegExp;
+/**
+ * @description Static "Thinking for {N}s…" header line the TUI prints at the
+ * TOP of a finished reasoning block (distinct from {@link SPINNER_TICK_RE},
+ * the LIVE rolling tick, and {@link POST_THINKING_TRAILER_RE}, the closing
+ * "Cooked for Ns" trailer). After `cleanOutput`'s ANSI-bold→`*…*` conversion
+ * the duration is bolded: `Thinking for *1m 6s*…`. The `⎿`-bodied reasoning
+ * summary follows on the next lines (see claudeToolFencing.test.ts).
+ *
+ * Anchored: glyph-or-bullet-optional `Thinking for`, a duration (`30s`,
+ * `1m 6s`, optionally `*`-wrapped), then the U+2026 ellipsis. The duration is
+ * load-bearing so a prose sentence "Thinking for a moment about X" cannot
+ * match (no `\d+s…` tail).
+ */
+export declare const THINKING_HEADER_RE: RegExp;
+/**
+ * @description A leading star-burst spinner-glyph line (`✻ ✽ ✶ ✢`) carrying an
+ * activity TITLE that ends in the `…` ellipsis but has NO `(elapsed · tokens)`
+ * stats anchor — e.g. `✻ Herding cats…` right after a turn starts, before the
+ * timer shows. {@link SPINNER_TICK_RE} requires the trailing `(…)` stats, so
+ * these bare-title frames slip past it and, being neither chrome nor a tool
+ * line, classify as PROSE and ship as answer content (live flood 2026-07-04,
+ * alongside the table). They are transient TUI activity, never content → drop.
+ *
+ * Two deliberate narrowings keep this from eating real text:
+ *  - the trailing `…` is REQUIRED — Claude's spinner activity always ends in the
+ *    ellipsis, so a `✻ <word> for 4 people` / `✻ Ready for input` prose look-alike
+ *    (no ellipsis) is preserved (see cleanOutput.test.ts), and a
+ *    {@link POST_THINKING_TRAILER_RE} `✻ Cooked for 27s` trailer is left to its
+ *    own filter;
+ *  - only the FOUR star-burst glyphs — exclusively TUI animation frames that
+ *    never lead prose. `·`/`*` are excluded (they lead `· item` / `* item`
+ *    markdown bullets), as is a {@link THINKING_HEADER_RE} `Thinking for Ns…`
+ *    header (kept verbatim under `/thinking full`).
+ */
+export declare function checkIsBareSpinnerActivityLine(line: string): boolean;
+/**
+ * @description Code-producing tool headers whose `⎿` result is code / diff /
+ * command output and should render as a monospaced Telegram code block. Two
+ * classes, differing in what the `⎿` line itself holds:
+ *
+ *  - OUTPUT tools (`Bash`/`Grep`/`Glob`): the `⎿`-line content IS the first
+ *    line of stdout, so it goes INSIDE the fence with the indented body;
+ *  - FILE tools (`Read`/`Edit`/`Update`/`Write`/`MultiEdit`/`NotebookEdit`):
+ *    the `⎿` line is a one-line summary (`Added N lines, removed M`) that
+ *    stays as prose — only the deeper-indented diff/file body below it is
+ *    fenced.
+ *
+ * Anchored on the tool NAME (optionally glyph-led and/or `*bold*` from the
+ * ANSI-bold conversion), NEVER on body indent: Claude wraps long thinking
+ * prose at the 300-col pane width into space-indented continuation lines
+ * byte-identical in shape to a diff/output body, so only a known code header
+ * may license fencing (a thinking block has no such header). Allowlist, not
+ * blocklist — unknown shapes stay prose.
+ */
+export declare const OUTPUT_TOOL_HEADER_RE: RegExp;
+export declare const FILE_TOOL_HEADER_RE: RegExp;
+/**
+ * @description ANY tool-call header line (`● Bash(…)`, `✓ Read(…)`,
+ * `● Update(…)`, `● Task(…)`, `● TodoWrite(…)`, `● WebFetch(…)`). MUST stay a
+ * superset of the two fence-deciding headers above (`OUTPUT_TOOL_HEADER_RE` +
+ * `FILE_TOOL_HEADER_RE`): used by the classifier to TAG a header line as
+ * `toolHeader` (and a sub-agent panel preview's `⎿ Tool(…)`) regardless of
+ * whether its body would be fenced. Anchored on the tool NAME from Claude's
+ * known set, optionally glyph-led and/or `*bold*`, followed by `(`.
+ * `Update` is Claude's TUI render of the Edit tool (`● Update(file)`) — the most
+ * common header; omitting it (live bug, all-minimal topic) let every Edit header
+ * and its sub-agent `⎿ Update(…)` previews bypass the verbosity routing and leak.
+ */
+export declare const ANY_TOOL_HEADER_RE: RegExp;
+/** Tool RESULT marker line: `  ⎿  <summary or first output line>`. */
+export declare const TOOL_RESULT_MARKER_RE: RegExp;
+/** An agent-authored fenced code block delimiter, possibly indented. */
+export declare const CODE_FENCE_LINE_RE: RegExp;
+/**
+ * @description Lines the bot's progress-collapse owns and must receive
+ * UN-fenced: a sub-agent task line (`◯`, optionally `❯`-cursor-led, U+25EF —
+ * NOT the `○`/`●` glyphs) and a compaction progress bar (`▰▱`). They are
+ * indented in the pane, so a stale `output` tool kind would otherwise route
+ * them through the orphan-continuation fence; the resulting ```` ``` ````
+ * delimiters then fail `checkIsProgressChunk` (progressLine.ts), so the burst
+ * is NOT coalesced and the topic floods with one fenced tick per second.
+ */
+export declare const PROGRESS_PASSTHROUGH_RE: RegExp;
+/**
+ * @description Transient activity tick the TUI paints INSIDE a tool-result
+ * body while the command is still running (`Running…`, `Waiting…`), with no
+ * elapsed-time paren. {@link SPINNER_TICK_RE} only catches the glyph-led
+ * `(Ns)` form, so these bare words slip through and get fenced as if they
+ * were stdout. They are ephemeral chrome, never command output: render plain,
+ * and DROP entirely when real output supersedes them in the same body.
+ */
+export declare const TRANSIENT_TICK_RE: RegExp;
+/**
+ * @description The TUI's "output was collapsed" marker (`… +1 tool use`,
+ * `… +33 lines`). Anchored to the literal `… +N tool use(s)/line(s)` shape so
+ * a real one-line stdout that merely ends in `…` is never matched. Chrome, not
+ * output → render plain, never fenced.
+ */
+export declare const COLLAPSE_MARKER_RE: RegExp;
+/**
+ * @description The tool-use-only subset of {@link COLLAPSE_MARKER_RE}: matches
+ * `… +N tool use(s)` but NOT `… +N line(s)`. WHY a dedicated regex: the
+ * "+N tool uses" collapse wall is ALWAYS sub-agent panel chatter, whereas the
+ * "+N lines" form `COLLAPSE_MARKER_RE` also matches is a legitimate tool-body
+ * summary. The classifier uses this to drop an ORPHAN "+N tool uses" wall (panel
+ * already closed / scrolled off) as chrome instead of leaking it as prose,
+ * without ever swallowing a real "+N lines" tool-body summary.
+ */
+export declare const COLLAPSE_TOOLUSE_MARKER_RE: RegExp;
+/**
+ * @description Turn / sub-agent completion summary (`Done (14 tool uses ·
+ * 66.9k tokens · 1m 55s)`). The `tokens` inside the paren is the load-bearing
+ * anchor — a real `Done (…)` stdout line without token stats is not matched.
+ * Chrome, not output → render plain, never fenced.
+ */
+export declare const COMPLETION_SUMMARY_RE: RegExp;
+/**
+ * @description A file-diff `NN +` CHANGE gutter line as Claude renders
+ * Read/Edit/Update diffs: a leading line number, then a literal `+` change
+ * marker (`40 +`, `3 +delta`, `51 + content`). Tight by design — `+1 done`,
+ * `3 lines changed`, `done` all fail it, so it never matches legit short prose.
+ *
+ * THE single source of truth for the short-`+`-gutter dedup bypass (live leak
+ * 2026-06-24): a short gutter re-rendered on a later poll and leaked because it
+ * was under the relay-window length gate. Both the relay window
+ * ({@link ../utils/recentRelayWindow}) and `checkIsStatusOutput` key on this
+ * shape — strictly `+` additions; `-` deletion gutters stay outside.
+ */
+export declare const DIFF_CHANGE_GUTTER_RE: RegExp;
+/**
+ * @description The bottom-right corner shortcut hint Claude Code v2.1.201
+ * paints on the footer row (`/rc`). Right-aligned at the pane edge, it can
+ * scrape as a line whose ONLY content is the hint token (heavy leading
+ * whitespace) — the line-set diff then relayed it as a 3-char status frame
+ * (`sendMessage "/rc"`, `✽ /rc · 0:01`; live 2026-07-06). Anchored
+ * to the WHOLE line being nothing but the literal hint, so prose that merely
+ * mentions `/rc` inline is never matched. Closed shape — if a future version
+ * paints a different corner hint, WIDEN the alternation (keep `/rc`), don't
+ * loosen the whole-line anchor.
+ */
+export declare const CORNER_HINT_RE: RegExp;
+/**
+ * @description Which tool a `⎿` result body belongs to, deciding how it is
+ * fenced: `output` (Bash/Grep/Glob — the `⎿` line is stdout, fenced with the
+ * body) vs `file` (Read/Edit/Update/Write — the `⎿` line is a prose summary,
+ * only the body below is fenced).
+ */
+export type ToolResultKind = 'output' | 'file';
+/**
+ * @description Whole-line TUI chrome a scrape chunk can carry that the relay
+ * already drops: rounded box-drawing borders, full-width rules, nav / hint
+ * footers ("Enter to select", "esc to …", "↑/↓ …"), the bypass-permissions
+ * footer, tab-bar rows, and the native-installer ad. Consolidated here from
+ * the inline filters in `stripTuiElementsWithContext` so the classifier tags
+ * the SAME lines as `chrome` without re-declaring each shape.
+ *
+ * Conservative by design — every branch is anchored on a TUI-only glyph or an
+ * exact phrase, so a real prose line is never mistaken for chrome (the
+ * classifier's default is `prose`).
+ */
+export declare function checkIsClaudeChromeLine(line: string): boolean;
+//# sourceMappingURL=claudeScrapeShapes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeScrapeShapes.d.ts","sourceRoot":"","sources":["../../src/utils/claudeScrapeShapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,QAAoB,CAAC;AAE1D,+EAA+E;AAC/E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,QAC4E,CAAC;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,wBAAwB,QACa,CAAC;AAEnD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,QAC0C,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,QAAiD,CAAC;AACpF,eAAO,MAAM,mBAAmB,QAC+C,CAAC;AAEhF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,QACuG,CAAC;AAEvI,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,QAAY,CAAC;AAE/C,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,QAAY,CAAC;AAE5C;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,QAA8B,CAAC;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,QAAkD,CAAC;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAA6C,CAAC;AAE7E;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,QAAoC,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAwC,CAAC;AAE3E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,QAAiB,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,QAAiB,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CA+B7D"}

package/dist/utils/claudeScrapeShapes.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * @description Single source of truth for the LINE-SHAPE regexes/predicates of
+ * a scraped, ANSI-cleaned Claude TUI pane. These were originally private to
+ * `adapters/claudeCliAdapter.ts`; they were lifted here so BOTH the adapter
+ * (`stripTuiElementsWithContext` / `fenceToolResultBodies`) and the chunk
+ * classifier (`utils/claudeChunkClassifier.ts`) consume ONE definition per
+ * shape — never a copy. The rationale comments live with each shape below.
+ *
+ * Exception: {@link checkIsClaudeChromeLine} is a DELIBERATE parallel of the
+ * adapter's inline chrome filters (the adapter drops those lines mid-strip and
+ * is NOT yet rewired to this predicate — that wiring is a behavior change
+ * deferred to S4–S6). Keep the two in sync until then; unify when the relay
+ * starts consuming the classifier.
+ *
+ * Pure module: regexes + small line predicates only, no I/O, no state. Whole-
+ * block detectors that need parsing state (question/survey extraction, input-
+ * echo) stay in the adapter and are imported there, not here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORNER_HINT_RE = exports.DIFF_CHANGE_GUTTER_RE = exports.COMPLETION_SUMMARY_RE = exports.COLLAPSE_TOOLUSE_MARKER_RE = exports.COLLAPSE_MARKER_RE = exports.TRANSIENT_TICK_RE = exports.PROGRESS_PASSTHROUGH_RE = exports.CODE_FENCE_LINE_RE = exports.TOOL_RESULT_MARKER_RE = exports.ANY_TOOL_HEADER_RE = exports.FILE_TOOL_HEADER_RE = exports.OUTPUT_TOOL_HEADER_RE = exports.THINKING_HEADER_RE = exports.POST_THINKING_TRAILER_RE = exports.SPINNER_TICK_RE = exports.LEADING_SPINNER_GLYPH_RE = void 0;
+exports.stripLeadingSpinnerGlyph = stripLeadingSpinnerGlyph;
+exports.checkIsBareSpinnerActivityLine = checkIsBareSpinnerActivityLine;
+exports.checkIsClaudeChromeLine = checkIsClaudeChromeLine;
+/**
+ * @description The full set of leading spinner / bullet glyphs the Claude TUI
+ * (and the bot's own rotating liveness frame, `CLAUDE_LIVENESS_GLYPHS =
+ * ['✻','✽','✶','✢']`) may prepend to a status/activity line, anchored at the
+ * line start with its trailing whitespace. Stripping it yields a
+ * GLYPH-INSENSITIVE signature so a frame that changed only its animation glyph
+ * dedups as identical. ONE definition for every call site that strips the lead
+ * glyph (status dedup, the liveness frame, the adapter's status dedup).
+ */
+exports.LEADING_SPINNER_GLYPH_RE = /^[✻✽✶✢·*●○⏺]\s*/;
+/** Strip a single leading spinner/bullet glyph (+ trailing ws) from a line. */
+function stripLeadingSpinnerGlyph(line) {
+    return line.replace(exports.LEADING_SPINNER_GLYPH_RE, '');
+}
+/**
+ * @description Active spinner tick, per-line shape used by Claude's TUI
+ * while it is thinking or running a tool. Examples:
+ *   `✽ Doing… (4s · ↓ 14 tokens)`
+ *   `* Brewing… (1m 30s · ↑ 88 tokens · thought for 17s)`
+ *   `· Working… (7s · ↓ 222 tokens)`
+ *
+ * Plan §2026-05-28 tg-output-readability / S4 (N1.b). Why a SECOND
+ * regex on top of `PROGRESS_LINE_RE` (in `progressLine.ts`): different
+ * job — this one strips tick lines that ride INSIDE a chunk that also
+ * carries real output, while `PROGRESS_LINE_RE` classifies whole
+ * pure-progress chunks bot-side. This regex does not require the token
+ * counter (`(5s)` alone matches), `PROGRESS_LINE_RE` does. Both accept
+ * a multi-word activity text since 2026-06-05 — the TUI now shows the
+ * active task title there ("Fixing streaming output overwrite…"), and
+ * the single-token `\S+…` let those ticks leak into permanent messages
+ * (adapter side) / flood the topic (bot side). Since 2026-06-11 both
+ * also accept single-level parenthesised segments inside the title —
+ * the TUI appends bits like "(sub-agent)" while a Task sub-agent runs
+ * ("Fixing relations add flow (sub-agent)…", the live topic flood), and
+ * a task title can carry its own parens. The trailing end-anchored
+ * `(<elapsed>[ · …])` parenthesis stays the load-bearing anchor — the
+ * same safety argument as the multi-word widening.
+ *
+ * The required text-with-ellipsis disambiguates this from a tool-call
+ * header (`● Bash(ls -la)`), which starts with the same `●` glyph but
+ * has no ellipsis.
+ */
+exports.SPINNER_TICK_RE = /^\s*[✻✽✶✢·*●○]\s+\S(?:[^()\n]|\([^()\n]*\))*?…\s*\((?:\d+h\s+)?(?:\d+m\s+)?\d+s(?:\s*·[^()]*)?\)\s*$/;
+/**
+ * @description Post-thinking trailer line that Claude's TUI prints
+ * AFTER it has finished thinking (just before resuming the prompt
+ * area). Examples observed in the live ExampleGroup debug session:
+ *   `✻ Cooked for 27s`
+ *   `✻ Cogitated for 20s`
+ *   `✻ Crunched for 7s`
+ *   `✻ Baked for 10s`
+ *   `✻ Churned for 20s`       (V3 iteration 1, 2026-05-28)
+ *   `✻ Sautéed for 20s`       (V3 iteration 2, 2026-05-28)
+ *
+ * Plan §2026-05-28 tg-output-readability / S3 (N1.a). The trailer
+ * carries zero novel info — the same time was already streaming in
+ * the active spinner that preceded it — so we drop it.
+ *
+ * Verb match is `\S+`, not an explicit list. The original plan called
+ * for an explicit list of `-ed` forms (Cooked|Cogitated|...) on the
+ * theory that a future Claude verb that IS real prose (e.g.
+ * `✻ Ready for input`) could be silently swallowed. Two live V3
+ * iterations on 2026-05-28 demonstrated the opposite failure mode:
+ * Claude ships new spinner verbs faster than we'd realistically
+ * extend the list (`Churned` and `Sautéed` both slipped through on
+ * first encounter). The triple anchor `<glyph> <verb> for <N>s` is
+ * shape-specific enough that real prose almost cannot satisfy it:
+ *   - line must START with a spinner glyph (`✻✽✶✢·*●○`) — outside
+ *     transient TUI status, Claude never emits these as the first
+ *     non-whitespace char of a prose line;
+ *   - line must END with `for \d+(?:m\s+\d+)?s` — a time literal,
+ *     not a generic noun;
+ *   - line has no other content (anchored `$`).
+ * `\S+` is the minimal relaxation: one non-whitespace token between
+ * the glyph and ` for `. Accepts `Sautéed`, `Churned`, future verbs,
+ * and rejects anything containing whitespace or extra structure.
+ */
+exports.POST_THINKING_TRAILER_RE = /^[✻✽✶✢·*●○]\s+\S+\s+for\s+\d+(?:m\s+\d+)?s\s*$/;
+/**
+ * @description Static "Thinking for {N}s…" header line the TUI prints at the
+ * TOP of a finished reasoning block (distinct from {@link SPINNER_TICK_RE},
+ * the LIVE rolling tick, and {@link POST_THINKING_TRAILER_RE}, the closing
+ * "Cooked for Ns" trailer). After `cleanOutput`'s ANSI-bold→`*…*` conversion
+ * the duration is bolded: `Thinking for *1m 6s*…`. The `⎿`-bodied reasoning
+ * summary follows on the next lines (see claudeToolFencing.test.ts).
+ *
+ * Anchored: glyph-or-bullet-optional `Thinking for`, a duration (`30s`,
+ * `1m 6s`, optionally `*`-wrapped), then the U+2026 ellipsis. The duration is
+ * load-bearing so a prose sentence "Thinking for a moment about X" cannot
+ * match (no `\d+s…` tail).
+ */
+exports.THINKING_HEADER_RE = /^\s*[●○⏺✻✽✶✢·*]?\s*Thinking for\s+\*?(?:\d+h\s+)?(?:\d+m\s+)?\d+s\*?…/;
+/**
+ * @description A leading star-burst spinner-glyph line (`✻ ✽ ✶ ✢`) carrying an
+ * activity TITLE that ends in the `…` ellipsis but has NO `(elapsed · tokens)`
+ * stats anchor — e.g. `✻ Herding cats…` right after a turn starts, before the
+ * timer shows. {@link SPINNER_TICK_RE} requires the trailing `(…)` stats, so
+ * these bare-title frames slip past it and, being neither chrome nor a tool
+ * line, classify as PROSE and ship as answer content (live flood 2026-07-04,
+ * alongside the table). They are transient TUI activity, never content → drop.
+ *
+ * Two deliberate narrowings keep this from eating real text:
+ *  - the trailing `…` is REQUIRED — Claude's spinner activity always ends in the
+ *    ellipsis, so a `✻ <word> for 4 people` / `✻ Ready for input` prose look-alike
+ *    (no ellipsis) is preserved (see cleanOutput.test.ts), and a
+ *    {@link POST_THINKING_TRAILER_RE} `✻ Cooked for 27s` trailer is left to its
+ *    own filter;
+ *  - only the FOUR star-burst glyphs — exclusively TUI animation frames that
+ *    never lead prose. `·`/`*` are excluded (they lead `· item` / `* item`
+ *    markdown bullets), as is a {@link THINKING_HEADER_RE} `Thinking for Ns…`
+ *    header (kept verbatim under `/thinking full`).
+ */
+function checkIsBareSpinnerActivityLine(line) {
+    return /^\s*[✻✽✶✢]\s+\S.*…\s*$/.test(line) && !exports.THINKING_HEADER_RE.test(line);
+}
+/**
+ * @description Code-producing tool headers whose `⎿` result is code / diff /
+ * command output and should render as a monospaced Telegram code block. Two
+ * classes, differing in what the `⎿` line itself holds:
+ *
+ *  - OUTPUT tools (`Bash`/`Grep`/`Glob`): the `⎿`-line content IS the first
+ *    line of stdout, so it goes INSIDE the fence with the indented body;
+ *  - FILE tools (`Read`/`Edit`/`Update`/`Write`/`MultiEdit`/`NotebookEdit`):
+ *    the `⎿` line is a one-line summary (`Added N lines, removed M`) that
+ *    stays as prose — only the deeper-indented diff/file body below it is
+ *    fenced.
+ *
+ * Anchored on the tool NAME (optionally glyph-led and/or `*bold*` from the
+ * ANSI-bold conversion), NEVER on body indent: Claude wraps long thinking
+ * prose at the 300-col pane width into space-indented continuation lines
+ * byte-identical in shape to a diff/output body, so only a known code header
+ * may license fencing (a thinking block has no such header). Allowlist, not
+ * blocklist — unknown shapes stay prose.
+ */
+exports.OUTPUT_TOOL_HEADER_RE = /^\s*[●○⏺⏳✓]?\s*\*?(?:Bash|Grep|Glob)\*?\s*\(/;
+exports.FILE_TOOL_HEADER_RE = /^\s*[●○⏺⏳✓]?\s*\*?(?:Read|Edit|Update|Write|MultiEdit|NotebookEdit)\*?\s*\(/;
+/**
+ * @description ANY tool-call header line (`● Bash(…)`, `✓ Read(…)`,
+ * `● Update(…)`, `● Task(…)`, `● TodoWrite(…)`, `● WebFetch(…)`). MUST stay a
+ * superset of the two fence-deciding headers above (`OUTPUT_TOOL_HEADER_RE` +
+ * `FILE_TOOL_HEADER_RE`): used by the classifier to TAG a header line as
+ * `toolHeader` (and a sub-agent panel preview's `⎿ Tool(…)`) regardless of
+ * whether its body would be fenced. Anchored on the tool NAME from Claude's
+ * known set, optionally glyph-led and/or `*bold*`, followed by `(`.
+ * `Update` is Claude's TUI render of the Edit tool (`● Update(file)`) — the most
+ * common header; omitting it (live bug, all-minimal topic) let every Edit header
+ * and its sub-agent `⎿ Update(…)` previews bypass the verbosity routing and leak.
+ */
+exports.ANY_TOOL_HEADER_RE = /^\s*[●○⏺⏳✓]?\s*\*?(?:Bash|Read|Write|Edit|Update|MultiEdit|NotebookEdit|Glob|Grep|Task|Agent|TodoWrite|WebFetch|WebSearch)\*?\s*\(/;
+/** Tool RESULT marker line: `  ⎿  <summary or first output line>`. */
+exports.TOOL_RESULT_MARKER_RE = /^(\s*)⎿/;
+/** An agent-authored fenced code block delimiter, possibly indented. */
+exports.CODE_FENCE_LINE_RE = /^\s*```/;
+/**
+ * @description Lines the bot's progress-collapse owns and must receive
+ * UN-fenced: a sub-agent task line (`◯`, optionally `❯`-cursor-led, U+25EF —
+ * NOT the `○`/`●` glyphs) and a compaction progress bar (`▰▱`). They are
+ * indented in the pane, so a stale `output` tool kind would otherwise route
+ * them through the orphan-continuation fence; the resulting ```` ``` ````
+ * delimiters then fail `checkIsProgressChunk` (progressLine.ts), so the burst
+ * is NOT coalesced and the topic floods with one fenced tick per second.
+ */
+exports.PROGRESS_PASSTHROUGH_RE = /^\s*(?:❯\s+)?◯\s|^\s*[▰▱]/;
+/**
+ * @description Transient activity tick the TUI paints INSIDE a tool-result
+ * body while the command is still running (`Running…`, `Waiting…`), with no
+ * elapsed-time paren. {@link SPINNER_TICK_RE} only catches the glyph-led
+ * `(Ns)` form, so these bare words slip through and get fenced as if they
+ * were stdout. They are ephemeral chrome, never command output: render plain,
+ * and DROP entirely when real output supersedes them in the same body.
+ */
+exports.TRANSIENT_TICK_RE = /^\s*(?:Running|Waiting)…\s*(?:\([^)]*\))?\s*$/;
+/**
+ * @description The TUI's "output was collapsed" marker (`… +1 tool use`,
+ * `… +33 lines`). Anchored to the literal `… +N tool use(s)/line(s)` shape so
+ * a real one-line stdout that merely ends in `…` is never matched. Chrome, not
+ * output → render plain, never fenced.
+ */
+exports.COLLAPSE_MARKER_RE = /^\s*…\s*\+\d+\s+(?:tool use|line)s?\b.*$/;
+/**
+ * @description The tool-use-only subset of {@link COLLAPSE_MARKER_RE}: matches
+ * `… +N tool use(s)` but NOT `… +N line(s)`. WHY a dedicated regex: the
+ * "+N tool uses" collapse wall is ALWAYS sub-agent panel chatter, whereas the
+ * "+N lines" form `COLLAPSE_MARKER_RE` also matches is a legitimate tool-body
+ * summary. The classifier uses this to drop an ORPHAN "+N tool uses" wall (panel
+ * already closed / scrolled off) as chrome instead of leaking it as prose,
+ * without ever swallowing a real "+N lines" tool-body summary.
+ */
+exports.COLLAPSE_TOOLUSE_MARKER_RE = /^\s*…\s*\+\d+\s+tool uses?\b.*$/;
+/**
+ * @description Turn / sub-agent completion summary (`Done (14 tool uses ·
+ * 66.9k tokens · 1m 55s)`). The `tokens` inside the paren is the load-bearing
+ * anchor — a real `Done (…)` stdout line without token stats is not matched.
+ * Chrome, not output → render plain, never fenced.
+ */
+exports.COMPLETION_SUMMARY_RE = /^\s*Done\s*\([^)]*tokens[^)]*\)\s*$/;
+/**
+ * @description A file-diff `NN +` CHANGE gutter line as Claude renders
+ * Read/Edit/Update diffs: a leading line number, then a literal `+` change
+ * marker (`40 +`, `3 +delta`, `51 + content`). Tight by design — `+1 done`,
+ * `3 lines changed`, `done` all fail it, so it never matches legit short prose.
+ *
+ * THE single source of truth for the short-`+`-gutter dedup bypass (live leak
+ * 2026-06-24): a short gutter re-rendered on a later poll and leaked because it
+ * was under the relay-window length gate. Both the relay window
+ * ({@link ../utils/recentRelayWindow}) and `checkIsStatusOutput` key on this
+ * shape — strictly `+` additions; `-` deletion gutters stay outside.
+ */
+exports.DIFF_CHANGE_GUTTER_RE = /^\s*\d+\s+\+/;
+/**
+ * @description The bottom-right corner shortcut hint Claude Code v2.1.201
+ * paints on the footer row (`/rc`). Right-aligned at the pane edge, it can
+ * scrape as a line whose ONLY content is the hint token (heavy leading
+ * whitespace) — the line-set diff then relayed it as a 3-char status frame
+ * (`sendMessage "/rc"`, `✽ /rc · 0:01`; live 2026-07-06). Anchored
+ * to the WHOLE line being nothing but the literal hint, so prose that merely
+ * mentions `/rc` inline is never matched. Closed shape — if a future version
+ * paints a different corner hint, WIDEN the alternation (keep `/rc`), don't
+ * loosen the whole-line anchor.
+ */
+exports.CORNER_HINT_RE = /^\s*\/rc\s*$/;
+/**
+ * @description Whole-line TUI chrome a scrape chunk can carry that the relay
+ * already drops: rounded box-drawing borders, full-width rules, nav / hint
+ * footers ("Enter to select", "esc to …", "↑/↓ …"), the bypass-permissions
+ * footer, tab-bar rows, and the native-installer ad. Consolidated here from
+ * the inline filters in `stripTuiElementsWithContext` so the classifier tags
+ * the SAME lines as `chrome` without re-declaring each shape.
+ *
+ * Conservative by design — every branch is anchored on a TUI-only glyph or an
+ * exact phrase, so a real prose line is never mistaken for chrome (the
+ * classifier's default is `prose`).
+ */
+function checkIsClaudeChromeLine(line) {
+    const trimmed = line.trim();
+    if (trimmed === '')
+        return false;
+    return (
+    // Full-width horizontal rule.
+    /^[─━]+$/.test(trimmed) ||
+        // Pure box-drawing / blank composite (rounded chrome borders).
+        /^[╭╮╰╯┌┐└┘├┤┬┴┼─━│┃\s]+$/.test(trimmed) ||
+        // Wide bordered chrome panel row (rounded corners, >50 chars).
+        (/[╭─╮│╰╯]/.test(line) && trimmed.length > 50) ||
+        // Block / shade UI fill.
+        /^[▐▛▜▌▝▘█▀▄░▒▓\s]+$/.test(trimmed) ||
+        // Tab-bar navigation row (← … →).
+        /^←.*→\s*$/.test(trimmed) ||
+        // Selection / navigation hint footers.
+        /Enter to select/i.test(line) ||
+        /\(shift\+tab to cycle\)/i.test(line) ||
+        /⏵⏵\s*(?:bypass permissions|accept edits)\s*(?:on|off)/i.test(line) ||
+        // Bottom-right corner shortcut hint (v2.1.201 `/rc`), scraped standalone.
+        exports.CORNER_HINT_RE.test(line) ||
+        // Input-box cursor row / cursor-led nav.
+        /^❯/.test(trimmed) ||
+        // Ephemeral "Tip:" affordance under a turn.
+        /^⎿\s*Tip:\s/i.test(trimmed) ||
+        // Native-installer ad / docs link.
+        /claude code has switched|native installer|Run.*install.*or see/i.test(line) ||
+        /docs\.anthropic\.com/i.test(line) ||
+        // Resume / welcome chrome.
+        /Recent activity|What's new|\/resume for more/i.test(line) ||
+        /Welcome\s*back/i.test(line));
+}
+//# sourceMappingURL=claudeScrapeShapes.js.map

package/dist/utils/claudeScrapeShapes.js.map

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

package/dist/utils/claudeSessionTitle.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @description Derive a human-readable title for a Claude session from its
+ * stored user prompts, so the `/sessions` picker shows the session's TOPIC
+ * instead of noise.
+ *
+ * Why this exists: current Claude Code (2.1.201) no longer writes the
+ * LLM-generated `type:"summary"` line the old picker relied on, so
+ * {@link listClaudeSessionsForWorkDir} always fell back to the LAST stored
+ * prompt — which for bot-driven sessions is almost always garbage (the
+ * `[Telegram thread context]` preamble, a `/effort` command echo, a
+ * `<task-notification>`, or a bare `yes`/`commit`/`...`). We instead pick the
+ * FIRST *meaningful* prompt: preamble/marker stripped, tooling noise skipped.
+ *
+ * Pure (string-in, string-out) so it is unit-tested in isolation.
+ */
+/**
+ * @description Strip the bot's service wrappers (thread-context preamble first —
+ * it is the outermost, then the scheduled-run marker) off a stored prompt and
+ * collapse it to a single display line. No noise filtering — the raw topic line.
+ */
+export declare function getSessionTitleLine(rawPrompt: string): string;
+/**
+ * @description A session-title candidate from ONE stored prompt: the stripped
+ * single-line topic, or `null` when the prompt is empty or tooling noise.
+ */
+export declare function getSessionTitleCandidate(rawPrompt: string): string | null;
+//# sourceMappingURL=claudeSessionTitle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeSessionTitle.d.ts","sourceRoot":"","sources":["../../src/utils/claudeSessionTitle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA2CH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK7D;AAWD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKzE"}