@get-bb/plugin-sdk 0.4.24 → 0.4.27

package/bundled-types/bb-plugin-sdk-provider-bridge-testing.d.ts

@@ -17,26 +17,6 @@ declare const threadEventItemPresentationLabelSchema: z.ZodObject<{
     pending: z.ZodString;
 }, z.core.$strip>;
 type ThreadEventItemPresentationLabel = z.infer<typeof threadEventItemPresentationLabelSchema>;
-/**
- * The row's leading icon, by name. Two vocabularies share the one field:
- *
- * - a host glyph (`{ glyph: "FileText" }`), the same names the plugin
- *   branding and provider declaration icons use;
- * - a plugin-declared icon (`{ glyph: "echo-provider/receipt" }`), the
- *   namespaced form `"<pluginId>/<name>"` that names an entry of the
- *   plugin's manifest map `bb.branding.experimental_icons`
- *   (`NAMESPACED_GLYPH_PATTERN` in plugin-icon.ts). The server rejects at
- *   ingest a namespaced glyph that is not the emitting plugin's own declared
- *   icon; clients resolve the name against the plugin inventory they hold
- *   and draw the SVG tinted with `currentColor`.
- *
- * Both are names, never bytes or paths: the row persists the name and
- * follows the plugin's current map at render time. If the plugin is gone or
- * the name is unknown when the row renders, the icon is simply not found and
- * the per-kind fallback glyph draws instead — accepted, so a persisted row
- * never depends on a file that may have moved. The schema stays a plain
- * non-blank string on purpose: persisted rows must parse forever.
- */
 declare const threadEventItemPresentationIconSchema: z.ZodObject<{
     glyph: z.ZodString;
 }, z.core.$strip>;
@@ -114,15 +94,6 @@ declare const threadEventWebFetchItemSchema: z.ZodObject<{
     url: z.ZodString;
 }, z.core.$strip>;
 type ThreadEventWebFetchItem = z.infer<typeof threadEventWebFetchItemSchema>;
