charness 0.0.0-stage → 3.0.0

package/dist/adapters/claudeJsonStreamAdapter.d.ts

@@ -0,0 +1,548 @@
+import { EventEmitter } from 'events';
+import type { AgentAdapter, AgentSession, AgentRuntimeInfo, CompactionResult, DisplayPrefsReader, JsonStreamTailOffset, JsonStreamTailWriter, OpenCodeQuestion, RecentTurn, ReattachRecap, ResumeSessionOptions, SeenWatermark, SeenWatermarkWriter } from '../types';
+import type { SessionKey } from '../sessionKey';
+import { ClaudeStreamLineReader } from '../utils/claudeStreamJson';
+import { type McpHealOutcome } from '../utils/claudeMcpHeal';
+import { type JsonStreamSessionPaths, type StdoutTailState } from '../utils/jsonStreamHost';
+import { type SessionLaunchDefaultsReader } from './sessionLaunchDefaults';
+/** The two lifecycles of the json-stream host (see {@link ClaudeJsonStreamAdapter.lifecycle}). */
+export type JsonStreamLifecycle = 'idle' | 'perTurn';
+/** Prefix of the per-turn token accounting line (L-D11); the process-level e2e
+ *  and the live cache check read it. */
+export declare const claudeJsonStreamUsageLogPrefix = "[ClaudeJson] usage ";
+/** Awaiter bookkeeping for a bot-issued compaction (see {@link StreamSession.pendingCompaction}). */
+interface PendingStreamCompaction {
+    resolve: (result: CompactionResult) => void;
+    /** The repeating silence watchdog (an INTERVAL, cleared on every resolve path). */
+    timer: NodeJS.Timeout | null;
+    /** Set when a `compact_status` reported `success` (wait for the boundary's tokens). */
+    sawSuccess: boolean;
+}
+/** The settled reply to a bot-issued control request (see
+ *  {@link ClaudeJsonStreamAdapter.requestControl}). */
+interface ControlResponseOutcome {
+    /** The response envelope's `subtype` was `success` (vs `error`). */
+    isSuccess: boolean;
+    /** The INNER `response` record, `null` for a plain ack that returns no data. */
+    payload: Record<string, unknown> | null;
+}
+/** Awaiter bookkeeping for ONE bot-issued control request, keyed by its
+ *  `request_id` in {@link StreamSession.pendingControlRequests}. */
+interface PendingControlRequest {
+    resolve: (outcome: ControlResponseOutcome | null) => void;
+    timer: NodeJS.Timeout;
+}
+/** The pending answer to a live AskUserQuestion control_request. */
+interface PendingStreamQuestion {
+    /** The control_request `request_id` the control_response must echo. */
+    requestId: string;
+    /** The AskUserQuestion `tool_use_id` (echoed as `toolUseID`). */
+    toolUseId: string;
+    /** The raw `input` (`{questions:[…]}`) — passed back verbatim + `answers`. */
+    rawInput: Record<string, unknown>;
+    /** The parsed questions (order matches the answer matrix). */
+    questions: OpenCodeQuestion[];
+}
+export interface StreamSession {
+    key: SessionKey;
+    workDir: string;
+    /** The `--session-id` UUID (== Claude on-disk transcript id, shared with the
+     *  tmux backend's `claudeSessionId`). */
+    sessionId: string;
+    /** pid of the external claude process (from the wrapper's `pid` file). */
+    pid: number;
+    /** Host-file layout (stdin fifo / stdout log / pid / exitcode / …). */
+    paths: JsonStreamSessionPaths;
+    /** Non-blocking write fd on the stdin FIFO. */
+    fifoFd: number;
+    /** Serialises FIFO writes so control frames and user turns keep wire order. */
+    stdinWriteChain: Promise<void>;
+    /** `stdout.jsonl` tail bookkeeping (byte offsets + stateful utf8 decode). */
+    tail: StdoutTailState;
+    pollTimer: NodeJS.Timeout | null;
+    pollDelayMs: number;
+    unchangedStreak: number;
+    /** One-shot oversize warning (no stdout rotation in v1 — locked decision). */
+    isOversizeWarned: boolean;
+    /** Last line-boundary offset handed to the tail writer (monotonic guard). */
+    lastPersistedTailOffset: number;
+    reader: ClaudeStreamLineReader;
+    isActive: boolean;
+    /** True between an explicit stop and process exit → emit `stopped` not `closed`. */
+    isStopping: boolean;
+    /** True when the stop is a SUSPEND (idle stop, the session kept resumable) → emit `suspended`, not `stopped`. */
+    isSuspending: boolean;
+    /** True while re-spawning for a model/effort change → suppress closed/stopped. */
+    isRespawning: boolean;
+    /** True from a user turn sent until its `result` → drives `checkIsBusy`. */
+    isBusy: boolean;
+    /** `Date.now()` of the last consumed stdout byte / turn-start kick. Feeds the
+     *  idle watchdog (`utils/jsonStreamBusyWatchdog`): stdout silence with nothing
+     *  in flight is how a stuck-busy session (a missed terminal `result`) is
+     *  detected and cleared, so the typing indicator can't hang for an hour. */
+    lastStdoutActivityAt: number;
+    /** `tool_use` ids started but whose `tool_result` hasn't returned. A non-empty
+     *  set means the agent is legitimately waiting on a tool (possibly silent, e.g.
+     *  a long Bash) → the idle watchdog must NOT clear busy. */
+    outstandingToolUseIds: Set<string>;
+    /** The model PINNED by an explicit `/model` pick — the `--model` spawn flag,
+     *  replayed verbatim on every effort/model re-spawn. `null` means "no pick,
+     *  claude runs its own default", so it must NOT be overwritten with the
+     *  resolved live id (that would silently pin the session to one snapshot). */
+    model: string | null;
+    /** The model claude itself reports in `system/init` (the resolved id, e.g.
+     *  `claude-opus-4-5-20251101`) — the only source of the LIVE model when no
+     *  explicit pick was made, which is every default start, every resume, and
+     *  every boot-time adopt. Read by {@link ClaudeJsonStreamAdapter.getCurrentModel}
+     *  so `/status` and the pinned banner can name the running model at all. */
+    reportedModel: string | null;
+    effort: string | null;
+    currentResponseText: string;
+    emittedLength: number;
+    outputTimer: NodeJS.Timeout | null;
+    reasoningText: string;
+    reasoningStartedAt: number | null;
+    reasoningTimer: NodeJS.Timeout | null;
+    reasoningActive: boolean;
+    toolNamesById: Map<string, string>;
+    /** AskUserQuestion `tool_use_id`s — their tool_result is the internal
+     *  "questions have been answered" echo, never rendered as a tool result. */
+    questionToolUseIds: Set<string>;
+    subagentActive: boolean;
+    childResponseText: string;
+    childEmittedLength: number;
+    childOutputTimer: NodeJS.Timeout | null;
+    pendingInitResolve: (() => void) | null;
+    initRequestId: string | null;
+    /** Control requests the BOT wrote that are awaiting their `control_response`,
+     *  keyed by `request_id` (the `initialize` handshake keeps its own resolver
+     *  above, since it predates this map and settles a plain `void`). Per session
+     *  object, so nothing can be read against a replaced session. */
+    pendingControlRequests: Map<string, PendingControlRequest>;
+    /** True from a bot-issued `/compact` turn until its terminal signal — suppresses
+     *  the compaction turn's own output so only the bot's confirmation shows. */
+    compactionInProgress: boolean;
+    /** Awaiter for the in-flight bot-issued compaction, resolved by the CLI's
+     *  `compact_boundary` / failing `compact_status` / turn end / timeout. */
+    pendingCompaction: PendingStreamCompaction | null;
+    pendingQuestion: PendingStreamQuestion | null;
+    apiErrorFired: boolean;
+    /**
+     * One-shot: swallow the NEXT terminal `result{is_error}` because it is the
+     * direct consequence of an interrupt WE issued (`sendInterrupt`), not a real
+     * provider error. Without it a user-initiated abort — a `/esc`, or the
+     * question-cancel path's SIGINT — surfaces the CLI's contentless error result
+     * as a bogus "Claude error: API error" line (`claudeStreamJson` falls back to
+     * the literal `'API error'` for an `is_error` result carrying no text).
+     * Consumed by the first `handleTurnEnd` after the interrupt.
+     */
+    swallowNextAbortError: boolean;
+    /** Last transcript byte offset persisted as the seen-watermark (S7 monotonic
+     *  guard). `-1` until the first advance so a never-advanced session writes on
+     *  its first relayed message. */
+    lastWatermarkOffset: number;
+    /**
+     * User messages written to stdin that Claude has not echoed back yet
+     * (`--replay-user-messages`): a message written mid-turn is read only when the
+     * running turn reaches a point to take it in. See `checkHasUnconsumedInput`.
+     */
+    unconsumedInputCount: number;
+    /**
+     * The CLI's live background-task list (`system/background_tasks_changed`,
+     * re-sent whole on every change): a background Bash / Monitor / sub-agent the
+     * process is still running between turns. Non-empty = working (L-D2) — a stop
+     * would kill them. Persisted with the tail offset so an adopt restores it.
+     */
+    backgroundTaskIds: Set<string>;
+    /** The CLI version reported on `system/init` (`claude_code_version`); the
+     *  auto-stop gate (L-D10) reads it. `null` until the first init / on an adopt. */
+    claudeCodeVersion: string | null;
+    /**
+     * Set while `onStdout` applies the lines of one chunk. The line reader hands
+     * the WHOLE chunk's lines over at once, so the line-boundary offset already
+     * sits at the chunk's end while later lines are still unapplied: a persist
+     * requested mid-chunk (a `result`'s flush) would record state the unapplied
+     * lines then change (a `background_tasks_changed` after the result) — and the
+     * monotonic guard would refuse the correct write. The persist is deferred to
+     * the end of the chunk instead.
+     */
+    applyingChunk: {
+        isPersistDeferred: boolean;
+    } | null;
+    /**
+     * An ADOPTED session's stdout size at the adopt (`null` otherwise, or once
+     * reached): the tail must consume up to here before the session's live state
+     * (busy, tasks, input) is trustworthy — see {@link ClaudeJsonStreamAdapter.whenAdoptReplayed}.
+     */
+    adoptCatchUpOffset: number | null;
+    /** Waiters of {@link ClaudeJsonStreamAdapter.whenAdoptReplayed}, settled when the catch-up offset is reached or the session ends. */
+    adoptCatchUpResolvers: Array<() => void>;
+}
+/**
+ * @description SECOND Claude backend: drives the `claude` CLI over its
+ * documented `--input-format stream-json --output-format stream-json` protocol
+ * (typed events, no TUI scrape) as an EXTERNAL tmux-hosted process per
+ * {@link SessionKey} (plan 2026-07-05-jsonstream-restart-isolation): a `#!/bin/sh`
+ * wrapper backgrounds claude with stdin on a FIFO the process itself holds
+ * `0<>` and stdout appended to a `stdout.jsonl` the adapter TAILS — so a bot
+ * restart (every hot reload) neither EOFs claude's stdin nor loses its output;
+ * the restarted bot re-adopts the tmux session and replays the missed tail.
+ * Same structured events, on the SAME subscription billing (proven
+ * `apiKeySource:"none"` + `seven_day` rate-limit event; the wrapper runs
+ * `env -u ANTHROPIC_API_KEY`, never `--bare`).
+ *
+ * Structural template is {@link import('./openCodeAdapter').OpenCodeAdapter}
+ * (event-driven, own process, per-key session map); the Claude on-disk
+ * transcript readers are reused for `/sessions` / resume / recap.
+ *
+ * Interactive questions (`AskUserQuestion`) reach Telegram through the same
+ * `question` event + pin flow as OpenCode: the CLI surfaces them as a
+ * `control_request` (`subtype:"can_use_tool"`, `tool_name:"AskUserQuestion"`)
+ * on stdout, answered with a `control_response` carrying
+ * `updatedInput.answers` on stdin — a wire protocol reverse-engineered from a
+ * live capture + the open-source `@anthropic-ai/claude-agent-sdk`. Ordinary
+ * tool permissions are auto-allowed (operator trusts their own agent — parity
+ * with the tmux backend's `bypassPermissions`), so only questions block.
+ *
+ * A topic flips between it and the tmux-scrape backend via `/claude_mode`
+ * (they share the on-disk transcript, so the switch resumes the same
+ * conversation). The DEFAULT Claude backend (`getDefaultClaudeBackendName`):
+ * `/login` is handled out-of-band by the bot (`claude auth login` in a pty),
+ * so it no longer needs a TUI to sign in.
+ */
+export declare class ClaudeJsonStreamAdapter extends EventEmitter implements AgentAdapter {
+    readonly name: string;
+    readonly label: string;
+    /**
+     * `idle` — the process stays between turns and is stopped at the idle mark (L3);
+     * `perTurn` — the process is stopped right after each turn (L5, L-D3), by the
+     * bot on the `turnEnded` event. Same host, same session layout: one process per
+     * conversation at a time whichever lifecycle runs it.
+     */
+    readonly lifecycle: JsonStreamLifecycle;
+    constructor(options?: {
+        lifecycle: JsonStreamLifecycle;
+    });
+    /** Emits incremental text deltas (like the tmux scrape) → the transports
+     *  synthesise continuation (`getDmDraftContinuation` / group delta path). */
+    readonly outputsDeltas = true;
+    /** No TUI banner → keep the bot's `agent.ready` cue + one-shot boot ping (L2). */
+    readonly selfGreetsOnStart = false;
+    private readonly sessions;
+    private readonly claudePath;
+    private displayPrefsReader;
+    private seenWatermarkWriter;
+    private jsonStreamTailWriter;
+    private sessionLaunchDefaultsReader;
+    /** The stops in flight — the module-level map shared by both lifecycles' instances (see {@link stopsInFlightByKey}). */
+    private readonly stopsInFlight;
+    setDisplayPrefsReader(reader: DisplayPrefsReader): void;
+    setSeenWatermarkWriter(writer: SeenWatermarkWriter): void;
+    setJsonStreamTailWriter(writer: JsonStreamTailWriter): void;
+    setSessionLaunchDefaultsReader(reader: SessionLaunchDefaultsReader): void;
+    private getLaunchOptions;
+    private getDisplayPrefs;
+    private advanceSeenWatermark;
+    startSession(key: SessionKey, workDir: string, _args?: string, sessionId?: string): Promise<void>;
+    resumeSession(key: SessionKey, workDir: string, sessionId: string, options?: ResumeSessionOptions): Promise<void>;
+    /**
+     * @description Spawn (or re-spawn) the CLI process for a thread as an
+     * EXTERNAL tmux-hosted process (wrapper + FIFO stdin + stdout file — the
+     * probe-proven layout in `utils/jsonStreamHost.ts`), start the stdout tail
+     * poller, and complete the `initialize` control handshake (which enables the
+     * `AskUserQuestion` control channel). Rejects — with the wrapper's exit code
+     * and a stderr excerpt — if the process fails to come up. Reused by start /
+     * resume / effort-respawn.
+     */
+    private spawnSession;
+    /** Arm the next tail poll (single-flight `setTimeout` chain, mirroring the
+     *  scrape backend's `schedulePoll` — never overlapping ticks). */
+    private schedulePoll;
+    /** Snap the tail cadence back to base — called on every stdin write, when
+     *  fresh output is expected shortly (mirrors the scrape backend's write snap). */
+    private snapPollToBase;
+    private pollTailTick;
+    /**
+     * @description Idle watchdog (bounded safety net). `isBusy` is cleared in
+     * exactly one place — a processed terminal `result` (`handleTurnEnd`) — so a
+     * single missed `result` (an aborted `interrupt`, a process gone quiet after
+     * the answer, a future CLI dropping the line) hangs the native typing
+     * indicator indefinitely. When the session is busy but stdout has been silent
+     * past {@link busyIdleWatchdogMs} and nothing is genuinely in flight, the turn
+     * has really ended: clear the flag. The pure decision + its rationale live in
+     * `utils/jsonStreamBusyWatchdog` — every in-flight signal (tool / sub-agent /
+     * question / batched answer) vetoes the clear, so a legitimately long-running
+     * turn is never truncated (a working agent never goes silent with nothing in
+     * flight — it streams deltas or waits on a tool/sub-agent/user).
+     */
+    private maybeClearBusyOnIdle;
+    /**
+     * @description Read whatever `stdout.jsonl` grew since the last poll and feed
+     * it through the SAME decode → line-reader → classifier pipeline the stdio
+     * pipe used to feed. Returns whether anything new was consumed (drives the
+     * adaptive poll backoff). After consuming, persists the line-boundary tail
+     * offset so a bot restart resumes exactly where processing stopped.
+     */
+    private drainStdoutTail;
+    /** Persist the tail's line-boundary offset (monotonic; inert until the
+     *  writer is registered — same idiom as the seen-watermark writer). */
+    private persistTailOffset;
+    /**
+     * @description Single teardown convergence point for the external process —
+     * both the explicit stop (`isStopping` → `stopped`) and the poll tick's exit
+     * detection (→ `closed`, with the wrapper-reported exit code and a stderr
+     * excerpt). Kills any tmux leftovers, removes the host dir, and cleans the
+     * MCP temp files. A respawn owns its own transition (`isRespawning`).
+     */
+    private finalizeExternalExit;
+    /** Close the FIFO fd AFTER any queued writes settle, so an in-flight write
+     *  never hits a closed fd (EBADF noise on every stop). */
+    private closeFifo;
+    /** Scan tmux for `cjson-…` sessions that outlived the bot (mirror of the
+     *  scrape backend's scan). The bot decides adopt-vs-orphan per key — this
+     *  method only lists. */
+    listExistingTmuxSessions(): Promise<Array<{
+        key: SessionKey;
+        sessionName: string;
+    }>>;
+    /** Kill an orphan `cjson-…` tmux session AND its host dir (the dir is
+     *  per-thread, derived from the parsed name; an unparseable name only
+     *  kills the tmux session). */
+    killOrphanTmuxSession(sessionName: string): Promise<void>;
+    /**
+     * @description Adopt an external json-stream process that survived a bot
+     * restart: reopen the stdin FIFO writer and resume the stdout tail from the
+     * persisted line-boundary offset — everything claude produced during the
+     * downtime replays through the normal pipeline, so the in-flight turn is
+     * delivered end-to-end (which is why the bot posts NO reattach recap for an
+     * adopt). An unknown / foreign-session offset seeds to the CURRENT EOF (no
+     * backlog flood — the first-migration case). No initialize handshake — the
+     * surviving process completed it at spawn; a pending question is restored
+     * from the sidecar so its buttons stay answerable. Returns `false` — after
+     * killing the leftovers — when the process is dead (exitcode present / pid
+     * gone / FIFO unheld): the caller falls back to the dead-process `--resume`
+     * reopen.
+     */
+    adoptExistingTmuxSession(key: SessionKey, sessionName: string, workDir: string, claudeSessionId: string, persistedTail: JsonStreamTailOffset | null): Promise<boolean>;
+    /**
+     * @description Resolves once an ADOPTED session's tail has consumed what its
+     * stdout held at the adopt — the replayed frames have rebuilt the live state
+     * (busy, tasks, input) — or once the session is gone. Immediate for a session
+     * that was not adopted or whose tail already sat at EOF. The stale-tool-list
+     * stop (L4) looks only after this: a look before it would read a turn in flight
+     * as idle.
+     */
+    whenAdoptReplayed(key: SessionKey): Promise<void>;
+    /** Settle the adopt catch-up once the tail consumed up to the adopt-time EOF (or the session ended). */
+    private settleAdoptCatchUp;
+    /** Restore a pending question persisted by a previous bot life (see
+     *  {@link writeQuestionSidecar}). Parse-boundary narrowing; the questions
+     *  array re-runs the same validator as a live control_request, so a corrupt
+     *  sidecar yields `null`, never a malformed pending question. */
+    private readQuestionSidecar;
+    private performInitialize;
+    stopSession(key: SessionKey): void;
+    /**
+     * @description Stop the process but KEEP the session resumable (lifecycle plan
+     * L3): the same teardown as a stop (SIGTERM, tmux kill, host dir removed —
+     * L-D13), converging on `suspended` instead of `stopped`, so the bot keeps the
+     * persisted id and the retry / compaction state the stop would drop. The caller
+     * checks `checkIsWorking` first — a suspend kills a background task like any
+     * stop. Joins a stop already in flight.
+     */
+    suspendSession(key: SessionKey): Promise<void>;
+    private stopSessionInternal;
+    /** Explicit stop = hard-kill the EXTERNAL process (released sessions are
+     *  never adopted — locked decision): SIGTERM the pid, kill the tmux session,
+     *  then converge through {@link finalizeExternalExit} (dir removal + `stopped`,
+     *  or `suspended` for an idle stop that keeps the session resumable). */
+    private performStop;
+    checkIsActive(key: SessionKey): boolean;
+    checkIsBusy(key: SessionKey): boolean;
+    checkHasUnconsumedInput(key: SessionKey): boolean;
+    /**
+     * @description Whether the process is WORKING and must not be stopped (L-D2):
+     * a running turn, a background task the CLI still runs (background Bash /
+     * Monitor / sub-agent — a stop kills them, and a finished one starts its own
+     * turn), input written but not yet taken in, or a bot-issued compaction in
+     * flight. An unknown / inactive session is not working.
+     */
+    checkIsWorking(key: SessionKey): boolean;
+    /** Background tasks, input not yet taken in, a compaction in flight — "working" minus the turn (L-D2). */
+    checkHasBackgroundWork(key: SessionKey): boolean;
+    /** The CLI version the live process reported on `system/init`, `null` until then (L-D10 gate input). */
+    getClaudeCodeVersion(key: SessionKey): string | null;
+    /** L-D10: only a CLI that reports the background-task list may be stopped automatically. */
+    checkIsAutoStopSupported(key: SessionKey): boolean;
+    getRuntimeInfo(key: SessionKey): Promise<AgentRuntimeInfo>;
+    getClaudeSessionId(key: SessionKey): string | null;
+    /**
+     * @description Real, CONFIRMED compaction on the json-stream backend (F3):
+     * send `/compact` (or `/compact <instruction>` for F2's closing section) as a
+     * stream-json user turn — the CLI parses the slash command, compacts, and
+     * reports the outcome on a `compact_boundary` (success, with token counts) /
+     * a failing `compact_status` frame. The whole turn's own output is suppressed
+     * (`compactionInProgress`) so only the bot's confirmation shows. Resolves the
+     * {@link CompactionResult} — a success carrying the boundary frame's pre/post
+     * token counts (`null` when only `compact_status success` was seen) — awaiting
+     * the terminal signal so the caller can post its notice AFTER the context was
+     * really compacted.
+     */
+    compactContext(key: SessionKey, instruction?: string): Promise<CompactionResult>;
+    /**
+     * @description Read the newest compaction summary from the on-disk transcript
+     * (the `isCompactSummary:true` message) so F2 can lift its appended closing
+     * section into the idle-compaction notice. Returns `null` when the session is
+     * inactive, the transcript is unreadable, or no summary is present.
+     */
+    getLatestCompactionSummary(key: SessionKey): Promise<string | null>;
+    sendInput(key: SessionKey, input: string): void;
+    sendSignal(key: SessionKey, _signal: string): void;
+    sendEscape(key: SessionKey): void;
+    private sendInterrupt;
+    /** Write one user turn, counting it until Claude echoes it back (it has read it). */
+    private writeUserMessage;
+    /** Enqueue one stream-json frame onto the stdin FIFO. Fire-and-forget for
+     *  callers (sync signature preserved); the per-session chain keeps wire
+     *  order and absorbs transient `EAGAIN` (see `writeFifoText`). */
+    private writeStdin;
+    private onStdout;
+    private applyStdoutLines;
+    /**
+     * @description Settle the CLI's reply to a control_request the BOT wrote,
+     * matched by `request_id`: the spawn-time `initialize` handshake, plus the MCP
+     * heal's `mcp_status` / `mcp_reconnect` round-trips. A response for an id we
+     * are not waiting on belongs to nothing of ours — ignore it rather than guess
+     * which awaiter it might settle.
+     */
+    private handleControlResponse;
+    /**
+     * @description Write ONE bot-issued control_request and resolve with its
+     * `control_response`, or `null` when none arrives within
+     * {@link mcpControlRequestTimeoutMs}. The reply comes back through the normal
+     * stdout-tail → classifier path (the CLI answers on the same stdio control
+     * channel `can_use_tool` uses), so the bounded timer is what keeps a silent
+     * CLI from hanging the caller. Never rejects: an unanswered request is an
+     * unknown, not an error.
+     *
+     * A session that is no longer the live one for its key gets NOTHING written:
+     * its fd is closed (and its number reusable), so a write after teardown could
+     * land in an unrelated file — and no reply could ever settle the awaiter
+     * anyway. Same identity guard as the poll tick and the exit finalizer.
+     */
+    private requestControl;
+    /**
+     * @description Heal the bot's own injected MCP server inside this LIVE session:
+     * ask `mcp_status`, and reconnect the server ONLY when it reports `failed`
+     * (the latched state a bot restart leaves behind — the CLI never retries it,
+     * so the bot's tools stay gone for the rest of the session). `connected` is
+     * left strictly alone, and any other status (`needs-auth`, an unknown future
+     * one) is skipped rather than guessed at — see `decideMcpHeal`.
+     *
+     * Control frames only: nothing written here can be read as a user turn, the
+     * session is never marked busy, and the pending-request map is keyed by
+     * `request_id` so the `can_use_tool` / `interrupt` paths are untouched.
+     *
+     * `healed` is reported off the reconnect's own ack, and that ack is MEASURED to
+     * be both synchronous and honest — so no confirming third round-trip is needed
+     * and adding one would only be ceremony. Against a still-dead endpoint the
+     * reconnect answers `{subtype:'error', error:'ECONNREFUSED…'}` (never a hollow
+     * success), and after a successful one an IMMEDIATELY following `mcp_status`
+     * already reads `connected`. Do not re-litigate this as a missing verification.
+     */
+    healMcpServer(key: SessionKey, serverName: string): Promise<McpHealOutcome>;
+    private applyAction;
+    private handleInit;
+    /** Replace the live background-task list with the frame's (it is re-sent
+     *  WHOLE on every change, so no diffing). The tail-offset persist that follows
+     *  this frame's drain carries the new list to `state.json`. */
+    private handleBackgroundTasks;
+    private handleCompactStatus;
+    private handleCompactBoundary;
+    /**
+     * Resolve (and clear) the in-flight compaction awaiter exactly once. Every way a bot-issued compaction can
+     * succeed (its boundary, its turn end, the timeout that saw its success) ends here, so a success is told
+     * once as `contextCompacted`.
+     */
+    private resolveCompaction;
+    private appendAnswerDelta;
+    private flushAnswer;
+    private appendThinkingDelta;
+    private finishReasoning;
+    private handleToolUse;
+    private handleToolResult;
+    private markSubagentActive;
+    private handleSubagentText;
+    private clearSubagent;
+    /** Every terminal `result` — a normal turn, a compaction turn, an error — ends with the `turnEnded` event. */
+    private handleTurnEnd;
+    private applyTurnEnd;
+    /**
+     * @description Advance the persisted seen-watermark to the transcript's current
+     * byte size when it grew past the last write (S7). A cheap `fs.statSync().size`
+     * (NOT a whole-file read — this runs per settled parent assistant message, not
+     * only at turn end) plus a monotonic guard, mirroring the tmux backend's
+     * {@link import('./claudeCliAdapter').ClaudeCliAdapter} advance so both Claude
+     * paths track "relayed up to here". Best-effort — a transcript not yet on disk
+     * leaves the watermark where it was; the next relayed message re-tries.
+     */
+    private advanceWatermarkFromTranscript;
+    /** Classify + emit an `apiError` once per episode; returns whether it fired. */
+    private maybeEmitApiError;
+    private handleControlRequest;
+    private surfaceQuestion;
+    /**
+     * @description Persist the pending question to the host dir. The external
+     * claude process stays BLOCKED on its `can_use_tool` across a bot restart,
+     * but the control_request line lies BEFORE the persisted tail offset (it was
+     * consumed pre-restart), so tail replay alone would never resurface it — the
+     * sidecar is what lets an adopting bot still answer over the FIFO. Removed
+     * the moment the question resolves (answer / reject); dies with the dir on
+     * stop.
+     */
+    private writeQuestionSidecar;
+    private clearQuestionSidecar;
+    /** Map the AskUserQuestion `input.questions` to the shared question shape
+     *  (dropping option `preview`, which breaks in the Telegram relay). */
+    private parseQuestions;
+    answerQuestion(key: SessionKey, answers: string[][]): void;
+    rejectQuestion(key: SessionKey): void;
+    private writeControlResponse;
+    getSessions(_key: SessionKey, workDir: string): Promise<AgentSession[]>;
+    getRecentTurns(_key: SessionKey, workDir: string, sessionId: string, limit: number): Promise<RecentTurn[]>;
+    getReattachRecap(key: SessionKey, workDir: string, sessionId: string, watermark: SeenWatermark | null): Promise<ReattachRecap>;
+    setModel(key: SessionKey, modelId: string): Promise<string | null>;
+    /**
+     * @description The model the session is RUNNING. Claude's own `system/init`
+     * report wins over the pinned `--model` pick: it is the resolved id (an alias
+     * like `opus` resolves to its snapshot) and it is the only value present when
+     * no pick was ever made. The pick is the fallback for the window between a
+     * `/model` re-spawn and its first `init`, so the label never blanks out
+     * mid-switch.
+     */
+    getCurrentModel(key: SessionKey): string | null;
+    getAvailableModels(): Promise<string[]>;
+    setEffort(key: SessionKey, level: string): Promise<string | null>;
+    getEffort(key: SessionKey): string | null;
+    getAvailableEffortLevels(_key: SessionKey): Promise<string[]>;
+    /**
+     * @description Apply a model/effort change by re-spawning the child with
+     * `--resume <sessionId>` (the on-disk session persists, so only an in-flight
+     * streaming reply is lost — same trade-off as OpenCode's server restart). The
+     * intermediate exit is suppressed (`isRespawning`) so the bot sees no
+     * closed/stopped churn.
+     */
+    private respawnWithChange;
+    private clearTimers;
+}
+/**
+ * @description Extract the newest compaction summary from a Claude on-disk
+ * transcript: the last JSONL line with `isCompactSummary === true`, whose
+ * `message.content` (a string, or `{type:'text'}` blocks) holds the summary the
+ * `/compact` turn produced. Returns `null` for an unreadable file or when no
+ * summary line is present. Reads the whole file — cheap enough for the
+ * once-per-idle-compaction call.
+ */
+export declare function readLatestCompactSummaryFromTranscript(filePath: string): string | null;
+export {};
+//# sourceMappingURL=claudeJsonStreamAdapter.d.ts.map

package/dist/adapters/claudeJsonStreamAdapter.d.ts.map

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