@meterbility/server 0.3.1

package/dist/html-QXNPWM2W.js

@@ -0,0 +1,24 @@
+import {
+  renderContext,
+  renderDiff,
+  renderFleet,
+  renderProbePanel,
+  renderRun,
+  renderRunList,
+  renderSettings,
+  renderShell,
+  renderStepCardFragment,
+  renderTests
+} from "./chunk-VULWJFYO.js";
+export {
+  renderContext,
+  renderDiff,
+  renderFleet,
+  renderProbePanel,
+  renderRun,
+  renderRunList,
+  renderSettings,
+  renderShell,
+  renderStepCardFragment,
+  renderTests
+};

package/dist/index.d.ts

@@ -0,0 +1,652 @@
+import * as _meterbility_shared from '@meterbility/shared';
+import { Action, Outcome, TokenUsage, ContextSnapshot, Step, ForkEdit, Run, ConversationMessage } from '@meterbility/shared';
+import { Store } from '@meterbility/collector';
+import { EventEmitter } from 'node:events';
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+/**
+ * Replay engine. v0 implements two modes:
+ *
+ *   deterministic_prefix: walk steps 0..fork_point, recompute and persist
+ *     context snapshots and decision refs from cached blobs. No external
+ *     calls. The new run is a "shadow" of the original until the fork
+ *     point, then live execution takes over (handled separately by the
+ *     fork command).
+ *
+ *   fully_live: re-run from start with edit applied. Requires an
+ *     Anthropic API key in ANTHROPIC_API_KEY. Not implemented in v0;
+ *     reserved for v0.1.
+ */
+type ReplayMode = "deterministic_prefix" | "fully_live";
+interface ReplayResult {
+    run_id: string;
+    prefix_steps: number;
+}
+/**
+ * Materialize a deterministic-prefix copy of `originRunId` up to (and
+ * including) `originStepId`. The resulting run shares all blob content
+ * with the origin (content-addressed dedup) but has its own row in the
+ * `runs` table and its own step rows. The Action and Outcome of the
+ * fork-point step may be rewritten by the caller before calling
+ * {@link liveSuffix}.
+ */
+declare function materializePrefix(store: Store, originRunId: string, forkStepId: string, edit: ForkEdit): Promise<ReplayResult>;
+/**
+ * Read the origin step's context snapshot, apply the edit, return a new
+ * snapshot. The new id is content-addressed off the rewritten components.
+ */
+declare function rewriteSnapshot(store: Store, snapshotId: string, edit: ForkEdit): Promise<ContextSnapshot>;
+/**
+ * Append one synthetic Step to a fork run carrying the live-suffix
+ * result. Used after fork_point edit has been applied and the operator
+ * has produced (or simulated) a new model response.
+ */
+declare function appendLiveStep(store: Store, runId: string, args: {
+    model: string;
+    action: Action;
+    outcome: Outcome;
+    tokens: TokenUsage;
+    latency_ms: number;
+    parent_step_id?: string;
+    snapshot: ContextSnapshot;
+    decisionContent: unknown;
+}): Promise<Step>;
+
+interface ForkArgs {
+    origin_run_id: string;
+    /** Either a full step id (stp_…) or a step sequence number. */
+    at: string | number;
+    edit: ForkEdit;
+}
+interface ForkOutcome {
+    fork_id: string;
+    fork_run_id: string;
+    prefix_steps: number;
+    /** True if a live-suffix step was also materialized. False if the
+     *  fork was created without a live model call (the operator can run
+     *  one later via the API/CLI). */
+    live: boolean;
+}
+/**
+ * High-level fork entry point. Resolves the target step, materializes
+ * the deterministic prefix, records the fork relationship, and (if
+ * `liveSuffix` is provided) generates one live step using the operator-
+ * supplied responder. We deliberately avoid hard-coding an Anthropic
+ * call here so the engine is testable without a network round-trip and
+ * so non-Anthropic providers can plug in later.
+ */
+declare function forkRun(store: Store, args: ForkArgs, liveSuffix?: LiveResponder): Promise<ForkOutcome>;
+interface LiveResponderArgs {
+    origin_step: _meterbility_shared.Step;
+    context_snapshot_id: string;
+    edit: ForkEdit;
+}
+interface LiveResponderResult {
+    model: string;
+    action: Action;
+    outcome?: Outcome;
+    tokens: TokenUsage;
+    latency_ms?: number;
+    decision_content: unknown;
+}
+type LiveResponder = (args: LiveResponderArgs) => Promise<LiveResponderResult>;
+/**
+ * A fake responder useful for tests and demos — produces a trivial
+ * "message" step with zero tokens. Real implementations call an LLM.
+ */
+declare function fakeResponder(text: string): LiveResponder;
+interface AnthropicResponderOptions {
+    apiKey: string;
+    model: string;
+    systemPrompt?: string;
+    maxTokens?: number;
+}
+/**
+ * Anthropic-backed live responder. Pulls the conversation history out
+ * of the snapshot's blobs, sends it to the API, and packages the
+ * response back into a Step. Kept here (not in adapters/) because it is
+ * runtime-agnostic — it works for any captured history regardless of
+ * which agent runtime produced it.
+ */
+declare function anthropicResponder(store: Store, opts: AnthropicResponderOptions): LiveResponder;
+
+/**
+ * Structural diff. Walks both runs in sequence order, aligning steps by
+ * sequence number. v0 only supports this "parallel" mode — semantic
+ * (embedding-based) alignment is on the v1 roadmap.
+ */
+type DiffRowKind = "shared" | "context_diff" | "decision_diff" | "action_diff" | "outcome_diff" | "only_a" | "only_b" | "diverged";
+interface DiffRow {
+    sequence: number;
+    kind: DiffRowKind;
+    a?: StepDigest;
+    b?: StepDigest;
+}
+interface StepDigest {
+    step_id: string;
+    model: string;
+    context_snapshot_id: string;
+    decision_ref: string;
+    action_kind: string;
+    tool_name?: string;
+    outcome_status: string;
+    outcome_summary?: string;
+    cost_cents: number;
+    tokens_total: number;
+    status: string;
+}
+interface DiffResult {
+    run_a_id: string;
+    run_b_id: string;
+    total_steps_a: number;
+    total_steps_b: number;
+    shared_prefix_length: number;
+    first_divergence_sequence?: number;
+    rows: DiffRow[];
+}
+declare function diffRuns(store: Store, runA: string, runB: string): DiffResult;
+
+type LiveStatus = "progressing" | "stalled" | "looping" | "awaiting_input" | "errored" | "completed";
+/**
+ * Heuristic context-window utilization derived from the last step's
+ * token usage. Anthropic's Opus 4.x models use a 200k window in stable
+ * mode and a 1M window in extended mode; we read both totals from the
+ * step's tokens and assume the larger of (input + cached_read) vs.
+ * (input alone) as the effective load. Returns 0–100.
+ */
+declare function contextUtilization(step?: Step): number;
+/**
+ * Classify a run's live status from its step stream. The order matters
+ * — a stalled run with an outstanding tool call is "awaiting_input"
+ * rather than "stalled," and "errored" beats everything else.
+ */
+declare function classifyRunStatus(run: Run, steps: Step[], stallSeconds: number): LiveStatus;
+/**
+ * Loop detection: the last `window` steps share the same tool and the
+ * same canonical input. Returns the loop signature or undefined if no
+ * loop is detected. window=4 by default; rationale per SPEC §10.x —
+ * three repeats can be coincidence, four is a pattern worth surfacing.
+ */
+declare function detectLoop(steps: Step[], window?: number): {
+    tool: string;
+    signature: string;
+    repeats: number;
+} | undefined;
+
+/**
+ * Live inspector — watches the Claude Code projects directory for new
+ * sessions and growing session files, runs incremental ingest, and
+ * emits structured events that the web UI subscribes to via SSE.
+ *
+ * v0.1 only watches Claude Code; the abstraction is generic enough that
+ * Codex (and others) will plug in by passing alternative discovery /
+ * ingest functions.
+ */
+type LiveEvent = {
+    type: "run:created";
+    run: Run;
+} | {
+    type: "run:updated";
+    run: Run;
+    new_steps: Step[];
+} | {
+    type: "run:completed";
+    run: Run;
+} | {
+    type: "fleet:snapshot";
+    entries: FleetEntry[];
+} | {
+    type: "alert";
+    run_id: string;
+    kind: "loop" | "stall" | "context_threshold" | "tool_called";
+    message: string;
+    meta?: Record<string, unknown>;
+}
+/**
+ * v0.3 §8.5 — fired once per step whose ingest produced one or more
+ * file_change rows. `paths` is the unique path set (deduped across
+ * old/new for renames); `partial` is true iff any row in the batch
+ * has `partial_diff = true` (e.g. Bash stubs).
+ */
+ | {
+    type: "files:changed";
+    run_id: string;
+    step_id: string;
+    paths: string[];
+    partial: boolean;
+}
+/**
+ * v0.3 §4.9 — fired on the `pause_requested → paused` transition,
+ * i.e. the moment the SDK actually blocked. `step_id` is the last
+ * step the inspector observed before the pause acknowledgment, the
+ * closest signal we have for "the step that would have started next."
+ */
+ | {
+    type: "run:paused";
+    run_id: string;
+    step_id: string | null;
+    paused_at: string;
+}
+/**
+ * v0.3 §4.9 — fired on the `paused | pause_requested → running`
+ * transition. `edits` counts distinct non-null inject values the
+ * inspector observed during the paused window. Best-effort: an
+ * inject queued and consumed entirely between two ticks won't be
+ * counted. Document, don't gold-plate.
+ */
+ | {
+    type: "run:resumed";
+    run_id: string;
+    edits: number;
+    resumed_at: string;
+};
+interface FleetEntry {
+    run: Run;
+    status: LiveStatus;
+    context_pct: number;
+    recent_tools: string[];
+    last_step_at?: string;
+    alerts: Array<{
+        kind: string;
+        message: string;
+    }>;
+}
+interface LiveOptions {
+    projectsRoot?: string;
+    /** Polling interval (ms) for the projects-root scan. Defaults to 1500. */
+    scanIntervalMs?: number;
+    /** Stall threshold in seconds. Step inactivity beyond this triggers an alert. */
+    stallSeconds?: number;
+    /** Context-threshold percentages that fire alerts (in %). */
+    contextThresholds?: number[];
+    /** Tools that, when called, fire a `tool_called` alert. */
+    watchTools?: string[];
+    /** Loop detection — N repeated identical tool calls. */
+    loopWindow?: number;
+}
+/**
+ * Build the fleet snapshot from the store. Pulled out of `LiveInspector`
+ * so the web UI can render the same view as a one-shot, even when
+ * `meter web` was launched without `--live`. Live mode passes its
+ * `firedAlerts` map; static mode passes nothing and just gets empty
+ * alert lists.
+ */
+declare function buildFleetEntries(store: Store, opts?: {
+    limit?: number;
+    stallSeconds?: number;
+    firedAlerts?: Map<string, Map<string, {
+        kind: string;
+        message: string;
+    }>>;
+}): FleetEntry[];
+declare class LiveInspector extends EventEmitter {
+    private store;
+    private opts;
+    private knownPaths;
+    private firedAlerts;
+    private lastSizes;
+    private lastStepCounts;
+    private lastStatus;
+    private probeTracks;
+    private timer?;
+    private stopped;
+    /** Set on the first scan so we can backfill state silently — historical
+     *  sessions on disk are not "new runs" the user just kicked off. */
+    private booted;
+    constructor(store: Store, opts?: LiveOptions);
+    start(): Promise<void>;
+    /**
+     * Sample the newest few sessions and validate their records against
+     * the shapes `types.ts` claims. One warning per unique drift hash
+     * (so a single schema change doesn't spam thousands of lines).
+     * Disabled when `METERBILITY_DISABLE_SHAPE_PROBE` is set — useful for
+     * tests with intentionally minimal fixtures.
+     */
+    private runShapeProbe;
+    stop(): void;
+    /**
+     * One scan: discover sessions, re-ingest any whose file has grown,
+     * compute the current fleet snapshot, fire alerts where appropriate.
+     *
+     * `silent: true` runs the same ingest pipeline but suppresses event
+     * emission — used for the first-tick backfill at startup so historical
+     * runs don't masquerade as freshly-created ones.
+     */
+    tick(opts?: {
+        silent?: boolean;
+    }): Promise<void>;
+    /**
+     * Emit `files:changed` if the given step has any file_change rows.
+     * Pulled into its own method so tests can exercise the dedup-paths
+     * shape without going through a full tick.
+     */
+    private emitFilesChangedIfAny;
+    /**
+     * Poll probe state for every run with an active probe file. Two-axis
+     * detection: the FSM `state` drives inject-window accounting; the
+     * `paused_at_ms` / `resumed_at_ms` timestamps drive `run:paused` /
+     * `run:resumed` emission. The timestamp axis matters because a full
+     * pause→ack→resume cycle can complete inside one 1500ms tick — a
+     * pure `state → state` comparison would silently swallow those
+     * events (the bug Codex flagged at this site).
+     *
+     * Runs without a probe file are skipped entirely: probe files only
+     * exist while a run is under operator control (created lazily by
+     * `requestPause` / `setInject`, removed by `clearProbe` on terminal
+     * cleanup), so the file's presence is the cleanest natural gate.
+     * Per-run reads are guarded — a single EACCES or corrupt file on
+     * one probe shouldn't degrade `/api/live` for every other run.
+     */
+    private pollProbeStates;
+    /** Compute the current fleet view (active + recently-completed runs). */
+    fleetEntries(): FleetEntry[];
+    private maybeAlert;
+}
+/**
+ * Runtime-toggleable owner of a LiveInspector. Existed implicitly in
+ * v0.2 (each `meter web --live` invocation built an inspector at
+ * startup and discarded it on close). v0.3 needs runtime toggling
+ * because the web UI's "Live" button starts/stops without restarting
+ * the server.
+ *
+ * The class is a thin shell — it forwards `on`/`off`/`fleetEntries`
+ * to whichever inspector instance is currently active, and a
+ * stopped-state stub for the off case so the routes always have
+ * something safe to call.
+ *
+ * Listener routing: the controller stores subscribers itself and
+ * re-binds them to any new inspector it spawns. That means an SSE
+ * client opened *before* live mode is enabled will start receiving
+ * events as soon as the operator hits the toggle, with no reconnect.
+ */
+declare class LiveController {
+    private store;
+    private inspector?;
+    private subscribers;
+    private storeOpts;
+    constructor(store: Store);
+    /** Spin up an inspector if one isn't already running. Idempotent. */
+    start(opts?: LiveOptions): Promise<void>;
+    /** Stop the running inspector if any. Idempotent. */
+    stop(): void;
+    isLive(): boolean;
+    on(event: "data", fn: (e: LiveEvent) => void): void;
+    off(event: "data", fn: (e: LiveEvent) => void): void;
+    /** Latest fleet snapshot — empty when not running. */
+    fleetEntries(): FleetEntry[];
+}
+
+/**
+ * Hono app over the local Store. Two surfaces share the same routes:
+ *  - JSON API (`/api/...`) — for future web/UI clients.
+ *  - Server-rendered HTML (`/`, `/runs/:id`, `/diff?a=&b=`) — what
+ *    `meter web` opens by default.
+ */
+interface BuildAppOptions {
+    /**
+     * v0.3 — runtime-toggleable live controller. Always present; the
+     * caller (serveApp) is responsible for starting it if --live was
+     * passed at boot. Routes dispatch through the controller so the
+     * web UI's Live button can start/stop without rebuilding the app.
+     */
+    controller?: LiveController;
+    /**
+     * v0.2 back-compat: tests that built an inspector manually can pass
+     * it via `live`. `buildApp` wraps it into a fresh controller and
+     * adopts the inspector's events. Prefer `controller` for new code.
+     */
+    live?: LiveInspector;
+}
+declare function buildApp(store: Store, opts?: BuildAppOptions): Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+interface ServeOptions {
+    port?: number;
+    host?: string;
+    live?: boolean;
+    liveOptions?: LiveOptions;
+}
+declare function serveApp(store: Store, opts?: ServeOptions): {
+    url: string;
+    close: () => void;
+    controller: LiveController;
+    /** Back-compat shim — returns the controller's current inspector
+     *  (undefined when not live). Existing callers that captured
+     *  `result.live` continue to compile. */
+    live?: LiveInspector;
+};
+
+/**
+ * Regression suite (v0.1).
+ *
+ * A test is a named bundle of assertions. Assertions are pure: they take
+ * a (run, steps) pair and return pass/fail. v0.1 supports the structural
+ * checks called out in SPEC §7.3 — tool-call presence, output-text
+ * matching, step counts, final status, cost ceiling. LLM-judge
+ * assertions are deferred to v1.
+ *
+ * Tests are stored in the local SQLite store as JSON-encoded assertion
+ * arrays so they round-trip cleanly via export/import.
+ */
+type AssertionKind = "includes_tool_call" | "excludes_tool_call" | "tool_call_count" | "output_contains" | "output_does_not_contain" | "min_steps" | "max_steps" | "final_status" | "max_cost_cents" | "no_error_step" | "step_status_at";
+interface Assertion {
+    kind: AssertionKind;
+    /** A flexible payload — string for text assertions, number for counts, etc. */
+    value: string | number;
+    /** Optional sequence index for `step_status_at`. */
+    at?: number;
+    /** Friendly label for reports. */
+    label?: string;
+}
+interface RegressionTest {
+    test_id: string;
+    name: string;
+    description?: string;
+    assertions: Assertion[];
+    canonical_run_id?: string;
+    created_at: string;
+}
+interface AssertionResult {
+    assertion: Assertion;
+    passed: boolean;
+    reason: string;
+}
+interface RegressionResult {
+    result_id: string;
+    test_id: string;
+    test_name: string;
+    run_id: string;
+    passed: boolean;
+    assertions: AssertionResult[];
+    created_at: string;
+}
+declare function listTests(store: Store): RegressionTest[];
+declare function getTestByName(store: Store, name: string): RegressionTest | undefined;
+declare function createTest(store: Store, args: {
+    name: string;
+    description?: string;
+    assertions: Assertion[];
+    canonical_run_id?: string;
+}): RegressionTest;
+declare function deleteTest(store: Store, name: string): boolean;
+declare function addAssertion(store: Store, testName: string, assertion: Assertion): RegressionTest;
+/**
+ * Build a starter test from a canonical run. Each tool used in the run
+ * becomes an `includes_tool_call`; final status becomes `final_status`;
+ * total step count becomes `max_steps × 1.5` and `min_steps × 0.5` — a
+ * loose envelope the operator can tighten by hand later.
+ */
+declare function deriveAssertionsFromRun(run: Run, steps: Step[]): Assertion[];
+declare function runTest(store: Store, test: RegressionTest, runId: string): RegressionResult;
+declare function listResults(store: Store, testId?: string, limit?: number): RegressionResult[];
+
+/**
+ * Multi-step continuation engine. After a fork has materialized its
+ * deterministic prefix, this drives the agent loop until either:
+ *   - the model produces a message (no tool call), or
+ *   - max iterations are exceeded, or
+ *   - a tool is requested that we cannot resolve in `simulate` mode.
+ *
+ * Two modes are offered, mirroring SPEC §7.2:
+ *
+ *   simulate — run the model live, but for each tool the model picks,
+ *     look up the *original* run's tool result and feed that back. Only
+ *     works when the model picks a tool whose call signature appears in
+ *     the origin run; otherwise the loop stops with a `simulate_miss`
+ *     marker tag on the last step.
+ *
+ *   live — run the model live AND execute tools via the caller-supplied
+ *     executor. Side-effecting; the caller takes responsibility for
+ *     sandboxing.
+ */
+type ContinuationMode = "simulate" | "live";
+interface ContinuationCallArgs {
+    /** History assembled so far (user/assistant turns, oldest → newest). */
+    history: ConversationMessage[];
+    /** The most recent step in the fork run. */
+    prior_step: Step;
+    /** Resolved system prompt content (if available). */
+    system_prompt?: string;
+    /** Iteration number, 0-indexed. */
+    iteration: number;
+}
+interface ContinuationCallResult {
+    model: string;
+    /** Raw model output to persist as decision blob. */
+    decision_content: unknown;
+    action: Action;
+    tokens: TokenUsage;
+    latency_ms: number;
+}
+type ContinuationModelCaller = (args: ContinuationCallArgs) => Promise<ContinuationCallResult>;
+interface ToolCall {
+    tool_name: string;
+    tool_use_id?: string;
+    tool_input: unknown;
+}
+interface ToolExecutionResult {
+    /** Anything serializable. Stored as a tool_result blob. */
+    output: unknown;
+    is_error?: boolean;
+    /** Human-readable one-liner. */
+    summary?: string;
+}
+type ToolExecutor = (call: ToolCall) => Promise<ToolExecutionResult>;
+interface ContinuationOptions {
+    mode: ContinuationMode;
+    modelCaller: ContinuationModelCaller;
+    /** Required in `live` mode; ignored in `simulate`. */
+    toolExecutor?: ToolExecutor;
+    /** Cap iterations to bound runaway loops. Defaults to 25. */
+    maxIterations?: number;
+    /** Origin run id — used by simulate mode to look up cached tool results. */
+    originRunId?: string;
+}
+interface ContinuationResult {
+    iterations_run: number;
+    steps_added: number;
+    terminal_reason: "model_completed" | "max_iterations" | "simulate_miss" | "tool_error" | "model_error";
+    final_step_id: string;
+}
+declare function continueFork(store: Store, forkRunId: string, opts: ContinuationOptions): Promise<ContinuationResult>;
+/**
+ * Helper: simulate-mode tool results store a `__ref` pointer rather than
+ * the inline bytes (so we don't double-store). Resolve it back to a real
+ * value when downstream code needs the actual result.
+ */
+declare function resolveSimulatedResult(store: Store, result: unknown): Promise<unknown>;
+
+/**
+ * Slack notifier — subscribes to a LiveInspector and posts shaped Block
+ * Kit messages to an incoming webhook. Stays out of the hot path: posts
+ * are fire-and-forget, errors are logged but don't crash the watcher.
+ *
+ * Anchor URLs use the server's externally-reachable origin (passed via
+ * `serverUrl`) so operators can jump from Slack into Meterbility's web UI.
+ */
+type SlackEventKind = "alert" | "run:created" | "run:completed";
+interface SlackNotifierOptions {
+    /** Incoming-webhook URL (https://hooks.slack.com/services/...). */
+    webhookUrl: string;
+    /** External origin of the local Meterbility web UI for clickable links. */
+    serverUrl?: string;
+    /** Which event types to post. Defaults to alerts only. */
+    events?: SlackEventKind[];
+    /** Optional channel override (only honored by some workspaces). */
+    channel?: string;
+    /** Cap posts per minute to keep things tame. Default 30. */
+    rateLimitPerMinute?: number;
+}
+declare class SlackNotifier {
+    private opts;
+    private bucket;
+    private detach?;
+    constructor(opts: SlackNotifierOptions);
+    attach(live: LiveInspector): void;
+    detachFrom(): void;
+    handleEvent(e: LiveEvent): Promise<void>;
+    /**
+     * Send a one-off test message — used by `meter slack test`.
+     */
+    sendTest(): Promise<void>;
+    private acquireRateLimitToken;
+    private formatPayload;
+}
+
+/**
+ * pretty.ts — schema-aware pretty-print for the four step-detail tabs
+ * (action, outcome, decision, cost) shown by `meter inspect` and the
+ * web step cards.
+ *
+ * Raw JSON stays the default everywhere; pretty mode is opt-in via the
+ * CLI `--pretty-print` flag or the per-step `Pretty (all tabs)` button
+ * on the web. This module is the single source of truth for both.
+ *
+ * Pure: no I/O. Callers pre-resolve blob refs and pass text in via
+ * `opts.toolResultText`.
+ */
+type PrettyMode = "ansi" | "plain" | "html";
+interface PrettyOptions {
+    mode: PrettyMode;
+    /** Cap for individual string values. Anything longer truncates with "… (N more chars)". */
+    maxStringLen?: number;
+    /** Spaces per indent level. */
+    indent?: number;
+    /** Caller pre-resolves outcome.tool_result_ref and passes the text here. */
+    toolResultText?: string;
+    /** Caller signal: the source decision string hit a slice cap upstream. */
+    truncated?: boolean;
+    /** Web-only: link to the raw blob endpoint (e.g. "/api/blob/abc..."). */
+    rawBlobHref?: string;
+}
+type TabKind = "action" | "outcome" | "decision" | "cost";
+/**
+ * Server-side slice limit for the decision preview blob (see
+ * `loadDecisionPreviews` in `web.ts`). When a decision string lands at
+ * the renderer with `length >= this`, the caller treats it as
+ * truncated and pretty mode swaps the `(not JSON)` fallback for
+ * `(truncated · view raw)`.
+ */
+declare const DECISION_PREVIEW_LIMIT = 32000;
+/**
+ * Render a multi-line string as `┃ ` prefixed lines. Handles both \n
+ * and \r\n. Truncates the rendered string at maxStringLen.
+ */
+declare function prettyMultilineString(s: string, opts: PrettyOptions): string;
+/**
+ * Render any JSON-ish value at the given depth. `depth` is the nesting
+ * level (object/array containers); strings and primitives don't
+ * increment it. Hits MAX_DEPTH at 16 and emits a marker.
+ */
+declare function prettyValue(v: unknown, opts: PrettyOptions, depth: number): string;
+declare function prettyTab(kind: TabKind, value: unknown, opts: PrettyOptions): string;
+/**
+ * Parse a JSON string and re-stringify with 2-space indent. If the
+ * input is not valid JSON, return it unchanged. Pure helper; no
+ * coloring, no schema awareness. Replaces:
+ *   - packages/cli/src/commands/inspect.ts:456 prettyJson
+ *   - packages/server/src/html.ts:3068        prettyJson
+ *   - packages/server/src/html.ts:3393        prettyJsonMaybe
+ */
+declare function reformatJsonString(s: string): string;
+
+export { type AnthropicResponderOptions, type Assertion, type AssertionKind, type AssertionResult, type BuildAppOptions, type ContinuationCallArgs, type ContinuationCallResult, type ContinuationMode, type ContinuationModelCaller, type ContinuationOptions, type ContinuationResult, DECISION_PREVIEW_LIMIT, type DiffResult, type DiffRow, type DiffRowKind, type FleetEntry, type ForkArgs, type ForkOutcome, LiveController, type LiveEvent, LiveInspector, type LiveOptions, type LiveResponder, type LiveResponderArgs, type LiveResponderResult, type LiveStatus, type PrettyMode, type PrettyOptions, type RegressionResult, type RegressionTest, type ReplayMode, type ReplayResult, type ServeOptions, type SlackEventKind, SlackNotifier, type SlackNotifierOptions, type StepDigest, type TabKind, type ToolCall, type ToolExecutionResult, type ToolExecutor, addAssertion, anthropicResponder, appendLiveStep, buildApp, buildFleetEntries, classifyRunStatus, contextUtilization, continueFork, createTest, deleteTest, deriveAssertionsFromRun, detectLoop, diffRuns, fakeResponder, forkRun, getTestByName, listResults, listTests, materializePrefix, prettyMultilineString, prettyTab, prettyValue, reformatJsonString, resolveSimulatedResult, rewriteSnapshot, runTest, serveApp };