@get-bb/plugin-sdk 0.4.24 → 0.4.27

package/dist/provider-bridge-acp.js

@@ -135,16 +135,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()
   })
@@ -183,21 +174,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(),
@@ -337,13 +318,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);
@@ -642,7 +617,6 @@ var workflowAgentStateValues = [
 ];
 var workflowAgentStateSchema = z5.enum(workflowAgentStateValues);
 var workflowAgentSnapshotSchema = z5.object({
-  /** 1-based agent counter; the stable identity for fold/replace semantics. */
   index: z5.number().int().positive(),
   label: z5.string(),
   state: workflowAgentStateSchema,
@@ -666,10 +640,8 @@ var workflowAgentSnapshotSchema = z5.object({
   durationMs: z5.number().optional()
 });
 var workflowPhaseSnapshotSchema = z5.object({
-  /** 1-based phase counter; meta.phases are seeded before any agent runs. */
   index: z5.number().int().positive(),
   title: z5.string(),
-  /** "child" marks a nested workflow() sub-run group. */
   kind: z5.string().optional()
 });
 var workflowProgressSnapshotSchema = z5.object({
@@ -702,9 +674,7 @@ function jsonByteLength(value) {
 import { z as z6 } from "zod";
 var THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH = 280;
 var threadEventItemPresentationLabelSchema = z6.object({
-  /** Present-tense row title while the item is in flight ("Reading file"). */
   pending: z6.string().min(1),
-  /** Past-tense row title once the item settled ("Read file"). */
   completed: z6.string().min(1)
 });
 var threadEventItemPresentationIconSchema = z6.object({
@@ -717,16 +687,9 @@ var threadEventItemPresentationTintSchema = z6.object({
 var threadEventItemPresentationSchema = z6.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
-  /** Row headline beside the label (a path, a query, a child thread title). */
   title: z6.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: z6.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
-  /** Low-value rows (TodoWrite, ToolSearch) clients collapse by default. */
   suppress: z6.boolean().optional(),
-  /** Accent colour per theme; omitted rows use the neutral row tint. */
   tint: threadEventItemPresentationTintSchema.optional()
 });
 
@@ -846,9 +809,7 @@ var pendingInteractionPermissionGrantApprovalSubjectSchema = z8.object({
 var pendingInteractionPlanApprovalSubjectSchema = z8.object({
   kind: z8.literal("plan"),
   itemId: z8.string().min(1),
-  /** The plan body, as Markdown. */
   plan: z8.string().min(1),
-  /** Where the provider saved the plan, or null when it kept it in memory. */
   planFilePath: z8.string().min(1).nullable()
 });
 var pendingInteractionToolUseApprovalSubjectSchema = z8.object({
@@ -1156,21 +1117,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"];
@@ -1222,18 +1175,10 @@ var clientTurnLifecycleEventDataSchema = z10.object({
 var turnRequestEventDataSchema = z10.object({
   direction: z10.literal("outbound"),
   requestId: clientTurnRequestIdSchema,
-  /** Failed request resumed by a guarded system continuation, when present. */
   continuationOfRequestId: clientTurnRequestIdSchema.optional(),
   source: z10.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: z10.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: z10.array(promptInputSchema),
@@ -1319,8 +1264,6 @@ var systemUserQuestionLifecycleEventDataSchema = z10.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 = z10.enum(
@@ -1364,11 +1307,6 @@ var systemProviderTurnWatchdogEventDataSchema = z10.object({
   activeTurnId: z10.string().min(1),
   activeTurnStartedAt: z10.number().int().nonnegative(),
   lastActivityEventSequence: z10.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: z10.string().min(1),
   lastActivityEventAt: z10.number().int().nonnegative(),
   providerId: z10.string().min(1),
@@ -1631,7 +1569,6 @@ var providerRateLimitStatusSchema = z13.enum([
   "unknown"
 ]);
 var providerRateLimitWindowSchema = z13.object({
-  /** Opaque provider-issued key. New provider windows must not break parsing. */
   providerKey: z13.string().min(1).nullable(),
   label: z13.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
@@ -1716,11 +1653,9 @@ var threadEventDelegationItemSchema = z13.object({
   type: z13.literal("delegation"),
   id: z13.string(),
   childRef: z13.string().min(1),
-  /** Human label for the delegated work (the child's description). */
   label: z13.string(),
   status: threadEventItemStatusSchema,
   background: z13.boolean(),
-  /** Terminal summary from the child; absent while it runs. */
   summary: z13.string().optional(),
   ...itemPresentationField,
   parentToolCallId: z13.string().optional()
@@ -1781,10 +1716,6 @@ var threadEventWarningCategorySchema = z13.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 = z13.object({
@@ -1813,28 +1744,15 @@ var toolCallProgressEventSchema = z13.object({
 var threadEventBackgroundTaskItemSchema = z13.object({
   type: z13.literal("backgroundTask"),
   id: z13.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: z13.string().optional(),
-  /** Raw SDK task discriminant (e.g. "local_workflow"); "unknown" when the provider omitted it. */
   taskType: z13.string(),
   description: z13.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  /** Ambient/housekeeping task; consumers hide it from the inline transcript. */
   skipTranscript: z13.boolean(),
-  /** meta.name of the workflow script; only present for workflow tasks. */
   workflowName: z13.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: z13.string().optional(),
   error: z13.string().optional(),
   outputFile: z13.string().optional(),
@@ -1842,7 +1760,6 @@ var threadEventBackgroundTaskItemSchema = z13.object({
   parentToolCallId: z13.string().optional()
 });
 var threadEventItemSchema = z13.discriminatedUnion("type", [
-  // bb authors user messages itself, so they carry no bridge presentation.
   z13.object({
     type: z13.literal("userMessage"),
     id: z13.string(),
@@ -1864,10 +1781,6 @@ var threadEventItemSchema = z13.discriminatedUnion("type", [
     cwd: z13.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: z13.string().optional(),
     exitCode: z13.number().optional(),
     durationMs: z13.number().optional(),
@@ -1900,10 +1813,6 @@ var threadEventItemSchema = z13.discriminatedUnion("type", [
     error: z13.string().optional(),
     durationMs: z13.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: z13.string().optional()
   }),
@@ -1952,12 +1861,9 @@ var unscopedProviderEventSchema = z13.discriminatedUnion("type", [
   z13.object({
     type: z13.literal("turn/completed"),
     threadId: z13.string(),
-    // Server reconciliation can synthesize interrupted completions when the
-    // original provider thread id was never persisted.
     providerThreadId: z13.string().nullable(),
     status: threadEventTurnStatusSchema,
     error: z13.object({ message: z13.string() }).optional(),
-    /** Provider-native point through which a replacement branch should retain history. */
     providerCheckpointId: z13.string().min(1).optional()
   }),
   z13.object({
@@ -2024,10 +1930,6 @@ var unscopedProviderEventSchema = z13.discriminatedUnion("type", [
     providerThreadId: z13.string(),
     itemId: z13.string(),
     delta: z13.string(),
-    /**
-     * When true, this delta replaces previously accumulated command output
-     * instead of appending to it. Omission means the delta appends.
-     */
     reset: z13.boolean().optional(),
     parentToolCallId: z13.string().optional()
   }),
@@ -2072,49 +1974,24 @@ var unscopedProviderEventSchema = z13.discriminatedUnion("type", [
     parentToolCallId: z13.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.
-   */
   z13.object({
     type: z13.literal("item/backgroundTask/progress"),
     threadId: z13.string(),
     providerThreadId: z13.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.
-   */
   z13.object({
     type: z13.literal("item/backgroundTask/completed"),
     threadId: z13.string(),
     providerThreadId: z13.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`.
-   */
   z13.object({
     type: z13.literal("item/delegation/progress"),
     threadId: z13.string(),
     providerThreadId: z13.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`.
-   */
   z13.object({
     type: z13.literal("item/delegation/completed"),
     threadId: z13.string(),
@@ -2161,16 +2038,6 @@ var unscopedProviderEventSchema = z13.discriminatedUnion("type", [
     providerThreadId: z13.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.
-   */
   z13.object({
     type: z13.literal("thread/extensionState/updated"),
     threadId: z13.string(),
@@ -2326,8 +2193,6 @@ var availableModelSchema = z15.object({
   id: z15.string(),
   model: z15.string(),
   displayName: z15.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: z15.string().min(1).optional(),
   description: z15.string(),
   supportedReasoningEfforts: z15.array(modelReasoningEffortSchema),
@@ -2341,20 +2206,8 @@ var providerCapabilitiesSchema = z15.object({
   supportsServiceTier: z15.boolean(),
   supportsNativeUserQuestion: z15.boolean(),
   supportsFork: z15.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: z15.boolean(),
   permissionModes: z15.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 = z15.object({
@@ -2377,17 +2230,11 @@ var providerComposerActionSchema = z15.discriminatedUnion("kind", [
   })
 ]);
 var providerStringsSchema = z15.object({
-  /** How to sign in on the host ("Run `claude` on the machine to sign in."). */
   signInHint: z15.string().min(1),
-  /** Shown when a session's credentials expired. */
   expiredHint: z15.string().min(1),
-  /** Where to install the agent. */
   installUrl: z15.string().min(1),
-  /** Brand prefix stripped from model display names ("Claude "). */
   brandPrefix: z15.string().min(1).optional(),
-  /** Plan-mode banner copy for providers that declare the `plan` action. */
   planModeCopy: z15.string().min(1).optional(),
-  /** Per-theme tint for the provider icon. */
   iconTint: z15.object({ light: z15.string().min(1), dark: z15.string().min(1) }).optional()
 });
 var providerOptionDescriptorSchema = z15.object({
@@ -2405,31 +2252,11 @@ var providerExtensionKindsSchema = z15.record(
 );
 var providerInfoSchema = z15.object({
   id: z15.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: z15.string().min(1),
   displayName: z15.string(),
-  /**
-   * Declared grouping key shared by related providers (the ACP agents).
-   * Absent when the provider declared none. Grouping only.
-   */
   family: z15.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: z15.object({ glyph: z15.string().min(1) }).optional(),
   logoUrl: z15.string().min(1).nullable(),
-  /** Sessionless maintenance requests the provider's bridge implements. */
   maintenance: z15.object({
     health: z15.boolean(),
     usage: z15.boolean(),
@@ -2438,13 +2265,6 @@ var providerInfoSchema = z15.object({
   capabilities: providerCapabilitiesSchema,
   composerActions: z15.array(providerComposerActionSchema),
   available: z15.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: z15.array(providerOptionDescriptorSchema).optional(),
   reasoningLevels: z15.array(providerOptionDescriptorSchema).optional(),
@@ -2585,88 +2405,22 @@ var bridgeGrammarVersionsSchema = z17.tuple([z17.number().int().positive(), z17.
 });
 var bridgeSteerModeSchema = z17.enum(["inject", "queue"]);
 var bridgeCapabilitiesSchema = z17.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: z17.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: z17.boolean().default(false),
-  /**
-   * The bridge pushes bb thread titles to the provider. When false the
-   * runtime never sends thread/name/set.
-   */
   threadRename: z17.boolean().default(false),
-  /** The bridge supports thread/goal/clear. */
   threadGoalClear: z17.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: z17.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: z17.object({ configure: z17.boolean().default(false) }).default({ configure: false })
 }).passthrough();
 var initializeParamsSchema = z17.object({
   protocolVersion: z17.number().int().positive(),
   client: z17.object({ name: z17.string().min(1), version: z17.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
@@ -2674,8 +2428,6 @@ var initializeParamsSchema = z17.object({
 }).passthrough();
 var initializeResultSchema = z17.object({
   protocolVersion: z17.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: z17.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
@@ -2688,16 +2440,9 @@ var bridgeExecutionOptionsSchema = z18.object({
   model: z18.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: z18.string().optional(),
   envVars: z18.record(z18.string(), z18.string()).optional(),
-  /** Provider-scoped session options. Opaque outside the owning bridge. */
   providerOptions: z18.record(z18.string(), z18.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
@@ -2708,9 +2453,7 @@ var providerMaintenanceParamsSchema = z19.object({
   cwd: z19.string().min(1).optional(),
   providerOptions: z19.record(z19.string(), z19.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z19.enum([
-  "thread_rewind"
-]);
+var providerInstallationRequirementSchema = z19.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
@@ -2758,26 +2501,20 @@ var providerUsageSchema = z19.discriminatedUnion("status", [
     accountEmail: z19.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z19.discriminatedUnion(
-  "supported",
-  [
-    z19.object({ supported: z19.literal(false) }).passthrough(),
-    z19.object({
-      supported: z19.literal(true),
-      health: providerHealthSchema
-    }).passthrough()
-  ]
-);
-var providerUsageResultSchema = z19.discriminatedUnion(
-  "supported",
-  [
-    z19.object({ supported: z19.literal(false) }).passthrough(),
-    z19.object({
-      supported: z19.literal(true),
-      usage: providerUsageSchema
-    }).passthrough()
-  ]
-);
+var providerHealthResultSchema = z19.discriminatedUnion("supported", [
+  z19.object({ supported: z19.literal(false) }).passthrough(),
+  z19.object({
+    supported: z19.literal(true),
+    health: providerHealthSchema
+  }).passthrough()
+]);
+var providerUsageResultSchema = z19.discriminatedUnion("supported", [
+  z19.object({ supported: z19.literal(false) }).passthrough(),
+  z19.object({
+    supported: z19.literal(true),
+    usage: providerUsageSchema
+  }).passthrough()
+]);
 var providerInstallationActionKindSchema = z19.enum([
   "install",
   "update"
@@ -2814,28 +2551,34 @@ var providerInstallationCommandSchema = z19.object({
   args: z19.array(z19.string()).max(64),
   displayCommand: z19.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z19.discriminatedUnion("kind", [
-  z19.object({ kind: z19.literal("installed") }).passthrough(),
-  z19.object({
-    kind: z19.literal("version_changed"),
-    previousVersion: z19.string().min(1)
-  }).passthrough(),
-  z19.object({
-    kind: z19.literal("version_at_least"),
-    version: z19.string().min(1)
-  }).passthrough()
-]);
-var providerInstallationRunResultSchema = z19.discriminatedUnion("available", [
-  z19.object({
-    available: z19.literal(false),
-    message: z19.string().min(1)
-  }).passthrough(),
-  z19.object({
-    available: z19.literal(true),
-    command: providerInstallationCommandSchema,
-    verification: providerInstallationVerificationSchema
-  }).passthrough()
-]);
+var providerInstallationVerificationSchema = z19.discriminatedUnion(
+  "kind",
+  [
+    z19.object({ kind: z19.literal("installed") }).passthrough(),
+    z19.object({
+      kind: z19.literal("version_changed"),
+      previousVersion: z19.string().min(1)
+    }).passthrough(),
+    z19.object({
+      kind: z19.literal("version_at_least"),
+      version: z19.string().min(1)
+    }).passthrough()
+  ]
+);
+var providerInstallationRunResultSchema = z19.discriminatedUnion(
+  "available",
+  [
+    z19.object({
+      available: z19.literal(false),
+      message: z19.string().min(1)
+    }).passthrough(),
+    z19.object({
+      available: z19.literal(true),
+      command: providerInstallationCommandSchema,
+      verification: providerInstallationVerificationSchema
+    }).passthrough()
+  ]
+);
 
 // ../provider-bridge-protocol/src/requests.ts
 import { z as z20 } from "zod";
@@ -2859,24 +2602,12 @@ var threadResumeParamsSchema = z20.object({
 var threadForkParamsSchema = z20.object({
   ...sessionConstructionFields,
   sourceProviderThreadId: z20.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: z20.string().min(1).optional()
 }).passthrough();
 var threadStopParamsSchema = z20.object({
   threadId: z20.string().min(1),
   providerThreadId: z20.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: z20.enum(["interrupt", "release"]),
-  /** Non-null when the stop interrupts an active provider turn. */
   activeTurnId: z20.string().min(1).nullable()
 }).passthrough();
 var threadRefParams = z20.object({
@@ -2916,7 +2647,6 @@ var skillsConfigureParamsSchema = z20.object({
 }).passthrough();
 var threadIdentityResultSchema = z20.object({
   providerThreadId: z20.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
   sessionRestorable: z20.boolean().optional()
 }).passthrough();
 var modelListResultSchema = z20.object({
@@ -2930,17 +2660,11 @@ import { z as z22 } from "zod";
 // ../provider-bridge-protocol/src/errors.ts
 import { z as z21 } 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 = z21.object({
@@ -2961,16 +2685,12 @@ var BRIDGE_NOTIFICATION_METHODS = {
 var threadIdentityNotificationSchema = z22.object({
   threadId: z22.string().min(1),
   providerThreadId: z22.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
   sessionRestorable: z22.boolean().optional()
 }).passthrough();
 var sessionReplacedNotificationSchema = z22.object({
   threadId: z22.string().min(1),
-  /** Identity of the replacement session (may equal the old identity). */
   providerThreadId: z22.string().min(1).nullable(),
-  /** Human-readable cause, shown in the timeline. */
   reason: z22.string().min(1),
-  /** True when provider-side context did not survive the replacement. */
   contextLost: z22.boolean().default(false)
 }).passthrough();
 var providerRawNotificationSchema = z22.object({
@@ -3018,14 +2738,6 @@ var interactionRequestParamsSchema = z23.object({
   threadId: z23.string().min(1).optional(),
   turnId: z23.union([z23.string().min(1), z23.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: z23.boolean().optional()
 }).passthrough();
 
@@ -3045,24 +2757,14 @@ var deltaItemKeySchema = z24.object({
 var providerTurnIdSchema = deltaKeyPartSchema;
 var deltaFileChangeSchema = z24.object({
   path: z24.string(),
-  /** The bridge states the change kind; the assembler never derives it. */
   kind: z24.enum(["add", "update", "delete"]),
   movePath: z24.string().optional(),
-  /** Provider-supplied unified diff; preferred over old/new text building. */
   diff: z24.string().optional(),
   oldText: z24.string().optional(),
-  /** When present the assembler builds the unified diff from old/new text. */
   newText: z24.string().optional()
 });
 var deltaBackgroundTaskShapeSchema = z24.object({
   type: z24.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: z24.string().min(1),
   taskType: z24.string(),
   description: z24.string(),
@@ -3116,20 +2818,8 @@ var deltaItemShapeSchema = z24.discriminatedUnion("type", [
   }),
   z24.object({
     type: z24.literal("fileChange"),
-    /** Empty while a path is not yet known, including bare close fallbacks. */
     changes: z24.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.
-   */
   z24.object({
     type: z24.literal("tool"),
     tool: z24.string(),
@@ -3159,7 +2849,6 @@ var deltaItemShapeSchema = z24.discriminatedUnion("type", [
   }),
   z24.object({ type: z24.literal("imageView"), path: z24.string() }),
   deltaBackgroundTaskShapeSchema,
-  // Grammar v3 shapes. Every existing shape above is kept unchanged.
   deltaFileReadShapeSchema,
   deltaSearchShapeSchema,
   deltaDelegationShapeSchema,
@@ -3193,51 +2882,21 @@ function requireExtensionPresentation(delta, ctx) {
   }
 }
 var threadDeltaSchema = z24.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).
-   */
   z24.object({
     kind: z24.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.
-   */
   z24.object({
     kind: z24.literal("input.provider"),
     text: z24.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.
-   */
   z24.object({
     kind: z24.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.
-   */
   z24.object({
     kind: z24.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
@@ -3246,40 +2905,15 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     claimIfIdle: z24.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).
-   */
   z24.object({
     kind: z24.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).
-   */
   z24.object({
     kind: z24.literal("item.close"),
     key: deltaItemKeySchema,
@@ -3287,32 +2921,12 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     resultText: z24.string().optional(),
     exitCode: z24.number().optional(),
     aggregatedOutput: z24.string().optional(),
-    /** Terminal approval verdict (codex declined → denied). Default null. */
     approvalStatus: z24.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.
-   */
   z24.object({
     kind: z24.literal("item.progress"),
     key: deltaItemKeySchema,
@@ -3322,17 +2936,6 @@ var threadDeltaSchema = z24.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.
-   */
   z24.object({
     kind: z24.literal("item.textDelta"),
     key: deltaItemKeySchema,
@@ -3341,18 +2944,6 @@ var threadDeltaSchema = z24.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.
-   */
   z24.object({
     kind: z24.literal("item.textClose"),
     key: deltaItemKeySchema,
@@ -3361,10 +2952,6 @@ var threadDeltaSchema = z24.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.
-   */
   z24.object({
     kind: z24.literal("item.outputDelta"),
     key: deltaItemKeySchema,
@@ -3373,26 +2960,12 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Cumulative command output snapshot (pi bash). The assembler diffs
-   * consecutive snapshots into `outputDelta`/`reset` events.
-   */
   z24.object({
     kind: z24.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
     text: z24.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.
-   */
   z24.object({
     kind: z24.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
@@ -3400,13 +2973,6 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     modelContextWindow: z24.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.
-   */
   z24.object({
     kind: z24.literal("contextWindow"),
     used: z24.number().nullable(),
@@ -3421,54 +2987,26 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
   z24.object({ kind: z24.literal("context.cleared") }),
-  /** The aggregate working-tree diff for a turn (codex turn/diff/updated). */
   z24.object({
     kind: z24.literal("turn.diff"),
     diff: z24.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  // Thread metadata (codex thread lifecycle notifications).
   z24.object({ kind: z24.literal("thread.started") }),
   z24.object({
     kind: z24.literal("thread.identity"),
     providerThreadId: z24.string().min(1)
   }),
   z24.object({ kind: z24.literal("thread.name"), name: z24.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`.
-   */
   z24.object({
     kind: z24.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.
-   */
   z24.object({
     kind: z24.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).
-   */
   z24.object({
     kind: z24.literal("provider.error"),
     message: z24.string(),
@@ -3480,13 +3018,6 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     threadScoped: z24.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.
-   */
   z24.object({
     kind: z24.literal("provider.modelFallback"),
     originalModel: z24.string().min(1),
@@ -3494,10 +3025,6 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     reason: z24.enum(["refusal", "provider"]),
     message: z24.string()
   }),
-  /**
-   * `vouchedTurn: true` scopes the warning to the open turn when one exists
-   * (ACP warnings are turn-scoped mid-turn); default is thread scope.
-   */
   z24.object({
     kind: z24.literal("provider.warning"),
     summary: z24.string().optional(),
@@ -3505,15 +3032,6 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     category: threadEventWarningCategorySchema.optional(),
     vouchedTurn: z24.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.
-   */
   z24.object({
     kind: z24.literal("unhandled"),
     raw: providerRawEventSchema,
@@ -3523,18 +3041,7 @@ var threadDeltaSchema = z24.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.
-   */
   z24.object({ kind: z24.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).
-   */
   z24.object({ kind: z24.literal("session.reset") })
 ]);
 var threadDeltaNotificationParamsSchema = z24.object({
@@ -3650,7 +3157,10 @@ var BridgeRecoveryError = class extends Error {
   code;
   recovery;
   constructor(args) {
-    super(args.message, args.cause === void 0 ? void 0 : { cause: args.cause });
+    super(
+      args.message,
+      args.cause === void 0 ? void 0 : { cause: args.cause }
+    );
     this.name = "BridgeRecoveryError";
     this.code = args.code;
     this.recovery = args.recovery;
@@ -3669,8 +3179,6 @@ function createBridgeIo({
       send2({
         jsonrpc: "2.0",
         id,
-        // Omitted rather than `undefined`: an error response without
-        // structured detail keeps the exact shape it has always had.
         error: { code, message, ...data === void 0 ? {} : { data } }
       });
     },
@@ -3708,12 +3216,7 @@ function runBridgeRequest(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/bridge-recorder.ts
-import {
-  closeSync,
-  mkdirSync,
-  openSync,
-  writeSync
-} from "node:fs";
+import { closeSync, mkdirSync, openSync, writeSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 var PROVIDER_BRIDGE_RECORD_DIR_ENV = "BB_PROVIDER_BRIDGE_RECORD_DIR";
@@ -3796,7 +3299,10 @@ function createBridgeRecorder(args) {
     }
     const scopeDir = join(dir, scope);
     mkdirSync(scopeDir, { recursive: true });
-    const fd = openSync(join(scopeDir, bridgeRecordingFileName(direction)), "a");
+    const fd = openSync(
+      join(scopeDir, bridgeRecordingFileName(direction)),
+      "a"
+    );
     fds.set(key, fd);
     return fd;
   }
@@ -3847,13 +3353,21 @@ function createBridgeRecorder(args) {
     const { stdin, stdout } = child;
     if (stdout) {
       const splitter = createRecordingLineSplitter(
-        (line) => record({ direction: "provider\u2192bridge", line, threadId: scope.threadId })
+        (line) => record({
+          direction: "provider\u2192bridge",
+          line,
+          threadId: scope.threadId
+        })
       );
       stdout.on("data", (chunk) => splitter.push(chunk));
     }
     if (stdin) {
       const splitter = createRecordingLineSplitter(
-        (line) => record({ direction: "bridge\u2192provider", line, threadId: scope.threadId })
+        (line) => record({
+          direction: "bridge\u2192provider",
+          line,
+          threadId: scope.threadId
+        })
       );
       const originalWrite = stdin.write.bind(stdin);
       stdin.write = ((chunk, ...rest) => {
@@ -4018,9 +3532,6 @@ function decodeToolCallResponsePayload(result) {
     };
   }
   return {
-    // Keep the legacy aggregate fields for provider bridges that already use
-    // this published helper. New consumers use contentBlocks so interleaved
-    // text and images retain the plugin result's order.
     content: text,
     contentBlocks,
     images,
@@ -4243,16 +3754,10 @@ import { z as z30 } from "zod";
 var normalizedToolCallRequestSchema = z30.object({
   providerThreadId: z30.string().min(1),
   threadId: z30.string().min(1).optional(),
-  // Canonical bridge wire form: required string when known, required null when
-  // the provider cannot resolve the BB turn id itself.
   turnId: z30.union([z30.string().min(1), z30.null()]),
   callId: z30.string().min(1),
   tool: z30.string().min(1),
   arguments: z30.unknown(),
-  /**
-   * turnId/callId are provider-native (thread/delta bridges hold no bb ids);
-   * the runtime adapter translates them through the delta assembler's maps.
-   */
   providerNativeIds: z30.boolean().optional()
 });
 
@@ -4684,9 +4189,7 @@ var acpFsWriteNotificationParamsSchema = z33.object({
   threadId: z33.string().min(1),
   path: z33.string().min(1),
   kind: z33.enum(["add", "update"]),
-  /** Absent on `add`: the file did not exist before the write. */
   oldText: z33.string().optional(),
-  /** The written file content; the assembler builds the diff from it. */
   content: z33.string()
 }).passthrough();
 var acpWarningNotificationParamsSchema = z33.object({
@@ -5160,8 +4663,6 @@ function grokClassifyToolCall(event) {
   const label = input?.description ?? input?.prompt ?? event.title ?? "Subagent";
   const shape = {
     type: "delegation",
-    // grok reports no child session id, so the tool call is the child ref:
-    // it is what its output and kill calls name.
     childRef: event.toolCallId,
     label,
     background: false
@@ -5253,8 +4754,6 @@ var ompBashRawOutputSchema = z35.object({
     signal: z35.unknown().optional(),
     async: z35.unknown().optional()
   }).passthrough(),
-  // If an OMP version emits generic ACP result fields, the shared parser
-  // owns those exit/output/timeout/signal semantics.
   exitCode: z35.number().int().nullable().optional(),
   exit_code: z35.number().int().nullable().optional(),
   stdout: z35.string().optional(),
@@ -5375,7 +4874,6 @@ var acpRawInputPathSchema = z36.object({
   path: z36.string().optional(),
   filePath: z36.string().optional(),
   file_path: z36.string().optional(),
-  /** grok's `read_file` / `search_replace` argument name. */
   target_file: z36.string().optional()
 }).passthrough();
 function resolveAcpToolCallPath(value, options) {
@@ -6512,8 +6010,6 @@ function createAcpDeltaTranslator(options = {}) {
         const status = params.data.status;
         return [
           ...flushOpenTurnWork(context, status),
-          // Only a completed maintenance prompt actually shrank the context; a
-          // failed or interrupted one must never report `thread/compacted`.
           ...status === "completed" ? [{ kind: "context.compacted" }] : [],
           {
             kind: "turn.boundary",
@@ -6713,12 +6209,6 @@ function buildToolUseSubject(toolCall, options, dialectClassify) {
     kind: "tool_use",
     itemId: toolCall.toolCallId,
     tool: described.item.type === "tool" ? described.item.tool : toolCall.kind ?? toolCall.startedToolCall?.kind ?? described.item.type,
-    // The reason is NOT stamped here. It rides the payload, where every
-    // surface reads it as the ask's title (`payload.reason ?? …`), while
-    // `presentation.detail` becomes a detail line beneath — so stamping it
-    // into both printed the agent's sentence twice on the app, mobile and
-    // the CLI. `detail` keeps only what the classification found that the
-    // reason does not already say (a delegation's report, say).
     presentation: described.presentation
   };
 }
@@ -6759,9 +6249,6 @@ function buildAcpPermissionInteractionPayload(args) {
       subject: {
         kind: "file_change",
         itemId: toolCall.toolCallId,
-        // The permission's own locations bound the write (opencode's
-        // external_directory names [file, parentDir]); the in-flight tool
-        // call's paths are the fallback.
         writeScope: resolveAcpFileChangeWriteScope(
           ownPaths.length > 0 ? ownPaths : operation.paths
         ),
@@ -6924,8 +6411,6 @@ function buildAcpNativeReasoningSupport(thoughtLevelOption) {
   );
   if (supportedReasoningEfforts.length === 0) {
     return {
-      // An omitted option preserves the legacy agent-managed fallback. A
-      // declared option is authoritative, even when bb cannot map its values.
       supportedReasoningEfforts: thoughtLevelOption === void 0 ? ACP_NATIVE_REASONING_EFFORTS : [],
       defaultReasoningEffort: "medium"
     };
@@ -7109,7 +6594,6 @@ function buildAgentModelCatalog(rawModels) {
         description: nameByLevel.get(level) ?? ""
       })),
       defaultReasoningEffort: defaultEntry.level,
-      // The agent lists its default model first.
       isDefault: models.length === 0
     });
     variantsByFamilyId.set(defaultVariant.id, byLevel);
@@ -7297,7 +6781,6 @@ function buildAcpModelSelectionParam(launchSpec, options, parameterizedModelPick
       selectFlag: launchSpec.modelCli.selectFlag,
       model,
       ...options.reasoningLevel !== void 0 ? { reasoningLevel: options.reasoningLevel } : {},
-      // Only "fast" changes launch resolution; "default" is the normal id.
       ...options.serviceTier === "fast" ? { serviceTier: options.serviceTier } : {}
     }
   };
@@ -7462,6 +6945,9 @@ function createAcpAgentConnection(options) {
       terminal: false
     });
     stdoutLines.on("line", (line) => {
+      if (stopping) {
+        return;
+      }
       const message = parseAgentLine(line);
       if (!message) {
         return;
@@ -7635,9 +7121,6 @@ var bridgeToolCallResponseSchema = z38.union([
         })
       ])
     ).optional(),
-    // The initialized response and older text-only responses omit images.
-    // Parsing them as an empty list keeps the re-executed packaged artifact
-    // compatible with that legacy socket shape.
     images: z38.array(z38.object({ data: z38.string(), mimeType: z38.string() })).default([]),
     isError: z38.boolean().optional()
   }),
@@ -8124,6 +7607,8 @@ async function forwardDynamicToolCall(args) {
 function handleDynamicToolBridgeSocket(bridge, socket) {
   let buffer = "";
   socket.setEncoding("utf8");
+  socket.on("error", () => {
+  });
   socket.on("data", (chunk) => {
     buffer += chunk;
     const newlineIndex = buffer.indexOf("\n");
@@ -8169,6 +7654,8 @@ async function ensureDynamicToolBridge() {
   dynamicToolBridgePromise = new Promise((resolveBridge, rejectBridge) => {
     const host = "127.0.0.1";
     const server = createServer((socket) => {
+      socket.on("error", () => {
+      });
       void dynamicToolBridgePromise?.then((bridge) => {
         handleDynamicToolBridgeSocket(bridge, socket);
       });
@@ -8930,8 +8417,6 @@ function handlePermissionRequest(session, params, responder) {
       toolCall: normalizedToolCall,
       options: parsed.data.options,
       cwd: session.cwd,
-      // The dialect reads the same side channels for the ask as for the
-      // row: a Cursor sub-agent asking keeps its delegation reading.
       classifyToolCall: session.dialect.classifyToolCall
     });
     void sendRuntimeRequest(BRIDGE_INBOUND_REQUEST_METHODS.interactionRequest, {
@@ -9664,24 +9149,10 @@ function decodeLaunchSpec(providerOptions) {
   return launchSpec.success ? launchSpec.data : null;
 }
 var acpProviderOptionsSchema = z39.object({
-  /**
-   * Environment-level extra write roots. Rides the opaque provider-options
-   * bag (packed by the registry) because the wire has no core
-   * field for it — same delivery as the ACP launch spec.
-   */
   additionalWorkspaceWriteRoots: z39.array(z39.string()).optional(),
-  /**
-   * The agent's dialect: which vendor side channels this bridge should
-   * read for it (see `dialect.ts`). Declared by the plugin that registers
-   * the provider, so a third-party registration of a known agent gets the
-   * same reporting fidelity a first-party one does.
-   */
   acpDialect: z39.string().min(1).optional(),
-  /** Enables an agent's separate model configuration options. */
   parameterizedModelPicker: z39.boolean().optional(),
-  /** Bare model ids shown before the collapsed "More models" pool. */
   primaryModels: z39.array(z39.string().min(1)).optional(),
-  /** Model ids to probe first during bounded native discovery. */
   reasoningProbePriorityModelIds: z39.array(z39.string().min(1)).optional()
 }).passthrough();
 function decodeAcpModelPickerOptions(providerOptions) {
@@ -9720,16 +9191,8 @@ async function handleRequest2(request) {
           threadGoalClear: false,
           fork: "tip",
           approvalEnforcedBy: "runtime",
-          // grammarVersions [3, 3] — this bridge emits the v3 delta grammar
-          // (one streaming dialect; the v3 item shapes land per bridge in
-          // WS1b). steerMode "queue" — ACP v1 has no mid-loop inject: a hard
-          // steer cancels the live prompt and re-prompts with the queued text
-          // at the next boundary.
           grammarVersions: [THREAD_DELTA_GRAMMAR_V3, THREAD_DELTA_GRAMMAR_V3],
           steerMode: "queue",
-          // Single-site addition (WS4 L4): the bridge handles skills/configure
-          // (it lists the roots in the session instructions) and must say so,
-          // or the runtime sends it no injected skills.
           skills: { configure: true }
         }
       };
@@ -10019,16 +9482,10 @@ async function probeAcpAgent(request) {
       command: request.command,
       args: [...request.args],
       cwd: request.cwd,
-      // The same environment the bridge would launch this agent in. Raw
-      // process.env would hand the agent ELECTRON_RUN_AS_NODE (the packaged
-      // daemon runs in electron-node mode) and the record-dir variable, so a
-      // probed agent would run somewhere its real launch never does.
       env: withoutBridgeRuntimeEnv({ ...process.env, ...request.env ?? {} }),
       recordThreadId: null,
       onNotification: () => {
       },
-      // A probe is not a session: an agent that asks the client anything
-      // before initialize returns gets a plain "not supported".
       onRequest: (_method, _params, responder) => {
         responder.error(-32601, "bb is probing this agent's capabilities");
       },
@@ -10042,7 +9499,9 @@ async function probeAcpAgent(request) {
   const timeout = new Promise((_resolve, reject) => {
     setTimeout(
       () => reject(
-        new Error(`the agent did not answer initialize within ${timeoutMs}ms`)
+        new Error(
+          `the agent did not answer initialize within ${timeoutMs}ms`
+        )
       ),
       timeoutMs
     ).unref?.();
@@ -10054,8 +9513,6 @@ async function probeAcpAgent(request) {
         params: {
           protocolVersion: ACP_PROTOCOL_VERSION,
           clientInfo: { name: "bb", version: "1.0.0" },
-          // The probe advertises what bb's bridge advertises, so an agent
-          // that varies its capabilities by client sees the same client.
           clientCapabilities: {
             fs: { readTextFile: true, writeTextFile: true },
             terminal: false