@cruxy/cli 1.0.2 → 1.0.4

package/dist/render/highlight.d.ts

@@ -1,47 +0,0 @@
-import type { Theme } from "../theme/index.js";
-/**
- * Best-effort, bounded syntax highlighting for fenced code blocks in streamed
- * markdown (U.2). Priorities, in order: never crash the stream, never hold the
- * stream back, then look nice.
- *
- * - Prose passes through immediately, byte for byte. The only hold-back is a
- *   line that is still a plausible fence opener (a leading backtick run), held
- *   until disambiguated — bounded by one short line, never a block.
- * - Inside a fence, lines are highlighted incrementally: each line is emitted
- *   the moment its newline arrives, so latency is one line, and committed
- *   output is never repainted.
- * - Unknown language → plain text. A tokenizer throw → that line plain. The
- *   tokenizer is hand-rolled (no highlighter dependency, in the same spirit as
- *   the hand-rolled HTTP client) and colors only what it is sure about:
- *   comments, strings, keywords, numbers.
- */
-/** Cross-line tokenizer state (block comments / multi-line strings). */
-export interface HighlightCarry {
-    /** Inside a block comment (`/* … *``/`). */
-    blockComment: boolean;
-    /** Inside a multi-line string; the delimiter that will close it. */
-    stringDelim: string | null;
-}
-/** One line of code → styled line + the carry for the next line. */
-export type LineHighlighter = (line: string, lang: string | null, carry: HighlightCarry) => {
-    text: string;
-    carry: HighlightCarry;
-};
-/** Incremental highlighter for one streamed text segment. */
-export interface StreamHighlighter {
-    /** Feed a delta; returns the styled text that is safe to emit now. */
-    push(delta: string): string;
-    /** Return whatever is still held (segment end); resets to prose state. */
-    flush(): string;
-}
-/**
- * Create the per-segment streaming highlighter. `highlightLine` is injectable
- * for tests (e.g. to prove a throwing tokenizer degrades to plain text).
- */
-export declare function createStreamHighlighter(theme: Theme, highlightLine?: LineHighlighter): StreamHighlighter;
-/**
- * Build the default per-line tokenizer over `c`. A plain left-to-right scan:
- * comments dim, strings green, keywords magenta, numbers yellow, everything
- * else untouched. Unknown language → identity.
- */
-export declare function defaultLineHighlighter(theme: Theme): LineHighlighter;

package/dist/render/index.d.ts

@@ -1,22 +0,0 @@
-import type { RenderStream, StreamRenderer } from "./types.js";
-export type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, TokenUsage, ToolLifecycleEvent, } from "./types.js";
-export { detectCapabilities, detectReducedMotion, resolveColumns, DEFAULT_COLUMNS, } from "./capabilities.js";
-export { attachResize, processResizeSignal, type ResizeSignal, } from "./resize.js";
-export { fit, fitMiddle, reflow, stripAnsi, visibleWidth, kvStack, MIN_VALUE_COLS, type KvRow, } from "./layout.js";
-export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, fitStatusLine, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
-export { createFrameClock, inTransition, intervalFrameTimer, spinnerGlyph, FRAME_INTERVAL_MS, TRANSITION_TICKS, type FrameClock, type FrameTimer, } from "./motion.js";
-export { renderActionPreview, PREVIEW_MAX_LINES } from "./diff.js";
-export { createStreamHighlighter, defaultLineHighlighter, type HighlightCarry, type LineHighlighter, type StreamHighlighter, } from "./highlight.js";
-export { PlainRenderer } from "./plain-renderer.js";
-export { ScreenReaderRenderer } from "./screen-reader-renderer.js";
-export { TtyRenderer } from "./tty-renderer.js";
-/**
- * Build the renderer for the detected environment (U.11 adds the first branch):
- * - `screenReader` → the linear, worded {@link ScreenReaderRenderer}, regardless
- *   of cursor support (a screen-reader TTY must not get the live region);
- * - else cursor-safe → the managed-live-region {@link TtyRenderer} (static, no
- *   timer, when `reducedMotion`);
- * - else → the append-only {@link PlainRenderer} (pipes, CI, `TERM=dumb`).
- * Everything downstream talks to {@link StreamRenderer} and never re-probes.
- */
-export declare function createRenderer(out?: RenderStream, err?: RenderStream, env?: NodeJS.ProcessEnv): StreamRenderer;

