charness 0.0.0-stage → 3.0.0

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,202 @@
+/**
+ * @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 (billing proof). */
+ | {
+    kind: 'rateLimit';
+    rateLimitType: string | null;
+    utilization: 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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"}

package/dist/utils/claudeStreamJson.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeStreamLineReader = void 0;
+exports.checkIsStreamRecord = checkIsStreamRecord;
+exports.parseStreamJsonLine = parseStreamJsonLine;
+exports.classifyClaudeStreamMessage = classifyClaudeStreamMessage;
+exports.buildCanUseToolAllow = buildCanUseToolAllow;
+exports.buildCanUseToolDeny = buildCanUseToolDeny;
+/** Narrow an untyped `JSON.parse` result to a plain object (parse-boundary
+ *  pattern for untrusted process output; mirrors `checkIsRecord` elsewhere). */
+function checkIsStreamRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * @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.
+ */
+class ClaudeStreamLineReader {
+    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) {
+        this.buffer += chunk;
+        const lines = [];
+        let nl;
+        while ((nl = this.buffer.indexOf('\n')) >= 0) {
+            const line = this.buffer.slice(0, nl);
+            this.buffer = this.buffer.slice(nl + 1);
+            if (line.trim())
+                lines.push(line);
+        }
+        return lines;
+    }
+    /** Any buffered, not-yet-terminated content (diagnostic only). */
+    get pending() {
+        return this.buffer;
+    }
+}
+exports.ClaudeStreamLineReader = ClaudeStreamLineReader;
+/** Parse one NDJSON line to a record, or `null` for blank / malformed
+ *  (a torn line that slipped past the reader) — never throws. */
+function parseStreamJsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    return checkIsStreamRecord(parsed) ? parsed : null;
+}
+/**
+ * @description Whether a non-tool-result `user` line is the
+ * `--replay-user-messages` echo of a message the bot wrote. The stream also
+ * carries `user` lines the CLI produced on its own, and counting one of those as
+ * our echo marks a message still waiting mid-turn as taken in (live
+ * `stdout.jsonl` logs): `isSynthetic` lines (a skill being loaded, the summary
+ * that opens a compacted session, `isReplay:false`), a sub-agent's own prompt
+ * and markers (`parent_tool_use_id` set), and a replayed background-task
+ * notification (`origin` set). Only POSITIVE evidence excludes a line, so a CLI
+ * that stamps none of these fields keeps counting every echo rather than none.
+ */
+function checkIsOwnInputEcho(msg) {
+    return msg.parent_tool_use_id == null
+        && msg.isSynthetic !== true
+        && msg.isReplay !== false
+        && msg.origin === undefined;
+}
+/** Read a non-negative integer field, defaulting an ABSENT field to 0 and
+ *  rejecting any other shape (`null`). */
+function readTokenCount(rec, key) {
+    const value = rec[key];
+    if (value === undefined)
+        return 0;
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : null;
+}
+/** Parse `result.usage`; `null` when absent or when any present count is malformed
+ *  (a half-read accounting would mislead the cache check — better no line). */
+function readResultUsage(usage) {
+    if (!checkIsStreamRecord(usage))
+        return null;
+    const inputTokens = readTokenCount(usage, 'input_tokens');
+    const cacheReadTokens = readTokenCount(usage, 'cache_read_input_tokens');
+    const cacheWriteTokens = readTokenCount(usage, 'cache_creation_input_tokens');
+    const outputTokens = readTokenCount(usage, 'output_tokens');
+    if (inputTokens === null || cacheReadTokens === null || cacheWriteTokens === null || outputTokens === null)
+        return null;
+    return { inputTokens, cacheReadTokens, cacheWriteTokens, outputTokens };
+}
+/** The turn's total over `result.modelUsage` (one entry per model used); `null` when absent or any entry is malformed. */
+function readModelUsageTotal(modelUsage) {
+    if (!checkIsStreamRecord(modelUsage))
+        return null;
+    const total = { inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0 };
+    for (const entry of Object.values(modelUsage)) {
+        if (!checkIsStreamRecord(entry))
+            return null;
+        const inputTokens = readTokenCount(entry, 'inputTokens');
+        const cacheReadTokens = readTokenCount(entry, 'cacheReadInputTokens');
+        const cacheWriteTokens = readTokenCount(entry, 'cacheCreationInputTokens');
+        const outputTokens = readTokenCount(entry, 'outputTokens');
+        if (inputTokens === null || cacheReadTokens === null || cacheWriteTokens === null || outputTokens === null)
+            return null;
+        total.inputTokens += inputTokens;
+        total.cacheReadTokens += cacheReadTokens;
+        total.cacheWriteTokens += cacheWriteTokens;
+        total.outputTokens += outputTokens;
+    }
+    return total;
+}
+function checkIsZeroUsage(usage) {
+    return usage.inputTokens === 0 && usage.cacheReadTokens === 0 && usage.cacheWriteTokens === 0 && usage.outputTokens === 0;
+}
+/** The turn's accounting: `result.usage`, or the `modelUsage` total when `usage` is all zero (a `/compact` turn). */
+function readTurnUsage(usage, modelUsage) {
+    const resultUsage = readResultUsage(usage);
+    if (resultUsage === null || !checkIsZeroUsage(resultUsage))
+        return resultUsage;
+    return readModelUsageTotal(modelUsage) ?? resultUsage;
+}
+/** The `task_id`s of a `background_tasks_changed` frame's `tasks` list; an
+ *  entry without a string id is skipped (it cannot be matched to anything). */
+function readBackgroundTaskIds(tasks) {
+    if (!Array.isArray(tasks))
+        return [];
+    const taskIds = [];
+    for (const task of tasks) {
+        if (checkIsStreamRecord(task) && typeof task.task_id === 'string')
+            taskIds.push(task.task_id);
+    }
+    return taskIds;
+}
+/** Read a string field, or null. */
+function readString(rec, key) {
+    const value = rec[key];
+    return typeof value === 'string' ? value : null;
+}
+/** Concatenate the text of a tool_result `content` (string, or array of
+ *  `{type:'text',text}` / `{type:'tool_result'…}` blocks). */
+function extractToolResultOutput(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === 'string') {
+            parts.push(block);
+            continue;
+        }
+        if (checkIsStreamRecord(block) && typeof block.text === 'string')
+            parts.push(block.text);
+    }
+    return parts.join('');
+}
+/**
+ * @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 `[]`.
+ */
+function classifyClaudeStreamMessage(msg) {
+    const type = msg.type;
+    const isSubagent = msg.parent_tool_use_id != null;
+    if (type === 'system' && msg.subtype === 'init') {
+        return [{
+                kind: 'init',
+                sessionId: readString(msg, 'session_id'),
+                model: readString(msg, 'model'),
+                apiKeySource: readString(msg, 'apiKeySource'),
+                claudeCodeVersion: readString(msg, 'claude_code_version'),
+            }];
+    }
+    if (type === 'system' && msg.subtype === 'background_tasks_changed') {
+        return [{ kind: 'backgroundTasks', taskIds: readBackgroundTaskIds(msg.tasks) }];
+    }
+    if (type === 'system' && msg.subtype === 'status') {
+        // A `/compact` turn reports its outcome on a status frame carrying
+        // `compact_result` (e.g. "success") and, on failure, `compact_error`. Every
+        // other status frame (a plain `status` string) is not interesting.
+        if ('compact_result' in msg || 'compact_error' in msg) {
+            return [{ kind: 'compactStatus', result: readString(msg, 'compact_result'), error: readString(msg, 'compact_error') }];
+        }
+        return [];
+    }
+    if (type === 'system' && msg.subtype === 'compact_boundary') {
+        const meta = checkIsStreamRecord(msg.compact_metadata) ? msg.compact_metadata : {};
+        return [{
+                kind: 'compactBoundary',
+                trigger: readString(meta, 'trigger'),
+                preTokens: typeof meta.pre_tokens === 'number' ? meta.pre_tokens : null,
+                postTokens: typeof meta.post_tokens === 'number' ? meta.post_tokens : null,
+            }];
+    }
+    if (type === 'system' && msg.subtype === 'api_retry') {
+        // The retry carries an `error` description (documented category enum + text).
+        const text = readString(msg, 'error') ?? readString(msg, 'message') ?? JSON.stringify(msg);
+        return [{ kind: 'apiRetry', text }];
+    }
+    if (type === 'rate_limit_event') {
+        const info = checkIsStreamRecord(msg.rate_limit_info) ? msg.rate_limit_info : {};
+        return [{
+                kind: 'rateLimit',
+                rateLimitType: readString(info, 'rateLimitType'),
+                utilization: typeof info.utilization === 'number' ? info.utilization : null,
+            }];
+    }
+    if (type === 'stream_event') {
+        const event = checkIsStreamRecord(msg.event) ? msg.event : null;
+        if (!event || event.type !== 'content_block_delta')
+            return [];
+        const delta = checkIsStreamRecord(event.delta) ? event.delta : null;
+        if (!delta)
+            return [];
+        if (delta.type === 'text_delta' && typeof delta.text === 'string') {
+            return delta.text ? [{ kind: 'textDelta', text: delta.text, isSubagent }] : [];
+        }
+        if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+            return delta.thinking ? [{ kind: 'thinkingDelta', text: delta.thinking, isSubagent }] : [];
+        }
+        return [];
+    }
+    if (type === 'assistant') {
+        // The settled assistant message. Text/thinking already streamed via deltas;
+        // here we only surface tool_use blocks (transient tool status).
+        const message = checkIsStreamRecord(msg.message) ? msg.message : null;
+        const content = message && Array.isArray(message.content) ? message.content : [];
+        const actions = [];
+        for (const block of content) {
+            if (!checkIsStreamRecord(block))
+                continue;
+            if (block.type === 'tool_use' && typeof block.name === 'string' && typeof block.id === 'string') {
+                actions.push({ kind: 'toolUse', tool: block.name, toolUseId: block.id, isSubagent });
+            }
+        }
+        return actions;
+    }
+    if (type === 'user') {
+        // Either a `--replay-user-messages` echo OR a tool_result fed back to the model.
+        const message = checkIsStreamRecord(msg.message) ? msg.message : null;
+        const content = message ? message.content : undefined;
+        if (Array.isArray(content)) {
+            const actions = [];
+            for (const block of content) {
+                if (checkIsStreamRecord(block) && block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+                    actions.push({ kind: 'toolResult', toolUseId: block.tool_use_id, output: extractToolResultOutput(block.content), isSubagent });
+                }
+            }
+            if (actions.length > 0)
+                return actions;
+        }
+        return checkIsOwnInputEcho(msg) ? [{ kind: 'userEcho' }] : [];
+    }
+    if (type === 'result') {
+        return [{
+                kind: 'turnEnd',
+                isError: msg.is_error === true,
+                errorText: readString(msg, 'api_error_status') ?? (msg.is_error === true ? (readString(msg, 'result') ?? 'API error') : null),
+                resultText: readString(msg, 'result'),
+                usage: readTurnUsage(msg.usage, msg.modelUsage),
+            }];
+    }
+    if (type === 'control_request') {
+        const request = checkIsStreamRecord(msg.request) ? msg.request : null;
+        const requestId = readString(msg, 'request_id');
+        const subtype = request ? readString(request, 'subtype') : null;
+        if (!request || !requestId || !subtype)
+            return [];
+        const action = { kind: 'controlRequest', requestId, subtype };
+        const toolName = readString(request, 'tool_name');
+        if (toolName)
+            action.toolName = toolName;
+        if (checkIsStreamRecord(request.input))
+            action.input = request.input;
+        const toolUseId = readString(request, 'tool_use_id');
+        if (toolUseId)
+            action.toolUseId = toolUseId;
+        const dialogKind = readString(request, 'dialog_kind');
+        if (dialogKind)
+            action.dialogKind = dialogKind;
+        return [action];
+    }
+    if (type === 'control_response') {
+        // Measured shape: `{response:{subtype:'success'|'error', request_id,
+        // response?:{…}}}` — the OUTER `response` carries the verdict + the id to
+        // match, the INNER one the returned record (present for `mcp_status`,
+        // ABSENT for a plain `mcp_reconnect` ack). Without a `request_id` the frame
+        // cannot be matched to the request it answers, so it is not actionable —
+        // same defensive rule as the `control_request` branch above.
+        const response = checkIsStreamRecord(msg.response) ? msg.response : null;
+        const requestId = response ? readString(response, 'request_id') : null;
+        if (!response || !requestId)
+            return [];
+        return [{
+                kind: 'controlResponse',
+                requestId,
+                isSuccess: readString(response, 'subtype') === 'success',
+                payload: checkIsStreamRecord(response.response) ? response.response : null,
+            }];
+    }
+    return [];
+}
+/**
+ * @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.
+ */
+function buildCanUseToolAllow(input, toolUseId) {
+    const response = { behavior: 'allow', updatedInput: input ?? {} };
+    if (toolUseId)
+        response.toolUseID = toolUseId;
+    return response;
+}
+/** Build the `deny` body of a `can_use_tool` control_response (schema requires
+ *  `message`). Used when the user declines / abandons an AskUserQuestion. */
+function buildCanUseToolDeny(message, toolUseId) {
+    const response = { behavior: 'deny', message };
+    if (toolUseId)
+        response.toolUseID = toolUseId;
+    return response;
+}
+//# sourceMappingURL=claudeStreamJson.js.map