charness 0.0.0-stage → 3.1.0

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"}

package/dist/utils/claudeSessionTitle.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionTitleLine = getSessionTitleLine;
+exports.getSessionTitleCandidate = getSessionTitleCandidate;
+const threadContextPreamble_1 = require("../threadContextPreamble");
+/**
+ * @description Leading `[Scheduled run "<name>"]` marker a scheduled run glues
+ * ahead of its prompt (see `scheduler/delivery.ts`). Anchored + single `\n`,
+ * matching how it is written.
+ */
+const scheduledRunMarkerRe = /^\[Scheduled run "[^"]*"\]\n/;
+/**
+ * @description Prompt prefixes that mark a stored user turn as bot/tooling
+ * plumbing rather than a real topic — never a session title. Matched after the
+ * preamble/marker is stripped and whitespace collapsed.
+ */
+const noisePromptPrefixes = [
+    '[Telegram thread context]', // a preamble with no prompt after it (strip failed)
+    '[Telegram file]',
+    '[Telegram album]',
+    '[Request interrupted',
+    '<local-command-', // stdout / stderr / caveat wrappers around a slash command
+    '<command-',
+    '<task-notification>',
+    '<system-reminder>',
+    '<tool-use-',
+    'Base directory for this skill:',
+    'Caveat: The messages below',
+];
+/**
+ * @description Whole-prompt values that are follow-up chatter, never a topic:
+ * bare affirmations / short control words (RU + EN) and the "continue" dots.
+ */
+const noiseExactPrompts = new Set([
+    '...', '..', '.', 'yes', 'no', 'ok', 'okay', 'y', 'n', 'go', 'go ahead',
+    'да', 'нет', 'ага', 'угу', 'давай', 'да, давай', 'да, давай.',
+    'commit', 'commit.', 'push', 'пуш', 'коммить', 'коммит', 'обнови my',
+]);
+/** Effort / model slash-command stdout that lost its `<local-command-*>` wrapper. */
+const commandEchoRe = /^set (effort level|model) /i;
+/**
+ * @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.
+ */
+function getSessionTitleLine(rawPrompt) {
+    let text = rawPrompt.trim();
+    text = (0, threadContextPreamble_1.stripThreadContextPreamble)(text);
+    text = text.replace(scheduledRunMarkerRe, '');
+    return text.replace(/\s+/g, ' ').trim();
+}
+/** @description Whether a stripped single-line prompt is tooling noise, not a topic. */
+function checkIsNoisePrompt(line) {
+    const lower = line.toLowerCase();
+    if (noiseExactPrompts.has(lower))
+        return true;
+    if (/^\.+$/.test(line))
+        return true; // pure dots ("continue" signal)
+    if (commandEchoRe.test(line))
+        return true;
+    return noisePromptPrefixes.some(prefix => line.startsWith(prefix));
+}
+/**
+ * @description A session-title candidate from ONE stored prompt: the stripped
+ * single-line topic, or `null` when the prompt is empty or tooling noise.
+ */
+function getSessionTitleCandidate(rawPrompt) {
+    const line = getSessionTitleLine(rawPrompt);
+    if (!line)
+        return null;
+    if (checkIsNoisePrompt(line))
+        return null;
+    return line;
+}
+//# sourceMappingURL=claudeSessionTitle.js.map

package/dist/utils/claudeSessionTitle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeSessionTitle.js","sourceRoot":"","sources":["../../src/utils/claudeSessionTitle.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAgDH,kDAKC;AAeD,4DAKC;AAvED,oEAAsE;AAEtE;;;;GAIG;AACH,MAAM,oBAAoB,GAAG,8BAA8B,CAAC;AAE5D;;;;GAIG;AACH,MAAM,mBAAmB,GAAG;IAC1B,2BAA2B,EAAE,oDAAoD;IACjF,iBAAiB;IACjB,kBAAkB;IAClB,sBAAsB;IACtB,iBAAiB,EAAE,2DAA2D;IAC9E,WAAW;IACX,qBAAqB;IACrB,mBAAmB;IACnB,YAAY;IACZ,gCAAgC;IAChC,4BAA4B;CAC7B,CAAC;AAEF;;;GAGG;AACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC;IAChC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU;IACvE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY;IAC7D,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW;CACrE,CAAC,CAAC;AAEH,qFAAqF;AACrF,MAAM,aAAa,GAAG,6BAA6B,CAAC;AAEpD;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,SAAiB;IACnD,IAAI,IAAI,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,GAAG,IAAA,kDAA0B,EAAC,IAAI,CAAC,CAAC;IACxC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC;IAC9C,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED,wFAAwF;AACxF,SAAS,kBAAkB,CAAC,IAAY;IACtC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACjC,IAAI,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9C,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,gCAAgC;IACrE,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1C,OAAO,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;AACrE,CAAC;AAED;;;GAGG;AACH,SAAgB,wBAAwB,CAAC,SAAiB;IACxD,MAAM,IAAI,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC5C,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,IAAI,kBAAkB,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1C,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/utils/claudeStreamJson.d.ts