package/dist/render/layout.d.ts

@@ -1,59 +0,0 @@
-import type { Theme } from "../theme/index.js";
-/** The visible text of a possibly-styled string (SGR removed). */
-export declare function stripAnsi(text: string): string;
-/**
- * Visible width in code points — the number a terminal cell count approximates.
- * Counts by code point (via spread) so a surrogate-pair glyph is 1, not 2, and
- * is never split. Wide (CJK/emoji) cells are counted as 1; full display-width
- * accounting is deliberately out of scope (U.12), but code-point counting is
- * already strictly more correct than the pre-U.12 `.length`.
- */
-export declare function visibleWidth(text: string): number;
-/**
- * Truncate `text` to at most `width` visible columns, appending an honest
- * ellipsis when anything was dropped. Text that already fits is returned
- * UNCHANGED (style preserved). A truncated string is returned as plain text:
- * dropping the style on the cut tail is the safe choice — re-styling a slice
- * risks emitting a half of an escape pair.
- *
- * `width < 1` yields "". When `width` is smaller than the ellipsis itself
- * (very-narrow), we show that many content characters rather than only dots —
- * a single legible char beats a clipped "…".
- */
-export declare function fit(text: string, width: number, ellipsis?: string): string;
-/**
- * Truncate the MIDDLE, preserving the head and tail. For a path or a search
- * hit, the tail (basename, `:line`) carries as much identity as the head
- * (root) — a right-truncation would hide the very thing that names it. Yields
- * `src/very/deep/…/Component.tsx`. Falls back to {@link fit} when there is no
- * room for both sides plus the ellipsis. Returns plain text when it truncates.
- */
-export declare function fitMiddle(text: string, width: number, ellipsis?: string): string;
-/**
- * Word-wrap `text` to `width` visible columns, returning the wrapped lines.
- * Wraps at spaces; a single token longer than `width` is hard-broken (its style
- * is dropped on the break). Existing newlines are preserved as paragraph
- * breaks. Use this — not {@link fit} — when meaning must survive in full (an
- * approval command you must see whole), trading vertical space for completeness.
- */
-export declare function reflow(text: string, width: number): string[];
-/** A key/value pair for {@link kvStack}. */
-export interface KvRow {
-    key: string;
-    value: string;
-}
-/**
- * Minimum value columns an aligned two-column table needs before it collapses
- * to a stack. Below this, the value column is too cramped to read, so stacking
- * (key on its own line, value reflowed beneath) is the honest presentation.
- */
-export declare const MIN_VALUE_COLS = 16;
-/**
- * The table→stack collapser (U.12). At a width that affords the widest key plus
- * {@link MIN_VALUE_COLS}, render aligned `key  value` rows (values truncated to
- * the remaining columns). Too narrow for that, STACK each pair — a bold key
- * line, then the value reflowed and indented — so a table never soft-wraps into
- * a misaligned mess and never hides a value. One column budgeter for every kv
- * caller.
- */
-export declare function kvStack(rows: KvRow[], width: number, theme: Theme): string[];

package/dist/render/motion.d.ts