-/**
- * A file the agent read. The single most common generic tool in the
- * production corpus (Claude `Read`: 7,568 calls across 141 threads rendered
- * as an opaque `toolCall`), so it earns a core kind: clients show the path,
- * the permission matrix treats it as a read, and no tool-name table is
- * needed to recognise it. `cmd` carries the native shell form when the
- * provider read through a command (`cat`, `sed -n`) rather than a structured
- * tool, so the row can still show what actually ran.
- */
 declare const threadEventFileReadItemSchema: z.ZodObject<{
     cmd: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
@@ -153,16 +124,6 @@ declare const threadEventFileReadItemSchema: z.ZodObject<{
     type: z.ZodLiteral<"fileRead">;
 }, z.core.$strip>;
 type ThreadEventFileReadItem = z.infer<typeof threadEventFileReadItemSchema>;
-/**
- * One kind for every exploration tool that is not a file read: grep, glob,
- * and directory listing, discriminated by `mode`. Claude `Grep` + `Glob` and
- * the shell `rg`/`ls`/`find` commands bridges already classify into
- * `command` activity intents all fold into it. `query` is the pattern: text
- * or a regex for `content`, a glob for `path`, and an optional filter for
- * `list` (empty when the whole directory is listed). `path` is the root the
- * search ran under when the provider named one. `cmd` carries the native
- * shell form when the provider searched through a command.
- */
 declare const threadEventSearchItemSchema: z.ZodObject<{
     cmd: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
@@ -199,22 +160,6 @@ declare const threadEventSearchItemSchema: z.ZodObject<{
     type: z.ZodLiteral<"search">;
 }, z.core.$strip>;
 type ThreadEventSearchItem = z.infer<typeof threadEventSearchItemSchema>;
-/**
- * The agent delegated work to a child agent. One kind replaces the three
- * encodings in the production data — codex `spawnAgent`/`wait` tool calls,
- * the Claude `Agent` tool call with nested child turns, and backgrounded
- * `local_agent` background tasks — and the `thread/openWork` notification:
- * an open delegation IS open work.
- *
- * `childRef` is the provider-native id of the child (a codex agent id, a
- * Claude subagent id, a bb child thread id when the delegation became a bb
- * thread); child turns link back through their `parentToolCallId`.
- * `background: true` marks a delegation that outlives its spawning turn, in
- * which case its progress and terminal state ride the thread-scoped
- * `item/delegation/progress` and `item/delegation/completed` events exactly
- * as `backgroundTask` does; a foreground delegation settles through the
- * ordinary turn-scoped `item/completed`.
- */
 declare const threadEventDelegationItemSchema: z.ZodObject<{
     background: z.ZodBoolean;
     childRef: z.ZodString;
@@ -247,14 +192,6 @@ declare const threadEventDelegationItemSchema: z.ZodObject<{
     type: z.ZodLiteral<"delegation">;
 }, z.core.$strip>;
 type ThreadEventDelegationItem = z.infer<typeof threadEventDelegationItemSchema>;
-/**
- * A structured plan snapshot the agent maintains as an item: codex
- * `update_plan` (its `turn/plan/updated` notification reaches 295 threads in
- * the production corpus and the UI discards it today) and the Claude
- * `TaskCreate`/`TaskUpdate`/`TodoWrite` family. Each snapshot carries the
- * full step list; a later snapshot supersedes an earlier one. Distinct from
- * the `plan` item, which is the free-text plan-mode document.
- */
 declare const threadEventPlanStepsItemSchema: z.ZodObject<{
     explanation: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
@@ -293,14 +230,6 @@ declare const threadEventPlanStepsItemSchema: z.ZodObject<{
     type: z.ZodLiteral<"planSteps">;
 }, z.core.$strip>;
 type ThreadEventPlanStepsItem = z.infer<typeof threadEventPlanStepsItemSchema>;
-/**
- * A plugin-defined item kind outside the core vocabulary
- * (`"<pluginId>/<name>"`, see provider-extension-kind.ts). The payload is
- * opaque JSON here; the server validates it against the owning plugin's
- * declared schema at ingest. `presentation` is REQUIRED — an
- * extension item has no core renderer to fall back on, so the declarative
- * base is the only thing every client can show.
- */
 declare const threadEventExtensionItemSchema: z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodString & z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>;
@@ -331,13 +260,6 @@ declare const threadEventExtensionItemSchema: z.ZodObject<{
     type: z.ZodLiteral<"extension">;
 }, z.core.$strip>;
 type ThreadEventExtensionItem = z.infer<typeof threadEventExtensionItemSchema>;
-/**
- * A materialized provider background task. Dynamic workflows (taskType
- * "local_workflow"), backgrounded shell commands (taskType "local_bash"), and
- * backgrounded subagents (taskType "local_agent" / "local_subagent") become
- * items. The item id is derived from the provider task id and stays stable
- * across the started → progress* → completed lifecycle.
- */
 declare const threadEventBackgroundTaskItemSchema: z.ZodObject<{
     description: z.ZodString;
     error: z.ZodOptional<z.ZodString>;
@@ -982,7 +904,6 @@ declare const threadEventItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"extension">;
 }, z.core.$strip>], "type">;
 type ThreadEventItem = z.infer<typeof threadEventItemSchema>;
-/** All thread events — provider-originated or system-originated. */
 declare const threadEventSchema: z.ZodPipe<z.ZodUnknown, z.ZodUnion<readonly [z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
     threadId: z.ZodString;
     type: z.ZodLiteral<"thread/started">;
@@ -3394,12 +3315,6 @@ declare const promptInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "type">;
 type PromptInput = z.infer<typeof promptInputSchema>;
 
-/**
- * The inclusive `[min, max]` range of `thread/delta` grammar versions a bridge
- * speaks. Distinct from the JSON-RPC `protocolVersion`: the envelope can stay
- * put while the delta vocabulary grows, and a bridge that speaks both v2 and
- * v3 says so here instead of forcing a daemon bump.
- */
 declare const bridgeGrammarVersionsSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
 type BridgeGrammarVersions = z.infer<typeof bridgeGrammarVersionsSchema>;
 
@@ -4185,15 +4100,6 @@ declare const threadDeltaSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "kind">;
 type ThreadDelta = z.infer<typeof threadDeltaSchema>;
 
-/**
- * The `thread/delta` grammar range this assembler speaks, reported to every
- * bridge in the `initialize` params so the two sides negotiate a version
- * (see `negotiateGrammarVersion` in the protocol). `[3, 3]`: the v2 dialects
- * (`message.*`, `usage.turn`/`usage.exact`) are deleted, so a bridge whose
- * range lacks 3 — including one that predates `grammarVersions` and reads as
- * `[2, 2]` — is refused at the handshake with a legible error instead of
- * connecting to an assembler that would drop its every stream.
- */
 declare const ASSEMBLER_GRAMMAR_VERSIONS: BridgeGrammarVersions;
 interface DiffCumulativeTextArgs {
     nextText: string;
@@ -4205,35 +4111,10 @@ interface DiffCumulativeTextResult {
     reset: boolean;
 }
 interface CreateDeltaAssemblerOptions {
-    /** Provider id stamped onto provider/unhandled events. */
     providerId: string;
-    /**
-     * Entropy prefix for minted turn/item ids. Defaults to fresh per-assembler
-     * entropy so ids never collide across assembler (process) restarts; tests
-     * inject a fixed prefix for determinism.
-     */
     entropyPrefix?: string;
-    /**
-     * Minimum gap between emitted `item.progress` events per item key
-     * (`flush: true` bypasses it; `item.close` always emits). 500ms default —
-     * the cadence the claude bridge hand-rolled for background-task snapshots,
-     * now the central policy for every provider's progress stream.
-     */
     progressThrottleMs?: number;
-    /**
-     * Coalescing window for streamed-text events (assistant/reasoning/plan
-     * deltas and command/fileChange output deltas) per stream. Within the
-     * window consecutive deltas concatenate into one emitted event of the same
-     * type; the buffer flushes trailing-edge with no timers — on the thread's
-     * next traffic once the window elapsed, on stream close, and before ANY
-     * non-batchable event for the thread (the ordering barrier: coalescing
-     * never reorders text relative to item opens/closes, turn events, errors,
-     * or other streams' flushes). The first delta of a fresh stream always
-     * emits immediately, keeping time-to-first-token unchanged. 100ms default;
-     * 0 disables batching (one event per delta).
-     */
     textDeltaFlushMs?: number;
-    /** Clock override for tests. */
     now?: () => number;
 }
 interface AssembleDeltasArgs {
@@ -4242,87 +4123,37 @@ interface AssembleDeltasArgs {
 }
 interface DeltaAssembler {
     assemble(args: AssembleDeltasArgs): ThreadEvent[];
-    /** bb item id minted for a provider item id (command-plane lookup). */
     getBbItemId(threadId: string, providerItemId: string): string | undefined;
-    /** Provider item id behind a bb item id (reverse command-plane lookup). */
     getProviderItemId(threadId: string, bbItemId: string): string | undefined;
-    /** bb turn id minted for a vouched provider turn id. */
     getBbTurnId(threadId: string, providerTurnId: string): string | undefined;
-    /** Provider turn id behind a bb turn id (steer/interrupt reverse lookup). */
     getProviderTurnId(threadId: string, bbTurnId: string): string | undefined;
     getOpenTurnId(threadId: string): string | undefined;
 }
 declare function createDeltaAssembler(options: CreateDeltaAssemblerOptions): DeltaAssembler;
 
-/**
- * Test-side view of the runtime's delta assembly: bridge tests capture raw
- * JSON-RPC output, and bridges emit `thread/delta` notifications rather than
- * finished `ThreadEvent`s. These helpers run captured notifications through
- * the real delta assembler — the exact translation the bridge protocol
- * adapter performs — so assertions keep working against canonical
- * `ThreadEvent`s.
- */
-
 interface CapturedBridgeNotification {
     method?: string;
     params?: unknown;
 }
 interface BridgeDeltaEventCollector {
     assembler: DeltaAssembler;
-    /** Canonical events for one captured notification (empty for non-deltas). */
     assembleMessage(message: CapturedBridgeNotification): ThreadEvent[];
 }
 declare function createBridgeDeltaEventCollector(providerId?: string): BridgeDeltaEventCollector;
-/**
- * All canonical events an ordered capture of bridge notifications assembles
- * to. Builds a fresh assembler per call, so feed it the full capture (not an
- * incremental slice) for deterministic ids.
- */
 declare function assembleCapturedThreadEvents(messages: readonly CapturedBridgeNotification[], providerId?: string): ThreadEvent[];
-/**
- * Removed (SDK 0.4.16): the conformance kit assembles `thread/delta` itself.
- * A transport hands `runBridgeConformance` the raw captured messages
- * (`CapturedBridgeJsonRpcOutput.takeMessages`) and the run names its
- * `providerId`; this stub stays one release so a suite written against the
- * old transport shape fails with the replacement named, not a missing export.
- */
 declare function toConformanceMessages(): never;
 
-/**
- * Transport abstraction the conformance kit drives. Black-box at the message
- * level: lines in, JSON-RPC messages out. Two expected implementations — an
- * in-process bridge (`send` = the bridge's exported line handler,
- * `takeMessages` = the captured output's drain) and a spawned bridge binary
- * (stdin write + stdout readline). The kit never sees which: it assembles
- * the bridge's `thread/delta` notifications itself, through the runtime's
- * real delta assembler, so the transport hands over raw wire messages only.
- */
 interface BridgeConformanceTransport {
-    /** Deliver one raw line to the bridge. */
     send(line: string): void;
-    /**
-     * Every JSON-RPC message the bridge emitted since the last call, in order:
-     * responses, notifications (`thread/delta` included) and bridge-initiated
-     * requests, as parsed JSON.
-     */
     takeMessages(): unknown[];
     close?(): Promise<void> | void;
 }
-/**
- * Retired. The kit once read its canonical events from a notification the
- * transport assembled under this method; it now assembles `thread/delta`
- * itself and reads nothing under this name. Kept because SDK 0.4.x published
- * it from `@get-bb/plugin-sdk/provider-bridge/testing`; removed at the next
- * major version.
- */
 declare const CONFORMANCE_ASSEMBLED_EVENT_METHOD = "conformance/assembledEvent";
 type ConformanceStatus = "fail" | "pass" | "skipped";
 interface ConformanceCheckResult {
-    /** Stable rule id, e.g. "rpc/unknown-method". */
     id: string;
     title: string;
     status: ConformanceStatus;
-    /** Failure or skip explanation; empty on pass. */
     detail: string;
 }
 interface ConformanceReport {
@@ -4331,119 +4162,35 @@ interface ConformanceReport {
 }
 
 interface ConformanceSessionFixture {
-    /** Workspace directory for the session under test. */
     cwd: string;
-    /** Prompt expected to elicit at least one assistant-message item. */
     promptInput: PromptInput[];
-    /**
-     * A prompt this provider accepts and completes locally, without producing
-     * any of the activity that opens a bb turn — Claude Code's `/clear` is the
-     * canonical example (#1431). Opting in enables
-     * `turn/settles-without-activity`.
-     *
-     * The kit cannot elicit this shape generically: only the bridge knows what
-     * its provider handles as zero work. A fixture that omits it produces no
-     * result for that rule rather than a skip, so bridges that have not opted in
-     * keep a fully green report.
-     */
     zeroWorkPromptInput?: PromptInput[];
-    /**
-     * A prompt that opens a turn and never settles it on its own, so the kit
-     * can interrupt it. Opting in enables `session/threads-independent` and
-     * `stop/interrupt-settles-before-result` (the kit names the turn to the
-     * bridge through its own assembler's reverse map). A fixture that omits it
-     * produces no result for those rules.
-     */
     interruptiblePromptInput?: PromptInput[];
-    /** Execution options for the session; the kit defaults to full mode. */
     options?: Record<string, unknown>;
-    /**
-     * The plugin's declared icons (`bb.branding.experimental_icons`): its
-     * plugin id and the declared names. Opting in enables
-     * `presentation/icon-namespaced-declared`, which fails when any item's
-     * `presentation.icon.glyph` is a namespaced glyph (`"<pluginId>/<name>"`)
-     * that names another plugin or an undeclared name — what the server
-     * would refuse at ingest with `provider/unhandled`. A `server: "bb"` tool
-     * row is not inspected: its presentation came from the plugin that
-     * registered the tool, and the server checks it against that plugin. A
-     * fixture that omits `icons` produces no result for the rule, like the
-     * other opt-in rules, so a bridge whose plugin declares no icons keeps a
-     * fully green report.
-     */
     icons?: {
         pluginId: string;
         names: readonly string[];
     };
 }
 
-/**
- * Recorded-traffic conformance.
- *
- * The scripted scenarios in `scenarios.ts` drive a bridge with a fake
- * provider the kit authors wrote. This set drives it with what the provider
- * CLI really emitted: a committed recording (`recordings/<provider>/<cell>`),
- * replayed through the bridge by `testing/parity.ts`, checked with the same
- * grammar rules. A bridge passes when the replay reproduces a complete,
- * schema-valid, grammar-clean session for every recorded cell — so a
- * translation change that only the real dialect exercises fails conformance,
- * not just a golden.
- *
- * Pure over a replay's output, like `checkItemOpensBeforeDelta`: the caller
- * owns the bridge transport and the replay; this module owns the verdicts.
- */
-
-/** The cells every bridge is expected to reproduce (the live-QA matrix core). */
 declare const RECORDED_CONFORMANCE_CELLS: readonly ["turn-tools", "steer", "stop-interrupt", "approval-allow", "approval-deny", "user-question", "resume", "fork"];
 type RecordedConformanceCell = (typeof RECORDED_CONFORMANCE_CELLS)[number];
 interface RecordedCellReplay {
     provider: string;
     cell: string;
-    /** Events the replayed bridge output assembled to, in order. */
     events: readonly ThreadEvent[];
-    /**
-     * Events the recording's own bridge output assembled to: the turn count the
-     * replay must reach. A provider that legitimately refused a cell (an ACP
-     * agent without `session/fork`) recorded no turns, and the replay must
-     * reproduce that rather than invent one.
-     */
     recordedEvents: readonly ThreadEvent[];
-    /** Requests the harness had to answer for the bridge, or gates that timed out. */
     stalls: readonly string[];
 }
-/**
- * The verdicts for one replayed cell. Rule ids are `recorded/<cell>/<rule>`
- * so a report lists every cell and a regression names the one it broke.
- */
 declare function checkRecordedCellReplay(replay: RecordedCellReplay): ConformanceCheckResult[];
 
 interface RunBridgeConformanceOptions {
     transport: BridgeConformanceTransport;
     session: ConformanceSessionFixture;
-    /**
-     * The provider id the bridge's plugin registers. The kit assembles the
-     * bridge's `thread/delta` stream through the runtime's real delta
-     * assembler, and the canonical events it builds carry this id, as the
-     * runtime's would.
-     */
     providerId: string;
-    /** Per-wait timeout. Conformant bridges answer fast; keep this tight. */
     timeoutMs?: number;
 }
-/**
- * Drive one bridge through the conformance scenarios: JSON-RPC hygiene, the
- * initialize handshake, then a shared session lifecycle (start → turn →
- * grammar checks → release stop → resume with its identity → id-uniqueness
- * → fork with its identity when the handshake declares fork → the opt-in
- * rules), released at the end the way the runtime releases a thread it
- * detaches. One transport for the whole run, mirroring a real bridge
- * lifetime.
- *
- * Against a conformant bridge every result passes. Against a bridge that is
- * not yet protocol-pure, the failures ARE the migration work list — run it
- * before migrating and pin the report, then make it shrink.
- */
 declare function runBridgeConformance(options: RunBridgeConformanceOptions): Promise<ConformanceReport>;
-/** Compact single-line-per-rule rendering for test snapshots and logs. */
 declare function formatConformanceReport(report: ConformanceReport): string;
 
 type BridgeJsonRpcId = string | number;
@@ -4465,16 +4212,11 @@ interface BridgeJsonRpcOutputMessage {
 }
 interface CapturedBridgeJsonRpcOutput {
     messages: BridgeJsonRpcOutputMessage[];
-    /**
-     * Every message since the last call: the conformance transport's drain
-     * (`{ send: handleLine, takeMessages: output.takeMessages }`).
-     */
     takeMessages(): BridgeJsonRpcOutputMessage[];
     restore(): void;
 }
 interface BridgeJsonRpcTestHarness {
     messages: BridgeJsonRpcOutputMessage[];
-    /** Every message since the last call: the conformance transport's drain. */
     takeMessages(): BridgeJsonRpcOutputMessage[];
     flushWork(): Promise<void>;
     hasResponse(id: BridgeJsonRpcId): boolean;
@@ -4482,64 +4224,22 @@ interface BridgeJsonRpcTestHarness {
     sendRequest(id: BridgeJsonRpcId, method: string, params: BridgeJsonRpcObject): void;
     waitForResponse(id: BridgeJsonRpcId): Promise<BridgeJsonRpcOutputMessage>;
 }
-/**
- * Capture everything a bridge writes to stdout as parsed JSON-RPC messages.
- * Patches `process.stdout.write` directly (no test-framework spy), so the
- * kit runs under any runner; `restore()` puts the original writer back.
- */
 declare function captureBridgeJsonRpcOutput(): CapturedBridgeJsonRpcOutput;
 declare function createBridgeJsonRpcTestHarness(handleLine: BridgeJsonRpcLineHandler): BridgeJsonRpcTestHarness;
 
-/**
- * Dual-path calibration support.
- *
- * A calibration replays one scripted provider session through both the legacy
- * adapter and the canonical bridge, then diffs the two ThreadEvent streams.
- * Anything the diff reports is either a deliberate, documented protocol
- * difference (the bridge synthesizes item/started, announces thread/identity,
- * …) or a regression — there is no third category, which is what makes these
- * suites a graduation gate.
- *
- * Ids legitimately differ between the paths: the legacy adapter numbers from
- * its process-lifetime translator ("turn-1", "claude-assistant-2"), while a
- * canonical session mints per-session entropy ("bt3f9a2b1c-1-…") so ids stay
- * unique across resumes (#1224). Normalization interns them by first-seen
- * order instead of matching either scheme, so a stream that *reused* an id
- * still diffs.
- */
 interface NormalizeCalibrationEventsOptions {
-    /**
-     * Ids the provider itself owns (tool call ids, checkpoints) are identical on
-     * both paths and are left alone. Anything reaching the intern table is a
-     * translator- or bridge-minted id.
-     */
     internedIdFields?: readonly string[];
 }
-/**
- * Normalize one path's stream. Each stream gets its own interner, so the token
- * a given id receives depends only on the order ids first appear — identical
- * across paths when the streams agree, different the moment they do not.
- */
 declare function normalizeCalibrationEvents(events: readonly ThreadEvent[], options?: NormalizeCalibrationEventsOptions): unknown[];
-/** Compact `type` (+ item type) rendering for asserting a known-divergence list. */
 declare function describeCalibrationEvents(events: readonly unknown[]): string[];
 
 declare const BRIDGE_RECORDING_DIRECTIONS: readonly ["runtime→bridge", "bridge→runtime", "provider→bridge", "bridge→provider"];
 type BridgeRecordingDirection = (typeof BRIDGE_RECORDING_DIRECTIONS)[number];
 interface BridgeRecordingEntry {
-    /** Wall-clock milliseconds when the line crossed. */
     ts: number;
-    /**
-     * The recorder's start time, identifying the bridge process that wrote the
-     * entry. A thread can span several bridge processes (the runtime restarts a
-     * bridge, or releases and later resumes the thread), each appending to the
-     * same files with its own `seq`; `(run, seq)` orders entries exactly.
-     */
     run: number;
-    /** Process-wide monotonic counter across all four lanes. */
     seq: number;
     dir: BridgeRecordingDirection;
-    /** The raw line, without its terminator. */
     line: string;
 }
 
@@ -4558,22 +4258,9 @@ interface BridgeRecordingManifest {
 interface BridgeRecording {
     dir: string;
     manifest: BridgeRecordingManifest | null;
-    /** Every lane merged back into wire order: by bridge process, then seq. */
     entries: BridgeRecordingEntry[];
 }
-/**
- * The file a bridge change re-records its side of the wire into
- * (`pnpm rerecord`): the `bridge→runtime` lane as THIS checkout's bridge
- * emits it for the recording's provider and runtime lanes. The recorded lane
- * itself is never rewritten — it is the recording, and a pre-migration
- * checkout paces its replay from it — so the current expectation lives
- * beside it. Absent until a bridge change first needs one.
- */
 declare const CURRENT_BRIDGE_LANE_FILE = "bridge\u2192runtime.current.ndjson";
-/**
- * The recording with its `bridge→runtime` lane replaced by the current
- * expectation when one exists: what the self-suite pins and compares.
- */
 declare function withCurrentBridgeLane(recording: BridgeRecording): BridgeRecording;
 declare function readBridgeRecording(dir: string): BridgeRecording;
 interface RecordedCell {
@@ -4581,13 +4268,8 @@ interface RecordedCell {
     cell: string;
     dir: string;
 }
-/**
- * Every `<provider>/<cell>` directory under a recordings root that holds at
- * least one lane, sorted for stable iteration.
- */
 declare function listRecordedCells(root: string): RecordedCell[];
 
-/** One stateful assembler: `thread/delta` notifications in, events out. */
 interface ParityAssembler {
     assembleMessage(message: {
         method?: string;
@@ -4595,140 +4277,55 @@ interface ParityAssembler {
     }): ThreadEvent[];
 }
 type CreateParityAssembler = (providerId: string) => ParityAssembler;
-/** Project canonical events into timeline rows (the server's projection). */
 type ParityRowProjector = (args: {
     events: readonly ThreadEvent[];
     providerId: string;
 }) => unknown[];
-/** A bridge process, ready to spawn: the bootstrap, the module, its scope. */
 interface ProviderBridgeLaunch {
     command: string;
     args: string[];
     cwd: string;
-    /** Added to the harness's own environment for the bridge process. */
     env: Record<string, string>;
 }
 interface ResolveProviderBridgeLaunchOptions {
-    /**
-     * The bridge module: the file whose `experimental_providerBridge` export the
-     * bootstrap runs. Absolute; a built artifact (`host.mjs`) or, with a
-     * TypeScript loader among `nodeArgs`, the source file.
-     */
     modulePath: string;
-    /** The plugin the bridge belongs to (its data and temp directories). */
     pluginId: string;
-    /** Working directory of the bridge process; defaults to the caller's. */
     cwd?: string;
-    /**
-     * The plugin data directory the bootstrap hands the bridge; defaults to a
-     * fresh temp directory per launch.
-     */
     dataDir?: string;
-    /**
-     * The provider-bridge bootstrap (`bridge-worker-entry`) that runs the
-     * module; defaults to the kit's own — the source entry in a bb checkout,
-     * the bundled one in the published SDK.
-     */
     bootstrapPath?: string;
-    /**
-     * Node flags before the bootstrap. Defaults: in a bb checkout (source
-     * bootstrap) `--conditions=source` plus the tsx loader; otherwise the tsx
-     * loader for a TypeScript module and nothing for a built one.
-     */
     nodeArgs?: string[];
 }
-/**
- * The process that runs one bridge module through the bootstrap — exactly the
- * shape the runtime spawns, so a replayed bridge sees the argv, stdin framing
- * and signal handling it gets in production.
- */
 declare function resolveProviderBridgeLaunch(options: ResolveProviderBridgeLaunchOptions): ProviderBridgeLaunch;
 type ReplayDialect = "claude-cli" | "json-rpc" | "pi-rpc";
-/**
- * How a provider's bridge is pointed at the replay child. Codex reads its
- * app-server command from env, Claude its CLI path from env, pi its RPC
- * command from env (`pi-rpc`: JSON lines plus the extension channel on fds
- * 3/4), and an ACP bridge its agent command from the launch spec inside
- * `thread/start`. A bridge with no provider child (the echo example) needs no
- * profile at all.
- */
 interface ReplayProviderProfile {
-    /** The protocol the replay child speaks on its pipe. */
     dialect: ReplayDialect;
-    /** Environment the bridge reads the child's command from. */
     env(args: {
         replayCommand: string[];
         wrapperPath: string;
         stateDir: string;
     }): Record<string, string>;
-    /** Rewrite a recorded runtime request that carries the child's command. */
     rewriteRuntimeLine?(line: string, args: {
         replayCommand: string[];
     }): string;
-    /**
-     * Provider state a bridge reads outside its provider pipe, seeded before
-     * the replay starts (the Claude SDK forks by copying the source session's
-     * transcript from disk).
-     */
     prepareState?(args: {
         recording: BridgeRecording;
         stateDir: string;
         workspaceDir: string;
     }): void;
 }
-/** A bridge that spawns no provider, or one whose child command is fixed. */
 declare const DEFAULT_REPLAY_PROFILE: ReplayProviderProfile;
 interface ReplayRecordingOptions {
     recordingDir: string;
-    /** The provider the recording belongs to; keys the assembler's ids. */
     providerId: string;
-    /** The bridge process to replay through (see `resolveProviderBridgeLaunch`). */
     bridge: ProviderBridgeLaunch;
-    /** How the bridge reaches the replay child; `DEFAULT_REPLAY_PROFILE` when omitted. */
     profile?: ReplayProviderProfile;
     createAssembler: CreateParityAssembler;
-    /**
-     * The assembler that plans the replay's gates from the recorded
-     * `bridge→runtime` lane; defaults to `createAssembler`. A re-recording run
-     * on a checkout whose grammar no longer accepts the whole recorded lane
-     * plans with the recording-time checkout's assembler instead.
-     */
     createPlanAssembler?: CreateParityAssembler;
-    /**
-     * Plan the replay's gates from the cell's current bridge lane
-     * (`bridge→runtime.current.ndjson`, see `withCurrentBridgeLane`) when one
-     * exists, instead of the recorded lane. The leg whose bridge wrote that
-     * lane parses all of it; the recording-time leg parses the recorded lane.
-     */
     planFromCurrentLane?: boolean;
-    /** Per-wait timeout for a gate or a response. */
     timeoutMs?: number;
-    /**
-     * The quiet period after which a request is sent even though the bridge
-     * has emitted fewer lines than the recording had before it — a divergent
-     * bridge pays this once per request instead of stalling. Only a plan from
-     * the recorded lane can be short for that reason: a plan from the current
-     * lane (`planFromCurrentLane`) was written by this very bridge, so a
-     * shortfall there is latency, never divergence, and the request waits for
-     * its events up to `timeoutMs` instead — a starved bridge (a loaded CI
-     * runner) still has provider lines to read, and a request sent on quiet
-     * alone lands before them, at a point the recording never had.
-     */
     orderTimeoutMs?: number;
-    /**
-     * Quiet period after the last bridge output before the replay is closed.
-     * An exact current-lane replay first waits for every planned event.
-     */
     settleMs?: number;
-    /**
-     * Quiet period a request waits for once the gates are met. The replay child
-     * plays every provider line before the request's cursor point a couple of
-     * milliseconds apart, so a short silence means the bridge has emitted all
-     * that the pre-request stream produces; without it a request the bridge
-     * acknowledges at once (a steer) lands at a load-dependent point.
-     */
     drainMs?: number;
-    /** Mirror the bridge's stderr (and the replay child's logs) here. */
     onStderr?: (text: string) => void;
 }
 interface ParityGrammarViolation {
@@ -4739,39 +4336,21 @@ interface ParityGrammarViolation {
 interface ParityRun {
     providerId: string;
     recordingDir: string;
-    /** Raw `bridge→runtime` lines, in order. */
     lines: string[];
-    /** When each line arrived, ms since the replay started (diagnostics). */
     lineTimes: number[];
-    /**
-     * For each line, the recorded `runtime→bridge` entry written last before
-     * it arrived (null before any was sent) — where the line sits in the
-     * recording's wire order, for a lane re-recorded through this bridge.
-     */
     lineAfter: Array<{
         run: number;
         seq: number;
         ts: number;
     } | null>;
-    /** Assembled events, minus the ones the grammar dropped (as the runtime does). */
     events: ThreadEvent[];
     grammarViolations: ParityGrammarViolation[];
-    /** Gates that timed out or requests that were never answered. */
     stalls: string[];
     stderr: string;
     exitCode: number | null;
 }
-/** The id of the harness's own `initialize` request; never part of a recording. */
 declare const PARITY_INITIALIZE_ID = "parity-initialize";
-/**
- * Replay one recording through one bridge. Resolves when the bridge exits
- * after the last recorded runtime line has been sent and answered.
- */
 declare function replayRecording(options: ReplayRecordingOptions): Promise<ParityRun>;
-/**
- * The events the recorded `bridge→runtime` lane assembles to, without any
- * bridge in the loop: the recording's own view of what the bridge emitted.
- */
 declare function assembleRecordedEvents(recording: BridgeRecording, createAssembler: CreateParityAssembler, providerId: string): {
     events: ThreadEvent[];
     grammarViolations: ParityGrammarViolation[];
@@ -4781,7 +4360,6 @@ interface ParityAllowlistEntry {
     provider: string | "*";
     cell: string | "*";
     layer: "events" | "rows";
-    /** A JSON pointer over the normalized list, with `*` and `**` wildcards. */
     path: string;
     pr: string;
     reason: string;
@@ -4795,16 +4373,13 @@ interface ParityComparison {
     cell: string;
     events: ParityLayerDiff;
     rows: ParityLayerDiff;
-    /** Grammar drops, compared as `rule:eventType` multisets. */
     grammar: ParityLayerDiff;
-    /** Allowlist entries that matched this cell but masked nothing. */
     staleAllowlist: ParityAllowlistEntry[];
     passed: boolean;
 }
 interface ParityInputs {
     events: readonly ThreadEvent[];
     rows: readonly unknown[];
-    /** Events the grammar dropped; a regression when the lists differ. */
     grammarViolations?: readonly ParityGrammarViolation[];
 }
 declare function compareParity(oldRun: ParityInputs, newRun: ParityInputs, allowlist: readonly ParityAllowlistEntry[], scope: {
@@ -4812,13 +4387,9 @@ declare function compareParity(oldRun: ParityInputs, newRun: ParityInputs, allow
     cell: string;
 }): ParityComparison;
 interface ReplayRecordedCellsOptions {
-    /** The `<provider>/<cell>` tree to read (see `listRecordedCells`). */
     recordingsRoot: string;
-    /** Which recorded providers this bridge serves (`acp` serves `acp-*`). */
     servesProvider: (providerId: string) => boolean;
-    /** Cell names to replay; defaults to every cell of those providers. */
     cells?: readonly string[];
-    /** The bridge process and replay profile for one cell's provider. */
     bridge: (cell: RecordedCell) => {
         launch: ProviderBridgeLaunch;
         profile?: ReplayProviderProfile;
@@ -4830,22 +4401,11 @@ interface ReplayRecordedCellsOptions {
 
 type RerecordCurrentBridgeLaneOptions = Omit<ReplayRecordingOptions, "planFromCurrentLane">;
 interface RerecordCurrentBridgeLaneResult {
-    /** The file written, or null when the replay stalled and nothing was. */
     file: string | null;
-    /** Lines in the new lane (the harness's own handshake excluded). */
     lines: number;
-    /** Events the replay assembled. */
     events: number;
-    /** A stalled replay leaves the current lane untouched. */
     stalls: string[];
 }
-/**
- * Replay one recording through a bridge and write what the bridge emitted
- * as the recording's current bridge lane. The replay plans its gates from
- * the recorded lane (or `createPlanAssembler`'s view of it), never from a
- * previous current lane: the new lane must reproduce the recorded session,
- * not the last re-recording of it.
- */
 declare function rerecordCurrentBridgeLane(options: RerecordCurrentBridgeLaneOptions): Promise<RerecordCurrentBridgeLaneResult>;
 
 export { ASSEMBLER_GRAMMAR_VERSIONS, CONFORMANCE_ASSEMBLED_EVENT_METHOD, CURRENT_BRIDGE_LANE_FILE, DEFAULT_REPLAY_PROFILE, PARITY_INITIALIZE_ID, RECORDED_CONFORMANCE_CELLS, assembleCapturedThreadEvents as experimental_assembleCapturedThreadEvents, assembleRecordedEvents as experimental_assembleRecordedEvents, captureBridgeJsonRpcOutput as experimental_captureBridgeJsonRpcOutput, checkRecordedCellReplay as experimental_checkRecordedCellReplay, compareParity as experimental_compareParity, createBridgeDeltaEventCollector as experimental_createBridgeDeltaEventCollector, createBridgeJsonRpcTestHarness as experimental_createBridgeJsonRpcTestHarness, createDeltaAssembler as experimental_createDeltaAssembler, describeCalibrationEvents as experimental_describeCalibrationEvents, formatConformanceReport as experimental_formatConformanceReport, listRecordedCells as experimental_listRecordedCells, normalizeCalibrationEvents as experimental_normalizeCalibrationEvents, readBridgeRecording as experimental_readBridgeRecording, replayRecording as experimental_replayRecording, rerecordCurrentBridgeLane as experimental_rerecordCurrentBridgeLane, resolveProviderBridgeLaunch as experimental_resolveProviderBridgeLaunch, runBridgeConformance as experimental_runBridgeConformance, toConformanceMessages as experimental_toConformanceMessages, withCurrentBridgeLane as experimental_withCurrentBridgeLane };