charness 0.0.0-stage → 3.0.0

package/dist/utils/claudeMcpHeal.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @description The wire shapes + the decision behind healing a `claude` session
+ * whose bot-injected MCP server (`telegramBot`) has latched `failed`.
+ *
+ * WHY this exists: a json-stream session is an EXTERNAL process, so it survives
+ * every bot restart — but the MCP client inside it does not retry a server it
+ * once failed to reach. A session that was alive across a restart therefore kept
+ * reporting `{name:'telegramBot', status:'failed'}` for the rest of its life and
+ * lost `schedule_*` / `compact_conversation` / `send_file_to_user` /
+ * `send_messages_to_user` with nothing short of replacing the session to bring
+ * them back. The CLI answers `mcp_status` / `mcp_reconnect` on the SAME stdio
+ * control channel the adapter already uses for permissions, and a reconnect
+ * measurably moves the server `failed` → `connected`.
+ *
+ * The request/response format is reverse-engineered (measured against a live
+ * `claude` process, not documented anywhere), so it lives in exactly ONE tested
+ * place — the adapter only mints ids, writes the frames, and reads the verdict.
+ * Pure: no IO, no timers, no adapter imports.
+ */
+/**
+ * @description How long to wait for ONE control round-trip before treating the
+ * server status as unknown. The channel is loopback stdio answered by a process
+ * that is already running, so a healthy reply lands in milliseconds — this is a
+ * generous upper bound that keeps a silent CLI from hanging the caller, not a
+ * tuning knob.
+ */
+export declare const mcpControlRequestTimeoutMs = 15000;
+/** `mcp_status` — ask the CLI for every MCP server it holds and its state. */
+export interface McpStatusControlRequest {
+    type: 'control_request';
+    request_id: string;
+    request: {
+        subtype: 'mcp_status';
+    };
+}
+/** `mcp_reconnect` — make the CLI re-handshake ONE server by name. */
+export interface McpReconnectControlRequest {
+    type: 'control_request';
+    request_id: string;
+    request: {
+        subtype: 'mcp_reconnect';
+        serverName: string;
+    };
+}
+/**
+ * @name McpHealDecision
+ * @description What to do about one server's reported status.
+ */
+export type McpHealDecision = 'reconnect' | 'healthy' | 'skip';
+/**
+ * @name McpHealOutcome
+ * @description What a heal attempt actually achieved — the adapter method's
+ * result, so a caller can log only the sessions it really repaired.
+ *  - `healed` — the server was `failed` and the reconnect answered success.
+ *  - `healthy` — nothing was wrong, no frame written beyond the status ask.
+ *  - `skipped` — the status says a reconnect is not the right move
+ *    ({@link decideMcpHeal}).
+ *  - `unavailable` — the heal could not be completed: no live session, the CLI
+ *    never answered (or refused) the status ask, or the reconnect itself was
+ *    refused. In every case the server is still whatever it was.
+ */
+export type McpHealOutcome = 'healed' | 'healthy' | 'skipped' | 'unavailable';
+/** Build the `mcp_status` control request (`requestId` is echoed back in the
+ *  response's `request_id`, which is how the reply is matched). */
+export declare function buildMcpStatusControlRequest(requestId: string): McpStatusControlRequest;
+/** Build the `mcp_reconnect` control request for ONE server. `serverName` is
+ *  camelCase on the wire (unlike the snake_case envelope fields). */
+export declare function buildMcpReconnectControlRequest(requestId: string, serverName: string): McpReconnectControlRequest;
+/**
+ * @description Read one server's `status` out of an `mcp_status` response
+ * payload (`{mcpServers:[{name, status, …}]}`). Returns `null` when the payload
+ * is absent / not the expected shape, when no entry carries that name, or when
+ * the entry has no string status — every one of which means "unknown", which
+ * {@link decideMcpHeal} deliberately refuses to act on.
+ */
+export declare function getMcpServerStatus(payload: Record<string, unknown> | null, serverName: string): string | null;
+/**
+ * @description Decide what a reported MCP server status calls for.
+ *
+ *  - `connected` → `healthy`: the server completed its handshake, so touching it
+ *    would only risk interrupting live tools.
+ *  - `failed` → `reconnect`: the exact latched state this whole path exists for —
+ *    the CLI never retries it on its own, and a reconnect is measurably what
+ *    brings the tools back.
+ *  - `needs-auth` → `skip`: a human must authorise that server; reconnecting
+ *    would fail again immediately and loop.
+ *  - anything else, INCLUDING `null` → `skip`: an unknown or unreadable status
+ *    must never be guessed into a live session. A future status name is then
+ *    inert rather than wrongly acted on.
+ */
+export declare function decideMcpHeal(status: string | null): McpHealDecision;
+//# sourceMappingURL=claudeMcpHeal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeMcpHeal.d.ts","sourceRoot":"","sources":["../../src/utils/claudeMcpHeal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,QAAQ,CAAC;AAEhD,8EAA8E;AAC9E,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,CAAC;CACpC;AAED,sEAAsE;AACtE,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3D;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;AAO9E;mEACmE;AACnE,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,uBAAuB,CAEvF;AAED;qEACqE;AACrE,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,0BAA0B,CAEjH;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS7G;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,eAAe,CAIpE"}