@@ -1,76 +0,0 @@
-import type { ThemeGlyphs } from "../theme/index.js";
-/**
- * Motion (U.10) — one frame clock drives every live animation on the render
- * seam, and a tiny set of pure frame→glyph/style primitives express it. The
- * design is the same honest-signal discipline as U.4 state: motion encodes real
- * state (work is progressing, the activity changed, a result landed) and never
- * decorates. It is a cosmetic overlay on the transient live region (U.2) — never
- * in the content path, never touching committed bytes.
- *
- * The single gate is `caps.spinner` (`cursor && !reducedMotion`, from U.11):
- * when motion is reduced the clock is *disabled* — it schedules nothing and
- * never ticks, so every motion collapses to its static end-state, drawn once.
- * There is exactly one clock per renderer (refcounted like the U.12 resize
- * signal), not a timer per surface.
- */
-/** The one frame cadence: 10 fps, the pre-U.10 spinner interval. Bounded by construction. */
-export declare const FRAME_INTERVAL_MS = 100;
-/**
- * How many frames a phase-transition emphasis lasts before it settles — ~300ms
- * at {@link FRAME_INTERVAL_MS}. Long enough for the eye to catch "the activity
- * changed", short enough to never read as decoration.
- */
-export declare const TRANSITION_TICKS = 3;
-/** Schedule/cancel a repeating tick; injectable so tests drive frames deterministically. */
-export interface FrameTimer {
-    schedule(callback: () => void, intervalMs: number): {
-        unref?: () => void;
-    };
-    cancel(handle: {
-        unref?: () => void;
-    }): void;
-}
-/** The real timer: a single unref'd interval that never holds the process open. */
-export declare const intervalFrameTimer: FrameTimer;
-/**
- * The one clock that drives all live animation. Subscribers get a monotonic
- * frame number on each tick; the underlying timer runs ONLY while at least one
- * subscriber is attached (refcounted), and is torn down on the last unsubscribe
- * — the same discipline that keeps the U.12 resize listener from leaking.
- */
-export interface FrameClock {
-    /**
-     * Attach a per-frame callback. The first subscriber starts the single timer;
-     * the returned function detaches and, when it was the last subscriber, stops
-     * the timer. A no-op subscription (returns a no-op unsubscribe) when the clock
-     * is disabled — reduced motion never schedules anything.
-     */
-    subscribe(onFrame: (frame: number) => void): () => void;
-    /** The current monotonic frame counter. Stays 0 while disabled (no ticks). */
-    readonly frame: number;
-    /** Whether motion runs at all — false under reduced motion (`caps.spinner`). */
-    readonly enabled: boolean;
-}
-/**
- * Build the frame clock. `enabled` is `caps.spinner`: when false the clock is
- * inert — {@link FrameClock.subscribe} schedules nothing, never ticks, and
- * `frame` never advances, so callers draw their static end-state once and stop.
- */
-export declare function createFrameClock(enabled: boolean, timer?: FrameTimer, intervalMs?: number): FrameClock;
-/**
- * The spinner glyph for a frame (U.10 progress motion): the animated braille
- * (or single-column ASCII) cycle when the clock runs, the static marker
- * otherwise. `animated=false` (reduced motion / no cursor) yields the static
- * glyph with no reference to `frame` — the honest still form of "working".
- */
-export declare function spinnerGlyph(frame: number, glyph: ThemeGlyphs, animated: boolean): string;
-/**
- * Whether a phase-transition emphasis is still playing (U.10): true for the
- * first {@link TRANSITION_TICKS} frames after the phase *identity* changed. The
- * caller records the frame the identity began on and passes it here; when the
- * clock is not advancing (reduced motion), `startFrame === frame` forever, so
- * this is briefly true only if drawn on the very first frame — the renderer
- * gates the whole emphasis behind `clock.enabled`, so a static draw always uses
- * the settled end-state.
- */
-export declare function inTransition(frame: number, startFrame: number): boolean;

package/dist/render/plain-renderer.d.ts

@@ -1,39 +0,0 @@
-import type { ActionPreview } from "../tools/types.js";
-import { type Theme } from "../theme/index.js";
-import type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, ToolLifecycleEvent } from "./types.js";
-/**
- * The append-only renderer for pipes, CI, and cursor-less terminals. Emits no
- * cursor-control sequences ever, and no color unless the capabilities say so
- * (FORCE_COLOR); with color off, not a single ANSI byte leaves this class.
- *
- * Assistant text goes to `out` verbatim (beyond the per-turn leading-newline
- * trim) so piped stdout stays pure model output; chrome (`note`) goes to `err`,
- * matching the logger's stdout/stderr split. Transient `status` has no meaning
- * in an append-only medium and is dropped — the loop reports anything durable
- * via `note`.
- */
-export declare class PlainRenderer implements StreamRenderer {
-    readonly caps: RenderCapabilities;
-    private readonly out;
-    private readonly err;
-    readonly theme: Theme;
-    /** Per-turn leading-newline trim; also tells endSegment whether to newline. */
-    private print;
-    private wroteInSegment;
-    /** In-flight tool call (serial by contract) for the end-note duration. */
-    private toolStart;
-    constructor(caps: RenderCapabilities, out: RenderStream, err: RenderStream);
-    private newPrinter;
-    beginTurn(): void;
-    write(delta: string): void;
-    endSegment(): void;
-    note(text: string): void;
-    preview(preview: ActionPreview): void;
-    status(): void;
-    setPhase(phase: RenderPhase | null): void;
-    progress(state: ProgressState | null): void;
-    toolLifecycle(event: ToolLifecycleEvent): void;
-    promptResolved(): void;
-    endTurn(): void;
-    close(): void;
-}

