@get-bb/plugin-sdk 0.4.24 → 0.4.28

package/dist/provider-bridge.js

@@ -740,7 +740,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;
@@ -759,8 +762,6 @@ function createBridgeIo({
       send({
         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 } }
       });
     },
@@ -798,12 +799,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 as StringDecoder2 } from "node:string_decoder";
 var PROVIDER_BRIDGE_RECORD_DIR_ENV = "BB_PROVIDER_BRIDGE_RECORD_DIR";
@@ -886,7 +882,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;
   }
@@ -937,13 +936,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) => {
@@ -1111,9 +1118,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,
@@ -1402,16 +1406,7 @@ var canonicalPromptMentionResourceSchema = z6.discriminatedUnion("kind", [
   z6.object({
     kind: z6.literal("plugin"),
     pluginId: z6.string(),
-    /**
-     * Named shared-UI icon hint supplied by the plugin mention item. Omitted
-     * by mentions persisted before icon hints were stored.
-     */
     icon: z6.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: z6.string(),
     label: z6.string()
   })
@@ -1450,21 +1445,11 @@ var promptInputSchema = z6.discriminatedUnion("type", [
   }),
   z6.object({
     type: z6.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: z6.string(),
     ...promptInputVisibilityFields
   }),
   z6.object({
     type: z6.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: z6.string(),
     name: z6.string().optional(),
     sizeBytes: z6.number().int().nonnegative().optional(),
@@ -1604,13 +1589,7 @@ var runtimeThreadExecutionBaseOptionsSchema = z6.object({
   model: z6.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);
@@ -1916,7 +1895,6 @@ var workflowAgentStateValues = [
 ];
 var workflowAgentStateSchema = z9.enum(workflowAgentStateValues);
 var workflowAgentSnapshotSchema = z9.object({
-  /** 1-based agent counter; the stable identity for fold/replace semantics. */
   index: z9.number().int().positive(),
   label: z9.string(),
   state: workflowAgentStateSchema,
@@ -1940,10 +1918,8 @@ var workflowAgentSnapshotSchema = z9.object({
   durationMs: z9.number().optional()
 });
 var workflowPhaseSnapshotSchema = z9.object({
-  /** 1-based phase counter; meta.phases are seeded before any agent runs. */
   index: z9.number().int().positive(),
   title: z9.string(),
-  /** "child" marks a nested workflow() sub-run group. */
   kind: z9.string().optional()
 });
 var workflowProgressSnapshotSchema = z9.object({
@@ -1994,9 +1970,7 @@ function jsonByteLength(value) {
 import { z as z10 } from "zod";
 var THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH = 280;
 var threadEventItemPresentationLabelSchema = z10.object({
-  /** Present-tense row title while the item is in flight ("Reading file"). */
   pending: z10.string().min(1),
-  /** Past-tense row title once the item settled ("Read file"). */
   completed: z10.string().min(1)
 });
 var threadEventItemPresentationIconSchema = z10.object({
@@ -2009,16 +1983,9 @@ var threadEventItemPresentationTintSchema = z10.object({
 var threadEventItemPresentationSchema = z10.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
-  /** Row headline beside the label (a path, a query, a child thread title). */
   title: z10.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: z10.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
-  /** Low-value rows (TodoWrite, ToolSearch) clients collapse by default. */
   suppress: z10.boolean().optional(),
-  /** Accent colour per theme; omitted rows use the neutral row tint. */
   tint: threadEventItemPresentationTintSchema.optional()
 });
 
@@ -2138,9 +2105,7 @@ var pendingInteractionPermissionGrantApprovalSubjectSchema = z12.object({
 var pendingInteractionPlanApprovalSubjectSchema = z12.object({
   kind: z12.literal("plan"),
   itemId: z12.string().min(1),
-  /** The plan body, as Markdown. */
   plan: z12.string().min(1),
-  /** Where the provider saved the plan, or null when it kept it in memory. */
   planFilePath: z12.string().min(1).nullable()
 });
 var pendingInteractionToolUseApprovalSubjectSchema = z12.object({
@@ -2457,21 +2422,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"];
@@ -2523,18 +2480,10 @@ var clientTurnLifecycleEventDataSchema = z14.object({
 var turnRequestEventDataSchema = z14.object({
   direction: z14.literal("outbound"),
   requestId: clientTurnRequestIdSchema,
-  /** Failed request resumed by a guarded system continuation, when present. */
   continuationOfRequestId: clientTurnRequestIdSchema.optional(),
   source: z14.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: z14.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: z14.array(promptInputSchema),
@@ -2620,15 +2569,14 @@ var systemUserQuestionLifecycleEventDataSchema = z14.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 = z14.enum(
   systemThreadInterruptedReasonValues
 );
 var systemThreadInterruptedEventDataSchema = z14.object({
-  reason: systemThreadInterruptedReasonSchema
+  reason: systemThreadInterruptedReasonSchema,
+  cause: z14.literal("host-connection-lost").optional()
 });
 var provisioningTranscriptEntrySchema = z14.object({
   type: z14.enum(["step", "output"]),
@@ -2665,11 +2613,6 @@ var systemProviderTurnWatchdogEventDataSchema = z14.object({
   activeTurnId: z14.string().min(1),
   activeTurnStartedAt: z14.number().int().nonnegative(),
   lastActivityEventSequence: z14.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: z14.string().min(1),
   lastActivityEventAt: z14.number().int().nonnegative(),
   providerId: z14.string().min(1),
@@ -2932,7 +2875,6 @@ var providerRateLimitStatusSchema = z17.enum([
   "unknown"
 ]);
 var providerRateLimitWindowSchema = z17.object({
-  /** Opaque provider-issued key. New provider windows must not break parsing. */
   providerKey: z17.string().min(1).nullable(),
   label: z17.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
@@ -3017,11 +2959,9 @@ var threadEventDelegationItemSchema = z17.object({
   type: z17.literal("delegation"),
   id: z17.string(),
   childRef: z17.string().min(1),
-  /** Human label for the delegated work (the child's description). */
   label: z17.string(),
   status: threadEventItemStatusSchema,
   background: z17.boolean(),
-  /** Terminal summary from the child; absent while it runs. */
   summary: z17.string().optional(),
   ...itemPresentationField,
   parentToolCallId: z17.string().optional()
@@ -3082,10 +3022,6 @@ var threadEventWarningCategorySchema = z17.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 = z17.object({
@@ -3114,28 +3050,15 @@ var toolCallProgressEventSchema = z17.object({
 var threadEventBackgroundTaskItemSchema = z17.object({
   type: z17.literal("backgroundTask"),
   id: z17.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: z17.string().optional(),
-  /** Raw SDK task discriminant (e.g. "local_workflow"); "unknown" when the provider omitted it. */
   taskType: z17.string(),
   description: z17.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  /** Ambient/housekeeping task; consumers hide it from the inline transcript. */
   skipTranscript: z17.boolean(),
-  /** meta.name of the workflow script; only present for workflow tasks. */
   workflowName: z17.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: z17.string().optional(),
   error: z17.string().optional(),
   outputFile: z17.string().optional(),
@@ -3143,7 +3066,6 @@ var threadEventBackgroundTaskItemSchema = z17.object({
   parentToolCallId: z17.string().optional()
 });
 var threadEventItemSchema = z17.discriminatedUnion("type", [
-  // bb authors user messages itself, so they carry no bridge presentation.
   z17.object({
     type: z17.literal("userMessage"),
     id: z17.string(),
@@ -3165,10 +3087,6 @@ var threadEventItemSchema = z17.discriminatedUnion("type", [
     cwd: z17.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: z17.string().optional(),
     exitCode: z17.number().optional(),
     durationMs: z17.number().optional(),
@@ -3201,10 +3119,6 @@ var threadEventItemSchema = z17.discriminatedUnion("type", [
     error: z17.string().optional(),
     durationMs: z17.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: z17.string().optional()
   }),
@@ -3253,12 +3167,9 @@ var unscopedProviderEventSchema = z17.discriminatedUnion("type", [
   z17.object({
     type: z17.literal("turn/completed"),
     threadId: z17.string(),
-    // Server reconciliation can synthesize interrupted completions when the
-    // original provider thread id was never persisted.
     providerThreadId: z17.string().nullable(),
     status: threadEventTurnStatusSchema,
     error: z17.object({ message: z17.string() }).optional(),
-    /** Provider-native point through which a replacement branch should retain history. */
     providerCheckpointId: z17.string().min(1).optional()
   }),
   z17.object({
@@ -3325,10 +3236,6 @@ var unscopedProviderEventSchema = z17.discriminatedUnion("type", [
     providerThreadId: z17.string(),
     itemId: z17.string(),
     delta: z17.string(),
-    /**
-     * When true, this delta replaces previously accumulated command output
-     * instead of appending to it. Omission means the delta appends.
-     */
     reset: z17.boolean().optional(),
     parentToolCallId: z17.string().optional()
   }),
@@ -3373,49 +3280,24 @@ var unscopedProviderEventSchema = z17.discriminatedUnion("type", [
     parentToolCallId: z17.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.
-   */
   z17.object({
     type: z17.literal("item/backgroundTask/progress"),
     threadId: z17.string(),
     providerThreadId: z17.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.
-   */
   z17.object({
     type: z17.literal("item/backgroundTask/completed"),
     threadId: z17.string(),
     providerThreadId: z17.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`.
-   */
   z17.object({
     type: z17.literal("item/delegation/progress"),
     threadId: z17.string(),
     providerThreadId: z17.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`.
-   */
   z17.object({
     type: z17.literal("item/delegation/completed"),
     threadId: z17.string(),
@@ -3462,16 +3344,6 @@ var unscopedProviderEventSchema = z17.discriminatedUnion("type", [
     providerThreadId: z17.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.
-   */
   z17.object({
     type: z17.literal("thread/extensionState/updated"),
     threadId: z17.string(),
@@ -3632,8 +3504,6 @@ var availableModelSchema = z19.object({
   id: z19.string(),
   model: z19.string(),
   displayName: z19.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: z19.string().min(1).optional(),
   description: z19.string(),
   supportedReasoningEfforts: z19.array(modelReasoningEffortSchema),
@@ -3647,20 +3517,8 @@ var providerCapabilitiesSchema = z19.object({
   supportsServiceTier: z19.boolean(),
   supportsNativeUserQuestion: z19.boolean(),
   supportsFork: z19.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: z19.boolean(),
   permissionModes: z19.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 = z19.object({
@@ -3683,17 +3541,11 @@ var providerComposerActionSchema = z19.discriminatedUnion("kind", [
   })
 ]);
 var providerStringsSchema = z19.object({
-  /** How to sign in on the host ("Run `claude` on the machine to sign in."). */
   signInHint: z19.string().min(1),
-  /** Shown when a session's credentials expired. */
   expiredHint: z19.string().min(1),
-  /** Where to install the agent. */
   installUrl: z19.string().min(1),
-  /** Brand prefix stripped from model display names ("Claude "). */
   brandPrefix: z19.string().min(1).optional(),
-  /** Plan-mode banner copy for providers that declare the `plan` action. */
   planModeCopy: z19.string().min(1).optional(),
-  /** Per-theme tint for the provider icon. */
   iconTint: z19.object({ light: z19.string().min(1), dark: z19.string().min(1) }).optional()
 });
 var providerOptionDescriptorSchema = z19.object({
@@ -3711,31 +3563,11 @@ var providerExtensionKindsSchema = z19.record(
 );
 var providerInfoSchema = z19.object({
   id: z19.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: z19.string().min(1),
   displayName: z19.string(),
-  /**
-   * Declared grouping key shared by related providers (the ACP agents).
-   * Absent when the provider declared none. Grouping only.
-   */
   family: z19.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: z19.object({ glyph: z19.string().min(1) }).optional(),
   logoUrl: z19.string().min(1).nullable(),
-  /** Sessionless maintenance requests the provider's bridge implements. */
   maintenance: z19.object({
     health: z19.boolean(),
     usage: z19.boolean(),
@@ -3744,13 +3576,6 @@ var providerInfoSchema = z19.object({
   capabilities: providerCapabilitiesSchema,
   composerActions: z19.array(providerComposerActionSchema),
   available: z19.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: z19.array(providerOptionDescriptorSchema).optional(),
   reasoningLevels: z19.array(providerOptionDescriptorSchema).optional(),
@@ -4084,16 +3909,10 @@ import { z as z21 } from "zod";
 var normalizedToolCallRequestSchema = z21.object({
   providerThreadId: z21.string().min(1),
   threadId: z21.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: z21.union([z21.string().min(1), z21.null()]),
   callId: z21.string().min(1),
   tool: z21.string().min(1),
   arguments: z21.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: z21.boolean().optional()
 });
 
@@ -4114,17 +3933,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({
@@ -4164,88 +3977,22 @@ var bridgeGrammarVersionsSchema = z24.tuple([z24.number().int().positive(), z24.
 });
 var bridgeSteerModeSchema = z24.enum(["inject", "queue"]);
 var bridgeCapabilitiesSchema = z24.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: z24.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: z24.boolean().default(false),
-  /**
-   * The bridge pushes bb thread titles to the provider. When false the
-   * runtime never sends thread/name/set.
-   */
   threadRename: z24.boolean().default(false),
-  /** The bridge supports thread/goal/clear. */
   threadGoalClear: z24.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: z24.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: z24.object({ configure: z24.boolean().default(false) }).default({ configure: false })
 }).passthrough();
 var initializeParamsSchema = z24.object({
   protocolVersion: z24.number().int().positive(),
   client: z24.object({ name: z24.string().min(1), version: z24.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
@@ -4253,8 +4000,6 @@ var initializeParamsSchema = z24.object({
 }).passthrough();
 var initializeResultSchema = z24.object({
   protocolVersion: z24.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: z24.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
@@ -4267,16 +4012,9 @@ var bridgeExecutionOptionsSchema = z25.object({
   model: z25.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: z25.string().optional(),
   envVars: z25.record(z25.string(), z25.string()).optional(),
-  /** Provider-scoped session options. Opaque outside the owning bridge. */
   providerOptions: z25.record(z25.string(), z25.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
@@ -4287,9 +4025,7 @@ var providerMaintenanceParamsSchema = z26.object({
   cwd: z26.string().min(1).optional(),
   providerOptions: z26.record(z26.string(), z26.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z26.enum([
-  "thread_rewind"
-]);
+var providerInstallationRequirementSchema = z26.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
@@ -4337,26 +4073,20 @@ var providerUsageSchema = z26.discriminatedUnion("status", [
     accountEmail: z26.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z26.discriminatedUnion(
-  "supported",
-  [
-    z26.object({ supported: z26.literal(false) }).passthrough(),
-    z26.object({
-      supported: z26.literal(true),
-      health: providerHealthSchema
-    }).passthrough()
-  ]
-);
-var providerUsageResultSchema = z26.discriminatedUnion(
-  "supported",
-  [
-    z26.object({ supported: z26.literal(false) }).passthrough(),
-    z26.object({
-      supported: z26.literal(true),
-      usage: providerUsageSchema
-    }).passthrough()
-  ]
-);
+var providerHealthResultSchema = z26.discriminatedUnion("supported", [
+  z26.object({ supported: z26.literal(false) }).passthrough(),
+  z26.object({
+    supported: z26.literal(true),
+    health: providerHealthSchema
+  }).passthrough()
+]);
+var providerUsageResultSchema = z26.discriminatedUnion("supported", [
+  z26.object({ supported: z26.literal(false) }).passthrough(),
+  z26.object({
+    supported: z26.literal(true),
+    usage: providerUsageSchema
+  }).passthrough()
+]);
 var providerInstallationActionKindSchema = z26.enum([
   "install",
   "update"
@@ -4393,28 +4123,34 @@ var providerInstallationCommandSchema = z26.object({
   args: z26.array(z26.string()).max(64),
   displayCommand: z26.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z26.discriminatedUnion("kind", [
-  z26.object({ kind: z26.literal("installed") }).passthrough(),
-  z26.object({
-    kind: z26.literal("version_changed"),
-    previousVersion: z26.string().min(1)
-  }).passthrough(),
-  z26.object({
-    kind: z26.literal("version_at_least"),
-    version: z26.string().min(1)
-  }).passthrough()
-]);
-var providerInstallationRunResultSchema = z26.discriminatedUnion("available", [
-  z26.object({
-    available: z26.literal(false),
-    message: z26.string().min(1)
-  }).passthrough(),
-  z26.object({
-    available: z26.literal(true),
-    command: providerInstallationCommandSchema,
-    verification: providerInstallationVerificationSchema
-  }).passthrough()
-]);
+var providerInstallationVerificationSchema = z26.discriminatedUnion(
+  "kind",
+  [
+    z26.object({ kind: z26.literal("installed") }).passthrough(),
+    z26.object({
+      kind: z26.literal("version_changed"),
+      previousVersion: z26.string().min(1)
+    }).passthrough(),
+    z26.object({
+      kind: z26.literal("version_at_least"),
+      version: z26.string().min(1)
+    }).passthrough()
+  ]
+);
+var providerInstallationRunResultSchema = z26.discriminatedUnion(
+  "available",
+  [
+    z26.object({
+      available: z26.literal(false),
+      message: z26.string().min(1)
+    }).passthrough(),
+    z26.object({
+      available: z26.literal(true),
+      command: providerInstallationCommandSchema,
+      verification: providerInstallationVerificationSchema
+    }).passthrough()
+  ]
+);
 
 // ../provider-bridge-protocol/src/requests.ts
 import { z as z27 } from "zod";
@@ -4458,24 +4194,12 @@ var threadResumeParamsSchema = z27.object({
 var threadForkParamsSchema = z27.object({
   ...sessionConstructionFields,
   sourceProviderThreadId: z27.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: z27.string().min(1).optional()
 }).passthrough();
 var threadStopParamsSchema = z27.object({
   threadId: z27.string().min(1),
   providerThreadId: z27.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: z27.enum(["interrupt", "release"]),
-  /** Non-null when the stop interrupts an active provider turn. */
   activeTurnId: z27.string().min(1).nullable()
 }).passthrough();
 var threadRefParams = z27.object({
@@ -4518,7 +4242,6 @@ var skillsConfigureParamsSchema = z27.object({
 }).passthrough();
 var threadIdentityResultSchema = z27.object({
   providerThreadId: z27.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
   sessionRestorable: z27.boolean().optional()
 }).passthrough();
 var modelListResultSchema = z27.object({
@@ -4538,16 +4261,12 @@ var BRIDGE_NOTIFICATION_METHODS = {
 var threadIdentityNotificationSchema = z28.object({
   threadId: z28.string().min(1),
   providerThreadId: z28.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
   sessionRestorable: z28.boolean().optional()
 }).passthrough();
 var sessionReplacedNotificationSchema = z28.object({
   threadId: z28.string().min(1),
-  /** Identity of the replacement session (may equal the old identity). */
   providerThreadId: z28.string().min(1).nullable(),
-  /** Human-readable cause, shown in the timeline. */
   reason: z28.string().min(1),
-  /** True when provider-side context did not survive the replacement. */
   contextLost: z28.boolean().default(false)
 }).passthrough();
 var providerRawNotificationSchema = z28.object({
@@ -4595,14 +4314,6 @@ var interactionRequestParamsSchema = z29.object({
   threadId: z29.string().min(1).optional(),
   turnId: z29.union([z29.string().min(1), z29.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: z29.boolean().optional()
 }).passthrough();
 
@@ -4622,24 +4333,14 @@ var deltaItemKeySchema = z30.object({
 var providerTurnIdSchema = deltaKeyPartSchema;
 var deltaFileChangeSchema = z30.object({
   path: z30.string(),
-  /** The bridge states the change kind; the assembler never derives it. */
   kind: z30.enum(["add", "update", "delete"]),
   movePath: z30.string().optional(),
-  /** Provider-supplied unified diff; preferred over old/new text building. */
   diff: z30.string().optional(),
   oldText: z30.string().optional(),
-  /** When present the assembler builds the unified diff from old/new text. */
   newText: z30.string().optional()
 });
 var deltaBackgroundTaskShapeSchema = z30.object({
   type: z30.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: z30.string().min(1),
   taskType: z30.string(),
   description: z30.string(),
@@ -4693,20 +4394,8 @@ var deltaItemShapeSchema = z30.discriminatedUnion("type", [
   }),
   z30.object({
     type: z30.literal("fileChange"),
-    /** Empty while a path is not yet known, including bare close fallbacks. */
     changes: z30.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.
-   */
   z30.object({
     type: z30.literal("tool"),
     tool: z30.string(),
@@ -4736,7 +4425,6 @@ var deltaItemShapeSchema = z30.discriminatedUnion("type", [
   }),
   z30.object({ type: z30.literal("imageView"), path: z30.string() }),
   deltaBackgroundTaskShapeSchema,
-  // Grammar v3 shapes. Every existing shape above is kept unchanged.
   deltaFileReadShapeSchema,
   deltaSearchShapeSchema,
   deltaDelegationShapeSchema,
@@ -4770,51 +4458,21 @@ function requireExtensionPresentation(delta, ctx) {
   }
 }
 var threadDeltaSchema = z30.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).
-   */
   z30.object({
     kind: z30.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.
-   */
   z30.object({
     kind: z30.literal("input.provider"),
     text: z30.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.
-   */
   z30.object({
     kind: z30.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.
-   */
   z30.object({
     kind: z30.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
@@ -4823,40 +4481,15 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     claimIfIdle: z30.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).
-   */
   z30.object({
     kind: z30.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).
-   */
   z30.object({
     kind: z30.literal("item.close"),
     key: deltaItemKeySchema,
@@ -4864,32 +4497,12 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     resultText: z30.string().optional(),
     exitCode: z30.number().optional(),
     aggregatedOutput: z30.string().optional(),
-    /** Terminal approval verdict (codex declined → denied). Default null. */
     approvalStatus: z30.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.
-   */
   z30.object({
     kind: z30.literal("item.progress"),
     key: deltaItemKeySchema,
@@ -4899,17 +4512,6 @@ var threadDeltaSchema = z30.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.
-   */
   z30.object({
     kind: z30.literal("item.textDelta"),
     key: deltaItemKeySchema,
@@ -4918,18 +4520,6 @@ var threadDeltaSchema = z30.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.
-   */
   z30.object({
     kind: z30.literal("item.textClose"),
     key: deltaItemKeySchema,
@@ -4938,10 +4528,6 @@ var threadDeltaSchema = z30.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.
-   */
   z30.object({
     kind: z30.literal("item.outputDelta"),
     key: deltaItemKeySchema,
@@ -4950,26 +4536,12 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  /**
-   * Cumulative command output snapshot (pi bash). The assembler diffs
-   * consecutive snapshots into `outputDelta`/`reset` events.
-   */
   z30.object({
     kind: z30.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
     text: z30.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.
-   */
   z30.object({
     kind: z30.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
@@ -4977,13 +4549,6 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     modelContextWindow: z30.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.
-   */
   z30.object({
     kind: z30.literal("contextWindow"),
     used: z30.number().nullable(),
@@ -4998,54 +4563,26 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
   z30.object({ kind: z30.literal("context.cleared") }),
-  /** The aggregate working-tree diff for a turn (codex turn/diff/updated). */
   z30.object({
     kind: z30.literal("turn.diff"),
     diff: z30.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  // Thread metadata (codex thread lifecycle notifications).
   z30.object({ kind: z30.literal("thread.started") }),
   z30.object({
     kind: z30.literal("thread.identity"),
     providerThreadId: z30.string().min(1)
   }),
   z30.object({ kind: z30.literal("thread.name"), name: z30.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`.
-   */
   z30.object({
     kind: z30.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.
-   */
   z30.object({
     kind: z30.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).
-   */
   z30.object({
     kind: z30.literal("provider.error"),
     message: z30.string(),
@@ -5057,13 +4594,6 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     threadScoped: z30.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.
-   */
   z30.object({
     kind: z30.literal("provider.modelFallback"),
     originalModel: z30.string().min(1),
@@ -5071,10 +4601,6 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     reason: z30.enum(["refusal", "provider"]),
     message: z30.string()
   }),
-  /**
-   * `vouchedTurn: true` scopes the warning to the open turn when one exists
-   * (ACP warnings are turn-scoped mid-turn); default is thread scope.
-   */
   z30.object({
     kind: z30.literal("provider.warning"),
     summary: z30.string().optional(),
@@ -5082,15 +4608,6 @@ var threadDeltaSchema = z30.discriminatedUnion("kind", [
     category: threadEventWarningCategorySchema.optional(),
     vouchedTurn: z30.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.
-   */
   z30.object({
     kind: z30.literal("unhandled"),
     raw: providerRawEventSchema,
@@ -5100,18 +4617,7 @@ var threadDeltaSchema = z30.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.
-   */
   z30.object({ kind: z30.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).
-   */
   z30.object({ kind: z30.literal("session.reset") })
 ]);
 var threadDeltaNotificationParamsSchema = z30.object({