charness 0.0.0-stage → 3.1.0

package/dist/utils/claudeRelayRouting.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * @description PURE decision layer that routes the {@link ClaudeChunkSegment}s
+ * of one classified Claude scrape chunk through a thread's display-verbosity
+ * prefs (S4 `/tool_results`). Given the ordered, tagged segments and the
+ * resolved prefs it decides — per segment — whether the lines are RELAYED as
+ * permanent output, TRUNCATED, or FOLDED into the rolling status frame, and
+ * returns the reassembled permanent text plus the latest folded activity line.
+ *
+ * Kept pure (no tmux / emit) so the segment×pref matrix is unit-testable
+ * without the live relay — same shape as `toolResultRender.ts` /
+ * `subagentRender.ts`. The Claude adapter's `pollOutput` calls this, then feeds
+ * `keptText` through `stripTuiElementsWithContext` exactly as the pre-S4 path
+ * did (the stripper stays the chrome/fence backstop).
+ *
+ * Scope: the TOOL, THINKING and PANEL-PREVIEW segments branch on a pref.
+ *  - `thinkingBlock` follows the `/thinking` pref (S5): full keeps it verbatim;
+ *    short collapses to one `💭 thought for {N}s` when a duration is parseable
+ *    from the block, else folds the live `☁️ thinking …` into status; minimal
+ *    always folds the live status, nothing permanent.
+ *  - `subagentPanelPreview` is ALWAYS folded to status (the overview-2 flood;
+ *    S6 formalises, doing it here is part of killing the flood).
+ *  - `prose` is ALWAYS kept (the agent's answer is never swallowed).
+ *  - `chrome` is ALWAYS dropped (as the pre-S4 stripper did).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolActivityLabel = getToolActivityLabel;
+exports.routeClaudeChunkSegments = routeClaudeChunkSegments;
+exports.checkIsClaudeRelayFastPath = checkIsClaudeRelayFastPath;
+const claudeChunkClassifier_1 = require("./claudeChunkClassifier");
+const toolResultRender_1 = require("./toolResultRender");
+const thinkingRender_1 = require("./thinkingRender");
+/** Tool names Claude's known headers carry, used to derive a compact activity
+ * label (`Bash`, `Read`, …). Matches the set in `claudeScrapeShapes.ANY_TOOL_HEADER_RE`. */
+const TOOL_NAME_RE = /\b(Bash|Read|Write|Edit|Update|MultiEdit|NotebookEdit|Glob|Grep|Task|Agent|TodoWrite|WebFetch|WebSearch)\b/;
+/**
+ * @description Extract a compact tool label from a tool-header line for the
+ * folded `minimal` activity line. Returns the tool NAME (`Bash`, `Read`, …)
+ * when recognised, else the trimmed first line as a last resort (never empty).
+ */
+function getToolActivityLabel(headerText) {
+    const firstLine = headerText.split('\n')[0] ?? '';
+    const nameMatch = firstLine.match(TOOL_NAME_RE);
+    if (nameMatch)
+        return nameMatch[1];
+    return firstLine.trim();
+}
+/**
+ * @description Route one classified chunk's segments through the tool-results
+ * mode (S4). Walks the segments IN ORDER so `keptText` preserves the pane's
+ * line order; `activityLine` carries only the LAST folded activity (the status
+ * frame shows one line). Pure — the caller threads cross-poll fence context and
+ * does the strip/emit.
+ *
+ * Per tag:
+ *  - `prose`                → keep verbatim (always).
+ *  - `thinkingBlock`        → full: keep verbatim; short: collapse to one
+ *                             `💭 thought for {N}s` when a duration is parseable,
+ *                             else fold the live `☁️ thinking …`; minimal: always
+ *                             fold the live status, nothing permanent.
+ *  - `toolHeader`/`toolBody`→ full: keep; short: keep header, truncate body;
+ *                             minimal: drop, fold a `🔧 <tool> …` activity from
+ *                             the latest header (built by the caller via i18n).
+ *  - `subagentPanelPreview` → always fold (drop, contribute an activity).
+ *  - `chrome`               → drop.
+ *
+ * @param segments classified segments, original order.
+ * @param toolResultsMode the thread's `/tool_results` pref.
+ * @param thinkingMode the thread's `/thinking` pref (S5).
+ * @param buildToolActivity caller-supplied builder turning a tool label into a
+ *   user-facing activity line (keeps i18n in `bot.ts`/`i18n.ts`, not here).
+ * @param buildPanelActivity caller-supplied builder for a folded panel preview.
+ * @param buildThinkingActivity caller-supplied builder for the folded live
+ *   `☁️ thinking …` status line (short with no duration / minimal).
+ * @param buildThoughtCollapsed caller-supplied builder turning a parsed duration
+ *   into the permanent `💭 thought for {N}s` line (short with a duration).
+ * @param truncationFooter the i18n "… (truncated, /tool_results full)" line
+ *   appended to a `short`-mode body that was actually capped — parity with the
+ *   OpenCode short path so a Claude user also learns `full` reveals the rest.
+ */
+function routeClaudeChunkSegments(segments, toolResultsMode, thinkingMode, buildToolActivity, buildPanelActivity, buildThinkingActivity, buildThoughtCollapsed, truncationFooter) {
+    const keptLines = [];
+    let activityLine = null;
+    /** The most recent tool-header label, so a minimal-mode body folds under its
+     * own header's label even when the header arrived in a separate segment. */
+    let latestToolLabel = null;
+    for (const segment of segments) {
+        switch (segment.tag) {
+            case claudeChunkClassifier_1.ClaudeChunkTag.Prose:
+                keptLines.push(segment.text);
+                break;
+            case claudeChunkClassifier_1.ClaudeChunkTag.ThinkingBlock: {
+                if (thinkingMode === 'full') {
+                    keptLines.push(segment.text);
+                }
+                else {
+                    // short/minimal: collapse to a permanent "💭 thought for {N}s" only
+                    // when short AND a duration is parseable from the scraped block;
+                    // otherwise fold the live "☁️ thinking …" into the status frame.
+                    const seconds = (0, thinkingRender_1.parseThinkingDurationSeconds)(segment.text);
+                    if (thinkingMode === 'short' && seconds !== null) {
+                        keptLines.push(buildThoughtCollapsed(seconds));
+                    }
+                    else {
+                        activityLine = buildThinkingActivity();
+                    }
+                }
+                break;
+            }
+            case claudeChunkClassifier_1.ClaudeChunkTag.ToolHeader: {
+                latestToolLabel = getToolActivityLabel(segment.text);
+                if (toolResultsMode === 'minimal') {
+                    activityLine = buildToolActivity(latestToolLabel);
+                }
+                else {
+                    // full and short both keep the header verbatim (short only caps the
+                    // body — the header names which tool ran).
+                    keptLines.push(segment.text);
+                }
+                break;
+            }
+            case claudeChunkClassifier_1.ClaudeChunkTag.ToolBody: {
+                if (toolResultsMode === 'full') {
+                    keptLines.push(segment.text);
+                }
+                else if (toolResultsMode === 'short') {
+                    const truncated = (0, toolResultRender_1.getTruncatedToolResult)(segment.text);
+                    keptLines.push(truncated.isTruncated ? `${truncated.text}\n${truncationFooter}` : truncated.text);
+                }
+                else {
+                    // minimal: drop the body; fold under the latest header's label (or a
+                    // generic 🔧 when a body's header streamed in a prior poll).
+                    activityLine = buildToolActivity(latestToolLabel ?? '');
+                }
+                break;
+            }
+            case claudeChunkClassifier_1.ClaudeChunkTag.SubagentPanelPreview:
+                activityLine = buildPanelActivity();
+                break;
+            case claudeChunkClassifier_1.ClaudeChunkTag.Chrome:
+                break;
+        }
+    }
+    return { keptText: keptLines.join('\n'), activityLine };
+}
+/**
+ * @description Whether a classified chunk can skip the segment-walk and run the
+ * pre-S4 direct strip→emit path BYTE-IDENTICALLY: all-`full` tool + thinking
+ * prefs AND no sub-agent panel-preview segment (the one thing the old path did
+ * NOT fold). The regression anchor — when true the relay output is provably the
+ * same as before S4. (Re-exported as a named helper so the live fast-path and
+ * its test assert the SAME predicate.)
+ */
+function checkIsClaudeRelayFastPath(segments, toolResultsMode, thinkingMode) {
+    if (toolResultsMode !== 'full' || thinkingMode !== 'full')
+        return false;
+    return !segments.some(segment => segment.tag === claudeChunkClassifier_1.ClaudeChunkTag.SubagentPanelPreview);
+}
+//# sourceMappingURL=claudeRelayRouting.js.map

package/dist/utils/claudeRelayRouting.js.map

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

package/dist/utils/claudeRuntimeInfo.d.ts

@@ -0,0 +1,26 @@
+import type { AgentRuntimeInfo } from '../types';
+export declare const claudeRuntimeInfoTailBytes: number;
+/**
+ * @description Return the documented context window for an exact Claude model
+ * family. Unknown aliases and model ids deliberately stay unknown rather than
+ * inheriting a default from a neighbouring model.
+ *
+ * The minor group is capped at two digits so a released id whose family carries
+ * no minor at all (`claude-opus-4-20250514`) can never have its 8-digit DATE
+ * read as the minor — that misread reported a 1M window for a 200k model.
+ * Such an id has no minor to match on, so it stays honestly unknown.
+ */
+export declare function getClaudeContextWindowTokens(model: string): number | null;
+/**
+ * @description Parse the latest valid main-session runtime fields from a Claude
+ * transcript. Sidechain records are not part of the topic's live conversation,
+ * so their version, model, and usage must never overwrite main-session data.
+ */
+export declare function parseClaudeRuntimeInfo(transcript: string): AgentRuntimeInfo;
+/**
+ * @description Read only the transcript tail needed for the latest runtime
+ * metadata. A nonzero read offset can start in a JSONL record, so that partial
+ * first line is discarded before parsing.
+ */
+export declare function readClaudeRuntimeInfo(filePath: string): Promise<AgentRuntimeInfo>;
+//# sourceMappingURL=claudeRuntimeInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeRuntimeInfo.d.ts","sourceRoot":"","sources":["../../src/utils/claudeRuntimeInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIjD,eAAO,MAAM,0BAA0B,QAAa,CAAC;AAyBrD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQzE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAiC3E;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmBvF"}

package/dist/utils/claudeRuntimeInfo.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeRuntimeInfoTailBytes = void 0;
+exports.getClaudeContextWindowTokens = getClaudeContextWindowTokens;
+exports.parseClaudeRuntimeInfo = parseClaudeRuntimeInfo;
+exports.readClaudeRuntimeInfo = readClaudeRuntimeInfo;
+const fs = __importStar(require("fs"));
+const claude45ContextWindowTokens = 200_000;
+const claude46AndLaterContextWindowTokens = 1_000_000;
+exports.claudeRuntimeInfoTailBytes = 128 * 1024;
+function checkIsRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function checkIsTokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+function getClaudeContextUsedTokens(usage) {
+    if (!checkIsRecord(usage) || !checkIsTokenCount(usage.input_tokens))
+        return null;
+    const outputTokens = usage.output_tokens;
+    const cacheReadTokens = usage.cache_read_input_tokens;
+    const cacheCreationTokens = usage.cache_creation_input_tokens;
+    if ((outputTokens !== undefined && !checkIsTokenCount(outputTokens)) ||
+        (cacheReadTokens !== undefined && !checkIsTokenCount(cacheReadTokens)) ||
+        (cacheCreationTokens !== undefined && !checkIsTokenCount(cacheCreationTokens))) {
+        return null;
+    }
+    return usage.input_tokens + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0) + (outputTokens ?? 0);
+}
+/**
+ * @description Return the documented context window for an exact Claude model
+ * family. Unknown aliases and model ids deliberately stay unknown rather than
+ * inheriting a default from a neighbouring model.
+ *
+ * The minor group is capped at two digits so a released id whose family carries
+ * no minor at all (`claude-opus-4-20250514`) can never have its 8-digit DATE
+ * read as the minor — that misread reported a 1M window for a 200k model.
+ * Such an id has no minor to match on, so it stays honestly unknown.
+ */
+function getClaudeContextWindowTokens(model) {
+    const match = model.toLowerCase().match(/(?:^|\/)claude-(?:opus|sonnet|haiku)-(\d+)-(\d{1,2})(?:-|$)/);
+    if (!match)
+        return null;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    if (major === 4 && minor === 5)
+        return claude45ContextWindowTokens;
+    if (major === 5 || (major === 4 && minor >= 6))
+        return claude46AndLaterContextWindowTokens;
+    return null;
+}
+/**
+ * @description Parse the latest valid main-session runtime fields from a Claude
+ * transcript. Sidechain records are not part of the topic's live conversation,
+ * so their version, model, and usage must never overwrite main-session data.
+ */
+function parseClaudeRuntimeInfo(transcript) {
+    let version = null;
+    let latestContextEntry = null;
+    for (const line of transcript.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!checkIsRecord(entry) || entry.isSidechain === true)
+            continue;
+        if (typeof entry.version === 'string' && entry.version.trim()) {
+            version = entry.version;
+        }
+        if (entry.type !== 'assistant' || !checkIsRecord(entry.message))
+            continue;
+        const model = entry.message.model;
+        const usedTokens = getClaudeContextUsedTokens(entry.message.usage);
+        if (typeof model === 'string' && model.trim() && usedTokens !== null) {
+            latestContextEntry = { model, contextUsedTokens: usedTokens };
+        }
+    }
+    return {
+        version,
+        model: latestContextEntry?.model ?? null,
+        contextWindowTokens: latestContextEntry === null ? null : getClaudeContextWindowTokens(latestContextEntry.model),
+        contextUsedTokens: latestContextEntry?.contextUsedTokens ?? null,
+    };
+}
+/**
+ * @description Read only the transcript tail needed for the latest runtime
+ * metadata. A nonzero read offset can start in a JSONL record, so that partial
+ * first line is discarded before parsing.
+ */
+async function readClaudeRuntimeInfo(filePath) {
+    let fileHandle = null;
+    try {
+        fileHandle = await fs.promises.open(filePath, 'r');
+        const { size } = await fileHandle.stat();
+        const bytesToRead = Math.min(size, exports.claudeRuntimeInfoTailBytes);
+        if (bytesToRead === 0)
+            return parseClaudeRuntimeInfo('');
+        const offset = size - bytesToRead;
+        const buffer = Buffer.alloc(bytesToRead);
+        const { bytesRead } = await fileHandle.read(buffer, 0, bytesToRead, offset);
+        const text = buffer.toString('utf8', 0, bytesRead);
+        if (offset === 0)
+            return parseClaudeRuntimeInfo(text);
+        const firstLineBreak = text.indexOf('\n');
+        return parseClaudeRuntimeInfo(firstLineBreak === -1 ? '' : text.slice(firstLineBreak + 1));
+    }
+    finally {
+        if (fileHandle)
+            await fileHandle.close();
+    }
+}
+//# sourceMappingURL=claudeRuntimeInfo.js.map