package/dist/render/resize.d.ts

@@ -1,36 +0,0 @@
-import type { RenderCapabilities, RenderStream } from "./types.js";
-/**
- * Resize reactivity (U.12). Terminal width lives in exactly one place —
- * {@link RenderCapabilities.width} — and this module is what keeps it current:
- * it listens for the OS resize signal, recomputes the width through the same
- * {@link resolveColumns} rule that seeded it, updates `caps.width` IN PLACE, and
- * pushes the new width to subscribers (the live region / transient frames).
- *
- * Committed output is never re-rendered from here — only surfaces that own a
- * redrawable region subscribe. Everything else simply reads the now-current
- * `caps.width` the next time it emits.
- *
- * The OS signal is injectable ({@link ResizeSignal}) so tests drive resize
- * deterministically without a real terminal or a real SIGWINCH.
- */
-/**
- * The OS resize signal, abstracted for testability. `on` registers a callback
- * fired on each terminal resize and returns an unsubscribe function.
- */
-export interface ResizeSignal {
-    on(listener: () => void): () => void;
-}
-/** The real signal: Node emits `SIGWINCH` on the process when a TTY resizes. */
-export declare const processResizeSignal: ResizeSignal;
-/**
- * Wire resize reactivity onto `caps`: install {@link RenderCapabilities.onResize}
- * and start listening for terminal resizes. One OS listener is shared across all
- * subscribers and is removed once the last one unsubscribes (and re-added if a
- * new subscriber arrives), so nothing is leaked and the process is never held
- * open by a stray handler.
- *
- * A no-op for streams that cannot resize (non-TTY / no `columns`): `onResize`
- * stays undefined and surfaces fall back to the static width. Idempotent —
- * calling twice on the same caps keeps the first wiring.
- */
-export declare function attachResize(caps: RenderCapabilities, stream?: RenderStream, env?: NodeJS.ProcessEnv, signal?: ResizeSignal): void;

package/dist/render/screen-reader-renderer.d.ts

@@ -1,45 +0,0 @@
-import { PlainRenderer } from "./plain-renderer.js";
-import type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, ToolLifecycleEvent } from "./types.js";
-/**
- * The screen-reader renderer (U.11): {@link PlainRenderer}'s linear,
- * append-only, zero-cursor-control output — plus two things a screen reader
- * needs that the plain path drops.
- *
- * 1. **Worded status.** Its theme resolves the {@link SCREEN_READER_GLYPHS}
- *    table (via `caps.screenReader`), so every inherited code path that writes
- *    `theme.glyph.success` prints `done` instead of `✓`, `failed` for `✗`, etc.
- *    Nothing here special-cases it — the glyph table does the work.
- *
- * 2. **Announced state.** A screen reader cannot see an in-place live region, so
- *    each state change is emitted as its own committed line (never a redraw):
- *    a phase becomes `working: read_file src/x.ts`, a tool run brackets as
- *    `working: …` → `done …`, and plan progress announces `step 2 of 5: title`.
- *    Announcements are deduped by phase *identity* so token-count updates within
- *    the same activity don't repeat a line.
- *
- * Everything else — text streaming, `endSegment`, `note`, `preview` — is
- * inherited unchanged. This is the whole of screen-reader mode: no parallel
- * path, no behavior change to the plain or TTY renderers.
- */
-export declare class ScreenReaderRenderer extends PlainRenderer {
-    /** Identity of the last phase announced, so we speak each activity once. */
-    private lastPhaseId;
-    /** Text of the last progress line announced, to avoid repeats. */
-    private lastProgress;
-    constructor(caps: RenderCapabilities, out: RenderStream, err: RenderStream);
-    /**
-     * Announce a phase transition as a committed line. `null`, `awaiting-approval`
-     * (the prompt block is its own announcement), and `calling-tool` (announced by
-     * {@link toolLifecycle}) are silent; repeats of the same activity are deduped.
-     */
-    setPhase(phase: RenderPhase | null): void;
-    /** Announce plan-step progress as `step i of n: title`, deduped. */
-    progress(state: ProgressState | null): void;
-    /**
-     * Bracket a tool call with two committed lines — `working: label` on start,
-     * `done/failed label` on end — so a screen-reader user hears both that a call
-     * began (crucial for long ones) and how it resolved. The end note + honest
-     * duration is the inherited plain behavior; only the start line is added.
-     */
-    toolLifecycle(event: ToolLifecycleEvent): void;
-}