@@ -0,0 +1,214 @@
+/**
+ * @description Pure parser for the `claude` CLI's
+ * `--output-format stream-json` protocol (the `claude-json-stream` adapter's
+ * event core). Kept dependency-free and side-effect-free so it is unit-testable
+ * against REAL captured stream-json samples (see `claudeStreamJson.test.ts`):
+ * the adapter feeds every stdout chunk through {@link ClaudeStreamLineReader}
+ * (partial-line buffering across chunks) and each complete line through
+ * {@link classifyClaudeStreamMessage}, which maps ONE stream-json message to a
+ * list of backend-neutral {@link ClaudeStreamAction}s the adapter then turns
+ * into `AgentAdapter` events.
+ *
+ * The wire format was reverse-engineered from a live `claude -p
+ * --input-format stream-json --output-format stream-json` run (v2.1.201) and
+ * cross-read against `@anthropic-ai/claude-agent-sdk` `sdk.d.ts` /`sdk.mjs`.
+ * Every event type below is backed by a captured sample.
+ */
+/** Narrow an untyped `JSON.parse` result to a plain object (parse-boundary
+ *  pattern for untrusted process output; mirrors `checkIsRecord` elsewhere). */
+export declare function checkIsStreamRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * @description Newline-delimited-JSON reader with partial-line buffering. The
+ * CLI writes one JSON object per line, but a stdout chunk can split a line at
+ * any byte (a mid-line truncation), so a naive `chunk.split('\n')` would try to
+ * `JSON.parse` half a line. {@link push} returns only the COMPLETE lines seen so
+ * far and retains the trailing partial in {@link buffer} until its newline
+ * arrives in a later chunk.
+ */
+export declare class ClaudeStreamLineReader {
+    private buffer;
+    /** Feed a stdout chunk; return every complete (newline-terminated) line it
+     *  completed, retaining any trailing partial for the next call. Blank lines
+     *  are dropped. */
+    push(chunk: string): string[];
+    /** Any buffered, not-yet-terminated content (diagnostic only). */
+    get pending(): string;
+}
+/** Parse one NDJSON line to a record, or `null` for blank / malformed
+ *  (a torn line that slipped past the reader) — never throws. */
+export declare function parseStreamJsonLine(line: string): Record<string, unknown> | null;
+/**
+ * @description Backend-neutral action produced from ONE stream-json message.
+ * The adapter turns these into `AgentAdapter` events (accumulation / debounce /
+ * control-channel handling stay in the adapter; classification stays pure here).
+ */
+export type ClaudeStreamAction = 
+/** `system/init` — the session is up (first one carries the authoritative id).
+ *  `claudeCodeVersion` is the CLI's own version (`claude_code_version`) — the
+ *  auto-stop gate reads it (`utils/claudeCodeVersion.ts`). */
+{
+    kind: 'init';
+    sessionId: string | null;
+    model: string | null;
+    apiKeySource: string | null;
+    claudeCodeVersion: string | null;
+}
+/** A streamed answer-text delta (`content_block_delta` `text_delta`). */
+ | {
+    kind: 'textDelta';
+    text: string;
+    isSubagent: boolean;
+}
+/** A streamed reasoning delta (`content_block_delta` `thinking_delta`). */
+ | {
+    kind: 'thinkingDelta';
+    text: string;
+    isSubagent: boolean;
+}
+/** A settled assistant `tool_use` block → drives the transient tool status. */
+ | {
+    kind: 'toolUse';
+    tool: string;
+    toolUseId: string;
+    isSubagent: boolean;
+}
+/** A `tool_result` fed back in a `user` message → the `toolResult` event. */
+ | {
+    kind: 'toolResult';
+    toolUseId: string;
+    output: string;
+    isSubagent: boolean;
+}
+/** The turn ended (`result`); `resultText` is the final answer text; `usage`
+ *  is the turn's token accounting (`null` when the frame carries none). */
+ | {
+    kind: 'turnEnd';
+    isError: boolean;
+    errorText: string | null;
+    resultText: string | null;
+    usage: ClaudeTurnUsage | null;
+}
+/**
+ * `system/background_tasks_changed` — the CLI's CURRENT list of background
+ * tasks (a background Bash / Monitor = `local_bash`, a background sub-agent =
+ * `local_agent`), re-sent whole on every change; an empty list means nothing
+ * runs in the background. A finished task starts its own turn
+ * (`task_notification`). Probed on Claude Code 2.1.287 — older CLIs never emit
+ * it, which is why auto-stop is gated on the version.
+ */
+ | {
+    kind: 'backgroundTasks';
+    taskIds: string[];
+}
+/** A control_request off stdout (permission / AskUserQuestion / dialog). */
+ | {
+    kind: 'controlRequest';
+    requestId: string;
+    subtype: string;
+    toolName?: string;
+    input?: Record<string, unknown>;
+    toolUseId?: string;
+    dialogKind?: string;
+}
+/**
+ * A control_response off stdout — the CLI's reply to a control_request the BOT
+ * wrote (the `initialize` handshake, the MCP `mcp_status` / `mcp_reconnect`
+ * round-trips). `payload` is the INNER `response` record, present only for a
+ * data-returning subtype. (The adapter also WRITES frames of this type to
+ * stdin when answering a `can_use_tool`; that is an unrelated write path.)
+ */
+ | {
+    kind: 'controlResponse';
+    requestId: string;
+    isSuccess: boolean;
+    payload: Record<string, unknown> | null;
+}
+/** `system/status` carrying a `/compact` outcome (`compact_result` /
+ *  `compact_error`) — how the json-stream backend confirms a compaction ran. */
+ | {
+    kind: 'compactStatus';
+    result: string | null;
+    error: string | null;
+}
+/** `system/compact_boundary` — a completed compaction; `compact_metadata`
+ *  carries `trigger` (manual/auto) and pre/post token counts. */
+ | {
+    kind: 'compactBoundary';
+    trigger: string | null;
+    preTokens: number | null;
+    postTokens: number | null;
+}
+/** `system/api_retry` — a provider retry the CLI is performing. */
+ | {
+    kind: 'apiRetry';
+    text: string;
+}
+/**
+ * `rate_limit_event` — subscription usage window signal, one per API request. `status` is `allowed` /
+ * `allowed_warning` / `rejected`, `rateLimitType` + `resetsAtMs` name the window the status is about, and
+ * `windows` lifts `rate_limit_info.unifiedWindows` (`five_hour`, `seven_day`, `seven_day_overage_included`
+ * with `utilization` 0..1 and a reset instant) — the per-profile usage cache feeds on them (`utils/claudeUsage.ts`).
+ */
+ | {
+    kind: 'rateLimit';
+    rateLimitType: string | null;
+    utilization: number | null;
+    status: string | null;
+    resetsAtMs: number | null;
+    windows: Array<{
+        name: string;
+        utilization: number;
+        resetsAtMs: number | null;
+    }>;
+}
+/** `--replay-user-messages` echo of a message the BOT wrote — the input-ack
+ *  signal (see {@link checkIsOwnInputEcho} for the user lines that are not). */
+ | {
+    kind: 'userEcho';
+};
+/**
+ * @description The token accounting of one turn, from `result.usage` — or, when
+ * that is all zero, the sum of the result's per-model `modelUsage` entries: a
+ * `/compact` turn's result reports its summary call only there (probe
+ * 2026-10-05). The cache fields are the cross-process prompt-cache proof: a
+ * resumed process whose `cacheReadTokens` covers the context read the previous
+ * process's cache.
+ */
+export interface ClaudeTurnUsage {
+    inputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    outputTokens: number;
+}
+/**
+ * @description Map ONE parsed stream-json message to zero or more
+ * {@link ClaudeStreamAction}s. Pure: no accumulation, no timers, no IO. An
+ * unrecognized / uninteresting message (status, thinking_tokens, message_start,
+ * content_block_start/stop, …) yields `[]`.
+ */
+export declare function classifyClaudeStreamMessage(msg: Record<string, unknown>): ClaudeStreamAction[];
+/** The `response` payload of a `can_use_tool` control_response (allow / deny). */
+export type CanUseToolResponse = {
+    behavior: 'allow';
+    updatedInput: Record<string, unknown>;
+    toolUseID?: string;
+} | {
+    behavior: 'deny';
+    message: string;
+    toolUseID?: string;
+};
+/**
+ * @description Build the `allow` body of a `can_use_tool` control_response.
+ *
+ * The CLI's control-response schema REQUIRES `updatedInput` to be a record on an
+ * allow — omit it and the CLI rejects the whole response ("Tool permission
+ * request failed: ZodError"), which silently blocks the tool it was meant to
+ * permit. This builder makes that field impossible to forget: `input` is echoed
+ * unchanged (`{}` when the request carried none). Used for the generic auto-allow
+ * of ordinary tools and for the empty-question fast-path.
+ */
+export declare function buildCanUseToolAllow(input: Record<string, unknown> | undefined, toolUseId: string | undefined): CanUseToolResponse;
+/** Build the `deny` body of a `can_use_tool` control_response (schema requires
+ *  `message`). Used when the user declines / abandons an AskUserQuestion. */
+export declare function buildCanUseToolDeny(message: string, toolUseId: string | undefined): CanUseToolResponse;
+//# sourceMappingURL=claudeStreamJson.d.ts.map

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

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