@get-bb/plugin-sdk 0.4.24 → 0.4.27

package/dist/provider-bridge-testing.js

@@ -111,16 +111,7 @@ var canonicalPromptMentionResourceSchema = z2.discriminatedUnion("kind", [
   z2.object({
     kind: z2.literal("plugin"),
     pluginId: z2.string(),
-    /**
-     * Named shared-UI icon hint supplied by the plugin mention item. Omitted
-     * by mentions persisted before icon hints were stored.
-     */
     icon: z2.string().nullable().optional(),
-    /**
-     * Opaque item reference minted by the server's mention search
-     * (`<providerId>:<provider item id>`); resolved back through the same
-     * plugin's mention provider at send time (plugin design §4.9).
-     */
     itemId: z2.string(),
     label: z2.string()
   })
@@ -159,21 +150,11 @@ var promptInputSchema = z2.discriminatedUnion("type", [
   }),
   z2.object({
     type: z2.literal("localImage"),
-    /**
-     * Absolute paths and URI-like values are passed through to the runtime.
-     * Relative paths are server-managed attachment references, not workspace
-     * relative files.
-     */
     path: z2.string(),
     ...promptInputVisibilityFields
   }),
   z2.object({
     type: z2.literal("localFile"),
-    /**
-     * Absolute paths and URI-like values are passed through to the runtime.
-     * Relative paths are server-managed attachment references, not workspace
-     * relative files.
-     */
     path: z2.string(),
     name: z2.string().optional(),
     sizeBytes: z2.number().int().nonnegative().optional(),
@@ -241,13 +222,7 @@ var runtimeThreadExecutionBaseOptionsSchema = z2.object({
   model: z2.string().min(1),
   serviceTier: serviceTierSchema,
   reasoningLevel: reasoningLevelSchema,
-  /** Present only when the prompt entered a BB prompt mode. */
   promptMode: promptModeSchema.optional(),
-  /**
-   * Plugin-derived, provider-scoped options. Always present — an empty
-   * object when the provider derives none — so the daemon never has to
-   * guess whether the server ran the hook.
-   */
   providerOptions: jsonObjectSchema
 });
 var runtimeThreadExecutionOptionsSchema = runtimeThreadExecutionBaseOptionsSchema.and(runtimePermissionPolicySchema);
@@ -280,7 +255,6 @@ var workflowAgentStateValues = [
 ];
 var workflowAgentStateSchema = z3.enum(workflowAgentStateValues);
 var workflowAgentSnapshotSchema = z3.object({
-  /** 1-based agent counter; the stable identity for fold/replace semantics. */
   index: z3.number().int().positive(),
   label: z3.string(),
   state: workflowAgentStateSchema,
@@ -304,10 +278,8 @@ var workflowAgentSnapshotSchema = z3.object({
   durationMs: z3.number().optional()
 });
 var workflowPhaseSnapshotSchema = z3.object({
-  /** 1-based phase counter; meta.phases are seeded before any agent runs. */
   index: z3.number().int().positive(),
   title: z3.string(),
-  /** "child" marks a nested workflow() sub-run group. */
   kind: z3.string().optional()
 });
 var workflowProgressSnapshotSchema = z3.object({
@@ -340,9 +312,7 @@ function jsonByteLength(value) {
 import { z as z4 } from "zod";
 var THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH = 280;
 var threadEventItemPresentationLabelSchema = z4.object({
-  /** Present-tense row title while the item is in flight ("Reading file"). */
   pending: z4.string().min(1),
-  /** Past-tense row title once the item settled ("Read file"). */
   completed: z4.string().min(1)
 });
 var threadEventItemPresentationIconSchema = z4.object({
@@ -355,16 +325,9 @@ var threadEventItemPresentationTintSchema = z4.object({
 var threadEventItemPresentationSchema = z4.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
-  /** Row headline beside the label (a path, a query, a child thread title). */
   title: z4.string().optional(),
-  /**
-   * Short Markdown summary shown in the row body. Length-capped here so a
-   * bridge cannot turn the persisted row into a transcript.
-   */
   detail: z4.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
-  /** Low-value rows (TodoWrite, ToolSearch) clients collapse by default. */
   suppress: z4.boolean().optional(),
-  /** Accent colour per theme; omitted rows use the neutral row tint. */
   tint: threadEventItemPresentationTintSchema.optional()
 });
 
@@ -484,9 +447,7 @@ var pendingInteractionPermissionGrantApprovalSubjectSchema = z6.object({
 var pendingInteractionPlanApprovalSubjectSchema = z6.object({
   kind: z6.literal("plan"),
   itemId: z6.string().min(1),
-  /** The plan body, as Markdown. */
   plan: z6.string().min(1),
-  /** Where the provider saved the plan, or null when it kept it in memory. */
   planFilePath: z6.string().min(1).nullable()
 });
 var pendingInteractionToolUseApprovalSubjectSchema = z6.object({
@@ -788,21 +749,13 @@ var systemEventTypeValues = [
   "client/turn/rejected",
   "client/turn/start",
   "system/error",
-  // Legacy persisted user-visible system event from a removed runtime path.
-  // Retained for read/decode/render compatibility only.
   "system/manager/user_message",
   "system/thread/interrupted",
   "system/operation",
   "system/interaction/lifecycle",
-  // Legacy persisted per-shape interaction events; every status change now
-  // appends one `system/interaction/lifecycle`. Retained for read/decode
-  // only: `convertLegacyStoredThreadEvent` projects a stored row into the
-  // lifecycle event, so no consumer sees these types.
   "system/permissionGrant/lifecycle",
   "system/userQuestion/lifecycle",
   "system/thread-provisioning",
-  // Legacy persisted watchdog diagnostic; retained for read/decode/render
-  // only, with no current producer.
   "system/provider-turn-watchdog"
 ];
 var threadTurnInitiatorValues = ["user", "agent", "system"];
@@ -854,18 +807,10 @@ var clientTurnLifecycleEventDataSchema = z8.object({
 var turnRequestEventDataSchema = z8.object({
   direction: z8.literal("outbound"),
   requestId: clientTurnRequestIdSchema,
-  /** Failed request resumed by a guarded system continuation, when present. */
   continuationOfRequestId: clientTurnRequestIdSchema.optional(),
   source: z8.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  // Non-null only when initiator === "agent". The invariant is enforced by
-  // writer typings rather than a schema refine so legacy persisted events
-  // (initiator: "agent", senderThreadId: null from before the field
-  // existed) still parse — the stored variant defaults both fields.
   senderThreadId: z8.string().nullable(),
-  // Family-B system-message taxonomy fields. Optional at the persisted-event
-  // level: legacy events (pre-taxonomy) lack them and must still parse. The
-  // projection defaults absent values to `unlabeled` / `null`.
   systemMessageKind: systemMessageKindSchema.optional(),
   systemMessageSubject: systemMessageSubjectSchema.nullable().optional(),
   input: z8.array(promptInputSchema),
@@ -951,8 +896,6 @@ var systemUserQuestionLifecycleEventDataSchema = z8.object({
 var systemThreadInterruptedReasonValues = [
   "manual-stop",
   "host-daemon-restarted",
-  // Legacy persisted watchdog interruption; retained for read/replay only,
-  // with no current producer.
   "provider-turn-idle"
 ];
 var systemThreadInterruptedReasonSchema = z8.enum(
@@ -996,11 +939,6 @@ var systemProviderTurnWatchdogEventDataSchema = z8.object({
   activeTurnId: z8.string().min(1),
   activeTurnStartedAt: z8.number().int().nonnegative(),
   lastActivityEventSequence: z8.number().int().positive(),
-  /**
-   * Diagnostic label only (the UI interpolates it verbatim). A plain string —
-   * not the activity enum — so editing event classifications never makes
-   * previously persisted watchdog events unparseable.
-   */
   lastActivityEventType: z8.string().min(1),
   lastActivityEventAt: z8.number().int().nonnegative(),
   providerId: z8.string().min(1),
@@ -1272,7 +1210,6 @@ var providerRateLimitStatusSchema = z11.enum([
   "unknown"
 ]);
 var providerRateLimitWindowSchema = z11.object({
-  /** Opaque provider-issued key. New provider windows must not break parsing. */
   providerKey: z11.string().min(1).nullable(),
   label: z11.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
@@ -1357,11 +1294,9 @@ var threadEventDelegationItemSchema = z11.object({
   type: z11.literal("delegation"),
   id: z11.string(),
   childRef: z11.string().min(1),
-  /** Human label for the delegated work (the child's description). */
   label: z11.string(),
   status: threadEventItemStatusSchema,
   background: z11.boolean(),
-  /** Terminal summary from the child; absent while it runs. */
   summary: z11.string().optional(),
   ...itemPresentationField,
   parentToolCallId: z11.string().optional()
@@ -1422,10 +1357,6 @@ var threadEventWarningCategorySchema = z11.enum([
   "deprecation",
   "config",
   "general",
-  /**
-   * The provider declined a compaction that bb asked for because there was
-   * nothing to compact. The warning settles the pending compaction row.
-   */
   "compaction-skipped"
 ]);
 var providerRawEventSchema = z11.object({
@@ -1454,28 +1385,15 @@ var toolCallProgressEventSchema = z11.object({
 var threadEventBackgroundTaskItemSchema = z11.object({
   type: z11.literal("backgroundTask"),
   id: z11.string(),
-  /**
-   * The provider's stable task id, shared by every generation (restart) of
-   * the same task; consumers use it to correlate a restarted task with its
-   * earlier generations. Absent only on events persisted before the field
-   * existed — those encoded the family in the item id's legacy `#N`
-   * generation suffix instead.
-   */
   familyId: z11.string().optional(),
-  /** Raw SDK task discriminant (e.g. "local_workflow"); "unknown" when the provider omitted it. */
   taskType: z11.string(),
   description: z11.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  /** Ambient/housekeeping task; consumers hide it from the inline transcript. */
   skipTranscript: z11.boolean(),
-  /** meta.name of the workflow script; only present for workflow tasks. */
   workflowName: z11.string().optional(),
-  /** Merged workflow tree; absent until the provider reports progress records. */
   workflow: workflowProgressSnapshotSchema.optional(),
-  /** Absent until the provider reports usage. */
   usage: backgroundTaskUsageSchema.optional(),
-  /** Terminal summary from the provider; absent while the task runs. */
   summary: z11.string().optional(),
   error: z11.string().optional(),
   outputFile: z11.string().optional(),
@@ -1483,7 +1401,6 @@ var threadEventBackgroundTaskItemSchema = z11.object({
   parentToolCallId: z11.string().optional()
 });
 var threadEventItemSchema = z11.discriminatedUnion("type", [
-  // bb authors user messages itself, so they carry no bridge presentation.
   z11.object({
     type: z11.literal("userMessage"),
     id: z11.string(),
@@ -1505,10 +1422,6 @@ var threadEventItemSchema = z11.discriminatedUnion("type", [
     cwd: z11.string(),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
-    /**
-     * Omitted when the process produced no stdout/stderr. Adapters should omit
-     * this field instead of emitting an empty string placeholder.
-     */
     aggregatedOutput: z11.string().optional(),
     exitCode: z11.number().optional(),
     durationMs: z11.number().optional(),
@@ -1541,10 +1454,6 @@ var threadEventItemSchema = z11.discriminatedUnion("type", [
     error: z11.string().optional(),
     durationMs: z11.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
-    /**
-     * The escape hatch for tools with no core kind: the bridge says how the
-     * row reads (label, glyph, headline, suppression).
-     */
     ...itemPresentationField,
     parentToolCallId: z11.string().optional()
   }),
@@ -1593,12 +1502,9 @@ var unscopedProviderEventSchema = z11.discriminatedUnion("type", [
   z11.object({
     type: z11.literal("turn/completed"),
     threadId: z11.string(),
-    // Server reconciliation can synthesize interrupted completions when the
-    // original provider thread id was never persisted.
     providerThreadId: z11.string().nullable(),
     status: threadEventTurnStatusSchema,
     error: z11.object({ message: z11.string() }).optional(),
-    /** Provider-native point through which a replacement branch should retain history. */
     providerCheckpointId: z11.string().min(1).optional()
   }),
   z11.object({
@@ -1665,10 +1571,6 @@ var unscopedProviderEventSchema = z11.discriminatedUnion("type", [
     providerThreadId: z11.string(),
     itemId: z11.string(),
     delta: z11.string(),
-    /**
-     * When true, this delta replaces previously accumulated command output
-     * instead of appending to it. Omission means the delta appends.
-     */
     reset: z11.boolean().optional(),
     parentToolCallId: z11.string().optional()
   }),
@@ -1713,49 +1615,24 @@ var unscopedProviderEventSchema = z11.discriminatedUnion("type", [
     parentToolCallId: z11.string().optional()
   }),
   toolCallProgressEventSchema,
-  /**
-   * Superseding state snapshot for an in-flight background task. Thread-scoped
-   * (not turn-scoped) because tasks outlive their spawning turn: late events
-   * must not interleave into later turns' sequence-contiguous windows. Each
-   * progress event carries the full current item state; consumers replace, not
-   * merge. The item is placed in the timeline by its turn-scoped item/started.
-   */
   z11.object({
     type: z11.literal("item/backgroundTask/progress"),
     threadId: z11.string(),
     providerThreadId: z11.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  /**
-   * Terminal state for a background task, carrying the full final item
-   * payload. Dedicated event (instead of the generic turn-scoped
-   * item/completed) because it may arrive turns after the item/started.
-   */
   z11.object({
     type: z11.literal("item/backgroundTask/completed"),
     threadId: z11.string(),
     providerThreadId: z11.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  /**
-   * Superseding snapshot for an in-flight background delegation (`background:
-   * true`). Thread-scoped for the same reason as `item/backgroundTask/
-   * progress`: a background child outlives its spawning turn, and late events
-   * must not interleave into later turns' sequence-contiguous windows. The
-   * item is placed in the timeline by its turn-scoped `item/started`.
-   */
   z11.object({
     type: z11.literal("item/delegation/progress"),
     threadId: z11.string(),
     providerThreadId: z11.string(),
     item: threadEventDelegationItemSchema
   }),
-  /**
-   * Terminal state for a background delegation, carrying the full final item.
-   * Dedicated event (instead of the turn-scoped `item/completed`) because it
-   * may arrive turns after the `item/started`. Foreground delegations settle
-   * through `item/completed`.
-   */
   z11.object({
     type: z11.literal("item/delegation/completed"),
     threadId: z11.string(),
@@ -1802,16 +1679,6 @@ var unscopedProviderEventSchema = z11.discriminatedUnion("type", [
     providerThreadId: z11.string(),
     rateLimits: providerRateLimitStateSchema
   }),
-  /**
-   * Plugin-declared thread state (grammar v3): a `"<pluginId>/<name>"` kind
-   * beside the core thread-state family (usage, context window, rate limits,
-   * model fallback, context cleared). Latest snapshot wins per `kind`: a
-   * bridge re-sends the whole state, never a diff, and a consumer keeps one
-   * value per kind. The server validated `payload` against the owning
-   * plugin's declared `state` schema at ingest; a payload that failed that
-   * check was persisted as `provider/unhandled` instead, so every stored row
-   * of this type carries a payload its plugin vouched for.
-   */
   z11.object({
     type: z11.literal("thread/extensionState/updated"),
     threadId: z11.string(),
@@ -1997,8 +1864,6 @@ var availableModelSchema = z13.object({
   id: z13.string(),
   model: z13.string(),
   displayName: z13.string(),
-  /** Provider route used to run this model when it is distinct from the
-   * selected agent provider (for example, a model provider nested under Pi). */
   routeProviderId: z13.string().min(1).optional(),
   description: z13.string(),
   supportedReasoningEfforts: z13.array(modelReasoningEffortSchema),
@@ -2012,20 +1877,8 @@ var providerCapabilitiesSchema = z13.object({
   supportsServiceTier: z13.boolean(),
   supportsNativeUserQuestion: z13.boolean(),
   supportsFork: z13.boolean(),
-  /**
-   * The provider can recreate a session at an earlier point, which is what
-   * edit-past-message rewind needs. Separate from `supportsFork`: ACP clones
-   * whole sessions (tip-only) and cannot stop at a checkpoint.
-   */
   supportsSessionRewind: z13.boolean(),
   permissionModes: z13.array(permissionModeSchema).min(1),
-  /**
-   * How far one `model/list` answer travels: `"host"` when the bridge answers
-   * from account or agent state and ignores the workspace path, so bb probes
-   * once per machine; `"workspace"` when project configuration can change the
-   * answer. Declared by the provider's plugin — core never infers it from an
-   * id.
-   */
   modelCatalogScope: providerModelCatalogScopeSchema
 });
 var providerComposerCommandSchema = z13.object({
@@ -2048,17 +1901,11 @@ var providerComposerActionSchema = z13.discriminatedUnion("kind", [
   })
 ]);
 var providerStringsSchema = z13.object({
-  /** How to sign in on the host ("Run `claude` on the machine to sign in."). */
   signInHint: z13.string().min(1),
-  /** Shown when a session's credentials expired. */
   expiredHint: z13.string().min(1),
-  /** Where to install the agent. */
   installUrl: z13.string().min(1),
-  /** Brand prefix stripped from model display names ("Claude "). */
   brandPrefix: z13.string().min(1).optional(),
-  /** Plan-mode banner copy for providers that declare the `plan` action. */
   planModeCopy: z13.string().min(1).optional(),
-  /** Per-theme tint for the provider icon. */
   iconTint: z13.object({ light: z13.string().min(1), dark: z13.string().min(1) }).optional()
 });
 var providerOptionDescriptorSchema = z13.object({
@@ -2076,31 +1923,11 @@ var providerExtensionKindsSchema = z13.record(
 );
 var providerInfoSchema = z13.object({
   id: z13.string(),
-  /**
-   * The plugin that registered the provider (`bb.providers.register`). The
-   * owner of the provider's extension-kind namespace, and the bundle the
-   * app loads on the first thread of this provider.
-   */
   pluginId: z13.string().min(1),
   displayName: z13.string(),
-  /**
-   * Declared grouping key shared by related providers (the ACP agents).
-   * Absent when the provider declared none. Grouping only.
-   */
   family: z13.string().min(1).optional(),
-  /**
-   * The declared icon, projected by form. A plugin-relative asset path
-   * (`icon: "./icons/agent.svg"`) is served by the provider-logo route and
-   * arrives here as `logoUrl`; a named host glyph (`icon: "Zap"`) has no
-   * bytes to serve and arrives as `icon.glyph`, the same vocabulary an
-   * item presentation's `icon` uses. A declaration names at most one form,
-   * so at most one of the two is set; `icon` is absent when the declaration
-   * named a path or nothing. Clients draw a vendored brand mark first, then
-   * `logoUrl`, then `icon.glyph`, then the display name's initial.
-   */
   icon: z13.object({ glyph: z13.string().min(1) }).optional(),
   logoUrl: z13.string().min(1).nullable(),
-  /** Sessionless maintenance requests the provider's bridge implements. */
   maintenance: z13.object({
     health: z13.boolean(),
     usage: z13.boolean(),
@@ -2109,13 +1936,6 @@ var providerInfoSchema = z13.object({
   capabilities: providerCapabilitiesSchema,
   composerActions: z13.array(providerComposerActionSchema),
   available: z13.boolean(),
-  // -------------------------------------------------------------------------
-  // Target-state projection (docs/provider-plugin-api.md §1). Optional and
-  // unfilled until WS2a projects them from the plugin declaration; absence
-  // means "the provider declared none", never a default. The
-  // `capabilities.supports*` fields above stay until WS2a stabilizes the
-  // surface as one unit.
-  // -------------------------------------------------------------------------
   strings: providerStringsSchema.optional(),
   serviceTiers: z13.array(providerOptionDescriptorSchema).optional(),
   reasoningLevels: z13.array(providerOptionDescriptorSchema).optional(),
@@ -2175,24 +1995,14 @@ var deltaItemKeySchema = z14.object({
 var providerTurnIdSchema = deltaKeyPartSchema;
 var deltaFileChangeSchema = z14.object({
   path: z14.string(),
-  /** The bridge states the change kind; the assembler never derives it. */
   kind: z14.enum(["add", "update", "delete"]),
   movePath: z14.string().optional(),
-  /** Provider-supplied unified diff; preferred over old/new text building. */
   diff: z14.string().optional(),
   oldText: z14.string().optional(),
-  /** When present the assembler builds the unified diff from old/new text. */
   newText: z14.string().optional()
 });
 var deltaBackgroundTaskShapeSchema = z14.object({
   type: z14.literal("backgroundTask"),
-  /**
-   * The provider's stable task id, shared by every generation (restart) of
-   * the same task. Rides through to the canonical item so consumers can
-   * correlate a restarted task with its earlier generations — the assembler
-   * mints fresh item ids per generation, so identity must travel as data,
-   * never as id text.
-   */
   familyId: z14.string().min(1),
   taskType: z14.string(),
   description: z14.string(),
@@ -2246,20 +2056,8 @@ var deltaItemShapeSchema = z14.discriminatedUnion("type", [
   }),
   z14.object({
     type: z14.literal("fileChange"),
-    /** Empty while a path is not yet known, including bare close fallbacks. */
     changes: z14.array(deltaFileChangeSchema)
   }),
-  /**
-   * The generic tool call: the escape hatch for tools with no core kind. In
-   * grammar v3 the bridge says how the row reads through the delta's
-   * `presentation` (label, icon, suppression) instead of core keeping a
-   * tool-name table. A `tool` item without presentation is read as legacy
-   * data: `@bb/domain`'s `upgradeLegacyToolItem` reshapes read/grep/glob/
-   * find/ls by name and suppresses the Task- and Todo-family bookkeeping
-   * calls when the stored row is parsed, and any other name renders with
-   * the generic tool row — until the backfill migration, after which
-   * `presentation` is required.
-   */
   z14.object({
     type: z14.literal("tool"),
     tool: z14.string(),
@@ -2289,7 +2087,6 @@ var deltaItemShapeSchema = z14.discriminatedUnion("type", [
   }),
   z14.object({ type: z14.literal("imageView"), path: z14.string() }),
   deltaBackgroundTaskShapeSchema,
-  // Grammar v3 shapes. Every existing shape above is kept unchanged.
   deltaFileReadShapeSchema,
   deltaSearchShapeSchema,
   deltaDelegationShapeSchema,
@@ -2323,51 +2120,21 @@ function requireExtensionPresentation(delta, ctx) {
   }
 }
 var threadDeltaSchema = z14.discriminatedUnion("kind", [
-  /**
-   * The provider consumed an input (immediate or steered). The assembler owns
-   * the queue-until-turn-opens behavior and the terminal-turn invariant.
-   * With `providerTurnId` the acceptance is emitted against that vouched turn
-   * directly (codex correlates acceptance to a named native turn).
-   */
   z14.object({
     kind: z14.literal("input.accepted"),
     clientRequestId: clientTurnRequestIdSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  /**
-   * Input the provider itself injected into the conversation, with no bb
-   * client request behind it (a pi extension's `sendMessage` custom message
-   * that triggered or steered a turn). The assembler records it as a
-   * `userMessage` item in the open turn so the transcript shows what the
-   * model was answering. Dropped silently when no turn is open: the provider
-   * appended it to its own context without running the agent, so there is no
-   * bb turn to attach it to.
-   */
   z14.object({
     kind: z14.literal("input.provider"),
     text: z14.string().min(1),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  /**
-   * An explicit provider signal opened work (pi `agent_start`, codex
-   * `turn/started`). With `providerTurnId` the turn lives in the keyed
-   * provider-turn space: several may be open at once (codex multiplexes
-   * subagent child turns onto one thread) and none of the current-turn
-   * machinery is touched.
-   */
   z14.object({
     kind: z14.literal("turn.open"),
     providerTurnId: providerTurnIdSchema.optional(),
-    /** Provider-native parent tool-call id for delegated child turns. */
     parentRef: deltaKeyPartSchema.optional()
   }),
-  /**
-   * The bridge's conclusion that the turn settled. `claimIfIdle: true` marks
-   * fallback closers that own a turn only if accepted input is pending
-   * (the old bridge-kit terminal-turn rule, applied centrally); an open turn is
-   * always settled. A keyed boundary (`providerTurnId`) always emits — the
-   * provider named the turn — and settles only that turn.
-   */
   z14.object({
     kind: z14.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
@@ -2376,40 +2143,15 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     claimIfIdle: z14.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  /**
-   * A parsed item opened. `attach: "currentOrLast"` pins the item to the turn
-   * that is open or just closed without opening a new one (pi threshold
-   * compaction); the default attaches to the open turn only. A known
-   * `providerItemId` reuses its minted bb id (an explicit open reopens the
-   * same item, codex's settle/reopen rule).
-   */
   z14.object({
     kind: z14.literal("item.open"),
     key: deltaItemKeySchema,
     item: deltaItemShapeSchema,
-    /**
-     * Grammar v3: how the row reads, persisted with the opened item. The
-     * one place presentation travels. Optional for core shapes while v2
-     * deltas are accepted; REQUIRED for `extension` shapes.
-     */
     presentation: deltaPresentationSchema.optional(),
     attach: deltaAttachSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  /**
-   * The item settled. `item` is REQUIRED and always carries the full terminal
-   * item shape (Michael's uniform close rule, 2026-08-18): the assembler
-   * builds the completed item from it. With a same-shaped item open under the
-   * key, the terminal shape wins and the opened item contributes only its
-   * minted id; with a different-shaped item open, the assembler closes the
-   * opened shape and then emits the terminal shape (ACP's dual-complete);
-   * with nothing open it builds the bare completed item.
-   *
-   * Provider-identified closes (`key.providerItemId`) dedup: a repeated close
-   * for a settled id is dropped and an explicit `item.open` reopens the id
-   * (codex retries the terminal notification after approvals).
-   */
   z14.object({
     kind: z14.literal("item.close"),
     key: deltaItemKeySchema,
@@ -2417,32 +2159,12 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     resultText: z14.string().optional(),
     exitCode: z14.number().optional(),
     aggregatedOutput: z14.string().optional(),
-    /** Terminal approval verdict (codex declined → denied). Default null. */
     approvalStatus: z14.literal("denied").optional(),
     item: deltaItemShapeSchema,
-    /**
-     * Grammar v3: the terminal presentation. Like `item`, the close carries
-     * the full terminal form; when absent the opened item's presentation
-     * survives onto the completed item (close-echo). REQUIRED for an
-     * `extension` shape, which has nothing to echo without it.
-     */
     presentation: deltaPresentationSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  /**
-   * Free-form progress on an open item (non-command tool updates), or — with
-   * `snapshot` — a re-embedded snapshot of work that outlives its turn: a
-   * background task (`item/backgroundTask/progress`) or, in grammar v3, a
-   * background delegation (`item/delegation/progress`); both thread-scoped,
-   * no turn required.
-   *
-   * Progress is throttled centrally by the assembler (one emission per item
-   * key per policy interval, 500ms default; the newest suppressed snapshot is
-   * flushed trailing-edge on the thread's next traffic once the window
-   * elapses, and an `item.close` supersedes it). `flush: true` bypasses the
-   * throttle and resets the window — status transitions must land immediately.
-   */
   z14.object({
     kind: z14.literal("item.progress"),
     key: deltaItemKeySchema,
@@ -2452,17 +2174,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Streamed text — the one streaming dialect. Every text stream is keyed
-   * like every other item: by the provider's own item id when the provider
-   * names its message items (codex), or by a bridge-chosen `key.channel`
-   * (`"assistant"`, `"thinking-2"`) plus `key.parentRef` for providers whose
-   * streams are anonymous (claude, pi, acp). The first delta for an unknown
-   * key synthesizes the channel's `item/started`; later deltas (and deltas
-   * for a provider id already opened or settled) reuse the mapped id. The
-   * assembler accumulates the stream text per open item so `item.textClose`
-   * can settle without a provider-final text.
-   */
   z14.object({
     kind: z14.literal("item.textDelta"),
     key: deltaItemKeySchema,
@@ -2471,18 +2182,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Settle a text stream. `text` present: the provider's final text, preferred
-   * over the accumulated stream (and enough on its own — a close for a key
-   * nothing streamed under completes a fresh item). `text` absent: settle
-   * with the accumulated stream text, completing nothing when the stream only
-   * ever received whitespace. Either way the key is released, so later text
-   * mints a fresh item. `channel` says which item to mint for a bare close
-   * and where a provider-final `text` lands on a reasoning item. Providers
-   * that name their message items may instead settle through `item.close`
-   * with the full terminal shape (the uniform close rule) — that is the same
-   * item lifecycle, not a second streaming dialect.
-   */
   z14.object({
     kind: z14.literal("item.textClose"),
     key: deltaItemKeySchema,
@@ -2491,10 +2190,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Item-keyed exact output append (codex command/fileChange output deltas).
-   * Never synthesizes an open and never diffs — the text is already a delta.
-   */
   z14.object({
     kind: z14.literal("item.outputDelta"),
     key: deltaItemKeySchema,
@@ -2503,26 +2198,12 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Cumulative command output snapshot (pi bash). The assembler diffs
-   * consecutive snapshots into `outputDelta`/`reset` events.
-   */
   z14.object({
     kind: z14.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
     text: z14.string(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Provider-reported usage — the one usage dialect. `total` is the running
-   * session total and `last` the most recent turn's usage; a provider that
-   * reports exact cumulative totals (codex) forwards both verbatim, and a
-   * provider that reports per-turn usage (claude, pi) sums `last` into
-   * `total` itself (`addTokenUsage` in the bridge kit), resetting at every
-   * session construction alongside `session.reset`. Emits
-   * `thread/tokenUsage/updated` only: a provider whose usage also measures
-   * the context window sends the `contextWindow` delta beside it.
-   */
   z14.object({
     kind: z14.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
@@ -2530,13 +2211,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     modelContextWindow: z14.number().nullable(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  /**
-   * Context-window meter. `attach: "currentOrLast"` legalizes post-turn
-   * attachment (pi reports after `agent_end` for the turn that just closed);
-   * a `providerTurnId` scopes the reading to that vouched turn instead
-   * (codex measures the window per native turn) and `attach` is then
-   * irrelevant.
-   */
   z14.object({
     kind: z14.literal("contextWindow"),
     used: z14.number().nullable(),
@@ -2551,54 +2225,26 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
   z14.object({ kind: z14.literal("context.cleared") }),
-  /** The aggregate working-tree diff for a turn (codex turn/diff/updated). */
   z14.object({
     kind: z14.literal("turn.diff"),
     diff: z14.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  // Thread metadata (codex thread lifecycle notifications).
   z14.object({ kind: z14.literal("thread.started") }),
   z14.object({
     kind: z14.literal("thread.identity"),
     providerThreadId: z14.string().min(1)
   }),
   z14.object({ kind: z14.literal("thread.name"), name: z14.string().min(1) }),
-  /**
-   * Plugin-declared thread state (grammar v3): `"<pluginId>/<name>"` kinds
-   * beside the core thread-state family (usage, context window, rate limits,
-   * model fallback, context cleared). Latest snapshot wins per kind — the
-   * assembler and the timeline keep one value per `kind`, so a bridge re-sends
-   * the whole state, never a diff. Codex goals ride this way (the codex
-   * plugin's `provider-codex/goal`, a null payload once cleared). The payload
-   * is opaque here; the server validates it against the plugin's declared
-   * `state` schema at ingest (the same site as extension items).
-   * The namespaced kind travels as `extensionKind` only because `kind` is
-   * this union's discriminator; the item shape and the persisted item call
-   * the same value `kind`.
-   */
   z14.object({
     kind: z14.literal("extension.state"),
     extensionKind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  /**
-   * Normalized rate-limit snapshot. The provider-dialect merge (codex's
-   * sticky rateLimitReachedType over sparse rolling updates) stays
-   * bridge-side — it is seeded from a per-child post-initialize read the
-   * assembler never sees.
-   */
   z14.object({
     kind: z14.literal("provider.rateLimits"),
     rateLimits: providerRateLimitStateSchema
   }),
-  /**
-   * Provider-reported error. `settlesTurn: true` also closes the turn that
-   * owns the error as failed (an open turn, or one claimed through pending
-   * accepted input). A `providerTurnId` scopes the error to that vouched
-   * turn; `threadScoped: true` pins thread scope (codex errors without a
-   * native turn id never attach to whatever turn happens to be open).
-   */
   z14.object({
     kind: z14.literal("provider.error"),
     message: z14.string(),
@@ -2610,13 +2256,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     threadScoped: z14.boolean().optional()
   }),
-  /**
-   * The provider switched models mid-flight (claude model fallback). Scoped to
-   * the open-or-just-closed turn when one exists, thread scope otherwise (the
-   * claude translator's currentOrLast rule). Cross-message dedup of the early
-   * assistant fallback block against the later system duplicate stays
-   * bridge-side — it is keyed by the bridge's own segment tracking.
-   */
   z14.object({
     kind: z14.literal("provider.modelFallback"),
     originalModel: z14.string().min(1),
@@ -2624,10 +2263,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     reason: z14.enum(["refusal", "provider"]),
     message: z14.string()
   }),
-  /**
-   * `vouchedTurn: true` scopes the warning to the open turn when one exists
-   * (ACP warnings are turn-scoped mid-turn); default is thread scope.
-   */
   z14.object({
     kind: z14.literal("provider.warning"),
     summary: z14.string().optional(),
@@ -2635,15 +2270,6 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     category: threadEventWarningCategorySchema.optional(),
     vouchedTurn: z14.boolean().optional()
   }),
-  /**
-   * The bridge's visibility classification decided this raw event is unknown.
-   * `vouchedTurn: true` scopes it to the open turn if one exists — the
-   * only-caller-vouched-turn-ids rule — and `providerTurnId` scopes it to
-   * that vouched provider turn. `onlyIfNoTurn: true` inverts the guard: the
-   * event surfaces only when NO turn is open (the old translators'
-   * "known event, no active turn" visibility fallback for events that
-   * otherwise translate to silence) and is dropped entirely mid-turn.
-   */
   z14.object({
     kind: z14.literal("unhandled"),
     raw: providerRawEventSchema,
@@ -2653,18 +2279,7 @@ var threadDeltaSchema = z14.discriminatedUnion("kind", [
     parentRef: deltaKeyPartSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  /**
-   * Lifecycle settlement: the session was interrupted. The assembler closes
-   * the open turn and open items as interrupted.
-   */
   z14.object({ kind: z14.literal("session.ended") }),
-  /**
-   * Provider-native id-space boundary: a new provider session was constructed
-   * for this thread (start/resume/fork/rebuild), so its native turn/item ids
-   * may repeat. Drops ALL assembly state for the thread — id maps, settled
-   * sets, open items and streams; the bridge settles any open work first
-   * (nothing is in flight at any construction site).
-   */
   z14.object({ kind: z14.literal("session.reset") })
 ]);
 var threadDeltaNotificationParamsSchema = z14.object({
@@ -4526,7 +4141,6 @@ var ConformanceClient = class {
   collector;
   nextId = 1;
   log = [];
-  /** Every assembled event, in wire order. */
   events = [];
   drainIntoLog() {
     for (const raw of this.transport.takeMessages()) {
@@ -4570,7 +4184,6 @@ var ConformanceClient = class {
     );
     return id;
   }
-  /** Poll until `resolve` yields a value or the deadline passes (→ null). */
   async waitFor(resolve3) {
     const deadline = Date.now() + this.timeoutMs;
     for (; ; ) {
@@ -4592,7 +4205,6 @@ var ConformanceClient = class {
       )
     );
   }
-  /** A settle window: drain for the given quiet period without expectations. */
   async settle(quietMs) {
     const deadline = Date.now() + quietMs;
     while (Date.now() < deadline) {
@@ -4640,88 +4252,22 @@ function negotiateGrammarVersion(runtime, bridge) {
 }
 var bridgeSteerModeSchema = z18.enum(["inject", "queue"]);
 var bridgeCapabilitiesSchema = z18.object({
-  /**
-   * A released session can be re-attached later from its persisted
-   * providerThreadId. The per-session `sessionRestorable` flag on
-   * thread-identity results refines this (an agent update can drop restore
-   * support mid-flight); this handshake value is the default for sessions
-   * that do not say.
-   */
   sessionRestore: z18.boolean().default(false),
-  /**
-   * The bridge mirrors bb archive state into the provider's own session
-   * list. When false the runtime never sends thread/archive or
-   * thread/unarchive.
-   */
   threadArchive: z18.boolean().default(false),
-  /**
-   * The bridge pushes bb thread titles to the provider. When false the
-   * runtime never sends thread/name/set.
-   */
   threadRename: z18.boolean().default(false),
-  /** The bridge supports thread/goal/clear. */
   threadGoalClear: z18.boolean().default(false),
-  /**
-   * Session cloning support ({@link providerForkSchema} — the same
-   * vocabulary the provider declaration uses). The declaration is a ceiling
-   * for UI affordances; this is the operative truth, and it may only narrow
-   * the declaration, never widen it.
-   */
   fork: providerForkSchema.default("none"),
-  /**
-   * Where the thread's approval policy is enforced. "runtime" bridges
-   * forward every approval request and the runtime applies the thread
-   * policy (including auto-deny). "provider" bridges enforce policy before
-   * forwarding, so every forwarded request is already known to need user
-   * input and the runtime must not reclassify it against mutable thread
-   * settings.
-   */
   approvalEnforcedBy: z18.enum(["runtime", "provider"]).default("runtime"),
-  /**
-   * The `thread/delta` grammar range this bridge speaks. A bridge that says
-   * nothing is read as speaking exactly the protocol version it negotiated,
-   * so the default is `[2, 2]` — never a wider range it never claimed.
-   * Every bridge in this repo emits v3 and reports `[3, 3]`, and the
-   * runtime's assembler speaks `[3, 3]` only (`ASSEMBLER_GRAMMAR_VERSIONS`),
-   * so a bridge that takes the default is refused at startup: the two
-   * ranges must intersect ({@link negotiateGrammarVersion}) and both sides
-   * emit the highest common version.
-   */
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ]),
-  /**
-   * Mid-turn steer delivery ({@link bridgeSteerModeSchema}). Defaults to
-   * `queue`, the conservative reading: absence is the definite "no" the
-   * rest of this handshake uses, and `inject` is the stronger promise (the
-   * steer reaches the model before the turn ends) a bridge must make
-   * explicitly. Nothing in the runtime, server, or clients reads it today:
-   * `turn/steer` is sent either way, and a steer whose turn is gone is
-   * dropped on the bridge's `staleTurn` recovery hint or `NO_ACTIVE_TURN`
-   * error (`steerTurn` in @bb/agent-runtime), whatever the mode. claude,
-   * codex, and pi declare `inject`; ACP and the echo example declare
-   * `queue`.
-   */
   steerMode: bridgeSteerModeSchema.default("queue"),
-  /**
-   * Which optional requests the bridge handles. `skills.configure`: the
-   * bridge accepts `skills/configure` (bb's injected skill roots). When
-   * false the runtime never sends it, so a bridge that answers unknown
-   * methods with METHOD_NOT_FOUND — as the protocol instructs — still
-   * starts threads; it simply runs without injected skills. A bridge that
-   * handles the request declares it; the runtime never probes.
-   */
   skills: z18.object({ configure: z18.boolean().default(false) }).default({ configure: false })
 }).passthrough();
 var initializeParamsSchema = z18.object({
   protocolVersion: z18.number().int().positive(),
   client: z18.object({ name: z18.string().min(1), version: z18.string().min(1) }),
-  /**
-   * The `thread/delta` grammar range the runtime's assembler accepts (see
-   * {@link negotiateGrammarVersion}). A runtime that predates the field
-   * reads as speaking exactly its protocol version.
-   */
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
@@ -4729,8 +4275,6 @@ var initializeParamsSchema = z18.object({
 }).passthrough();
 var initializeResultSchema = z18.object({
   protocolVersion: z18.number().int().positive(),
-  // An absent capabilities block reads as "no capabilities" via the inner
-  // per-field defaults, so older bridges parse to explicit values.
   capabilities: z18.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
@@ -4743,16 +4287,9 @@ var bridgeExecutionOptionsSchema = z19.object({
   model: z19.string().min(1).optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
-  /**
-   * BB prompt mode (`"plan"`), present only when the prompt entered one
-   * through the provider's declared composer action. Each bridge maps it
-   * onto the agent's native equivalent.
-   */
   promptMode: promptModeSchema.optional(),
-  /** Frozen for the life of a provider session; applied at construction. */
   instructions: z19.string().optional(),
   envVars: z19.record(z19.string(), z19.string()).optional(),
-  /** Provider-scoped session options. Opaque outside the owning bridge. */
   providerOptions: z19.record(z19.string(), z19.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
@@ -4763,9 +4300,7 @@ var providerMaintenanceParamsSchema = z20.object({
   cwd: z20.string().min(1).optional(),
   providerOptions: z20.record(z20.string(), z20.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z20.enum([
-  "thread_rewind"
-]);
+var providerInstallationRequirementSchema = z20.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
@@ -4813,26 +4348,20 @@ var providerUsageSchema = z20.discriminatedUnion("status", [
     accountEmail: z20.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z20.discriminatedUnion(
-  "supported",
-  [
-    z20.object({ supported: z20.literal(false) }).passthrough(),
-    z20.object({
-      supported: z20.literal(true),
-      health: providerHealthSchema
-    }).passthrough()
-  ]
-);
-var providerUsageResultSchema = z20.discriminatedUnion(
-  "supported",
-  [
-    z20.object({ supported: z20.literal(false) }).passthrough(),
-    z20.object({
-      supported: z20.literal(true),
-      usage: providerUsageSchema
-    }).passthrough()
-  ]
-);
+var providerHealthResultSchema = z20.discriminatedUnion("supported", [
+  z20.object({ supported: z20.literal(false) }).passthrough(),
+  z20.object({
+    supported: z20.literal(true),
+    health: providerHealthSchema
+  }).passthrough()
+]);
+var providerUsageResultSchema = z20.discriminatedUnion("supported", [
+  z20.object({ supported: z20.literal(false) }).passthrough(),
+  z20.object({
+    supported: z20.literal(true),
+    usage: providerUsageSchema
+  }).passthrough()
+]);
 var providerInstallationActionKindSchema = z20.enum([
   "install",
   "update"
@@ -4869,28 +4398,34 @@ var providerInstallationCommandSchema = z20.object({
   args: z20.array(z20.string()).max(64),
   displayCommand: z20.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z20.discriminatedUnion("kind", [
-  z20.object({ kind: z20.literal("installed") }).passthrough(),
-  z20.object({
-    kind: z20.literal("version_changed"),
-    previousVersion: z20.string().min(1)
-  }).passthrough(),
-  z20.object({
-    kind: z20.literal("version_at_least"),
-    version: z20.string().min(1)
-  }).passthrough()
-]);
-var providerInstallationRunResultSchema = z20.discriminatedUnion("available", [
-  z20.object({
-    available: z20.literal(false),
-    message: z20.string().min(1)
-  }).passthrough(),
-  z20.object({
-    available: z20.literal(true),
-    command: providerInstallationCommandSchema,
-    verification: providerInstallationVerificationSchema
-  }).passthrough()
-]);
+var providerInstallationVerificationSchema = z20.discriminatedUnion(
+  "kind",
+  [
+    z20.object({ kind: z20.literal("installed") }).passthrough(),
+    z20.object({
+      kind: z20.literal("version_changed"),
+      previousVersion: z20.string().min(1)
+    }).passthrough(),
+    z20.object({
+      kind: z20.literal("version_at_least"),
+      version: z20.string().min(1)
+    }).passthrough()
+  ]
+);
+var providerInstallationRunResultSchema = z20.discriminatedUnion(
+  "available",
+  [
+    z20.object({
+      available: z20.literal(false),
+      message: z20.string().min(1)
+    }).passthrough(),
+    z20.object({
+      available: z20.literal(true),
+      command: providerInstallationCommandSchema,
+      verification: providerInstallationVerificationSchema
+    }).passthrough()
+  ]
+);
 
 // ../provider-bridge-protocol/src/requests.ts
 import { z as z21 } from "zod";
@@ -4934,24 +4469,12 @@ var threadResumeParamsSchema = z21.object({
 var threadForkParamsSchema = z21.object({
   ...sessionConstructionFields,
   sourceProviderThreadId: z21.string().min(1),
-  /**
-   * Absent means fork at the tip. Bridges whose handshake advertises
-   * `fork: "tip"` reject a request carrying a checkpoint instead of
-   * silently cloning more history than the bb timeline shows.
-   */
   sourceProviderCheckpointId: z21.string().min(1).optional()
 }).passthrough();
 var threadStopParamsSchema = z21.object({
   threadId: z21.string().min(1),
   providerThreadId: z21.string().min(1),
-  /**
-   * "interrupt" stops an active turn and settles it as interrupted.
-   * "release" detaches an idle session so its resources can be reclaimed;
-   * it must never fabricate an interruption. One verb serving both intents
-   * is the #1584 incident — the field is required.
-   */
   intent: z21.enum(["interrupt", "release"]),
-  /** Non-null when the stop interrupts an active provider turn. */
   activeTurnId: z21.string().min(1).nullable()
 }).passthrough();
 var threadRefParams = z21.object({
@@ -4990,7 +4513,6 @@ var skillsConfigureParamsSchema = z21.object({
 }).passthrough();
 var threadIdentityResultSchema = z21.object({
   providerThreadId: z21.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
   sessionRestorable: z21.boolean().optional()
 }).passthrough();
 var modelListResultSchema = z21.object({
@@ -5004,17 +4526,11 @@ import { z as z23 } from "zod";
 // ../provider-bridge-protocol/src/errors.ts
 import { z as z22 } from "zod";
 var BRIDGE_JSON_RPC_ERRORS = {
-  /** Standard JSON-RPC: params failed schema validation. */
   INVALID_PARAMS: -32602,
-  /** Standard JSON-RPC: method not implemented by this bridge. */
   METHOD_NOT_FOUND: -32601,
-  /** Generic bridge failure. */
   BRIDGE_ERROR: -32e3,
-  /** A turn/steer arrived but the session has no active turn. */
   NO_ACTIVE_TURN: -32001,
-  /** thread/resume for a session the provider can no longer restore. */
   SESSION_NOT_RESTORABLE: -32002,
-  /** thread/fork with a checkpoint on a bridge that only forks at the tip. */
   FORK_CHECKPOINT_UNSUPPORTED: -32003
 };
 var providerRecoveryHintSchema = z22.object({
@@ -5028,16 +4544,12 @@ var bridgeErrorDataSchema = z22.object({ recovery: providerRecoveryHintSchema.op
 var threadIdentityNotificationSchema = z23.object({
   threadId: z23.string().min(1),
   providerThreadId: z23.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
   sessionRestorable: z23.boolean().optional()
 }).passthrough();
 var sessionReplacedNotificationSchema = z23.object({
   threadId: z23.string().min(1),
-  /** Identity of the replacement session (may equal the old identity). */
   providerThreadId: z23.string().min(1).nullable(),
-  /** Human-readable cause, shown in the timeline. */
   reason: z23.string().min(1),
-  /** True when provider-side context did not survive the replacement. */
   contextLost: z23.boolean().default(false)
 }).passthrough();
 var providerRawNotificationSchema = z23.object({
@@ -5081,14 +4593,6 @@ var interactionRequestParamsSchema = z24.object({
   threadId: z24.string().min(1).optional(),
   turnId: z24.union([z24.string().min(1), z24.null()]),
   payload: pendingInteractionPayloadSchema,
-  /**
-   * The request's turn id and approval-subject item ids are in the
-   * provider's native id space (a `thread/delta` bridge holds no bb ids):
-   * the runtime adapter translates them through the delta assembler's maps
-   * before the interaction reaches the app. Omission means the ids are
-   * already app-visible (bridges whose approval subjects never referenced
-   * timeline ids — ACP's approval ids never matched timeline ids).
-   */
   providerNativeIds: z24.boolean().optional()
 }).passthrough();
 
@@ -5332,7 +4836,10 @@ function checkPresentationIconsDeclared(events, icons) {
       "no item carried a presentation to inspect"
     );
   }
-  return pass(PRESENTATION_ICONS_DECLARED_ID, PRESENTATION_ICONS_DECLARED_TITLE);
+  return pass(
+    PRESENTATION_ICONS_DECLARED_ID,
+    PRESENTATION_ICONS_DECLARED_TITLE
+  );
 }
 async function runRpcHygieneScenarios(client) {
   const results = [];
@@ -5452,7 +4959,9 @@ async function runHandshakeScenario(client) {
   const parsed = initializeResultSchema.safeParse(response.result);
   if (!parsed.success) {
     return failed(
-      `result did not parse: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")} (got ${JSON.stringify(response.result ?? response.error)})`
+      `result did not parse: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(
+        "; "
+      )} (got ${JSON.stringify(response.result ?? response.error)})`
     );
   }
   if (parsed.data.protocolVersion !== PROVIDER_BRIDGE_PROTOCOL_VERSION) {
@@ -5824,7 +5333,11 @@ async function runForkIdentityScenario(context, threadId) {
   const response = await client.waitForResponse(forkId);
   if (response === null) {
     return [
-      fail(FORK_IDENTITY_ID, FORK_IDENTITY_TITLE, "thread/fork was not answered")
+      fail(
+        FORK_IDENTITY_ID,
+        FORK_IDENTITY_TITLE,
+        "thread/fork was not answered"
+      )
     ];
   }
   if (response.error !== void 0) {
@@ -6018,7 +5531,11 @@ async function runInterruptStopScenario(context, threadId) {
   const stopResponse = await client.waitForResponse(stopId);
   if (stopResponse === null) {
     return [
-      fail(INTERRUPT_SETTLES_ID, INTERRUPT_SETTLES_TITLE, "thread/stop was not answered")
+      fail(
+        INTERRUPT_SETTLES_ID,
+        INTERRUPT_SETTLES_TITLE,
+        "thread/stop was not answered"
+      )
     ];
   }
   if (stopResponse.error !== void 0) {
@@ -6334,11 +5851,7 @@ async function runBridgeConformance(options) {
     ...await runSessionLifecycleScenarios({
       client,
       fixture: options.session,
-      // The same reverse mapping the runtime applies when it names a turn
-      // to the bridge: the assembler's provider↔bb turn-id map.
       resolveProviderTurnId: (threadId, bbTurnId) => collector.assembler.getProviderTurnId(threadId, bbTurnId),
-      // A failed handshake reads as the definite absences the schema
-      // defaults to: no fork, so the fork rule is not attempted.
       fork: handshake.capabilities?.fork ?? "none"
     })
   );
@@ -6556,7 +6069,13 @@ function describeCalibrationEvents(events) {
 
 // ../provider-bridge-protocol/src/testing/parity.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync2, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync as existsSync2,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { isAbsolute, join as join2, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -6632,7 +6151,10 @@ function bridgeRecordingFileName(direction) {
 var COMMITTED_RECORDINGS_ROOT = fileURLToPath(
   new URL("../../recordings", import.meta.url)
 );
-var RECORDINGS_CHECKOUT_ROOT = resolve(COMMITTED_RECORDINGS_ROOT, "../../..");
+var RECORDINGS_CHECKOUT_ROOT = resolve(
+  COMMITTED_RECORDINGS_ROOT,
+  "../../.."
+);
 function compareRecordingEntries(left, right) {
   return left.run - right.run || left.seq - right.seq;
 }
@@ -6662,7 +6184,9 @@ function readBridgeRecordingLane(dir, direction) {
     if (raw.length === 0) continue;
     const entry = parseEntry(raw, file, index + 1);
     if (entry.dir !== direction) {
-      throw new Error(`${file}:${index + 1}: entry direction ${entry.dir} in the ${direction} lane`);
+      throw new Error(
+        `${file}:${index + 1}: entry direction ${entry.dir} in the ${direction} lane`
+      );
     }
     entries.push(entry);
   }
@@ -6680,7 +6204,9 @@ function readCurrentBridgeLane(dir) {
     if (raw.length === 0) continue;
     const entry = parseEntry(raw, file, index + 1);
     if (entry.dir !== "bridge\u2192runtime") {
-      throw new Error(`${file}:${index + 1}: entry direction ${entry.dir} in the current bridge lane`);
+      throw new Error(
+        `${file}:${index + 1}: entry direction ${entry.dir} in the current bridge lane`
+      );
     }
     entries.push(entry);
   }
@@ -6700,7 +6226,9 @@ function withCurrentBridgeLane(recording) {
 }
 function readBridgeRecording(dir) {
   const manifestPath = join(dir, "manifest.json");
-  const manifest = existsSync(manifestPath) ? JSON.parse(readFileSync(manifestPath, "utf8")) : null;
+  const manifest = existsSync(manifestPath) ? JSON.parse(
+    readFileSync(manifestPath, "utf8")
+  ) : null;
   const entries = [];
   for (const direction of BRIDGE_RECORDING_DIRECTIONS) {
     entries.push(...readBridgeRecordingLane(dir, direction));
@@ -6731,8 +6259,12 @@ function listRecordedCells(root) {
 }
 
 // ../provider-bridge-protocol/src/testing/parity.ts
-var SOURCE_BOOTSTRAP = fileURLToPath2(new URL("../bridge-worker-entry.ts", import.meta.url));
-var BUNDLED_BOOTSTRAP = fileURLToPath2(new URL("./provider-bridge-worker-entry.mjs", import.meta.url));
+var SOURCE_BOOTSTRAP = fileURLToPath2(
+  new URL("../bridge-worker-entry.ts", import.meta.url)
+);
+var BUNDLED_BOOTSTRAP = fileURLToPath2(
+  new URL("./provider-bridge-worker-entry.mjs", import.meta.url)
+);
 function resolveProviderBridgeBootstrapPath() {
   if (existsSync2(SOURCE_BOOTSTRAP)) return SOURCE_BOOTSTRAP;
   if (existsSync2(BUNDLED_BOOTSTRAP)) return BUNDLED_BOOTSTRAP;
@@ -6754,7 +6286,9 @@ function defaultNodeArgs(bootstrapPath, modulePath) {
 }
 function resolveProviderBridgeLaunch(options) {
   if (!isAbsolute(options.modulePath)) {
-    throw new Error(`bridge module path must be absolute: ${options.modulePath}`);
+    throw new Error(
+      `bridge module path must be absolute: ${options.modulePath}`
+    );
   }
   const bootstrapPath = options.bootstrapPath ?? resolveProviderBridgeBootstrapPath();
   const dataDir = options.dataDir ?? mkdtempSync(join2(tmpdir(), "bb-parity-data-"));
@@ -6869,7 +6403,9 @@ function methodOfRecordedBridgeRequest(recording, response, id) {
   }
   return void 0;
 }
-var REPLAY_CHILD_PATH = fileURLToPath2(new URL("./replay-provider-child.mjs", import.meta.url));
+var REPLAY_CHILD_PATH = fileURLToPath2(
+  new URL("./replay-provider-child.mjs", import.meta.url)
+);
 var PARITY_INITIALIZE_ID = "parity-initialize";
 function sleep(ms) {
   return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
@@ -6883,7 +6419,9 @@ async function replayRecording(options) {
   const profile = options.profile ?? DEFAULT_REPLAY_PROFILE;
   const recording = readBridgeRecording(options.recordingDir);
   const stateDir = mkdtempSync(join2(tmpdir(), "bb-parity-replay-"));
-  const workspaceDir = realpathSync(mkdtempSync(join2(tmpdir(), "bb-parity-ws-")));
+  const workspaceDir = realpathSync(
+    mkdtempSync(join2(tmpdir(), "bb-parity-ws-"))
+  );
   const replayCommand = [
     process.execPath,
     REPLAY_CHILD_PATH,
@@ -6951,7 +6489,11 @@ async function replayRecording(options) {
   const recordedAnswers = /* @__PURE__ */ new Map();
   for (const step of steps) {
     if (step.message !== null && isResponse(step.message)) {
-      const method = methodOfRecordedBridgeRequest(recording, step.entry, step.message.id) ?? "?";
+      const method = methodOfRecordedBridgeRequest(
+        recording,
+        step.entry,
+        step.message.id
+      ) ?? "?";
       const queue = recordedAnswers.get(method) ?? [];
       queue.push(step.message);
       recordedAnswers.set(method, queue);
@@ -6976,7 +6518,9 @@ async function replayRecording(options) {
     const queue = recordedAnswers.get(method);
     const recorded = queue?.shift();
     if (recorded === void 0) {
-      stalls.push(`no recorded answer for bridge request ${method} (${String(message.id)})`);
+      stalls.push(
+        `no recorded answer for bridge request ${method} (${String(message.id)})`
+      );
       write(
         JSON.stringify({
           jsonrpc: "2.0",
@@ -7003,7 +6547,10 @@ async function replayRecording(options) {
         return;
       }
       if (isRequest(message)) {
-        pendingBridgeRequests.push({ id: message.id, method: message.method });
+        pendingBridgeRequests.push({
+          id: message.id,
+          method: message.method
+        });
         answerBridgeRequest(message);
         return;
       }
@@ -7012,13 +6559,19 @@ async function replayRecording(options) {
         try {
           assembled = liveAssembler.assembleMessage(message);
         } catch (error) {
-          stalls.push(`invalid thread/delta: ${error instanceof Error ? error.message : String(error)}`);
+          stalls.push(
+            `invalid thread/delta: ${error instanceof Error ? error.message : String(error)}`
+          );
           return;
         }
         for (const event of assembled) {
           const result2 = grammar.observe(event);
           if (result2.kind === "violation") {
-            grammarViolations.push({ rule: result2.rule, reason: result2.reason, eventType: event.type });
+            grammarViolations.push({
+              rule: result2.rule,
+              reason: result2.reason,
+              eventType: event.type
+            });
             continue;
           }
           events.push(event);
@@ -7043,8 +6596,12 @@ async function replayRecording(options) {
       await sleep(10);
     }
   }
-  const firstStep = steps.find((step) => step.message !== null && isRequest(step.message));
-  setCursor(firstStep === void 0 ? "end" : { run: firstStep.entry.run, seq: firstStep.entry.seq });
+  const firstStep = steps.find(
+    (step) => step.message !== null && isRequest(step.message)
+  );
+  setCursor(
+    firstStep === void 0 ? "end" : { run: firstStep.entry.run, seq: firstStep.entry.seq }
+  );
   write(
     JSON.stringify({
       jsonrpc: "2.0",
@@ -7061,7 +6618,11 @@ async function replayRecording(options) {
   for (const step of steps) {
     if (step.message === null || !isRequest(step.message)) {
       if (step.message !== null && !isResponse(step.message)) {
-        lastSentRuntimeEntry = { run: step.entry.run, seq: step.entry.seq, ts: step.entry.ts };
+        lastSentRuntimeEntry = {
+          run: step.entry.run,
+          seq: step.entry.seq,
+          ts: step.entry.ts
+        };
         write(step.entry.line);
       }
       continue;
@@ -7096,23 +6657,40 @@ async function replayRecording(options) {
       const threadId = request.params.threadId;
       if (typeof threadId === "string") grammar.clearThread(threadId);
     }
-    const rewritten = rewriteRecordedMachineFacts(step.entry.line, workspaceDir);
+    const rewritten = rewriteRecordedMachineFacts(
+      step.entry.line,
+      workspaceDir
+    );
     const line = profile.rewriteRuntimeLine === void 0 ? rewritten : profile.rewriteRuntimeLine(rewritten, { replayCommand });
-    lastSentRuntimeEntry = { run: step.entry.run, seq: step.entry.seq, ts: step.entry.ts };
+    lastSentRuntimeEntry = {
+      run: step.entry.run,
+      seq: step.entry.seq,
+      ts: step.entry.ts
+    };
     write(line);
     sentRequestIds.push(String(request.id));
-    const nextStep = steps.slice(steps.indexOf(step) + 1).find((candidate) => candidate.message !== null && isRequest(candidate.message));
-    setCursor(nextStep === void 0 ? "end" : { run: nextStep.entry.run, seq: nextStep.entry.seq });
+    const nextStep = steps.slice(steps.indexOf(step) + 1).find(
+      (candidate) => candidate.message !== null && isRequest(candidate.message)
+    );
+    setCursor(
+      nextStep === void 0 ? "end" : { run: nextStep.entry.run, seq: nextStep.entry.seq }
+    );
   }
   setCursor("end");
-  await waitFor("the last responses", () => sentRequestIds.every((id) => answeredIds.has(id)));
+  await waitFor(
+    "the last responses",
+    () => sentRequestIds.every((id) => answeredIds.has(id))
+  );
   if (plannedEventCount !== null) {
     await waitFor(
       `all ${plannedEventCount} planned events before closing the bridge`,
       () => events.length >= plannedEventCount
     );
   }
-  await waitFor("the stream to settle", () => Date.now() - lastOutputAt >= settleMs);
+  await waitFor(
+    "the stream to settle",
+    () => Date.now() - lastOutputAt >= settleMs
+  );
   child.stdin?.end();
   const exitCode = await Promise.race([
     exited,
@@ -7154,18 +6732,25 @@ function assembleRecordedEvents(recording, createAssembler, providerId) {
     }
     if (entry.dir !== "bridge\u2192runtime") continue;
     const message = parseWire(entry.line);
-    if (message === null || message.method !== THREAD_DELTA_NOTIFICATION_METHOD) continue;
+    if (message === null || message.method !== THREAD_DELTA_NOTIFICATION_METHOD)
+      continue;
     let assembled;
     try {
       assembled = assembler.assembleMessage(message);
     } catch (error) {
-      invalidDeltas.push(error instanceof Error ? error.message : String(error));
+      invalidDeltas.push(
+        error instanceof Error ? error.message : String(error)
+      );
       continue;
     }
     for (const event of assembled) {
       const result2 = grammar.observe(event);
       if (result2.kind === "violation") {
-        grammarViolations.push({ rule: result2.rule, reason: result2.reason, eventType: event.type });
+        grammarViolations.push({
+          rule: result2.rule,
+          reason: result2.reason,
+          eventType: event.type
+        });
         continue;
       }
       events.push(event);
@@ -7272,7 +6857,10 @@ function entryApplies(entry, provider, cell) {
 }
 function compareParity(oldRun, newRun, allowlist, scope) {
   const layers = {
-    events: [normalizeParityEvents(oldRun.events), normalizeParityEvents(newRun.events)],
+    events: [
+      normalizeParityEvents(oldRun.events),
+      normalizeParityEvents(newRun.events)
+    ],
     rows: [normalizeParityRows(oldRun.rows), normalizeParityRows(newRun.rows)]
   };
   const staleAllowlist = [];
@@ -7287,8 +6875,12 @@ function compareParity(oldRun, newRun, allowlist, scope) {
   const events = diffLayer(layers.events[0], layers.events[1]);
   const rows = diffLayer(layers.rows[0], layers.rows[1]);
   const grammar = diffLayer(
-    (oldRun.grammarViolations ?? []).map((violation2) => `${violation2.rule}:${violation2.eventType}`),
-    (newRun.grammarViolations ?? []).map((violation2) => `${violation2.rule}:${violation2.eventType}`)
+    (oldRun.grammarViolations ?? []).map(
+      (violation2) => `${violation2.rule}:${violation2.eventType}`
+    ),
+    (newRun.grammarViolations ?? []).map(
+      (violation2) => `${violation2.rule}:${violation2.eventType}`
+    )
   );
   const clean = (diff) => diff.onlyInOld.length === 0 && diff.onlyInNew.length === 0;
   return {
@@ -7322,7 +6914,12 @@ async function rerecordCurrentBridgeLane(options) {
   const recording = readBridgeRecording(options.recordingDir);
   const run = await replayRecording({ ...options, planFromCurrentLane: false });
   if (run.stalls.length > 0) {
-    return { file: null, lines: 0, events: run.events.length, stalls: run.stalls };
+    return {
+      file: null,
+      lines: 0,
+      events: run.events.length,
+      stalls: run.stalls
+    };
   }
   const firstRuntime = recording.entries.find(
     (entry) => entry.dir === "runtime\u2192bridge"
@@ -7361,7 +6958,6 @@ async function rerecordCurrentBridgeLane(options) {
     entries.push({
       ts: anchor.ts + ordinal,
       run: anchor.run,
-      // Fractional: after the anchoring runtime entry, before the next one.
       seq: anchor.seq + ordinal / (run.lines.length + 1),
       dir: BRIDGE_TO_RUNTIME,
       line