package/dist/render/state.d.ts

@@ -1,49 +0,0 @@
-import { type ThemeGlyphs } from "../theme/index.js";
-import type { ProgressState, RenderPhase } from "./types.js";
-/**
- * The U.4 state→text mapping: pure data → string, like plan/render.ts and
- * diff.ts, so both renderers (and tests) share one composition with no
- * terminal in sight. Color is deliberately absent — the live line is drawn
- * dim as a whole by the TTY renderer; state text is content, not chrome.
- *
- * Glyphs (ellipsis, token arrows, the ` · ` joiner) come from the theme (U.1);
- * they default to the unicode table so colorless/test callers are unchanged,
- * and the TTY renderer passes its capability-resolved set for ASCII fallback.
- */
-/**
- * Threshold before elapsed time appears on a live state or a committed tool
- * note. Below this, a timer is noise; above it, it's the answer to "is this
- * stuck?".
- */
-export declare const ELAPSED_AFTER_MS = 5000;
-/** `342`, `1.2k`, `3.4M` — token counts at status-line width. */
-export declare function formatTokens(n: number): string;
-/** `37s`, `2m08s` — durations at status-line width. */
-export declare function formatElapsed(ms: number): string;
-/** The live-line text for a phase. `awaiting-approval` never renders (the line hides). */
-export declare function describePhase(phase: RenderPhase, glyph?: ThemeGlyphs): string;
-/**
- * Identity key for the elapsed clock: the clock resets when the phase becomes
- * a *different activity*, not on every payload update — a thinking phase that
- * gains token counts keeps its start time; a new tool label starts fresh.
- */
-export declare function phaseIdentity(phase: RenderPhase | null): string;
-/**
- * Compose the single live line: `[2/5] title · read_file src/x.ts… (12s)`.
- * Elapsed appears only past {@link ELAPSED_AFTER_MS} — callers pass it only
- * when they can keep it ticking honestly (no timer → no frozen number).
- */
-export declare function composeStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs?: number, glyph?: ThemeGlyphs): string;
-/**
- * The width-aware live line (U.12): {@link composeStatusLine} with honest
- * degradation tiers so the status line never soft-wraps and never loses its
- * essential meaning — *what is happening*. Priority is phase (the action) >
- * the `[i/n] title` progress prefix (context) > the elapsed clock (decor), so
- * as width shrinks we shed decor first and identity last:
- *
- * - wide: `[2/5] title · read_file src/x.ts… (12s)`
- * - medium: drop the elapsed clock
- * - narrow: drop the `[i/n] title` prefix, keep the phase
- * - very-narrow: {@link fit} the phase text with an honest ellipsis
- */
-export declare function fitStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs: number | undefined, glyph: ThemeGlyphs, width: number): string;

package/dist/render/tty-renderer.d.ts