package/dist/utils/claudeRuntimeInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeRuntimeInfo.js","sourceRoot":"","sources":["../../src/utils/claudeRuntimeInfo.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,oEAQC;AAOD,wDAiCC;AAOD,sDAmBC;AAlHD,uCAAyB;AAGzB,MAAM,2BAA2B,GAAG,OAAO,CAAC;AAC5C,MAAM,mCAAmC,GAAG,SAAS,CAAC;AACzC,QAAA,0BAA0B,GAAG,GAAG,GAAG,IAAI,CAAC;AAErD,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAc;IACvC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AACtG,CAAC;AAED,SAAS,0BAA0B,CAAC,KAAc;IAChD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IACjF,MAAM,YAAY,GAAG,KAAK,CAAC,aAAa,CAAC;IACzC,MAAM,eAAe,GAAG,KAAK,CAAC,uBAAuB,CAAC;IACtD,MAAM,mBAAmB,GAAG,KAAK,CAAC,2BAA2B,CAAC;IAC9D,IACE,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;QAChE,CAAC,eAAe,KAAK,SAAS,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC;QACtE,CAAC,mBAAmB,KAAK,SAAS,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,EAC9E,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC,YAAY,GAAG,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,CAAC,mBAAmB,IAAI,CAAC,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC;AACxG,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,4BAA4B,CAAC,KAAa;IACxD,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,6DAA6D,CAAC,CAAC;IACvG,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,2BAA2B,CAAC;IACnE,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAAE,OAAO,mCAAmC,CAAC;IAC3F,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,UAAkB;IACvD,IAAI,OAAO,GAAkB,IAAI,CAAC;IAClC,IAAI,kBAAkB,GAAwD,IAAI,CAAC;IAEnF,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO;YAAE,SAAS;QACvB,IAAI,KAAc,CAAC;QACnB,IAAI,CAAC;YACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;QAAC,MAAM,CAAC;YACP,SAAS;QACX,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,WAAW,KAAK,IAAI;YAAE,SAAS;QAElE,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;YAC9D,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC1B,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC;YAAE,SAAS;QAE1E,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAClC,MAAM,UAAU,GAAG,0BAA0B,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACnE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACrE,kBAAkB,GAAG,EAAE,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,CAAC;QAChE,CAAC;IACH,CAAC;IAED,OAAO;QACL,OAAO;QACP,KAAK,EAAE,kBAAkB,EAAE,KAAK,IAAI,IAAI;QACxC,mBAAmB,EAAE,kBAAkB,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,4BAA4B,CAAC,kBAAkB,CAAC,KAAK,CAAC;QAChH,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,IAAI,IAAI;KACjE,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,qBAAqB,CAAC,QAAgB;IAC1D,IAAI,UAAU,GAAkC,IAAI,CAAC;IACrD,IAAI,CAAC;QACH,UAAU,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QACnD,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;QACzC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,kCAA0B,CAAC,CAAC;QAC/D,IAAI,WAAW,KAAK,CAAC;YAAE,OAAO,sBAAsB,CAAC,EAAE,CAAC,CAAC;QAEzD,MAAM,MAAM,GAAG,IAAI,GAAG,WAAW,CAAC;QAClC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACzC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;QAC5E,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;QACnD,IAAI,MAAM,KAAK,CAAC;YAAE,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC;QAEtD,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1C,OAAO,sBAAsB,CAAC,cAAc,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7F,CAAC;YAAS,CAAC;QACT,IAAI,UAAU;YAAE,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;IAC3C,CAAC;AACH,CAAC"}

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