package/dist/utils/claudeMcpHeal.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * @description The wire shapes + the decision behind healing a `claude` session
+ * whose bot-injected MCP server (`telegramBot`) has latched `failed`.
+ *
+ * WHY this exists: a json-stream session is an EXTERNAL process, so it survives
+ * every bot restart — but the MCP client inside it does not retry a server it
+ * once failed to reach. A session that was alive across a restart therefore kept
+ * reporting `{name:'telegramBot', status:'failed'}` for the rest of its life and
+ * lost `schedule_*` / `compact_conversation` / `send_file_to_user` /
+ * `send_messages_to_user` with nothing short of replacing the session to bring
+ * them back. The CLI answers `mcp_status` / `mcp_reconnect` on the SAME stdio
+ * control channel the adapter already uses for permissions, and a reconnect
+ * measurably moves the server `failed` → `connected`.
+ *
+ * The request/response format is reverse-engineered (measured against a live
+ * `claude` process, not documented anywhere), so it lives in exactly ONE tested
+ * place — the adapter only mints ids, writes the frames, and reads the verdict.
+ * Pure: no IO, no timers, no adapter imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpControlRequestTimeoutMs = void 0;
+exports.buildMcpStatusControlRequest = buildMcpStatusControlRequest;
+exports.buildMcpReconnectControlRequest = buildMcpReconnectControlRequest;
+exports.getMcpServerStatus = getMcpServerStatus;
+exports.decideMcpHeal = decideMcpHeal;
+const claudeStreamJson_1 = require("./claudeStreamJson");
+/**
+ * @description How long to wait for ONE control round-trip before treating the
+ * server status as unknown. The channel is loopback stdio answered by a process
+ * that is already running, so a healthy reply lands in milliseconds — this is a
+ * generous upper bound that keeps a silent CLI from hanging the caller, not a
+ * tuning knob.
+ */
+exports.mcpControlRequestTimeoutMs = 15000;
+/** The status of a server that completed its handshake — nothing to do. */
+const mcpStatusConnected = 'connected';
+/** The status of a server whose connection attempt failed and is never retried. */
+const mcpStatusFailed = 'failed';
+/** Build the `mcp_status` control request (`requestId` is echoed back in the
+ *  response's `request_id`, which is how the reply is matched). */
+function buildMcpStatusControlRequest(requestId) {
+    return { type: 'control_request', request_id: requestId, request: { subtype: 'mcp_status' } };
+}
+/** Build the `mcp_reconnect` control request for ONE server. `serverName` is
+ *  camelCase on the wire (unlike the snake_case envelope fields). */
+function buildMcpReconnectControlRequest(requestId, serverName) {
+    return { type: 'control_request', request_id: requestId, request: { subtype: 'mcp_reconnect', serverName } };
+}
+/**
+ * @description Read one server's `status` out of an `mcp_status` response
+ * payload (`{mcpServers:[{name, status, …}]}`). Returns `null` when the payload
+ * is absent / not the expected shape, when no entry carries that name, or when
+ * the entry has no string status — every one of which means "unknown", which
+ * {@link decideMcpHeal} deliberately refuses to act on.
+ */
+function getMcpServerStatus(payload, serverName) {
+    if (!payload)
+        return null;
+    const servers = payload.mcpServers;
+    if (!Array.isArray(servers))
+        return null;
+    for (const entry of servers) {
+        if (!(0, claudeStreamJson_1.checkIsStreamRecord)(entry) || entry.name !== serverName)
+            continue;
+        return typeof entry.status === 'string' ? entry.status : null;
+    }
+    return null;
+}
+/**
+ * @description Decide what a reported MCP server status calls for.
+ *
+ *  - `connected` → `healthy`: the server completed its handshake, so touching it
+ *    would only risk interrupting live tools.
+ *  - `failed` → `reconnect`: the exact latched state this whole path exists for —
+ *    the CLI never retries it on its own, and a reconnect is measurably what
+ *    brings the tools back.
+ *  - `needs-auth` → `skip`: a human must authorise that server; reconnecting
+ *    would fail again immediately and loop.
+ *  - anything else, INCLUDING `null` → `skip`: an unknown or unreadable status
+ *    must never be guessed into a live session. A future status name is then
+ *    inert rather than wrongly acted on.
+ */
+function decideMcpHeal(status) {
+    if (status === mcpStatusConnected)
+        return 'healthy';
+    if (status === mcpStatusFailed)
+        return 'reconnect';
+    return 'skip';
+}
+//# sourceMappingURL=claudeMcpHeal.js.map