@@ -1,106 +0,0 @@
-import type { ActionPreview } from "../tools/types.js";
-import { type Theme } from "../theme/index.js";
-import type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, ToolLifecycleEvent } from "./types.js";
-/**
- * The interactive renderer: committed content is append-only; the one transient
- * thing on screen is a single managed status line, redrawn in place.
- *
- * The no-flicker discipline, concretely:
- * - Only the status line is ever rewritten, via `\r` + erase-line — never a
- *   screen clear, never a repaint of committed rows.
- * - Every committed write first erases the status line, so the live region is
- *   always the last row and committed text can never interleave with it. A
- *   committed write *dismisses* the status (it does not redraw underneath), so
- *   nothing re-renders per delta while text streams.
- * - The status text is hard-truncated to the terminal width: a soft-wrapped
- *   status would span two rows and erase-line could no longer clean it up.
- *
- * Fenced code blocks are highlighted incrementally (see highlight.ts): prose
- * deltas pass straight through, code is styled line-by-line on arrival.
- *
- * U.4 layers semantic state onto the SAME single live line — no new screen
- * real estate, no extra timers. Two registers compose into it:
- * - `phase` (loop-owned; cleared by endTurn) — thinking / calling-tool / …
- * - `progressState` (plan-executor-owned; cleared only via progress(null))
- * A committed write still only *hides* the drawn line (registers survive);
- * the next state transition redraws. Nothing redraws per streamed delta, so
- * the U.2 first-chunk-immediate guarantee is untouched.
- *
- * U.10 puts every live animation on ONE frame clock (see motion.ts) instead of
- * a private interval: the spinner glyph and the phase-transition emphasis draw
- * off `clock.frame`, subscribed only while the line is visible and torn down on
- * hide/close (no leaked timer). Reduced motion disables the clock — the line is
- * drawn once in its static end-state. The result reveal is a one-time entrance
- * emphasis on a committed tool note (never a redraw of committed bytes), so it
- * needs no clock. Motion is a cosmetic overlay on the live region only; it never
- * gates a committed write, so the latency guarantee holds with motion active.
- */
-export declare class TtyRenderer implements StreamRenderer {
-    readonly caps: RenderCapabilities;
-    private readonly out;
-    readonly theme: Theme;
-    private print;
-    private highlighter;
-    private wroteInSegment;
-    /** Ad-hoc/legacy status text; wins over composed state when set. */
-    private rawStatus;
-    private phase;
-    private progressState;
-    /** When the current phase *identity* began — drives honest elapsed display. */
-    private phaseStartedAt;
-    /** In-flight tool call (serial by contract) for end-note duration. */
-    private toolStart;
-    /** Phase (+ its clock) displaced by an approval prompt, for promptResolved. */
-    private displaced;
-    /** Whether the live line is currently drawn on screen. */
-    private lineVisible;
-    /** The one frame clock driving live animation (U.10); disabled under reduced motion. */
-    private readonly clock;
-    /** Detach from the clock; null when the live line is hidden (no ticks wanted). */
-    private unsubscribeFrame;
-    /** Clock frame the current phase *identity* began on — drives the transition emphasis (U.10). */
-    private phaseStartFrame;
-    private closed;
-    /** Unsubscribe from the resize signal (U.12); null when the stream can't resize. */
-    private unsubscribeResize;
-    constructor(caps: RenderCapabilities, out: RenderStream);
-    /**
-     * Redraw the live line at the current `caps.width` after a resize. A no-op
-     * when nothing is drawn (so a resize between turns writes zero bytes) — the
-     * next state transition will draw at the new width anyway.
-     */
-    private reflowLive;
-    private newPrinter;
-    /** Append committed content, erasing the status line first if one is live. */
-    private commit;
-    /**
-     * Erase the drawn live line and stop the spinner — WITHOUT clearing the
-     * state registers. Committed content takes the screen; the next state
-     * transition redraws with full context. (This is what keeps streaming
-     * zero-cost: no redraw-under per delta.)
-     */
-    private hideLine;
-    /** Detach from the frame clock — the timer stops once this is the last subscriber. */
-    private stopFrames;
-    /**
-     * The current live-line text, composed from the registers. `null` means the
-     * line must be hidden: nothing to say, or an interactive prompt owns the
-     * terminal (`awaiting-approval` — two things can't share the last row).
-     */
-    private currentLine;
-    /** Redraw the live line from current state, or hide it when there is none. */
-    private refresh;
-    private drawLine;
-    beginTurn(): void;
-    write(delta: string): void;
-    endSegment(): void;
-    note(text: string): void;
-    preview(preview: ActionPreview): void;
-    status(text: string | null): void;
-    setPhase(phase: RenderPhase | null): void;
-    progress(state: ProgressState | null): void;
-    toolLifecycle(event: ToolLifecycleEvent): void;
-    promptResolved(): void;
-    endTurn(): void;
-    close(): void;
-}