package/dist/utils/claudeMcpHeal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeMcpHeal.js","sourceRoot":"","sources":["../../src/utils/claudeMcpHeal.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAsDH,oEAEC;AAID,0EAEC;AASD,gDASC;AAgBD,sCAIC;AAlGD,yDAAyD;AAEzD;;;;;;GAMG;AACU,QAAA,0BAA0B,GAAG,KAAK,CAAC;AAoChD,2EAA2E;AAC3E,MAAM,kBAAkB,GAAG,WAAW,CAAC;AACvC,mFAAmF;AACnF,MAAM,eAAe,GAAG,QAAQ,CAAC;AAEjC;mEACmE;AACnE,SAAgB,4BAA4B,CAAC,SAAiB;IAC5D,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,CAAC;AAChG,CAAC;AAED;qEACqE;AACrE,SAAgB,+BAA+B,CAAC,SAAiB,EAAE,UAAkB;IACnF,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,EAAE,CAAC;AAC/G,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,kBAAkB,CAAC,OAAuC,EAAE,UAAkB;IAC5F,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IACzC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAA,sCAAmB,EAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;YAAE,SAAS;QACvE,OAAO,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAChE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,aAAa,CAAC,MAAqB;IACjD,IAAI,MAAM,KAAK,kBAAkB;QAAE,OAAO,SAAS,CAAC;IACpD,IAAI,MAAM,KAAK,eAAe;QAAE,OAAO,WAAW,CAAC;IACnD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/utils/claudeRelayRouting.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @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).
+ */
+import { type ClaudeChunkSegment } from './claudeChunkClassifier';
+import type { DisplayVerbosityMode } from '../types';
+/** Result of {@link routeClaudeChunkSegments}. */
+export interface ClaudeRelayRouting {
+    /** The lines to relay as PERMANENT output (reassembled, NL-joined). May be
+     * empty when every routable segment folded to status. */
+    keptText: string;
+    /** The LATEST folded activity (a `minimal` tool header, a panel preview, or a
+     * folded `☁️ thinking …` status) to show in the rolling status frame, or null
+     * when nothing folded. */
+    activityLine: string | null;
+}
+/**
+ * @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).
+ */
+export declare function getToolActivityLabel(headerText: string): string;
+/**
+ * @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.
+ */
+export declare function routeClaudeChunkSegments(segments: ClaudeChunkSegment[], toolResultsMode: DisplayVerbosityMode, thinkingMode: DisplayVerbosityMode, buildToolActivity: (toolLabel: string) => string, buildPanelActivity: () => string, buildThinkingActivity: () => string, buildThoughtCollapsed: (seconds: number) => string, truncationFooter: string): ClaudeRelayRouting;
+/**
+ * @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.)
+ */
+export declare function checkIsClaudeRelayFastPath(segments: ClaudeChunkSegment[], toolResultsMode: DisplayVerbosityMode, thinkingMode: DisplayVerbosityMode): boolean;
+//# sourceMappingURL=claudeRelayRouting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeRelayRouting.d.ts","sourceRoot":"","sources":["../../src/utils/claudeRelayRouting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAOrD,kDAAkD;AAClD,MAAM,WAAW,kBAAkB;IACjC;6DACyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB;;8BAE0B;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,kBAAkB,EAAE,EAC9B,eAAe,EAAE,oBAAoB,EACrC,YAAY,EAAE,oBAAoB,EAClC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,EAChD,kBAAkB,EAAE,MAAM,MAAM,EAChC,qBAAqB,EAAE,MAAM,MAAM,EACnC,qBAAqB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,EAClD,gBAAgB,EAAE,MAAM,GACvB,kBAAkB,CAkEpB;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,kBAAkB,EAAE,EAC9B,eAAe,EAAE,oBAAoB,EACrC,YAAY,EAAE,oBAAoB,GACjC,OAAO,CAGT"}

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