@get-bb/plugin-sdk 0.4.15 → 0.4.17

package/dist/provider-bridge-testing.js

@@ -1,103 +1,3 @@
-// ../provider-bridge-protocol/src/conformance/client.ts
-function isWireMessage(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var ConformanceClient = class {
-  constructor(transport, timeoutMs) {
-    this.transport = transport;
-    this.timeoutMs = timeoutMs;
-  }
-  transport;
-  timeoutMs;
-  nextId = 1;
-  log = [];
-  drainIntoLog() {
-    for (const raw of this.transport.takeMessages()) {
-      if (isWireMessage(raw)) {
-        this.log.push(raw);
-      }
-    }
-  }
-  sendRaw(line) {
-    this.transport.send(line);
-  }
-  notify(method, params) {
-    this.transport.send(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        method,
-        ...params !== void 0 ? { params } : {}
-      })
-    );
-  }
-  request(method, params) {
-    const id = this.nextId;
-    this.nextId += 1;
-    this.transport.send(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        id,
-        method,
-        ...params !== void 0 ? { params } : {}
-      })
-    );
-    return id;
-  }
-  /** Poll until `resolve` yields a value or the deadline passes (→ null). */
-  async waitFor(resolve2) {
-    const deadline = Date.now() + this.timeoutMs;
-    for (; ; ) {
-      this.drainIntoLog();
-      const value = resolve2();
-      if (value !== void 0) {
-        return value;
-      }
-      if (Date.now() > deadline) {
-        return null;
-      }
-      await new Promise((r) => setTimeout(r, 15));
-    }
-  }
-  async waitForResponse(id) {
-    return this.waitFor(
-      () => this.log.find(
-        (message) => message.id === id && message.method === void 0
-      )
-    );
-  }
-  /** A settle window: drain for the given quiet period without expectations. */
-  async settle(quietMs) {
-    const deadline = Date.now() + quietMs;
-    while (Date.now() < deadline) {
-      this.drainIntoLog();
-      await new Promise((r) => setTimeout(r, 15));
-    }
-    this.drainIntoLog();
-  }
-  responsesFor(id) {
-    return this.log.filter(
-      (message) => message.id === id && message.method === void 0
-    );
-  }
-  notifications(method) {
-    return this.log.filter(
-      (message) => message.id === void 0 && typeof message.method === "string" && (method === void 0 || message.method === method)
-    );
-  }
-};
-var clientRequestCounter = 0;
-function nextConformanceClientRequestId() {
-  const alphabet = "23456789abcdefghijkmnpqrstuvwxyz";
-  clientRequestCounter += 1;
-  let remaining = clientRequestCounter;
-  let suffix = "";
-  while (suffix.length < 10) {
-    suffix = alphabet[remaining % alphabet.length] + suffix;
-    remaining = Math.floor(remaining / alphabet.length);
-  }
-  return `creq_${suffix}`;
-}
-
 // ../domain/src/shared-types.ts
 import { z as z2 } from "zod";
 
@@ -431,6 +331,10 @@ import { z as z6 } from "zod";
 
 // ../domain/src/plugin-interaction-limits.ts
 var PLUGIN_INTERACTION_MAX_TITLE_LENGTH = 160;
+var PLUGIN_INTERACTION_MAX_PAYLOAD_BYTES = 64 * 1024;
+function jsonByteLength(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
 
 // ../domain/src/item-presentation.ts
 import { z as z4 } from "zod";
@@ -692,26 +596,21 @@ var pluginPendingInteractionPayloadSchema = z6.object({
   title: z6.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
   data: jsonValueSchema
 });
-var pendingInteractionPayloadSchema = z6.discriminatedUnion("kind", [
-  approvalPendingInteractionPayloadSchema,
-  userQuestionPendingInteractionPayloadSchema
-]);
-var planReviewInteractionRequestPayloadSchema = z6.object({
-  kind: z6.literal("plan_review"),
-  itemId: z6.string().min(1),
-  /** The plan body, as Markdown. */
-  plan: z6.string().min(1),
-  /** Where the provider saved the plan, or null when it kept it in memory. */
-  planFilePath: z6.string().min(1).nullable()
-});
 var pluginExtensionInteractionRequestPayloadSchema = z6.object({
   kind: extensionKindSchema,
   title: z6.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
-  data: jsonValueSchema
+  data: jsonValueSchema.refine(
+    (value) => jsonByteLength(value) <= PLUGIN_INTERACTION_MAX_PAYLOAD_BYTES,
+    { message: "Plugin request data exceeds 64 KiB" }
+  )
 });
 var interactionRequestPayloadSchema = z6.union([
   userQuestionPendingInteractionPayloadSchema,
-  planReviewInteractionRequestPayloadSchema,
+  pluginExtensionInteractionRequestPayloadSchema
+]);
+var pendingInteractionPayloadSchema = z6.union([
+  approvalPendingInteractionPayloadSchema,
+  userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
 ]);
 var approvalDecisionDiscriminatorError = "Invalid discriminator value. Expected 'allow_once' | 'allow_for_session' | 'deny'";
@@ -746,14 +645,36 @@ var userQuestionPendingInteractionResolutionSchema = z6.object({
 var pluginPendingInteractionResolutionSchema = z6.object({
   kind: z6.literal("plugin_submitted")
 });
+var pluginExtensionInteractionResolutionSchema = z6.object({
+  kind: z6.literal("request_answer"),
+  value: jsonValueSchema
+});
 var pendingInteractionResolutionSchema = z6.union(
   [
     approvalPendingInteractionResolutionSchema,
     userQuestionPendingInteractionResolutionSchema,
-    pluginPendingInteractionResolutionSchema
+    pluginPendingInteractionResolutionSchema,
+    pluginExtensionInteractionResolutionSchema
   ],
   approvalDecisionDiscriminatorError
 );
+var approvalInteractionOutcomeSchema = z6.object({
+  payload: approvalPendingInteractionPayloadSchema,
+  resolution: approvalPendingInteractionResolutionSchema
+});
+var userQuestionInteractionOutcomeSchema = z6.object({
+  payload: userQuestionPendingInteractionPayloadSchema,
+  resolution: userQuestionPendingInteractionResolutionSchema
+});
+var pluginExtensionInteractionOutcomeSchema = z6.object({
+  payload: pluginExtensionInteractionRequestPayloadSchema,
+  resolution: pluginExtensionInteractionResolutionSchema
+});
+var providerInteractionOutcomeSchema = z6.union([
+  approvalInteractionOutcomeSchema,
+  userQuestionInteractionOutcomeSchema,
+  pluginExtensionInteractionOutcomeSchema
+]);
 var pendingInteractionProviderOriginSchema = z6.object({
   kind: z6.literal("provider"),
   providerId: z6.string().min(1),
@@ -771,10 +692,7 @@ var pendingInteractionCreateSchema = z6.object({
   providerId: z6.string().min(1),
   providerThreadId: z6.string().min(1),
   providerRequestId: z6.string().min(1),
-  payload: z6.union([
-    approvalPendingInteractionPayloadSchema,
-    userQuestionPendingInteractionPayloadSchema
-  ])
+  payload: pendingInteractionPayloadSchema
 });
 var pendingInteractionBaseSchema = z6.object({
   id: z6.string().min(1),
@@ -785,21 +703,30 @@ var pendingInteractionBaseSchema = z6.object({
   expiresAt: z6.number().int().nonnegative().nullable().optional(),
   resolvedAt: z6.number().int().nonnegative().nullable()
 });
-var providerPendingInteractionSchema = pendingInteractionBaseSchema.extend({
+var providerPendingInteractionBaseSchema = pendingInteractionBaseSchema.extend({
   turnId: z6.string().min(1),
   providerId: z6.string().min(1),
   providerThreadId: z6.string().min(1),
   providerRequestId: z6.string().min(1),
-  origin: pendingInteractionProviderOriginSchema.optional(),
-  payload: z6.union([
-    approvalPendingInteractionPayloadSchema,
-    userQuestionPendingInteractionPayloadSchema
-  ]),
-  resolution: z6.union([
-    approvalPendingInteractionResolutionSchema,
-    userQuestionPendingInteractionResolutionSchema
-  ]).nullable()
+  origin: pendingInteractionProviderOriginSchema.optional()
+});
+var approvalPendingInteractionSchema = providerPendingInteractionBaseSchema.extend({
+  payload: approvalPendingInteractionPayloadSchema,
+  resolution: approvalPendingInteractionResolutionSchema.nullable()
+});
+var userQuestionPendingInteractionSchema = providerPendingInteractionBaseSchema.extend({
+  payload: userQuestionPendingInteractionPayloadSchema,
+  resolution: userQuestionPendingInteractionResolutionSchema.nullable()
 });
+var pluginExtensionPendingInteractionSchema = providerPendingInteractionBaseSchema.extend({
+  payload: pluginExtensionInteractionRequestPayloadSchema,
+  resolution: pluginExtensionInteractionResolutionSchema.nullable()
+});
+var providerPendingInteractionSchema = z6.union([
+  approvalPendingInteractionSchema,
+  userQuestionPendingInteractionSchema,
+  pluginExtensionPendingInteractionSchema
+]);
 var pluginPendingInteractionSchema = pendingInteractionBaseSchema.extend({
   turnId: z6.string().min(1).nullable(),
   origin: pendingInteractionPluginOriginSchema,
@@ -810,6 +737,45 @@ var pendingInteractionSchema = z6.union([
   providerPendingInteractionSchema,
   pluginPendingInteractionSchema
 ]);
+var interactionLifecycleRecordBaseSchema = z6.object({
+  id: z6.string().min(1),
+  status: pendingInteractionStatusSchema,
+  statusReason: z6.string().nullable()
+});
+var interactionLifecycleProviderOriginSchema = z6.object({
+  kind: z6.literal("provider"),
+  providerId: z6.string().min(1),
+  providerRequestId: z6.string().min(1)
+});
+var approvalInteractionLifecycleRecordPayloadSchema = approvalPendingInteractionPayloadSchema.omit({ availableDecisions: true });
+var approvalInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
+  origin: interactionLifecycleProviderOriginSchema,
+  payload: approvalInteractionLifecycleRecordPayloadSchema,
+  resolution: approvalPendingInteractionResolutionSchema.nullable()
+});
+var userQuestionInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
+  origin: interactionLifecycleProviderOriginSchema,
+  payload: userQuestionPendingInteractionPayloadSchema,
+  resolution: userQuestionPendingInteractionResolutionSchema.nullable()
+});
+var pluginInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
+  origin: pendingInteractionPluginOriginSchema,
+  payload: pluginPendingInteractionPayloadSchema.omit({ data: true }),
+  resolution: pluginPendingInteractionResolutionSchema.nullable()
+});
+var pluginExtensionInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
+  origin: interactionLifecycleProviderOriginSchema,
+  payload: pluginExtensionInteractionRequestPayloadSchema.omit({
+    data: true
+  }),
+  resolution: pluginExtensionInteractionResolutionSchema.omit({ value: true }).nullable()
+});
+var interactionLifecycleSchema = z6.union([
+  approvalInteractionLifecycleSchema,
+  userQuestionInteractionLifecycleSchema,
+  pluginInteractionLifecycleSchema,
+  pluginExtensionInteractionLifecycleSchema
+]);
 
 // ../domain/src/protocol-ids.ts
 import { z as z7 } from "zod";
@@ -827,6 +793,11 @@ var systemEventTypeValues = [
   "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",
@@ -956,6 +927,9 @@ var systemOperationEventDataSchema = z8.object({
   operationId: z8.string(),
   metadata: z8.record(z8.string(), jsonValueSchema).optional()
 });
+var systemInteractionLifecycleEventDataSchema = z8.object({
+  interaction: interactionLifecycleSchema
+});
 var systemPermissionGrantLifecycleEventDataSchema = z8.object({
   interactionId: z8.string(),
   providerId: z8.string(),
@@ -1163,6 +1137,10 @@ var threadEventScopeDefinitionByType = {
     policy: "thread-or-turn",
     rationale: "Thread-management operations use thread scope outside provider turns; tool-owned operations use turn scope so the operation stays with the tool call that caused it."
   },
+  "system/interaction/lifecycle": {
+    policy: "thread-or-turn",
+    rationale: "A provider interaction belongs to the turn that raised it; a plugin may raise one outside any turn."
+  },
   "system/permissionGrant/lifecycle": { policy: "turn" },
   "system/userQuestion/lifecycle": { policy: "turn" },
   "system/thread-provisioning": {
@@ -1558,8 +1536,6 @@ var threadEventItemSchema = z11.discriminatedUnion("type", [
     server: z11.string().optional(),
     tool: z11.string(),
     arguments: z11.record(z11.string(), z11.unknown()).optional(),
-    /** Server-enriched labels for a native plugin tool's timeline row. */
-    statusLabels: z11.object({ pending: z11.string(), completed: z11.string() }).optional(),
     status: threadEventItemStatusSchema,
     result: z11.unknown().optional(),
     error: z11.string().optional(),
@@ -1567,8 +1543,7 @@ var threadEventItemSchema = z11.discriminatedUnion("type", [
     truncation: threadEventItemTruncationSchema.optional(),
     /**
      * The escape hatch for tools with no core kind: the bridge says how the
-     * row reads. Supersedes the server-enriched `statusLabels` when both are
-     * present (WS3 deletes `statusLabels`).
+     * row reads (label, glyph, headline, suppression).
      */
     ...itemPresentationField,
     parentToolCallId: z11.string().optional()
@@ -1905,6 +1880,10 @@ var unscopedSystemEventSchema = z11.discriminatedUnion("type", [
     type: z11.literal("system/operation"),
     threadId: z11.string()
   }).merge(systemOperationEventDataSchema),
+  z11.object({
+    type: z11.literal("system/interaction/lifecycle"),
+    threadId: z11.string()
+  }).merge(systemInteractionLifecycleEventDataSchema),
   z11.object({
     type: z11.literal("system/permissionGrant/lifecycle"),
     threadId: z11.string()
@@ -1949,20 +1928,33 @@ var rejectLegacyClientRequestSequenceSchema = z11.unknown().superRefine((value,
 });
 var threadEventSchema = rejectLegacyClientRequestSequenceSchema.pipe(
   z11.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
-    const result = validateThreadEventScope({
+    const result2 = validateThreadEventScope({
       type: event.type,
       scope: event.scope
     });
-    if (!result.valid) {
+    if (!result2.valid) {
       ctx.addIssue({
         code: z11.ZodIssueCode.custom,
-        message: result.message ?? "Invalid thread event scope",
+        message: result2.message ?? "Invalid thread event scope",
         path: ["scope"]
       });
       return;
     }
   })
 );
+function isThreadEventWithItem(event) {
+  switch (event.type) {
+    case "item/started":
+    case "item/completed":
+    case "item/delegation/progress":
+    case "item/delegation/completed":
+    case "item/backgroundTask/progress":
+    case "item/backgroundTask/completed":
+      return true;
+    default:
+      return false;
+  }
+}
 var threadEventTypeValues = [
   ...providerEventTypeValues,
   ...systemEventTypeValues
@@ -1973,6 +1965,23 @@ var threadEventTypeSchema = z11.string().refine(
   "Invalid thread event type"
 );
 
+// ../domain/src/plugin-icon.ts
+var PLUGIN_ICON_MAX_BYTES = 32 * 1024;
+var NAMESPACED_GLYPH_PATTERN = /^[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/u;
+function isNamespacedGlyph(glyph) {
+  return NAMESPACED_GLYPH_PATTERN.test(glyph);
+}
+function parseNamespacedGlyph(glyph) {
+  if (!isNamespacedGlyph(glyph)) {
+    return null;
+  }
+  const separator = glyph.indexOf("/");
+  return {
+    pluginId: glyph.slice(0, separator),
+    name: glyph.slice(separator + 1)
+  };
+}
+
 // ../domain/src/provider-fork.ts
 import { z as z12 } from "zod";
 var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
@@ -1996,6 +2005,7 @@ var availableModelSchema = z13.object({
   defaultReasoningEffort: reasoningLevelSchema,
   isDefault: z13.boolean()
 });
+var providerModelCatalogScopeSchema = z13.enum(["host", "workspace"]);
 var providerCapabilitiesSchema = z13.object({
   supportsThreadArchive: z13.boolean(),
   supportsThreadRename: z13.boolean(),
@@ -2008,7 +2018,15 @@ var providerCapabilitiesSchema = z13.object({
    * whole sessions (tip-only) and cannot stop at a checkpoint.
    */
   supportsSessionRewind: z13.boolean(),
-  permissionModes: z13.array(permissionModeSchema).min(1)
+  permissionModes: z13.array(permissionModeSchema).min(1),
+  /**
+   * How far one `model/list` answer travels: `"host"` when the bridge answers
+   * from account or agent state and ignores the workspace path, so bb probes
+   * once per machine; `"workspace"` when project configuration can change the
+   * answer. Declared by the provider's plugin — core never infers it from an
+   * id.
+   */
+  modelCatalogScope: providerModelCatalogScopeSchema
 });
 var providerComposerCommandSchema = z13.object({
   trigger: promptMentionCommandTriggerSchema,
@@ -2058,25 +2076,44 @@ var providerExtensionKindsSchema = z13.record(
 );
 var providerInfoSchema = z13.object({
   id: z13.string(),
+  /**
+   * The plugin that registered the provider (`bb.providers.register`). The
+   * owner of the provider's extension-kind namespace, and the bundle the
+   * app loads on the first thread of this provider.
+   */
+  pluginId: z13.string().min(1),
   displayName: z13.string(),
   /**
    * Declared grouping key shared by related providers (the ACP agents).
    * Absent when the provider declared none. Grouping only.
    */
   family: z13.string().min(1).optional(),
+  /**
+   * The declared icon, projected by form. A plugin-relative asset path
+   * (`icon: "./icons/agent.svg"`) is served by the provider-logo route and
+   * arrives here as `logoUrl`; a named host glyph (`icon: "Zap"`) has no
+   * bytes to serve and arrives as `icon.glyph`, the same vocabulary an
+   * item presentation's `icon` uses. A declaration names at most one form,
+   * so at most one of the two is set; `icon` is absent when the declaration
+   * named a path or nothing. Clients draw a vendored brand mark first, then
+   * `logoUrl`, then `icon.glyph`, then the display name's initial.
+   */
+  icon: z13.object({ glyph: z13.string().min(1) }).optional(),
   logoUrl: z13.string().min(1).nullable(),
-  /** Sessionless maintenance methods declared by the provider plugin. */
-  experimental_providerHealth: z13.boolean(),
-  experimental_providerUsage: z13.boolean(),
-  experimental_providerInstallation: z13.boolean(),
+  /** Sessionless maintenance requests the provider's bridge implements. */
+  maintenance: z13.object({
+    health: z13.boolean(),
+    usage: z13.boolean(),
+    installation: z13.boolean()
+  }),
   capabilities: providerCapabilitiesSchema,
   composerActions: z13.array(providerComposerActionSchema),
   available: z13.boolean(),
   // -------------------------------------------------------------------------
   // Target-state projection (docs/provider-plugin-api.md §1). Optional and
   // unfilled until WS2a projects them from the plugin declaration; absence
-  // means "the provider declared none", never a default. The `experimental_*`
-  // and `capabilities.supports*` fields above stay until WS2a stabilizes the
+  // 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(),
@@ -2122,954 +2159,358 @@ var dynamicToolSchema = z13.object({
   presentation: threadEventItemPresentationSchema.optional()
 });
 
-// ../provider-bridge-protocol/src/conformance/scenarios.ts
-import { z as z23 } from "zod";
-
-// ../provider-bridge-protocol/src/version.ts
-var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
-var THREAD_DELTA_GRAMMAR_V3 = 3;
-
-// ../provider-bridge-protocol/src/handshake.ts
+// ../provider-bridge-protocol/src/thread-delta.ts
 import { z as z14 } from "zod";
-var bridgeGrammarVersionsSchema = z14.tuple([z14.number().int().positive(), z14.number().int().positive()]).refine(([min, max]) => min <= max, {
-  message: "grammarVersions must be an ascending [min, max] range"
+var THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
+var deltaPresentationSchema = threadEventItemPresentationSchema;
+var THREAD_DELTA_KEY_SEPARATOR = "";
+var deltaKeyPartSchema = z14.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
+  message: "provider keys must not contain the internal key separator (\\u001f)"
 });
-function negotiateGrammarVersion(runtime, bridge) {
-  const min = Math.max(runtime[0], bridge[0]);
-  const max = Math.min(runtime[1], bridge[1]);
-  return min <= max ? max : null;
-}
-var bridgeSteerModeSchema = z14.enum(["inject", "queue"]);
-var bridgeCapabilitiesSchema = z14.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: z14.boolean().default(false),
+var deltaItemKeySchema = z14.object({
+  providerItemId: deltaKeyPartSchema.optional(),
+  channel: deltaKeyPartSchema.optional(),
+  parentRef: deltaKeyPartSchema.optional()
+});
+var providerTurnIdSchema = deltaKeyPartSchema;
+var deltaFileChangeSchema = z14.object({
+  path: z14.string(),
+  /** The bridge states the change kind; the assembler never derives it. */
+  kind: z14.enum(["add", "update", "delete"]),
+  movePath: z14.string().optional(),
+  /** Provider-supplied unified diff; preferred over old/new text building. */
+  diff: z14.string().optional(),
+  oldText: z14.string().optional(),
+  /** When present the assembler builds the unified diff from old/new text. */
+  newText: z14.string().optional()
+});
+var deltaBackgroundTaskShapeSchema = z14.object({
+  type: z14.literal("backgroundTask"),
   /**
-   * The bridge mirrors bb archive state into the provider's own session
-   * list. When false the runtime never sends thread/archive or
-   * thread/unarchive.
+   * 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.
    */
-  threadArchive: z14.boolean().default(false),
+  familyId: z14.string().min(1),
+  taskType: z14.string(),
+  description: z14.string(),
+  status: threadEventItemStatusSchema,
+  taskStatus: backgroundTaskStatusSchema,
+  skipTranscript: z14.boolean(),
+  workflowName: z14.string().optional(),
+  workflow: workflowProgressSnapshotSchema.optional(),
+  usage: backgroundTaskUsageSchema.optional(),
+  summary: z14.string().optional(),
+  error: z14.string().optional(),
+  outputFile: z14.string().optional()
+});
+var deltaFileReadShapeSchema = z14.object({
+  type: z14.literal("fileRead"),
+  path: z14.string(),
+  cmd: z14.string().optional()
+});
+var deltaSearchShapeSchema = z14.object({
+  type: z14.literal("search"),
+  mode: threadEventSearchModeSchema,
+  query: z14.string(),
+  path: z14.string().optional(),
+  cmd: z14.string().optional()
+});
+var deltaDelegationShapeSchema = z14.object({
+  type: z14.literal("delegation"),
+  childRef: deltaKeyPartSchema,
+  label: z14.string(),
+  background: z14.boolean(),
+  summary: z14.string().optional()
+});
+var deltaPlanStepsShapeSchema = z14.object({
+  type: z14.literal("planSteps"),
+  steps: z14.array(threadEventPlanStepSchema),
+  explanation: z14.string().optional()
+});
+var deltaExtensionShapeSchema = z14.object({
+  type: z14.literal("extension"),
+  kind: extensionKindSchema,
+  payload: jsonValueSchema
+});
+var deltaItemShapeSchema = z14.discriminatedUnion("type", [
+  z14.object({
+    type: z14.literal("command"),
+    command: z14.string(),
+    cwd: z14.string(),
+    aggregatedOutput: z14.string().optional(),
+    exitCode: z14.number().optional(),
+    durationMs: z14.number().optional()
+  }),
+  z14.object({
+    type: z14.literal("fileChange"),
+    /** Empty while a path is not yet known, including bare close fallbacks. */
+    changes: z14.array(deltaFileChangeSchema)
+  }),
   /**
-   * The bridge pushes bb thread titles to the provider. When false the
-   * runtime never sends thread/name/set.
+   * 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.
    */
-  threadRename: z14.boolean().default(false),
-  /** The bridge supports thread/goal/clear. */
-  threadGoalClear: z14.boolean().default(false),
+  z14.object({
+    type: z14.literal("tool"),
+    tool: z14.string(),
+    server: z14.string().optional(),
+    args: z14.unknown().optional(),
+    result: z14.unknown().optional(),
+    error: z14.string().optional(),
+    durationMs: z14.number().optional()
+  }),
+  z14.object({ type: z14.literal("compaction") }),
+  z14.object({ type: z14.literal("agentMessage"), text: z14.string() }),
+  z14.object({
+    type: z14.literal("reasoning"),
+    summary: z14.array(z14.string()),
+    content: z14.array(z14.string())
+  }),
+  z14.object({ type: z14.literal("plan"), text: z14.string() }),
+  z14.object({
+    type: z14.literal("webSearch"),
+    queries: z14.array(z14.string()).min(1)
+  }),
+  z14.object({
+    type: z14.literal("webFetch"),
+    url: z14.string(),
+    prompt: z14.string().nullable().optional(),
+    pattern: z14.string().nullable()
+  }),
+  z14.object({ type: z14.literal("imageView"), path: z14.string() }),
+  deltaBackgroundTaskShapeSchema,
+  // Grammar v3 shapes. Every existing shape above is kept unchanged.
+  deltaFileReadShapeSchema,
+  deltaSearchShapeSchema,
+  deltaDelegationShapeSchema,
+  deltaPlanStepsShapeSchema,
+  deltaExtensionShapeSchema
+]);
+var deltaProgressSnapshotSchema = z14.discriminatedUnion("type", [
+  deltaBackgroundTaskShapeSchema,
+  deltaDelegationShapeSchema
+]);
+var deltaTextChannelSchema = z14.enum([
+  "agentMessage",
+  "reasoningSummary",
+  "reasoningText",
+  "plan"
+]);
+var deltaOutputChannelSchema = z14.enum(["command", "fileChange"]);
+var deltaErrorSchema = z14.object({ message: z14.string() });
+var deltaAttachSchema = z14.enum(["open", "currentOrLast"]);
+var deltaNoTurnFallbackSchema = z14.object({
+  raw: providerRawEventSchema,
+  rawType: z14.string()
+});
+function requireExtensionPresentation(delta, ctx) {
+  if (delta.item.type === "extension" && delta.presentation === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "extension items require a presentation on item.open/item.close",
+      path: ["presentation"]
+    });
+  }
+}
+var threadDeltaSchema = z14.discriminatedUnion("kind", [
   /**
-   * 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.
+   * 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).
    */
-  fork: providerForkSchema.default("none"),
+  z14.object({
+    kind: z14.literal("input.accepted"),
+    clientRequestId: clientTurnRequestIdSchema,
+    providerTurnId: providerTurnIdSchema.optional()
+  }),
   /**
-   * 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.
+   * 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.
    */
-  approvalEnforcedBy: z14.enum(["runtime", "provider"]).default("runtime"),
+  z14.object({
+    kind: z14.literal("input.provider"),
+    text: z14.string().min(1),
+    parentRef: deltaKeyPartSchema.optional()
+  }),
   /**
-   * The `thread/delta` grammar range this bridge speaks. A bridge that says
-   * nothing speaks exactly the protocol version it negotiated — today's
-   * bridges all emit v2 — so the default is `[2, 2]`, never a wider range
-   * it never claimed. A v3-capable bridge reports `[2, 3]` (or `[3, 3]`
-   * once the v2 paths are deleted) and emits the highest version inside
-   * the intersection with the runtime's `initialize` params range
-   * ({@link negotiateGrammarVersion}); the runtime rejects a disjoint
-   * range at startup.
+   * 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.
    */
-  grammarVersions: bridgeGrammarVersionsSchema.default([
-    PROVIDER_BRIDGE_PROTOCOL_VERSION,
-    PROVIDER_BRIDGE_PROTOCOL_VERSION
-  ]),
+  z14.object({
+    kind: z14.literal("turn.open"),
+    providerTurnId: providerTurnIdSchema.optional(),
+    /** Provider-native parent tool-call id for delegated child turns. */
+    parentRef: deltaKeyPartSchema.optional()
+  }),
   /**
-   * 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 branches on it yet, so the default
-   * changes no behavior today; claude and codex declare `inject` before WS4
-   * reads it.
+   * 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.
    */
-  steerMode: bridgeSteerModeSchema.default("queue")
-}).passthrough();
-var initializeParamsSchema = z14.object({
-  protocolVersion: z14.number().int().positive(),
-  client: z14.object({ name: z14.string().min(1), version: z14.string().min(1) }),
+  z14.object({
+    kind: z14.literal("turn.boundary"),
+    status: threadEventTurnStatusSchema,
+    error: deltaErrorSchema.optional(),
+    providerCheckpointId: z14.string().min(1).optional(),
+    claimIfIdle: z14.boolean().optional(),
+    providerTurnId: providerTurnIdSchema.optional()
+  }),
   /**
-   * 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.
+   * 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).
    */
-  grammarVersions: bridgeGrammarVersionsSchema.default([
-    PROVIDER_BRIDGE_PROTOCOL_VERSION,
-    PROVIDER_BRIDGE_PROTOCOL_VERSION
-  ])
-}).passthrough();
-var initializeResultSchema = z14.object({
-  protocolVersion: z14.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: z14.preprocess(
-    (value) => value ?? {},
-    bridgeCapabilitiesSchema
-  )
-}).passthrough();
-
-// ../provider-bridge-protocol/src/execution-options.ts
-import { z as z15 } from "zod";
-var bridgeExecutionOptionsSchema = z15.object({
-  model: z15.string().min(1).optional(),
-  serviceTier: serviceTierSchema.optional(),
-  reasoningLevel: reasoningLevelSchema.optional(),
+  z14.object({
+    kind: z14.literal("item.open"),
+    key: deltaItemKeySchema,
+    item: deltaItemShapeSchema,
+    /**
+     * Grammar v3: how the row reads, persisted with the opened item. The
+     * one place presentation travels. Optional for core shapes while v2
+     * deltas are accepted; REQUIRED for `extension` shapes.
+     */
+    presentation: deltaPresentationSchema.optional(),
+    attach: deltaAttachSchema.optional(),
+    providerTurnId: providerTurnIdSchema.optional(),
+    noTurnFallback: deltaNoTurnFallbackSchema.optional()
+  }).superRefine(requireExtensionPresentation),
   /**
-   * 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.
+   * 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).
    */
-  promptMode: promptModeSchema.optional(),
-  /** Frozen for the life of a provider session; applied at construction. */
-  instructions: z15.string().optional(),
-  envVars: z15.record(z15.string(), z15.string()).optional(),
-  /** Provider-scoped session options. Opaque outside the owning bridge. */
-  providerOptions: z15.record(z15.string(), z15.unknown()).optional()
-}).and(runtimePermissionPolicySchema);
-
-// ../provider-bridge-protocol/src/provider-maintenance.ts
-import { z as z16 } from "zod";
-var experimental_providerMaintenanceParamsSchema = z16.object({
-  providerId: z16.string().min(1),
-  cwd: z16.string().min(1).optional(),
-  providerOptions: z16.record(z16.string(), z16.unknown()).optional()
-}).passthrough();
-var experimental_providerInstallationRequirementSchema = z16.enum([
-  "thread_rewind"
-]);
-var experimental_providerInstallationStatusParamsSchema = experimental_providerMaintenanceParamsSchema.extend({
-  requirement: experimental_providerInstallationRequirementSchema.optional()
-});
-var experimental_providerHealthSchema = z16.object({
-  status: z16.enum([
-    "ready",
-    "not_installed",
-    "unauthenticated",
-    "expired",
-    "unsupported_version",
-    "unknown"
-  ]),
-  statusMessage: z16.string().min(1).nullable(),
-  accountEmail: z16.string().nullable(),
-  planLabel: z16.string().min(1).nullable(),
-  installedVersion: z16.string().min(1).nullable(),
-  minimumSupportedVersion: z16.string().min(1).nullable(),
-  canInstall: z16.boolean(),
-  canUpdate: z16.boolean(),
-  loginCommand: z16.string().min(1).nullable()
-}).passthrough();
-var experimental_providerUsageWindowSchema = z16.object({
-  label: z16.string().min(1),
-  usedPercent: z16.number().min(0).max(100),
-  resetsAt: z16.string().min(1).nullable(),
-  cost: z16.object({
-    usedUsdCents: z16.number().int().nonnegative(),
-    limitUsdCents: z16.number().int().positive()
-  }).optional()
-}).passthrough();
-var experimental_providerUsageSchema = z16.discriminatedUnion("status", [
-  z16.object({
-    status: z16.literal("ok"),
-    accountEmail: z16.string().email().nullable(),
-    planLabel: z16.string().min(1).nullable(),
-    windows: z16.array(experimental_providerUsageWindowSchema)
-  }).passthrough(),
-  z16.object({ status: z16.literal("not_installed") }).passthrough(),
-  z16.object({ status: z16.literal("unauthenticated") }).passthrough(),
-  z16.object({ status: z16.literal("expired") }).passthrough(),
-  z16.object({
-    status: z16.literal("error"),
-    message: z16.string().min(1),
-    planLabel: z16.string().min(1).nullable().default(null),
-    accountEmail: z16.string().nullable().default(null)
-  }).passthrough()
-]);
-var experimental_providerHealthResultSchema = z16.discriminatedUnion(
-  "supported",
-  [
-    z16.object({ supported: z16.literal(false) }).passthrough(),
-    z16.object({
-      supported: z16.literal(true),
-      health: experimental_providerHealthSchema
-    }).passthrough()
-  ]
-);
-var experimental_providerUsageResultSchema = z16.discriminatedUnion(
-  "supported",
-  [
-    z16.object({ supported: z16.literal(false) }).passthrough(),
-    z16.object({
-      supported: z16.literal(true),
-      usage: experimental_providerUsageSchema
-    }).passthrough()
-  ]
-);
-var experimental_providerInstallationActionKindSchema = z16.enum([
-  "install",
-  "update"
-]);
-var experimental_providerInstallationActionSchema = z16.object({
-  kind: experimental_providerInstallationActionKindSchema,
-  label: z16.enum(["Install", "Update"]),
-  command: z16.string().min(1)
-}).passthrough();
-var experimental_providerInstallationSourceSchema = z16.enum([
-  "notInstalled",
-  "npmGlobal",
-  "external"
-]);
-var experimental_providerInstallationStatusSchema = z16.object({
-  executableName: z16.string().min(1),
-  executablePath: z16.string().min(1).nullable(),
-  installed: z16.boolean(),
-  installSource: experimental_providerInstallationSourceSchema,
-  currentVersion: z16.string().min(1).nullable(),
-  latestVersion: z16.string().min(1).nullable(),
-  minimumSupportedVersion: z16.string().min(1).nullable(),
-  npmPackageName: z16.string().min(1).nullable(),
-  npmGlobalPackageVersion: z16.string().min(1).nullable(),
-  installAction: experimental_providerInstallationActionSchema.nullable(),
-  needsUpdate: z16.boolean(),
-  versionUnsupported: z16.boolean()
-}).passthrough();
-var experimental_providerInstallationRunParamsSchema = experimental_providerMaintenanceParamsSchema.extend({
-  action: experimental_providerInstallationActionKindSchema
-});
-var experimental_providerInstallationCommandSchema = z16.object({
-  command: z16.string().min(1),
-  args: z16.array(z16.string()).max(64),
-  displayCommand: z16.string().min(1)
-}).passthrough();
-var experimental_providerInstallationVerificationSchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("installed") }).passthrough(),
-  z16.object({
-    kind: z16.literal("version_changed"),
-    previousVersion: z16.string().min(1)
-  }).passthrough(),
-  z16.object({
-    kind: z16.literal("version_at_least"),
-    version: z16.string().min(1)
-  }).passthrough()
-]);
-var experimental_providerInstallationRunResultSchema = z16.discriminatedUnion("available", [
-  z16.object({
-    available: z16.literal(false),
-    message: z16.string().min(1)
-  }).passthrough(),
-  z16.object({
-    available: z16.literal(true),
-    command: experimental_providerInstallationCommandSchema,
-    verification: experimental_providerInstallationVerificationSchema
-  }).passthrough()
-]);
-
-// ../provider-bridge-protocol/src/requests.ts
-import { z as z17 } from "zod";
-var BRIDGE_REQUEST_METHODS = {
-  initialize: "initialize",
-  modelList: "model/list",
-  experimentalProviderHealth: "provider/health",
-  experimentalProviderUsage: "provider/usage",
-  experimentalProviderInstallationStatus: "provider/installation/status",
-  experimentalProviderInstallationRun: "provider/installation/run",
-  threadStart: "thread/start",
-  threadResume: "thread/resume",
-  threadFork: "thread/fork",
-  threadStop: "thread/stop",
-  threadDiscard: "thread/discard",
-  threadNameSet: "thread/name/set",
-  threadArchive: "thread/archive",
-  threadUnarchive: "thread/unarchive",
-  threadGoalClear: "thread/goal/clear",
-  turnStart: "turn/start",
-  turnSteer: "turn/steer",
-  skillsConfigure: "skills/configure"
-};
-var sessionConstructionFields = {
-  threadId: z17.string().min(1),
-  cwd: z17.string().min(1),
-  options: bridgeExecutionOptionsSchema,
-  dynamicTools: z17.array(dynamicToolSchema).optional(),
-  disallowedTools: z17.array(z17.string().min(1)).optional(),
-  instructionMode: instructionModeSchema
-};
-var modelListParamsSchema = z17.object({ cwd: z17.string().min(1).optional() }).passthrough();
-var threadStartParamsSchema = z17.object({
-  ...sessionConstructionFields,
-  input: z17.array(promptInputSchema).optional()
-}).passthrough();
-var threadResumeParamsSchema = z17.object({
-  ...sessionConstructionFields,
-  providerThreadId: z17.string().min(1)
-}).passthrough();
-var threadForkParamsSchema = z17.object({
-  ...sessionConstructionFields,
-  sourceProviderThreadId: z17.string().min(1),
+  z14.object({
+    kind: z14.literal("item.close"),
+    key: deltaItemKeySchema,
+    status: threadEventItemStatusSchema,
+    resultText: z14.string().optional(),
+    exitCode: z14.number().optional(),
+    aggregatedOutput: z14.string().optional(),
+    /** Terminal approval verdict (codex declined → denied). Default null. */
+    approvalStatus: z14.literal("denied").optional(),
+    item: deltaItemShapeSchema,
+    /**
+     * Grammar v3: the terminal presentation. Like `item`, the close carries
+     * the full terminal form; when absent the opened item's presentation
+     * survives onto the completed item (close-echo). REQUIRED for an
+     * `extension` shape, which has nothing to echo without it.
+     */
+    presentation: deltaPresentationSchema.optional(),
+    providerTurnId: providerTurnIdSchema.optional(),
+    noTurnFallback: deltaNoTurnFallbackSchema.optional()
+  }).superRefine(requireExtensionPresentation),
   /**
-   * 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.
+   * 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.
    */
-  sourceProviderCheckpointId: z17.string().min(1).optional()
-}).passthrough();
-var threadStopParamsSchema = z17.object({
-  threadId: z17.string().min(1),
-  providerThreadId: z17.string().min(1),
+  z14.object({
+    kind: z14.literal("item.progress"),
+    key: deltaItemKeySchema,
+    message: z14.string().optional(),
+    snapshot: deltaProgressSnapshotSchema.optional(),
+    flush: z14.boolean().optional(),
+    providerTurnId: providerTurnIdSchema.optional(),
+    noTurnFallback: deltaNoTurnFallbackSchema.optional()
+  }),
   /**
-   * "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.
+   * 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.
    */
-  intent: z17.enum(["interrupt", "release"]),
-  /** Non-null when the stop interrupts an active provider turn. */
-  activeTurnId: z17.string().min(1).nullable()
-}).passthrough();
-var threadRefParams = z17.object({
-  threadId: z17.string().min(1),
-  providerThreadId: z17.string().min(1)
-}).passthrough();
-var threadNameSetParamsSchema = z17.object({
-  threadId: z17.string().min(1),
-  providerThreadId: z17.string().min(1),
-  title: z17.string().min(1)
-}).passthrough();
-var turnInputFields = {
-  threadId: z17.string().min(1),
-  providerThreadId: z17.string().min(1),
-  input: z17.array(promptInputSchema),
-  clientRequestId: clientTurnRequestIdSchema,
-  options: bridgeExecutionOptionsSchema
-};
-var turnStartParamsSchema = z17.object(turnInputFields).passthrough();
-var turnSteerParamsSchema = z17.object({
-  ...turnInputFields,
-  expectedTurnId: z17.string().min(1)
-}).passthrough();
-var skillsConfigureRootSchema = z17.object({
-  id: z17.string().min(1),
-  path: z17.string().min(1),
-  skills: z17.array(
-    z17.object({
-      name: z17.string().min(1),
-      description: z17.string()
-    }).passthrough()
-  )
-}).passthrough();
-var skillsConfigureParamsSchema = z17.object({
-  roots: z17.array(skillsConfigureRootSchema)
-}).passthrough();
-var threadIdentityResultSchema = z17.object({
-  providerThreadId: z17.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
-  sessionRestorable: z17.boolean().optional()
-}).passthrough();
-var modelListResultSchema = z17.object({
-  models: z17.array(availableModelSchema),
-  selectedOnlyModels: z17.array(availableModelSchema).default([])
-}).passthrough();
-
-// ../provider-bridge-protocol/src/notifications.ts
-import { z as z18 } from "zod";
-var threadIdentityNotificationSchema = z18.object({
-  threadId: z18.string().min(1),
-  providerThreadId: z18.string().min(1),
-  /** Refines the handshake's `sessionRestore` for this session. */
-  sessionRestorable: z18.boolean().optional()
-}).passthrough();
-var sessionReplacedNotificationSchema = z18.object({
-  threadId: z18.string().min(1),
-  /** Identity of the replacement session (may equal the old identity). */
-  providerThreadId: z18.string().min(1).nullable(),
-  /** Human-readable cause, shown in the timeline. */
-  reason: z18.string().min(1),
-  /** True when provider-side context did not survive the replacement. */
-  contextLost: z18.boolean().default(false)
-}).passthrough();
-var providerRawNotificationSchema = z18.object({
-  threadId: z18.string().min(1).optional(),
-  coverage: z18.enum(["noise", "unknown"]),
-  payload: z18.unknown()
-}).passthrough();
-var providerRecoveryNotificationSchema = z18.object({
-  threadId: z18.string().min(1).optional(),
-  kind: providerRecoveryKindSchema,
-  message: z18.string().min(1),
-  retryable: z18.boolean()
-}).passthrough();
-var errorNotificationSchema = z18.object({
-  threadId: z18.string().min(1).optional(),
-  message: z18.string().min(1)
-}).passthrough();
-
-// ../provider-bridge-protocol/src/bridge-requests.ts
-import { z as z19 } from "zod";
-var toolCallRequestParamsSchema = z19.object({
-  providerThreadId: z19.string().min(1),
-  threadId: z19.string().min(1).optional(),
-  turnId: z19.union([z19.string().min(1), z19.null()]),
-  callId: z19.string().min(1),
-  tool: z19.string().min(1),
-  arguments: z19.unknown()
-}).passthrough();
-var toolCallResultSchema = z19.object({
-  success: z19.boolean(),
-  contentItems: z19.array(
-    z19.discriminatedUnion("type", [
-      z19.object({ type: z19.literal("inputText"), text: z19.string() }),
-      z19.object({
-        type: z19.literal("inputImage"),
-        imageUrl: z19.string().min(1)
-      })
-    ])
-  )
-}).passthrough();
-var interactionRequestParamsSchema = z19.object({
-  providerThreadId: z19.string().min(1),
-  threadId: z19.string().min(1).optional(),
-  turnId: z19.union([z19.string().min(1), z19.null()]),
-  payload: pendingInteractionPayloadSchema,
+  z14.object({
+    kind: z14.literal("item.textDelta"),
+    key: deltaItemKeySchema,
+    channel: deltaTextChannelSchema,
+    text: z14.string(),
+    providerTurnId: providerTurnIdSchema.optional(),
+    noTurnFallback: deltaNoTurnFallbackSchema.optional()
+  }),
   /**
-   * 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).
+   * 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.
    */
-  providerNativeIds: z19.boolean().optional()
-}).passthrough();
-
-// ../provider-bridge-protocol/src/errors.ts
-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
-};
-
-// ../provider-bridge-protocol/src/thread-event-grammar.ts
-var ITEM_STREAMING_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "item/agentMessage/delta",
-  "item/plan/delta",
-  "item/commandExecution/outputDelta",
-  "item/fileChange/outputDelta",
-  "item/reasoning/summaryTextDelta",
-  "item/reasoning/textDelta",
-  "item/mcpToolCall/progress",
-  "item/toolCall/progress"
-]);
-var MAX_ITEM_IDS_PER_THREAD = 512;
-var THREAD_EVENT_GRAMMAR_RULES = {
-  itemOpensBeforeDelta: "item/opens-before-delta",
-  itemSettlesOnce: "item/settles-once",
-  turnStartsOnce: "turn/starts-once",
-  turnSettlesOnce: "turn/settles-once",
-  turnKnown: "turn/known"
-};
-var OK = { kind: "ok" };
-var ThreadEventGrammar = class {
-  #byThreadId = /* @__PURE__ */ new Map();
-  clear() {
-    this.#byThreadId.clear();
-  }
-  clearThread(threadId) {
-    this.#byThreadId.delete(threadId);
-  }
-  observe(event) {
-    const state = this.#stateFor(event.threadId);
-    switch (event.type) {
-      case "turn/started": {
-        const turnId = turnIdOf(event);
-        if (turnId === void 0) {
-          return OK;
-        }
-        if (state.completedTurnIds.has(turnId)) {
-          return violation(
-            THREAD_EVENT_GRAMMAR_RULES.turnStartsOnce,
-            `turn/started for turn "${turnId}", which already completed`
-          );
-        }
-        if (state.startedTurnIds.has(turnId)) {
-          return violation(
-            THREAD_EVENT_GRAMMAR_RULES.turnStartsOnce,
-            `turn/started for turn "${turnId}", which is already open`
-          );
-        }
-        state.startedTurnIds.add(turnId);
-        return OK;
-      }
-      case "turn/completed": {
-        const turnId = turnIdOf(event);
-        if (turnId === void 0) {
-          return OK;
-        }
-        if (state.completedTurnIds.has(turnId)) {
-          return violation(
-            THREAD_EVENT_GRAMMAR_RULES.turnSettlesOnce,
-            `turn/completed for turn "${turnId}", which already completed`
-          );
-        }
-        if (!state.startedTurnIds.has(turnId)) {
-          return violation(
-            THREAD_EVENT_GRAMMAR_RULES.turnKnown,
-            `turn/completed for turn "${turnId}", which never started`
-          );
-        }
-        state.startedTurnIds.delete(turnId);
-        state.completedTurnIds.add(turnId);
-        return OK;
-      }
-      case "item/started": {
-        state.openItemIds.add(event.item.id);
-        state.settledItemIds.delete(event.item.id);
-        trim(state.openItemIds);
-        return OK;
-      }
-      case "item/completed":
-      case "item/backgroundTask/completed":
-      case "item/delegation/completed": {
-        const itemId = event.item.id;
-        if (state.settledItemIds.has(itemId)) {
-          return violation(
-            THREAD_EVENT_GRAMMAR_RULES.itemSettlesOnce,
-            `${event.type} for item "${itemId}", which already settled`
-          );
-        }
-        state.openItemIds.delete(itemId);
-        state.settledItemIds.add(itemId);
-        trim(state.settledItemIds);
-        return OK;
-      }
-      case "item/backgroundTask/progress":
-      case "item/delegation/progress": {
-        return this.#checkOpenItem(state, event.type, event.item.id);
-      }
-      default: {
-        if (!ITEM_STREAMING_EVENT_TYPES.has(event.type)) {
-          return OK;
-        }
-        if (!("itemId" in event) || typeof event.itemId !== "string") {
-          return OK;
-        }
-        return this.#checkOpenItem(state, event.type, event.itemId);
-      }
-    }
-  }
-  #checkOpenItem(state, eventType, itemId) {
-    if (state.openItemIds.has(itemId)) {
-      return OK;
-    }
-    return violation(
-      THREAD_EVENT_GRAMMAR_RULES.itemOpensBeforeDelta,
-      `${eventType} for item "${itemId}" arrived before item/started`
-    );
-  }
-  #stateFor(threadId) {
-    const existing = this.#byThreadId.get(threadId);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const created = {
-      openItemIds: /* @__PURE__ */ new Set(),
-      settledItemIds: /* @__PURE__ */ new Set(),
-      startedTurnIds: /* @__PURE__ */ new Set(),
-      completedTurnIds: /* @__PURE__ */ new Set()
-    };
-    this.#byThreadId.set(threadId, created);
-    return created;
-  }
-};
-function violation(rule, reason) {
-  return { kind: "violation", rule, reason };
-}
-function turnIdOf(event) {
-  return "scope" in event ? getThreadEventScopeTurnId(event.scope) : void 0;
-}
-function trim(itemIds) {
-  while (itemIds.size > MAX_ITEM_IDS_PER_THREAD) {
-    const oldest = itemIds.values().next();
-    if (oldest.done === true) {
-      return;
-    }
-    itemIds.delete(oldest.value);
-  }
-}
-
-// ../provider-bridge-protocol/src/thread-delta.ts
-import { z as z20 } from "zod";
-var THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
-var deltaPresentationSchema = threadEventItemPresentationSchema;
-var THREAD_DELTA_KEY_SEPARATOR = "";
-var deltaKeyPartSchema = z20.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
-  message: "provider keys must not contain the internal key separator (\\u001f)"
-});
-var deltaItemKeySchema = z20.object({
-  providerItemId: deltaKeyPartSchema.optional(),
-  channel: deltaKeyPartSchema.optional(),
-  parentRef: deltaKeyPartSchema.optional()
-});
-var providerTurnIdSchema = deltaKeyPartSchema;
-var deltaFileChangeSchema = z20.object({
-  path: z20.string(),
-  /** The bridge states the change kind; the assembler never derives it. */
-  kind: z20.enum(["add", "update", "delete"]),
-  movePath: z20.string().optional(),
-  /** Provider-supplied unified diff; preferred over old/new text building. */
-  diff: z20.string().optional(),
-  oldText: z20.string().optional(),
-  /** When present the assembler builds the unified diff from old/new text. */
-  newText: z20.string().optional()
-});
-var deltaBackgroundTaskShapeSchema = z20.object({
-  type: z20.literal("backgroundTask"),
+  z14.object({
+    kind: z14.literal("item.textClose"),
+    key: deltaItemKeySchema,
+    channel: deltaTextChannelSchema,
+    text: z14.string().optional(),
+    providerTurnId: providerTurnIdSchema.optional(),
+    noTurnFallback: deltaNoTurnFallbackSchema.optional()
+  }),
   /**
-   * 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.
+   * Item-keyed exact output append (codex command/fileChange output deltas).
+   * Never synthesizes an open and never diffs — the text is already a delta.
    */
-  familyId: z20.string().min(1),
-  taskType: z20.string(),
-  description: z20.string(),
-  status: threadEventItemStatusSchema,
-  taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z20.boolean(),
-  workflowName: z20.string().optional(),
-  workflow: workflowProgressSnapshotSchema.optional(),
-  usage: backgroundTaskUsageSchema.optional(),
-  summary: z20.string().optional(),
-  error: z20.string().optional(),
-  outputFile: z20.string().optional()
-});
-var deltaFileReadShapeSchema = z20.object({
-  type: z20.literal("fileRead"),
-  path: z20.string(),
-  cmd: z20.string().optional()
-});
-var deltaSearchShapeSchema = z20.object({
-  type: z20.literal("search"),
-  mode: threadEventSearchModeSchema,
-  query: z20.string(),
-  path: z20.string().optional(),
-  cmd: z20.string().optional()
-});
-var deltaDelegationShapeSchema = z20.object({
-  type: z20.literal("delegation"),
-  childRef: deltaKeyPartSchema,
-  label: z20.string(),
-  background: z20.boolean(),
-  summary: z20.string().optional()
-});
-var deltaPlanStepsShapeSchema = z20.object({
-  type: z20.literal("planSteps"),
-  steps: z20.array(threadEventPlanStepSchema),
-  explanation: z20.string().optional()
-});
-var deltaExtensionShapeSchema = z20.object({
-  type: z20.literal("extension"),
-  kind: extensionKindSchema,
-  payload: jsonValueSchema
-});
-var deltaItemShapeSchema = z20.discriminatedUnion("type", [
-  z20.object({
-    type: z20.literal("command"),
-    command: z20.string(),
-    cwd: z20.string(),
-    aggregatedOutput: z20.string().optional(),
-    exitCode: z20.number().optional(),
-    durationMs: z20.number().optional()
-  }),
-  z20.object({
-    type: z20.literal("fileChange"),
-    /** Empty only on bare close-without-open fallbacks (path unknown). */
-    changes: z20.array(deltaFileChangeSchema)
+  z14.object({
+    kind: z14.literal("item.outputDelta"),
+    key: deltaItemKeySchema,
+    channel: deltaOutputChannelSchema,
+    text: z14.string(),
+    providerTurnId: providerTurnIdSchema.optional(),
+    noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
   /**
-   * 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 renders with the
-   * generic tool row.
+   * Cumulative command output snapshot (pi bash). The assembler diffs
+   * consecutive snapshots into `outputDelta`/`reset` events.
    */
-  z20.object({
-    type: z20.literal("tool"),
-    tool: z20.string(),
-    server: z20.string().optional(),
-    args: z20.unknown().optional(),
-    result: z20.unknown().optional(),
-    error: z20.string().optional(),
-    durationMs: z20.number().optional()
-  }),
-  z20.object({ type: z20.literal("compaction") }),
-  z20.object({ type: z20.literal("agentMessage"), text: z20.string() }),
-  z20.object({
-    type: z20.literal("reasoning"),
-    summary: z20.array(z20.string()),
-    content: z20.array(z20.string())
-  }),
-  z20.object({ type: z20.literal("plan"), text: z20.string() }),
-  z20.object({
-    type: z20.literal("webSearch"),
-    queries: z20.array(z20.string()).min(1)
-  }),
-  z20.object({
-    type: z20.literal("webFetch"),
-    url: z20.string(),
-    prompt: z20.string().nullable().optional(),
-    pattern: z20.string().nullable()
-  }),
-  z20.object({ type: z20.literal("imageView"), path: z20.string() }),
-  deltaBackgroundTaskShapeSchema,
-  // Grammar v3 shapes. Every existing shape above is kept unchanged.
-  deltaFileReadShapeSchema,
-  deltaSearchShapeSchema,
-  deltaDelegationShapeSchema,
-  deltaPlanStepsShapeSchema,
-  deltaExtensionShapeSchema
-]);
-var deltaProgressSnapshotSchema = z20.discriminatedUnion("type", [
-  deltaBackgroundTaskShapeSchema,
-  deltaDelegationShapeSchema
-]);
-var deltaTextChannelSchema = z20.enum([
-  "agentMessage",
-  "reasoningSummary",
-  "reasoningText",
-  "plan"
-]);
-var deltaOutputChannelSchema = z20.enum(["command", "fileChange"]);
-var deltaErrorSchema = z20.object({ message: z20.string() });
-var deltaAttachSchema = z20.enum(["open", "currentOrLast"]);
-var deltaNoTurnFallbackSchema = z20.object({
-  raw: providerRawEventSchema,
-  rawType: z20.string()
-});
-function requireExtensionPresentation(delta, ctx) {
-  if (delta.item.type === "extension" && delta.presentation === void 0) {
-    ctx.addIssue({
-      code: "custom",
-      message: "extension items require a presentation on item.open/item.close",
-      path: ["presentation"]
-    });
-  }
-}
-var threadDeltaSchema = z20.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).
-   */
-  z20.object({
-    kind: z20.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.
-   */
-  z20.object({
-    kind: z20.literal("input.provider"),
-    text: z20.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.
-   */
-  z20.object({
-    kind: z20.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.
-   */
-  z20.object({
-    kind: z20.literal("turn.boundary"),
-    status: threadEventTurnStatusSchema,
-    error: deltaErrorSchema.optional(),
-    providerCheckpointId: z20.string().min(1).optional(),
-    claimIfIdle: z20.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).
-   */
-  z20.object({
-    kind: z20.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).
-   */
-  z20.object({
-    kind: z20.literal("item.close"),
-    key: deltaItemKeySchema,
-    status: threadEventItemStatusSchema,
-    resultText: z20.string().optional(),
-    exitCode: z20.number().optional(),
-    aggregatedOutput: z20.string().optional(),
-    /** Terminal approval verdict (codex declined → denied). Default null. */
-    approvalStatus: z20.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.
-   */
-  z20.object({
-    kind: z20.literal("item.progress"),
-    key: deltaItemKeySchema,
-    message: z20.string().optional(),
-    snapshot: deltaProgressSnapshotSchema.optional(),
-    flush: z20.boolean().optional(),
-    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.
-   */
-  z20.object({
-    kind: z20.literal("item.textDelta"),
-    key: deltaItemKeySchema,
-    channel: deltaTextChannelSchema,
-    text: z20.string(),
-    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.
-   */
-  z20.object({
-    kind: z20.literal("item.textClose"),
-    key: deltaItemKeySchema,
-    channel: deltaTextChannelSchema,
-    text: z20.string().optional(),
-    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.
-   */
-  z20.object({
-    kind: z20.literal("item.outputDelta"),
-    key: deltaItemKeySchema,
-    channel: deltaOutputChannelSchema,
-    text: z20.string(),
-    providerTurnId: providerTurnIdSchema.optional(),
-    noTurnFallback: deltaNoTurnFallbackSchema.optional()
-  }),
-  /**
-   * Cumulative command output snapshot (pi bash). The assembler diffs
-   * consecutive snapshots into `outputDelta`/`reset` events.
-   */
-  z20.object({
-    kind: z20.literal("command.outputSnapshot"),
+  z14.object({
+    kind: z14.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
-    text: z20.string(),
+    text: z14.string(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
   /**
@@ -3082,11 +2523,11 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * `thread/tokenUsage/updated` only: a provider whose usage also measures
    * the context window sends the `contextWindow` delta beside it.
    */
-  z20.object({
-    kind: z20.literal("usage"),
+  z14.object({
+    kind: z14.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
     last: threadEventTokenUsageBreakdownSchema,
-    modelContextWindow: z20.number().nullable(),
+    modelContextWindow: z14.number().nullable(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
   /**
@@ -3096,33 +2537,33 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * (codex measures the window per native turn) and `attach` is then
    * irrelevant.
    */
-  z20.object({
-    kind: z20.literal("contextWindow"),
-    used: z20.number().nullable(),
-    size: z20.number().nullable().optional(),
-    estimated: z20.boolean(),
+  z14.object({
+    kind: z14.literal("contextWindow"),
+    used: z14.number().nullable(),
+    size: z14.number().nullable().optional(),
+    estimated: z14.boolean(),
     attach: deltaAttachSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z20.object({
-    kind: z20.literal("context.compacted"),
+  z14.object({
+    kind: z14.literal("context.compacted"),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z20.object({ kind: z20.literal("context.cleared") }),
+  z14.object({ kind: z14.literal("context.cleared") }),
   /** The aggregate working-tree diff for a turn (codex turn/diff/updated). */
-  z20.object({
-    kind: z20.literal("turn.diff"),
-    diff: z20.string(),
+  z14.object({
+    kind: z14.literal("turn.diff"),
+    diff: z14.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
   // Thread metadata (codex thread lifecycle notifications).
-  z20.object({ kind: z20.literal("thread.started") }),
-  z20.object({
-    kind: z20.literal("thread.identity"),
-    providerThreadId: z20.string().min(1)
+  z14.object({ kind: z14.literal("thread.started") }),
+  z14.object({
+    kind: z14.literal("thread.identity"),
+    providerThreadId: z14.string().min(1)
   }),
-  z20.object({ kind: z20.literal("thread.name"), name: z20.string().min(1) }),
+  z14.object({ kind: z14.literal("thread.name"), name: z14.string().min(1) }),
   /**
    * Plugin-declared thread state (grammar v3): `"<pluginId>/<name>"` kinds
    * beside the core thread-state family (usage, context window, rate limits,
@@ -3136,8 +2577,8 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * this union's discriminator; the item shape and the persisted item call
    * the same value `kind`.
    */
-  z20.object({
-    kind: z20.literal("extension.state"),
+  z14.object({
+    kind: z14.literal("extension.state"),
     extensionKind: extensionKindSchema,
     payload: jsonValueSchema
   }),
@@ -3147,8 +2588,8 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * bridge-side — it is seeded from a per-child post-initialize read the
    * assembler never sees.
    */
-  z20.object({
-    kind: z20.literal("provider.rateLimits"),
+  z14.object({
+    kind: z14.literal("provider.rateLimits"),
     rateLimits: providerRateLimitStateSchema
   }),
   /**
@@ -3158,16 +2599,16 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * turn; `threadScoped: true` pins thread scope (codex errors without a
    * native turn id never attach to whatever turn happens to be open).
    */
-  z20.object({
-    kind: z20.literal("provider.error"),
-    message: z20.string(),
-    detail: z20.string().optional(),
-    willRetry: z20.boolean().optional(),
+  z14.object({
+    kind: z14.literal("provider.error"),
+    message: z14.string(),
+    detail: z14.string().optional(),
+    willRetry: z14.boolean().optional(),
     category: providerErrorCategorySchema.optional(),
     errorInfo: providerErrorInfoSchema.optional(),
-    settlesTurn: z20.boolean().optional(),
+    settlesTurn: z14.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
-    threadScoped: z20.boolean().optional()
+    threadScoped: z14.boolean().optional()
   }),
   /**
    * The provider switched models mid-flight (claude model fallback). Scoped to
@@ -3176,23 +2617,23 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * assistant fallback block against the later system duplicate stays
    * bridge-side — it is keyed by the bridge's own segment tracking.
    */
-  z20.object({
-    kind: z20.literal("provider.modelFallback"),
-    originalModel: z20.string().min(1),
-    fallbackModel: z20.string().min(1),
-    reason: z20.enum(["refusal", "provider"]),
-    message: z20.string()
+  z14.object({
+    kind: z14.literal("provider.modelFallback"),
+    originalModel: z14.string().min(1),
+    fallbackModel: z14.string().min(1),
+    reason: z14.enum(["refusal", "provider"]),
+    message: z14.string()
   }),
   /**
    * `vouchedTurn: true` scopes the warning to the open turn when one exists
    * (ACP warnings are turn-scoped mid-turn); default is thread scope.
    */
-  z20.object({
-    kind: z20.literal("provider.warning"),
-    summary: z20.string().optional(),
-    details: z20.string().optional(),
+  z14.object({
+    kind: z14.literal("provider.warning"),
+    summary: z14.string().optional(),
+    details: z14.string().optional(),
     category: threadEventWarningCategorySchema.optional(),
-    vouchedTurn: z20.boolean().optional()
+    vouchedTurn: z14.boolean().optional()
   }),
   /**
    * The bridge's visibility classification decided this raw event is unknown.
@@ -3203,12 +2644,12 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * "known event, no active turn" visibility fallback for events that
    * otherwise translate to silence) and is dropped entirely mid-turn.
    */
-  z20.object({
-    kind: z20.literal("unhandled"),
+  z14.object({
+    kind: z14.literal("unhandled"),
     raw: providerRawEventSchema,
-    rawType: z20.string(),
-    vouchedTurn: z20.boolean(),
-    onlyIfNoTurn: z20.boolean().optional(),
+    rawType: z14.string(),
+    vouchedTurn: z14.boolean(),
+    onlyIfNoTurn: z14.boolean().optional(),
     parentRef: deltaKeyPartSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
@@ -3216,7 +2657,7 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * Lifecycle settlement: the session was interrupted. The assembler closes
    * the open turn and open items as interrupted.
    */
-  z20.object({ kind: z20.literal("session.ended") }),
+  z14.object({ kind: z14.literal("session.ended") }),
   /**
    * Provider-native id-space boundary: a new provider session was constructed
    * for this thread (start/resume/fork/rebuild), so its native turn/item ids
@@ -3224,28 +2665,32 @@ var threadDeltaSchema = z20.discriminatedUnion("kind", [
    * sets, open items and streams; the bridge settles any open work first
    * (nothing is in flight at any construction site).
    */
-  z20.object({ kind: z20.literal("session.reset") })
+  z14.object({ kind: z14.literal("session.reset") })
 ]);
-var threadDeltaNotificationParamsSchema = z20.object({
-  threadId: z20.string().min(1),
-  deltas: z20.array(threadDeltaSchema)
+var threadDeltaNotificationParamsSchema = z14.object({
+  threadId: z14.string().min(1),
+  deltas: z14.array(threadDeltaSchema)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/assembler/delta-assembler.ts
 import { randomUUID } from "node:crypto";
 
+// ../provider-bridge-protocol/src/version.ts
+var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
+var THREAD_DELTA_GRAMMAR_V3 = 3;
+
 // ../provider-bridge-protocol/src/bridge-kit/adapter-utils.ts
-import { z as z22 } from "zod";
+import { z as z16 } from "zod";
 
 // ../provider-bridge-protocol/src/bridge-kit/tool-arg-schemas.ts
-import { z as z21 } from "zod";
-var bashArgsSchema = z21.object({
-  command: z21.string().optional(),
-  cwd: z21.string().optional()
+import { z as z15 } from "zod";
+var bashArgsSchema = z15.object({
+  command: z15.string().optional(),
+  cwd: z15.string().optional()
 }).passthrough();
-var textBlockSchema = z21.object({
-  type: z21.literal("text"),
-  text: z21.string()
+var textBlockSchema = z15.object({
+  type: z15.literal("text"),
+  text: z15.string()
 });
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility-helpers.ts
@@ -3254,10 +2699,10 @@ function isRecord(value) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/adapter-utils.ts
-var contentWrapperSchema = z22.object({
-  content: z22.array(z22.unknown())
+var contentWrapperSchema = z16.object({
+  content: z16.array(z16.unknown())
 }).passthrough();
-var shellEnvironmentVariableKeySchema = z22.string().regex(/^[A-Z_][A-Z0-9_]*$/i);
+var shellEnvironmentVariableKeySchema = z16.string().regex(/^[A-Z_][A-Z0-9_]*$/i);
 var MAX_EXACT_LINE_DIFF_CELLS = 1e6;
 function splitComparableLines(text) {
   const normalized = text.replace(/\r\n?/gu, "\n");
@@ -4087,7 +3532,7 @@ function createDeltaAssembler(options) {
         );
       case "tool": {
         const toolArguments = toOptionalRecord(shape.args);
-        const result = shape.result ?? close.resultText;
+        const result2 = shape.result ?? close.resultText;
         return withParentToolCallId(
           {
             type: "toolCall",
@@ -4096,7 +3541,7 @@ function createDeltaAssembler(options) {
             tool: shape.tool,
             ...toolArguments ? { arguments: toolArguments } : {},
             status: close.status,
-            ...result === void 0 ? {} : { result },
+            ...result2 === void 0 ? {} : { result: result2 },
             ...shape.error === void 0 ? {} : { error: shape.error },
             ...shape.durationMs === void 0 ? {} : { durationMs: shape.durationMs }
           },
@@ -4864,178 +4309,942 @@ function createDeltaAssembler(options) {
       case "turn.diff": {
         const turnId = delta.providerTurnId !== void 0 ? resolveVouchedTurnId(state, delta.providerTurnId) : state.currentTurnId;
         if (turnId === void 0) {
-          return;
+          return;
+        }
+        events.push({
+          type: "turn/diff/updated",
+          threadId: UNSTAMPED_THREAD_ID,
+          providerThreadId: "",
+          scope: turnScope(turnId),
+          diff: delta.diff
+        });
+        return;
+      }
+      case "thread.started": {
+        events.push({
+          type: "thread/started",
+          threadId: UNSTAMPED_THREAD_ID,
+          scope: threadScope()
+        });
+        return;
+      }
+      case "thread.identity": {
+        events.push({
+          type: "thread/identity",
+          threadId: UNSTAMPED_THREAD_ID,
+          providerThreadId: delta.providerThreadId,
+          scope: threadScope()
+        });
+        return;
+      }
+      case "thread.name": {
+        events.push({
+          type: "thread/name/updated",
+          threadId: UNSTAMPED_THREAD_ID,
+          providerThreadId: "",
+          scope: threadScope(),
+          threadName: delta.name
+        });
+        return;
+      }
+      case "provider.rateLimits": {
+        events.push({
+          type: "provider/rateLimits/updated",
+          threadId: UNSTAMPED_THREAD_ID,
+          providerThreadId: "",
+          scope: threadScope(),
+          rateLimits: delta.rateLimits
+        });
+        return;
+      }
+      case "extension.state": {
+        events.push({
+          type: "thread/extensionState/updated",
+          threadId: UNSTAMPED_THREAD_ID,
+          providerThreadId: "",
+          scope: threadScope(),
+          kind: delta.extensionKind,
+          payload: delta.payload
+        });
+        return;
+      }
+      case "session.reset": {
+        return;
+      }
+      case "session.ended": {
+        const turnId = state.currentTurnId ?? (state.pendingAccepted.length > 0 ? ensureTurnOpen(state, events) : void 0);
+        if (turnId === void 0) {
+          return;
+        }
+        for (const open of state.openItemsByKey.values()) {
+          if (open.threadAttached) {
+            continue;
+          }
+          const streamed = open.text.length > 0 || open.summaryText.length > 0;
+          const item = (streamed ? settleTextItem(open, void 0, void 0) : void 0) ?? completeStartedItem(
+            open.item,
+            { status: "interrupted" },
+            void 0
+          );
+          events.push({
+            type: "item/completed",
+            threadId: UNSTAMPED_THREAD_ID,
+            providerThreadId: "",
+            scope: turnScope(turnId),
+            item
+          });
+        }
+        events.push({
+          type: "turn/completed",
+          threadId: UNSTAMPED_THREAD_ID,
+          providerThreadId: "",
+          scope: turnScope(turnId),
+          status: "interrupted"
+        });
+        finishTurn(state);
+        return;
+      }
+    }
+  }
+  return {
+    assemble(args) {
+      const events = [];
+      const sink = {
+        push: (...newEvents) => {
+          for (const event of newEvents) {
+            const textDelta = textDeltaFlushMs > 0 ? asTextDeltaEvent(event) : void 0;
+            const state = states.get(args.threadId);
+            if (textDelta !== void 0 && state !== void 0) {
+              bufferTextDelta(state, textDelta, events);
+              continue;
+            }
+            if (state !== void 0) {
+              flushPendingText(state, events);
+            }
+            events.push(event);
+          }
+        }
+      };
+      const existing = args.deltas[0]?.kind === "session.reset" ? void 0 : states.get(args.threadId);
+      if (existing !== void 0) {
+        flushElapsedPendingText(existing, events);
+        const progressKeysInBatch = /* @__PURE__ */ new Set();
+        for (const delta of args.deltas) {
+          if (delta.kind === "item.progress") {
+            progressKeysInBatch.add(itemKeyString(delta.key));
+          }
+        }
+        flushElapsedPendingProgress(existing, sink, progressKeysInBatch);
+      }
+      for (const delta of args.deltas) {
+        if (delta.kind === "session.reset") {
+          const state = states.get(args.threadId);
+          if (state !== void 0) {
+            flushPendingText(state, events);
+          }
+          states.delete(args.threadId);
+          continue;
+        }
+        if (delta.kind === "item.textClose" || delta.kind === "item.close" || delta.kind === "session.ended") {
+          const state = states.get(args.threadId);
+          if (state !== void 0) {
+            flushPendingText(state, events);
+          }
+        }
+        handleDelta(stateFor(args.threadId), delta, sink);
+      }
+      return events;
+    },
+    getBbItemId(threadId, providerItemId) {
+      return states.get(threadId)?.bbItemIdByProviderItemId.get(providerItemId);
+    },
+    getProviderItemId(threadId, bbItemId) {
+      return states.get(threadId)?.providerItemIdByBbItemId.get(bbItemId);
+    },
+    getBbTurnId(threadId, providerTurnId) {
+      return states.get(threadId)?.bbTurnIdByProviderTurnId.get(providerTurnId);
+    },
+    getProviderTurnId(threadId, bbTurnId) {
+      return states.get(threadId)?.providerTurnIdByBbTurnId.get(bbTurnId);
+    },
+    getOpenTurnId(threadId) {
+      return states.get(threadId)?.currentTurnId;
+    }
+  };
+}
+
+// ../provider-bridge-protocol/src/testing/bridge-delta-assembly.ts
+function createBridgeDeltaEventCollector(providerId = "pi") {
+  const assembler = createDeltaAssembler({ providerId, textDeltaFlushMs: 0 });
+  return {
+    assembler,
+    assembleMessage(message) {
+      if (message.method !== THREAD_DELTA_NOTIFICATION_METHOD) {
+        return [];
+      }
+      const parsed = threadDeltaNotificationParamsSchema.safeParse(
+        message.params
+      );
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid thread/delta notification: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(
+            "; "
+          )} (params: ${JSON.stringify(message.params)?.slice(0, 400)})`
+        );
+      }
+      return assembler.assemble({
+        threadId: parsed.data.threadId,
+        deltas: parsed.data.deltas
+      });
+    }
+  };
+}
+function assembleCapturedThreadEvents(messages, providerId = "pi") {
+  const collector = createBridgeDeltaEventCollector(providerId);
+  return messages.flatMap((message) => collector.assembleMessage(message));
+}
+function toConformanceMessages() {
+  throw new Error(
+    "experimental_toConformanceMessages was removed: experimental_runBridgeConformance assembles thread/delta itself. Hand it a transport whose takeMessages returns the raw captured messages (CapturedBridgeJsonRpcOutput.takeMessages) and pass the bridge's providerId."
+  );
+}
+
+// ../provider-bridge-protocol/src/conformance/client.ts
+import { z as z17 } from "zod";
+function isWireMessage(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var threadDeltaAddressSchema = z17.object({ threadId: z17.string() }).passthrough();
+var ConformanceClient = class {
+  constructor(transport, timeoutMs, collector) {
+    this.transport = transport;
+    this.timeoutMs = timeoutMs;
+    this.collector = collector;
+  }
+  transport;
+  timeoutMs;
+  collector;
+  nextId = 1;
+  log = [];
+  /** Every assembled event, in wire order. */
+  events = [];
+  drainIntoLog() {
+    for (const raw of this.transport.takeMessages()) {
+      if (!isWireMessage(raw)) {
+        continue;
+      }
+      const logIndex = this.log.length;
+      this.log.push(raw);
+      if (raw.method !== THREAD_DELTA_NOTIFICATION_METHOD) {
+        continue;
+      }
+      const events = this.collector.assembleMessage(raw);
+      const address = threadDeltaAddressSchema.parse(raw.params);
+      for (const event of events) {
+        this.events.push({ threadId: address.threadId, event, logIndex });
+      }
+    }
+  }
+  sendRaw(line) {
+    this.transport.send(line);
+  }
+  notify(method, params) {
+    this.transport.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        method,
+        ...params !== void 0 ? { params } : {}
+      })
+    );
+  }
+  request(method, params) {
+    const id = this.nextId;
+    this.nextId += 1;
+    this.transport.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...params !== void 0 ? { params } : {}
+      })
+    );
+    return id;
+  }
+  /** Poll until `resolve` yields a value or the deadline passes (→ null). */
+  async waitFor(resolve3) {
+    const deadline = Date.now() + this.timeoutMs;
+    for (; ; ) {
+      this.drainIntoLog();
+      const value = resolve3();
+      if (value !== void 0) {
+        return value;
+      }
+      if (Date.now() > deadline) {
+        return null;
+      }
+      await new Promise((r) => setTimeout(r, 15));
+    }
+  }
+  async waitForResponse(id) {
+    return this.waitFor(
+      () => this.log.find(
+        (message) => message.id === id && message.method === void 0
+      )
+    );
+  }
+  /** A settle window: drain for the given quiet period without expectations. */
+  async settle(quietMs) {
+    const deadline = Date.now() + quietMs;
+    while (Date.now() < deadline) {
+      this.drainIntoLog();
+      await new Promise((r) => setTimeout(r, 15));
+    }
+    this.drainIntoLog();
+  }
+  responsesFor(id) {
+    return this.log.filter(
+      (message) => message.id === id && message.method === void 0
+    );
+  }
+  notifications(method) {
+    return this.log.filter(
+      (message) => message.id === void 0 && typeof message.method === "string" && (method === void 0 || message.method === method)
+    );
+  }
+};
+var clientRequestCounter = 0;
+function nextConformanceClientRequestId() {
+  const alphabet = "23456789abcdefghijkmnpqrstuvwxyz";
+  clientRequestCounter += 1;
+  let remaining = clientRequestCounter;
+  let suffix = "";
+  while (suffix.length < 10) {
+    suffix = alphabet[remaining % alphabet.length] + suffix;
+    remaining = Math.floor(remaining / alphabet.length);
+  }
+  return `creq_${suffix}`;
+}
+
+// ../provider-bridge-protocol/src/conformance/scenarios.ts
+import { z as z25 } from "zod";
+
+// ../provider-bridge-protocol/src/handshake.ts
+import { z as z18 } from "zod";
+var bridgeGrammarVersionsSchema = z18.tuple([z18.number().int().positive(), z18.number().int().positive()]).refine(([min, max]) => min <= max, {
+  message: "grammarVersions must be an ascending [min, max] range"
+});
+function negotiateGrammarVersion(runtime, bridge) {
+  const min = Math.max(runtime[0], bridge[0]);
+  const max = Math.min(runtime[1], bridge[1]);
+  return min <= max ? max : null;
+}
+var bridgeSteerModeSchema = z18.enum(["inject", "queue"]);
+var bridgeCapabilitiesSchema = z18.object({
+  /**
+   * A released session can be re-attached later from its persisted
+   * providerThreadId. The per-session `sessionRestorable` flag on
+   * thread-identity results refines this (an agent update can drop restore
+   * support mid-flight); this handshake value is the default for sessions
+   * that do not say.
+   */
+  sessionRestore: z18.boolean().default(false),
+  /**
+   * The bridge mirrors bb archive state into the provider's own session
+   * list. When false the runtime never sends thread/archive or
+   * thread/unarchive.
+   */
+  threadArchive: z18.boolean().default(false),
+  /**
+   * The bridge pushes bb thread titles to the provider. When false the
+   * runtime never sends thread/name/set.
+   */
+  threadRename: z18.boolean().default(false),
+  /** The bridge supports thread/goal/clear. */
+  threadGoalClear: z18.boolean().default(false),
+  /**
+   * Session cloning support ({@link providerForkSchema} — the same
+   * vocabulary the provider declaration uses). The declaration is a ceiling
+   * for UI affordances; this is the operative truth, and it may only narrow
+   * the declaration, never widen it.
+   */
+  fork: providerForkSchema.default("none"),
+  /**
+   * Where the thread's approval policy is enforced. "runtime" bridges
+   * forward every approval request and the runtime applies the thread
+   * policy (including auto-deny). "provider" bridges enforce policy before
+   * forwarding, so every forwarded request is already known to need user
+   * input and the runtime must not reclassify it against mutable thread
+   * settings.
+   */
+  approvalEnforcedBy: z18.enum(["runtime", "provider"]).default("runtime"),
+  /**
+   * The `thread/delta` grammar range this bridge speaks. A bridge that says
+   * nothing is read as speaking exactly the protocol version it negotiated,
+   * so the default is `[2, 2]` — never a wider range it never claimed.
+   * Every bridge in this repo emits v3 and reports `[3, 3]`, and the
+   * runtime's assembler speaks `[3, 3]` only (`ASSEMBLER_GRAMMAR_VERSIONS`),
+   * so a bridge that takes the default is refused at startup: the two
+   * ranges must intersect ({@link negotiateGrammarVersion}) and both sides
+   * emit the highest common version.
+   */
+  grammarVersions: bridgeGrammarVersionsSchema.default([
+    PROVIDER_BRIDGE_PROTOCOL_VERSION,
+    PROVIDER_BRIDGE_PROTOCOL_VERSION
+  ]),
+  /**
+   * Mid-turn steer delivery ({@link bridgeSteerModeSchema}). Defaults to
+   * `queue`, the conservative reading: absence is the definite "no" the
+   * rest of this handshake uses, and `inject` is the stronger promise (the
+   * steer reaches the model before the turn ends) a bridge must make
+   * explicitly. Nothing in the runtime, server, or clients reads it today:
+   * `turn/steer` is sent either way, and a steer whose turn is gone is
+   * dropped on the bridge's `staleTurn` recovery hint or `NO_ACTIVE_TURN`
+   * error (`steerTurn` in @bb/agent-runtime), whatever the mode. claude,
+   * codex, and pi declare `inject`; ACP and the echo example declare
+   * `queue`.
+   */
+  steerMode: bridgeSteerModeSchema.default("queue"),
+  /**
+   * Which optional requests the bridge handles. `skills.configure`: the
+   * bridge accepts `skills/configure` (bb's injected skill roots). When
+   * false the runtime never sends it, so a bridge that answers unknown
+   * methods with METHOD_NOT_FOUND — as the protocol instructs — still
+   * starts threads; it simply runs without injected skills. A bridge that
+   * handles the request declares it; the runtime never probes.
+   */
+  skills: z18.object({ configure: z18.boolean().default(false) }).default({ configure: false })
+}).passthrough();
+var initializeParamsSchema = z18.object({
+  protocolVersion: z18.number().int().positive(),
+  client: z18.object({ name: z18.string().min(1), version: z18.string().min(1) }),
+  /**
+   * The `thread/delta` grammar range the runtime's assembler accepts (see
+   * {@link negotiateGrammarVersion}). A runtime that predates the field
+   * reads as speaking exactly its protocol version.
+   */
+  grammarVersions: bridgeGrammarVersionsSchema.default([
+    PROVIDER_BRIDGE_PROTOCOL_VERSION,
+    PROVIDER_BRIDGE_PROTOCOL_VERSION
+  ])
+}).passthrough();
+var initializeResultSchema = z18.object({
+  protocolVersion: z18.number().int().positive(),
+  // An absent capabilities block reads as "no capabilities" via the inner
+  // per-field defaults, so older bridges parse to explicit values.
+  capabilities: z18.preprocess(
+    (value) => value ?? {},
+    bridgeCapabilitiesSchema
+  )
+}).passthrough();
+
+// ../provider-bridge-protocol/src/execution-options.ts
+import { z as z19 } from "zod";
+var bridgeExecutionOptionsSchema = z19.object({
+  model: z19.string().min(1).optional(),
+  serviceTier: serviceTierSchema.optional(),
+  reasoningLevel: reasoningLevelSchema.optional(),
+  /**
+   * BB prompt mode (`"plan"`), present only when the prompt entered one
+   * through the provider's declared composer action. Each bridge maps it
+   * onto the agent's native equivalent.
+   */
+  promptMode: promptModeSchema.optional(),
+  /** Frozen for the life of a provider session; applied at construction. */
+  instructions: z19.string().optional(),
+  envVars: z19.record(z19.string(), z19.string()).optional(),
+  /** Provider-scoped session options. Opaque outside the owning bridge. */
+  providerOptions: z19.record(z19.string(), z19.unknown()).optional()
+}).and(runtimePermissionPolicySchema);
+
+// ../provider-bridge-protocol/src/provider-maintenance.ts
+import { z as z20 } from "zod";
+var providerMaintenanceParamsSchema = z20.object({
+  providerId: z20.string().min(1),
+  cwd: z20.string().min(1).optional(),
+  providerOptions: z20.record(z20.string(), z20.unknown()).optional()
+}).passthrough();
+var providerInstallationRequirementSchema = z20.enum([
+  "thread_rewind"
+]);
+var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
+  requirement: providerInstallationRequirementSchema.optional()
+});
+var providerHealthSchema = z20.object({
+  status: z20.enum([
+    "ready",
+    "not_installed",
+    "unauthenticated",
+    "expired",
+    "unsupported_version",
+    "unknown"
+  ]),
+  statusMessage: z20.string().min(1).nullable(),
+  accountEmail: z20.string().nullable(),
+  planLabel: z20.string().min(1).nullable(),
+  installedVersion: z20.string().min(1).nullable(),
+  minimumSupportedVersion: z20.string().min(1).nullable(),
+  canInstall: z20.boolean(),
+  canUpdate: z20.boolean(),
+  loginCommand: z20.string().min(1).nullable()
+}).passthrough();
+var providerUsageWindowSchema = z20.object({
+  label: z20.string().min(1),
+  usedPercent: z20.number().min(0).max(100),
+  resetsAt: z20.string().min(1).nullable(),
+  cost: z20.object({
+    usedUsdCents: z20.number().int().nonnegative(),
+    limitUsdCents: z20.number().int().positive()
+  }).optional()
+}).passthrough();
+var providerUsageSchema = z20.discriminatedUnion("status", [
+  z20.object({
+    status: z20.literal("ok"),
+    accountEmail: z20.string().email().nullable(),
+    planLabel: z20.string().min(1).nullable(),
+    windows: z20.array(providerUsageWindowSchema)
+  }).passthrough(),
+  z20.object({ status: z20.literal("not_installed") }).passthrough(),
+  z20.object({ status: z20.literal("unauthenticated") }).passthrough(),
+  z20.object({ status: z20.literal("expired") }).passthrough(),
+  z20.object({
+    status: z20.literal("error"),
+    message: z20.string().min(1),
+    planLabel: z20.string().min(1).nullable().default(null),
+    accountEmail: z20.string().nullable().default(null)
+  }).passthrough()
+]);
+var providerHealthResultSchema = z20.discriminatedUnion(
+  "supported",
+  [
+    z20.object({ supported: z20.literal(false) }).passthrough(),
+    z20.object({
+      supported: z20.literal(true),
+      health: providerHealthSchema
+    }).passthrough()
+  ]
+);
+var providerUsageResultSchema = z20.discriminatedUnion(
+  "supported",
+  [
+    z20.object({ supported: z20.literal(false) }).passthrough(),
+    z20.object({
+      supported: z20.literal(true),
+      usage: providerUsageSchema
+    }).passthrough()
+  ]
+);
+var providerInstallationActionKindSchema = z20.enum([
+  "install",
+  "update"
+]);
+var providerInstallationActionSchema = z20.object({
+  kind: providerInstallationActionKindSchema,
+  label: z20.enum(["Install", "Update"]),
+  command: z20.string().min(1)
+}).passthrough();
+var providerInstallationSourceSchema = z20.enum([
+  "notInstalled",
+  "npmGlobal",
+  "external"
+]);
+var providerInstallationStatusSchema = z20.object({
+  executableName: z20.string().min(1),
+  executablePath: z20.string().min(1).nullable(),
+  installed: z20.boolean(),
+  installSource: providerInstallationSourceSchema,
+  currentVersion: z20.string().min(1).nullable(),
+  latestVersion: z20.string().min(1).nullable(),
+  minimumSupportedVersion: z20.string().min(1).nullable(),
+  npmPackageName: z20.string().min(1).nullable(),
+  npmGlobalPackageVersion: z20.string().min(1).nullable(),
+  installAction: providerInstallationActionSchema.nullable(),
+  needsUpdate: z20.boolean(),
+  versionUnsupported: z20.boolean()
+}).passthrough();
+var providerInstallationRunParamsSchema = providerMaintenanceParamsSchema.extend({
+  action: providerInstallationActionKindSchema
+});
+var providerInstallationCommandSchema = z20.object({
+  command: z20.string().min(1),
+  args: z20.array(z20.string()).max(64),
+  displayCommand: z20.string().min(1)
+}).passthrough();
+var providerInstallationVerificationSchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("installed") }).passthrough(),
+  z20.object({
+    kind: z20.literal("version_changed"),
+    previousVersion: z20.string().min(1)
+  }).passthrough(),
+  z20.object({
+    kind: z20.literal("version_at_least"),
+    version: z20.string().min(1)
+  }).passthrough()
+]);
+var providerInstallationRunResultSchema = z20.discriminatedUnion("available", [
+  z20.object({
+    available: z20.literal(false),
+    message: z20.string().min(1)
+  }).passthrough(),
+  z20.object({
+    available: z20.literal(true),
+    command: providerInstallationCommandSchema,
+    verification: providerInstallationVerificationSchema
+  }).passthrough()
+]);
+
+// ../provider-bridge-protocol/src/requests.ts
+import { z as z21 } from "zod";
+var BRIDGE_REQUEST_METHODS = {
+  initialize: "initialize",
+  modelList: "model/list",
+  providerHealth: "provider/health",
+  providerUsage: "provider/usage",
+  providerInstallationStatus: "provider/installation/status",
+  providerInstallationRun: "provider/installation/run",
+  threadStart: "thread/start",
+  threadResume: "thread/resume",
+  threadFork: "thread/fork",
+  threadStop: "thread/stop",
+  threadDiscard: "thread/discard",
+  threadNameSet: "thread/name/set",
+  threadArchive: "thread/archive",
+  threadUnarchive: "thread/unarchive",
+  threadGoalClear: "thread/goal/clear",
+  turnStart: "turn/start",
+  turnSteer: "turn/steer",
+  skillsConfigure: "skills/configure"
+};
+var sessionConstructionFields = {
+  threadId: z21.string().min(1),
+  cwd: z21.string().min(1),
+  options: bridgeExecutionOptionsSchema,
+  dynamicTools: z21.array(dynamicToolSchema).optional(),
+  disallowedTools: z21.array(z21.string().min(1)).optional(),
+  instructionMode: instructionModeSchema
+};
+var modelListParamsSchema = z21.object({ cwd: z21.string().min(1).optional() }).passthrough();
+var threadStartParamsSchema = z21.object({
+  ...sessionConstructionFields,
+  input: z21.array(promptInputSchema).optional()
+}).passthrough();
+var threadResumeParamsSchema = z21.object({
+  ...sessionConstructionFields,
+  providerThreadId: z21.string().min(1)
+}).passthrough();
+var threadForkParamsSchema = z21.object({
+  ...sessionConstructionFields,
+  sourceProviderThreadId: z21.string().min(1),
+  /**
+   * Absent means fork at the tip. Bridges whose handshake advertises
+   * `fork: "tip"` reject a request carrying a checkpoint instead of
+   * silently cloning more history than the bb timeline shows.
+   */
+  sourceProviderCheckpointId: z21.string().min(1).optional()
+}).passthrough();
+var threadStopParamsSchema = z21.object({
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1),
+  /**
+   * "interrupt" stops an active turn and settles it as interrupted.
+   * "release" detaches an idle session so its resources can be reclaimed;
+   * it must never fabricate an interruption. One verb serving both intents
+   * is the #1584 incident — the field is required.
+   */
+  intent: z21.enum(["interrupt", "release"]),
+  /** Non-null when the stop interrupts an active provider turn. */
+  activeTurnId: z21.string().min(1).nullable()
+}).passthrough();
+var threadRefParams = z21.object({
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1)
+}).passthrough();
+var threadNameSetParamsSchema = z21.object({
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1),
+  title: z21.string().min(1)
+}).passthrough();
+var turnInputFields = {
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1),
+  input: z21.array(promptInputSchema),
+  clientRequestId: clientTurnRequestIdSchema,
+  options: bridgeExecutionOptionsSchema
+};
+var turnStartParamsSchema = z21.object(turnInputFields).passthrough();
+var turnSteerParamsSchema = z21.object({
+  ...turnInputFields,
+  expectedTurnId: z21.string().min(1)
+}).passthrough();
+var skillsConfigureRootSchema = z21.object({
+  id: z21.string().min(1),
+  path: z21.string().min(1),
+  skills: z21.array(
+    z21.object({
+      name: z21.string().min(1),
+      description: z21.string()
+    }).passthrough()
+  )
+}).passthrough();
+var skillsConfigureParamsSchema = z21.object({
+  roots: z21.array(skillsConfigureRootSchema)
+}).passthrough();
+var threadIdentityResultSchema = z21.object({
+  providerThreadId: z21.string().min(1),
+  /** Refines the handshake's `sessionRestore` for this session. */
+  sessionRestorable: z21.boolean().optional()
+}).passthrough();
+var modelListResultSchema = z21.object({
+  models: z21.array(availableModelSchema),
+  selectedOnlyModels: z21.array(availableModelSchema).default([])
+}).passthrough();
+
+// ../provider-bridge-protocol/src/notifications.ts
+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({
+  kind: providerRecoveryKindSchema,
+  message: z22.string().min(1),
+  retryable: z22.boolean()
+});
+var bridgeErrorDataSchema = z22.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
+
+// ../provider-bridge-protocol/src/notifications.ts
+var threadIdentityNotificationSchema = z23.object({
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1),
+  /** Refines the handshake's `sessionRestore` for this session. */
+  sessionRestorable: z23.boolean().optional()
+}).passthrough();
+var sessionReplacedNotificationSchema = z23.object({
+  threadId: z23.string().min(1),
+  /** Identity of the replacement session (may equal the old identity). */
+  providerThreadId: z23.string().min(1).nullable(),
+  /** Human-readable cause, shown in the timeline. */
+  reason: z23.string().min(1),
+  /** True when provider-side context did not survive the replacement. */
+  contextLost: z23.boolean().default(false)
+}).passthrough();
+var providerRawNotificationSchema = z23.object({
+  threadId: z23.string().min(1).optional(),
+  coverage: z23.enum(["noise", "unknown"]),
+  payload: z23.unknown()
+}).passthrough();
+var providerRecoveryNotificationSchema = z23.object({
+  threadId: z23.string().min(1).optional(),
+  ...providerRecoveryHintSchema.shape
+}).passthrough();
+var errorNotificationSchema = z23.object({
+  threadId: z23.string().min(1).optional(),
+  message: z23.string().min(1)
+}).passthrough();
+
+// ../provider-bridge-protocol/src/bridge-requests.ts
+import { z as z24 } from "zod";
+var toolCallRequestParamsSchema = z24.object({
+  providerThreadId: z24.string().min(1),
+  threadId: z24.string().min(1).optional(),
+  turnId: z24.union([z24.string().min(1), z24.null()]),
+  callId: z24.string().min(1),
+  tool: z24.string().min(1),
+  arguments: z24.unknown()
+}).passthrough();
+var toolCallResultSchema = z24.object({
+  success: z24.boolean(),
+  contentItems: z24.array(
+    z24.discriminatedUnion("type", [
+      z24.object({ type: z24.literal("inputText"), text: z24.string() }),
+      z24.object({
+        type: z24.literal("inputImage"),
+        imageUrl: z24.string().min(1)
+      })
+    ])
+  )
+}).passthrough();
+var interactionRequestParamsSchema = z24.object({
+  providerThreadId: z24.string().min(1),
+  threadId: z24.string().min(1).optional(),
+  turnId: z24.union([z24.string().min(1), z24.null()]),
+  payload: pendingInteractionPayloadSchema,
+  /**
+   * The request's turn id and approval-subject item ids are in the
+   * provider's native id space (a `thread/delta` bridge holds no bb ids):
+   * the runtime adapter translates them through the delta assembler's maps
+   * before the interaction reaches the app. Omission means the ids are
+   * already app-visible (bridges whose approval subjects never referenced
+   * timeline ids — ACP's approval ids never matched timeline ids).
+   */
+  providerNativeIds: z24.boolean().optional()
+}).passthrough();
+
+// ../provider-bridge-protocol/src/thread-event-grammar.ts
+var ITEM_STREAMING_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "item/agentMessage/delta",
+  "item/plan/delta",
+  "item/commandExecution/outputDelta",
+  "item/fileChange/outputDelta",
+  "item/reasoning/summaryTextDelta",
+  "item/reasoning/textDelta",
+  "item/mcpToolCall/progress",
+  "item/toolCall/progress"
+]);
+var MAX_ITEM_IDS_PER_THREAD = 512;
+var THREAD_EVENT_GRAMMAR_RULES = {
+  itemOpensBeforeDelta: "item/opens-before-delta",
+  itemSettlesOnce: "item/settles-once",
+  turnStartsOnce: "turn/starts-once",
+  turnSettlesOnce: "turn/settles-once",
+  turnKnown: "turn/known"
+};
+var OK = { kind: "ok" };
+var ThreadEventGrammar = class {
+  #byThreadId = /* @__PURE__ */ new Map();
+  clear() {
+    this.#byThreadId.clear();
+  }
+  clearThread(threadId) {
+    this.#byThreadId.delete(threadId);
+  }
+  observe(event) {
+    const state = this.#stateFor(event.threadId);
+    switch (event.type) {
+      case "turn/started": {
+        const turnId = turnIdOf(event);
+        if (turnId === void 0) {
+          return OK;
         }
-        events.push({
-          type: "turn/diff/updated",
-          threadId: UNSTAMPED_THREAD_ID,
-          providerThreadId: "",
-          scope: turnScope(turnId),
-          diff: delta.diff
-        });
-        return;
-      }
-      case "thread.started": {
-        events.push({
-          type: "thread/started",
-          threadId: UNSTAMPED_THREAD_ID,
-          scope: threadScope()
-        });
-        return;
-      }
-      case "thread.identity": {
-        events.push({
-          type: "thread/identity",
-          threadId: UNSTAMPED_THREAD_ID,
-          providerThreadId: delta.providerThreadId,
-          scope: threadScope()
-        });
-        return;
-      }
-      case "thread.name": {
-        events.push({
-          type: "thread/name/updated",
-          threadId: UNSTAMPED_THREAD_ID,
-          providerThreadId: "",
-          scope: threadScope(),
-          threadName: delta.name
-        });
-        return;
-      }
-      case "provider.rateLimits": {
-        events.push({
-          type: "provider/rateLimits/updated",
-          threadId: UNSTAMPED_THREAD_ID,
-          providerThreadId: "",
-          scope: threadScope(),
-          rateLimits: delta.rateLimits
-        });
-        return;
-      }
-      case "extension.state": {
-        events.push({
-          type: "thread/extensionState/updated",
-          threadId: UNSTAMPED_THREAD_ID,
-          providerThreadId: "",
-          scope: threadScope(),
-          kind: delta.extensionKind,
-          payload: delta.payload
-        });
-        return;
-      }
-      case "session.reset": {
-        return;
+        if (state.completedTurnIds.has(turnId)) {
+          return violation(
+            THREAD_EVENT_GRAMMAR_RULES.turnStartsOnce,
+            `turn/started for turn "${turnId}", which already completed`
+          );
+        }
+        if (state.startedTurnIds.has(turnId)) {
+          return violation(
+            THREAD_EVENT_GRAMMAR_RULES.turnStartsOnce,
+            `turn/started for turn "${turnId}", which is already open`
+          );
+        }
+        state.startedTurnIds.add(turnId);
+        return OK;
       }
-      case "session.ended": {
-        const turnId = state.currentTurnId ?? (state.pendingAccepted.length > 0 ? ensureTurnOpen(state, events) : void 0);
+      case "turn/completed": {
+        const turnId = turnIdOf(event);
         if (turnId === void 0) {
-          return;
+          return OK;
         }
-        for (const open of state.openItemsByKey.values()) {
-          if (open.threadAttached) {
-            continue;
-          }
-          const streamed = open.text.length > 0 || open.summaryText.length > 0;
-          const item = (streamed ? settleTextItem(open, void 0, void 0) : void 0) ?? completeStartedItem(
-            open.item,
-            { status: "interrupted" },
-            void 0
+        if (state.completedTurnIds.has(turnId)) {
+          return violation(
+            THREAD_EVENT_GRAMMAR_RULES.turnSettlesOnce,
+            `turn/completed for turn "${turnId}", which already completed`
           );
-          events.push({
-            type: "item/completed",
-            threadId: UNSTAMPED_THREAD_ID,
-            providerThreadId: "",
-            scope: turnScope(turnId),
-            item
-          });
         }
-        events.push({
-          type: "turn/completed",
-          threadId: UNSTAMPED_THREAD_ID,
-          providerThreadId: "",
-          scope: turnScope(turnId),
-          status: "interrupted"
-        });
-        finishTurn(state);
-        return;
-      }
-    }
-  }
-  return {
-    assemble(args) {
-      const events = [];
-      const sink = {
-        push: (...newEvents) => {
-          for (const event of newEvents) {
-            const textDelta = textDeltaFlushMs > 0 ? asTextDeltaEvent(event) : void 0;
-            const state = states.get(args.threadId);
-            if (textDelta !== void 0 && state !== void 0) {
-              bufferTextDelta(state, textDelta, events);
-              continue;
-            }
-            if (state !== void 0) {
-              flushPendingText(state, events);
-            }
-            events.push(event);
-          }
+        if (!state.startedTurnIds.has(turnId)) {
+          return violation(
+            THREAD_EVENT_GRAMMAR_RULES.turnKnown,
+            `turn/completed for turn "${turnId}", which never started`
+          );
         }
-      };
-      const existing = args.deltas[0]?.kind === "session.reset" ? void 0 : states.get(args.threadId);
-      if (existing !== void 0) {
-        flushElapsedPendingText(existing, events);
-        const progressKeysInBatch = /* @__PURE__ */ new Set();
-        for (const delta of args.deltas) {
-          if (delta.kind === "item.progress") {
-            progressKeysInBatch.add(itemKeyString(delta.key));
-          }
+        state.startedTurnIds.delete(turnId);
+        state.completedTurnIds.add(turnId);
+        return OK;
+      }
+      case "item/started": {
+        state.openItemIds.add(event.item.id);
+        state.settledItemIds.delete(event.item.id);
+        trim(state.openItemIds);
+        return OK;
+      }
+      case "item/completed":
+      case "item/backgroundTask/completed":
+      case "item/delegation/completed": {
+        const itemId = event.item.id;
+        if (state.settledItemIds.has(itemId)) {
+          return violation(
+            THREAD_EVENT_GRAMMAR_RULES.itemSettlesOnce,
+            `${event.type} for item "${itemId}", which already settled`
+          );
         }
-        flushElapsedPendingProgress(existing, sink, progressKeysInBatch);
+        state.openItemIds.delete(itemId);
+        state.settledItemIds.add(itemId);
+        trim(state.settledItemIds);
+        return OK;
       }
-      for (const delta of args.deltas) {
-        if (delta.kind === "session.reset") {
-          const state = states.get(args.threadId);
-          if (state !== void 0) {
-            flushPendingText(state, events);
-          }
-          states.delete(args.threadId);
-          continue;
+      case "item/backgroundTask/progress":
+      case "item/delegation/progress": {
+        return this.#checkOpenItem(state, event.type, event.item.id);
+      }
+      default: {
+        if (!ITEM_STREAMING_EVENT_TYPES.has(event.type)) {
+          return OK;
         }
-        if (delta.kind === "item.textClose" || delta.kind === "item.close" || delta.kind === "session.ended") {
-          const state = states.get(args.threadId);
-          if (state !== void 0) {
-            flushPendingText(state, events);
-          }
+        if (!("itemId" in event) || typeof event.itemId !== "string") {
+          return OK;
         }
-        handleDelta(stateFor(args.threadId), delta, sink);
+        return this.#checkOpenItem(state, event.type, event.itemId);
       }
-      return events;
-    },
-    getBbItemId(threadId, providerItemId) {
-      return states.get(threadId)?.bbItemIdByProviderItemId.get(providerItemId);
-    },
-    getProviderItemId(threadId, bbItemId) {
-      return states.get(threadId)?.providerItemIdByBbItemId.get(bbItemId);
-    },
-    getBbTurnId(threadId, providerTurnId) {
-      return states.get(threadId)?.bbTurnIdByProviderTurnId.get(providerTurnId);
-    },
-    getProviderTurnId(threadId, bbTurnId) {
-      return states.get(threadId)?.providerTurnIdByBbTurnId.get(bbTurnId);
-    },
-    getOpenTurnId(threadId) {
-      return states.get(threadId)?.currentTurnId;
     }
-  };
+  }
+  #checkOpenItem(state, eventType, itemId) {
+    if (state.openItemIds.has(itemId)) {
+      return OK;
+    }
+    return violation(
+      THREAD_EVENT_GRAMMAR_RULES.itemOpensBeforeDelta,
+      `${eventType} for item "${itemId}" arrived before item/started`
+    );
+  }
+  #stateFor(threadId) {
+    const existing = this.#byThreadId.get(threadId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const created = {
+      openItemIds: /* @__PURE__ */ new Set(),
+      settledItemIds: /* @__PURE__ */ new Set(),
+      startedTurnIds: /* @__PURE__ */ new Set(),
+      completedTurnIds: /* @__PURE__ */ new Set()
+    };
+    this.#byThreadId.set(threadId, created);
+    return created;
+  }
+};
+function violation(rule, reason) {
+  return { kind: "violation", rule, reason };
 }
-
-// ../provider-bridge-protocol/src/conformance/types.ts
-var CONFORMANCE_ASSEMBLED_EVENT_METHOD = "conformance/assembledEvent";
-function reportPassed(results) {
-  return results.every((result) => result.status === "pass");
+function turnIdOf(event) {
+  return "scope" in event ? getThreadEventScopeTurnId(event.scope) : void 0;
+}
+function trim(itemIds) {
+  while (itemIds.size > MAX_ITEM_IDS_PER_THREAD) {
+    const oldest = itemIds.values().next();
+    if (oldest.done === true) {
+      return;
+    }
+    itemIds.delete(oldest.value);
+  }
 }
 
 // ../provider-bridge-protocol/src/conformance/scenarios.ts
-var assembledEventNotificationSchema = z23.object({ threadId: z23.string().min(1), event: threadEventSchema }).passthrough();
+var IDENTITY_RESULT_SHAPE = "{ providerThreadId, sessionRestorable? }";
+function identityProblem(parsed, result2) {
+  return `the result must be ${IDENTITY_RESULT_SHAPE} \u2014 the runtime adopts no session without providerThreadId on the result (a thread/identity notification does not substitute for it); issues: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")} (got ${JSON.stringify(result2)})`;
+}
 function pass(id, title) {
   return { id, title, status: "pass", detail: "" };
 }
@@ -5055,17 +5264,12 @@ function defaultOptions(fixture) {
 }
 function threadEvents(context, threadId) {
   context.client.drainIntoLog();
-  const events = [];
-  for (const message of context.client.notifications(
-    CONFORMANCE_ASSEMBLED_EVENT_METHOD
-  )) {
-    const parsed = assembledEventNotificationSchema.safeParse(message.params);
-    if (parsed.success && parsed.data.threadId === threadId) {
-      events.push(parsed.data.event);
-    }
-  }
-  return events;
+  return context.client.events.filter((entry) => entry.threadId === threadId).map((entry) => entry.event);
 }
+var persistedEventSchema = z25.preprocess(
+  (event) => JSON.parse(JSON.stringify(event)),
+  threadEventSchema
+);
 function errorCode(message) {
   const code = message?.error?.code;
   return typeof code === "number" ? code : void 0;
@@ -5074,12 +5278,12 @@ var ITEM_OPENS_BEFORE_DELTA_TITLE = "every item's first event is item/started";
 function checkItemOpensBeforeDelta(events) {
   const grammar = new ThreadEventGrammar();
   for (const event of events) {
-    const result = grammar.observe(event);
-    if (result.kind === "violation" && result.rule === THREAD_EVENT_GRAMMAR_RULES.itemOpensBeforeDelta) {
+    const result2 = grammar.observe(event);
+    if (result2.kind === "violation" && result2.rule === THREAD_EVENT_GRAMMAR_RULES.itemOpensBeforeDelta) {
       return fail(
         THREAD_EVENT_GRAMMAR_RULES.itemOpensBeforeDelta,
         ITEM_OPENS_BEFORE_DELTA_TITLE,
-        result.reason
+        result2.reason
       );
     }
   }
@@ -5092,6 +5296,44 @@ function checkItemOpensBeforeDelta(events) {
   }
   return pass("item/opens-before-delta", ITEM_OPENS_BEFORE_DELTA_TITLE);
 }
+var PRESENTATION_ICONS_DECLARED_ID = "presentation/icon-namespaced-declared";
+var PRESENTATION_ICONS_DECLARED_TITLE = "every namespaced presentation glyph names one of the plugin's declared icons";
+function checkPresentationIconsDeclared(events, icons) {
+  const declared = new Set(icons.names);
+  let inspected = 0;
+  for (const event of events) {
+    if (!isThreadEventWithItem(event)) {
+      continue;
+    }
+    if (event.item.type === "toolCall" && event.item.server === "bb") {
+      continue;
+    }
+    const glyph = "presentation" in event.item ? event.item.presentation?.icon.glyph : void 0;
+    if (glyph === void 0) {
+      continue;
+    }
+    inspected += 1;
+    const parsed = parseNamespacedGlyph(glyph);
+    if (parsed === null) {
+      continue;
+    }
+    if (parsed.pluginId !== icons.pluginId || !declared.has(parsed.name)) {
+      return fail(
+        PRESENTATION_ICONS_DECLARED_ID,
+        PRESENTATION_ICONS_DECLARED_TITLE,
+        `${event.type} ${event.item.type} "${event.item.id}" names presentation.icon "${glyph}", which is not an icon declared by plugin "${icons.pluginId}" (declared: ${icons.names.length === 0 ? "none" : icons.names.join(", ")}); the server would persist it as provider/unhandled`
+      );
+    }
+  }
+  if (inspected === 0) {
+    return skipped(
+      PRESENTATION_ICONS_DECLARED_ID,
+      PRESENTATION_ICONS_DECLARED_TITLE,
+      "no item carried a presentation to inspect"
+    );
+  }
+  return pass(PRESENTATION_ICONS_DECLARED_ID, PRESENTATION_ICONS_DECLARED_TITLE);
+}
 async function runRpcHygieneScenarios(client) {
   const results = [];
   let unknownMethodsAnswered = false;
@@ -5200,29 +5442,23 @@ async function runHandshakeScenario(client) {
   });
   const response = await client.waitForResponse(id);
   const title = "initialize answers a versioned handshake with capabilities";
+  const failed = (detail) => ({
+    results: [fail("handshake/initialize", title, detail)],
+    capabilities: null
+  });
   if (response === null) {
-    return [fail("handshake/initialize", title, "no response")];
+    return failed("no response");
   }
   const parsed = initializeResultSchema.safeParse(response.result);
   if (!parsed.success) {
-    return [
-      fail(
-        "handshake/initialize",
-        title,
-        `result did not parse: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(
-          "; "
-        )} (got ${JSON.stringify(response.result ?? response.error)})`
-      )
-    ];
+    return failed(
+      `result did not parse: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")} (got ${JSON.stringify(response.result ?? response.error)})`
+    );
   }
   if (parsed.data.protocolVersion !== PROVIDER_BRIDGE_PROTOCOL_VERSION) {
-    return [
-      fail(
-        "handshake/initialize",
-        title,
-        `bridge answered protocol version ${parsed.data.protocolVersion}; this kit (and the runtime) require ${PROVIDER_BRIDGE_PROTOCOL_VERSION}`
-      )
-    ];
+    return failed(
+      `bridge answered protocol version ${parsed.data.protocolVersion}; this kit (and the runtime) require ${PROVIDER_BRIDGE_PROTOCOL_VERSION}`
+    );
   }
   const [bridgeMin, bridgeMax] = parsed.data.capabilities.grammarVersions;
   if (negotiateGrammarVersion(
@@ -5230,15 +5466,53 @@ async function runHandshakeScenario(client) {
     parsed.data.capabilities.grammarVersions
   ) === null) {
     const [runtimeMin, runtimeMax] = ASSEMBLER_GRAMMAR_VERSIONS;
+    return failed(
+      `bridge reported grammarVersions [${bridgeMin}, ${bridgeMax}]; the runtime's assembler speaks [${runtimeMin}, ${runtimeMax}], so the handshake would be refused`
+    );
+  }
+  return {
+    results: [
+      pass("handshake/initialize", title),
+      ...await runSkillsConfigureDeclaredScenario(
+        client,
+        parsed.data.capabilities.skills.configure
+      )
+    ],
+    capabilities: parsed.data.capabilities
+  };
+}
+var SKILLS_CONFIGURE_DECLARED_ID = "skills/configure-declared";
+var SKILLS_CONFIGURE_DECLARED_TITLE = "skills/configure is handled iff the handshake declares skills.configure";
+async function runSkillsConfigureDeclaredScenario(client, declared) {
+  const id = client.request(BRIDGE_REQUEST_METHODS.skillsConfigure, {
+    roots: []
+  });
+  const response = await client.waitForResponse(id);
+  if (response === null) {
     return [
       fail(
-        "handshake/initialize",
-        title,
-        `bridge reported grammarVersions [${bridgeMin}, ${bridgeMax}]; the runtime's assembler speaks [${runtimeMin}, ${runtimeMax}], so the handshake would be refused`
+        SKILLS_CONFIGURE_DECLARED_ID,
+        SKILLS_CONFIGURE_DECLARED_TITLE,
+        "skills/configure was not answered"
+      )
+    ];
+  }
+  if (declared) {
+    return response.error === void 0 ? [pass(SKILLS_CONFIGURE_DECLARED_ID, SKILLS_CONFIGURE_DECLARED_TITLE)] : [
+      fail(
+        SKILLS_CONFIGURE_DECLARED_ID,
+        SKILLS_CONFIGURE_DECLARED_TITLE,
+        `the handshake declares skills.configure but the request failed: ${JSON.stringify(response.error)}`
       )
     ];
   }
-  return [pass("handshake/initialize", title)];
+  return errorCode(response) === BRIDGE_JSON_RPC_ERRORS.METHOD_NOT_FOUND ? [pass(SKILLS_CONFIGURE_DECLARED_ID, SKILLS_CONFIGURE_DECLARED_TITLE)] : [
+    fail(
+      SKILLS_CONFIGURE_DECLARED_ID,
+      SKILLS_CONFIGURE_DECLARED_TITLE,
+      `the handshake does not declare skills.configure, yet the bridge answered the request with ${JSON.stringify(response.error ?? response.result)}; declare it (the runtime never sends an undeclared request)`
+    )
+  ];
 }
 async function runSessionLifecycleScenarios(context) {
   const { client, fixture } = context;
@@ -5270,7 +5544,7 @@ async function runSessionLifecycleScenarios(context) {
           fail(
             "session/start-identity",
             title,
-            `result did not parse: ${JSON.stringify(response.result)}`
+            identityProblem(parsed, response.result)
           )
         );
       } else {
@@ -5331,20 +5605,27 @@ async function runSessionLifecycleScenarios(context) {
     }
     {
       client.drainIntoLog();
-      const raw = client.notifications(CONFORMANCE_ASSEMBLED_EVENT_METHOD);
-      const invalid = raw.filter(
-        (message) => !assembledEventNotificationSchema.safeParse(message.params).success
+      const invalid = client.events.filter(
+        (entry) => !persistedEventSchema.safeParse(entry.event).success
       );
       const title2 = "every assembled event is a valid ThreadEvent";
       results.push(
         invalid.length === 0 ? pass("events/schema-valid", title2) : fail(
           "events/schema-valid",
           title2,
-          `${invalid.length} assembled event notification(s) failed validation; first: ${JSON.stringify(invalid[0]?.params).slice(0, 400)}`
+          `${invalid.length} assembled event(s) failed validation; first: ${JSON.stringify(invalid[0]?.event).slice(0, 400)}`
         )
       );
     }
     results.push(checkItemOpensBeforeDelta(threadEvents(context, threadId)));
+    if (fixture.icons !== void 0) {
+      results.push(
+        checkPresentationIconsDeclared(
+          threadEvents(context, threadId),
+          fixture.icons
+        )
+      );
+    }
   }
   if (context.providerThreadId === void 0) {
     results.push(
@@ -5397,13 +5678,11 @@ async function runSessionLifecycleScenarios(context) {
       results.push(pass("stop/release-not-interrupted", title));
     }
   }
+  const uniquenessTitle = "turn and item ids never repeat across a resume";
   if (context.providerThreadId === void 0) {
     results.push(
-      skipped(
-        "session/resume-id-uniqueness",
-        "turn and item ids never repeat across a resume",
-        startSkipDetail
-      )
+      skipped(RESUME_IDENTITY_ID, RESUME_IDENTITY_TITLE, startSkipDetail),
+      skipped("session/resume-id-uniqueness", uniquenessTitle, startSkipDetail)
     );
   } else {
     const resumeId = client.request(BRIDGE_REQUEST_METHODS.threadResume, {
@@ -5414,16 +5693,30 @@ async function runSessionLifecycleScenarios(context) {
       instructionMode: "append"
     });
     const resumeResponse = await client.waitForResponse(resumeId);
-    const title = "turn and item ids never repeat across a resume";
-    if (resumeResponse === null || resumeResponse.error !== void 0) {
+    const title = uniquenessTitle;
+    const resumed = resumeResponse === null || resumeResponse.error !== void 0 ? null : threadIdentityResultSchema.safeParse(resumeResponse.result);
+    if (resumed === null) {
+      const detail = resumeResponse === null ? "thread/resume was not answered" : `thread/resume failed: ${JSON.stringify(resumeResponse.error)}`;
       results.push(
+        skipped(RESUME_IDENTITY_ID, RESUME_IDENTITY_TITLE, detail),
+        skipped("session/resume-id-uniqueness", title, detail)
+      );
+    } else if (!resumed.success) {
+      results.push(
+        fail(
+          RESUME_IDENTITY_ID,
+          RESUME_IDENTITY_TITLE,
+          identityProblem(resumed, resumeResponse?.result)
+        ),
         skipped(
           "session/resume-id-uniqueness",
           title,
-          resumeResponse === null ? "thread/resume was not answered" : `thread/resume failed: ${JSON.stringify(resumeResponse.error)}`
+          "prerequisite session/resume-identity failed"
         )
       );
     } else {
+      context.providerThreadId = resumed.data.providerThreadId;
+      results.push(pass(RESUME_IDENTITY_ID, RESUME_IDENTITY_TITLE));
       const turnId = client.request(BRIDGE_REQUEST_METHODS.turnStart, {
         threadId,
         providerThreadId: context.providerThreadId,
@@ -5486,9 +5779,392 @@ async function runSessionLifecycleScenarios(context) {
       }
     }
   }
+  results.push(...await runForkIdentityScenario(context, threadId));
   results.push(...await runZeroWorkTurnScenario(context, threadId));
+  results.push(...await runArchivedResumeRecoveryScenario(context, threadId));
+  results.push(...await runThreadsIndependentScenario(context, threadId));
+  results.push(...await runInterruptStopScenario(context, threadId));
+  if (context.providerThreadId !== void 0) {
+    const releaseId = client.request(BRIDGE_REQUEST_METHODS.threadStop, {
+      threadId,
+      providerThreadId: context.providerThreadId,
+      intent: "release",
+      activeTurnId: null
+    });
+    await client.waitForResponse(releaseId);
+  }
   return results;
 }
+var RESUME_IDENTITY_ID = "session/resume-identity";
+var RESUME_IDENTITY_TITLE = "thread/resume returns a provider thread identity";
+var FORK_IDENTITY_ID = "session/fork-identity";
+var FORK_IDENTITY_TITLE = "thread/fork returns a provider thread identity for the forked session";
+async function runForkIdentityScenario(context, threadId) {
+  const { client, fixture } = context;
+  if (context.fork === "none") {
+    return [];
+  }
+  if (context.providerThreadId === void 0) {
+    return [
+      skipped(
+        FORK_IDENTITY_ID,
+        FORK_IDENTITY_TITLE,
+        "prerequisite session/start-identity failed"
+      )
+    ];
+  }
+  const forkThreadId = `${threadId}_fork`;
+  const forkId = client.request(BRIDGE_REQUEST_METHODS.threadFork, {
+    threadId: forkThreadId,
+    cwd: fixture.cwd,
+    sourceProviderThreadId: context.providerThreadId,
+    options: defaultOptions(fixture),
+    instructionMode: "append"
+  });
+  const response = await client.waitForResponse(forkId);
+  if (response === null) {
+    return [
+      fail(FORK_IDENTITY_ID, FORK_IDENTITY_TITLE, "thread/fork was not answered")
+    ];
+  }
+  if (response.error !== void 0) {
+    return [
+      fail(
+        FORK_IDENTITY_ID,
+        FORK_IDENTITY_TITLE,
+        `the handshake declares fork "${context.fork}", yet forking the lifecycle session at its tip failed: ${JSON.stringify(response.error)}`
+      )
+    ];
+  }
+  const parsed = threadIdentityResultSchema.safeParse(response.result);
+  if (!parsed.success) {
+    return [
+      fail(
+        FORK_IDENTITY_ID,
+        FORK_IDENTITY_TITLE,
+        identityProblem(parsed, response.result)
+      )
+    ];
+  }
+  const releaseId = client.request(BRIDGE_REQUEST_METHODS.threadStop, {
+    threadId: forkThreadId,
+    providerThreadId: parsed.data.providerThreadId,
+    intent: "release",
+    activeTurnId: null
+  });
+  await client.waitForResponse(releaseId);
+  return [pass(FORK_IDENTITY_ID, FORK_IDENTITY_TITLE)];
+}
+var THREADS_INDEPENDENT_ID = "session/threads-independent";
+var THREADS_INDEPENDENT_TITLE = "requests on different threads are independent";
+async function runThreadsIndependentScenario(context, threadId) {
+  const { client, fixture } = context;
+  const interruptiblePromptInput = fixture.interruptiblePromptInput;
+  if (interruptiblePromptInput === void 0) {
+    return [];
+  }
+  if (context.providerThreadId === void 0) {
+    return [
+      skipped(
+        THREADS_INDEPENDENT_ID,
+        THREADS_INDEPENDENT_TITLE,
+        "prerequisite session/start-identity failed"
+      )
+    ];
+  }
+  const startedBefore = threadEvents(context, threadId).filter(
+    (event) => event.type === "turn/started"
+  ).length;
+  const holdId = client.request(BRIDGE_REQUEST_METHODS.turnStart, {
+    threadId,
+    providerThreadId: context.providerThreadId,
+    input: interruptiblePromptInput,
+    clientRequestId: nextConformanceClientRequestId(),
+    options: defaultOptions(fixture)
+  });
+  const held = await client.waitFor(() => {
+    const starts = threadEvents(context, threadId).filter(
+      (event) => event.type === "turn/started"
+    );
+    return starts.length > startedBefore ? starts[startedBefore] : void 0;
+  });
+  await client.waitForResponse(holdId);
+  if (held === null) {
+    return [
+      fail(
+        THREADS_INDEPENDENT_ID,
+        THREADS_INDEPENDENT_TITLE,
+        "the interruptible prompt never opened a turn"
+      )
+    ];
+  }
+  const otherThreadId = `${threadId}_other`;
+  const startId = client.request(BRIDGE_REQUEST_METHODS.threadStart, {
+    threadId: otherThreadId,
+    cwd: fixture.cwd,
+    options: defaultOptions(fixture),
+    instructionMode: "append"
+  });
+  const startResponse = await client.waitForResponse(startId);
+  const startResult = threadIdentityResultSchema.safeParse(
+    startResponse?.result
+  );
+  if (startResponse === null || !startResult.success) {
+    return [
+      fail(
+        THREADS_INDEPENDENT_ID,
+        THREADS_INDEPENDENT_TITLE,
+        `the second thread did not start while the first held a turn: ${JSON.stringify(startResponse?.error ?? startResponse?.result)}`
+      )
+    ];
+  }
+  const turnId = client.request(BRIDGE_REQUEST_METHODS.turnStart, {
+    threadId: otherThreadId,
+    providerThreadId: startResult.data.providerThreadId,
+    input: fixture.promptInput,
+    clientRequestId: nextConformanceClientRequestId(),
+    options: defaultOptions(fixture)
+  });
+  const completed = await client.waitFor(
+    () => threadEvents(context, otherThreadId).find(
+      (event) => event.type === "turn/completed"
+    )
+  );
+  await client.waitForResponse(turnId);
+  const stopId = client.request(BRIDGE_REQUEST_METHODS.threadStop, {
+    threadId: otherThreadId,
+    providerThreadId: startResult.data.providerThreadId,
+    intent: "release",
+    activeTurnId: null
+  });
+  await client.waitForResponse(stopId);
+  if (completed === null) {
+    return [
+      fail(
+        THREADS_INDEPENDENT_ID,
+        THREADS_INDEPENDENT_TITLE,
+        "the second thread's turn never completed while the first thread held a turn"
+      )
+    ];
+  }
+  const firstStillOpen = !threadEvents(context, threadId).some(
+    (event) => event.type === "turn/completed" && getThreadEventScopeTurnId(event.scope) === getThreadEventScopeTurnId(held.scope)
+  );
+  if (!firstStillOpen) {
+    return [
+      fail(
+        THREADS_INDEPENDENT_ID,
+        THREADS_INDEPENDENT_TITLE,
+        "the held turn on the first thread settled while the second thread ran"
+      )
+    ];
+  }
+  return [pass(THREADS_INDEPENDENT_ID, THREADS_INDEPENDENT_TITLE)];
+}
+var INTERRUPT_SETTLES_ID = "stop/interrupt-settles-before-result";
+var INTERRUPT_SETTLES_TITLE = "thread/stop {interrupt} settles the turn before it is answered";
+async function runInterruptStopScenario(context, threadId) {
+  const { client, fixture } = context;
+  const interruptiblePromptInput = fixture.interruptiblePromptInput;
+  if (interruptiblePromptInput === void 0) {
+    return [];
+  }
+  if (context.providerThreadId === void 0) {
+    return [
+      skipped(
+        INTERRUPT_SETTLES_ID,
+        INTERRUPT_SETTLES_TITLE,
+        "prerequisite session/start-identity failed"
+      )
+    ];
+  }
+  let started = openTurnStart(context, threadId);
+  if (started === void 0) {
+    const startedBefore = threadEvents(context, threadId).filter(
+      (event) => event.type === "turn/started"
+    ).length;
+    const turnRequestId = client.request(BRIDGE_REQUEST_METHODS.turnStart, {
+      threadId,
+      providerThreadId: context.providerThreadId,
+      input: interruptiblePromptInput,
+      clientRequestId: nextConformanceClientRequestId(),
+      options: defaultOptions(fixture)
+    });
+    started = await client.waitFor(() => {
+      const starts = threadEvents(context, threadId).filter(
+        (event) => event.type === "turn/started"
+      );
+      return starts.length > startedBefore ? starts[startedBefore] : void 0;
+    }) ?? void 0;
+    await client.waitForResponse(turnRequestId);
+  }
+  if (started === void 0 || started.scope.kind !== "turn") {
+    return [
+      fail(
+        INTERRUPT_SETTLES_ID,
+        INTERRUPT_SETTLES_TITLE,
+        "the interruptible prompt never opened a turn"
+      )
+    ];
+  }
+  const bbTurnId = started.scope.turnId;
+  const providerTurnId = context.resolveProviderTurnId(threadId, bbTurnId) ?? bbTurnId;
+  const stopId = client.request(BRIDGE_REQUEST_METHODS.threadStop, {
+    threadId,
+    providerThreadId: context.providerThreadId,
+    intent: "interrupt",
+    activeTurnId: providerTurnId
+  });
+  const stopResponse = await client.waitForResponse(stopId);
+  if (stopResponse === null) {
+    return [
+      fail(INTERRUPT_SETTLES_ID, INTERRUPT_SETTLES_TITLE, "thread/stop was not answered")
+    ];
+  }
+  if (stopResponse.error !== void 0) {
+    return [
+      fail(
+        INTERRUPT_SETTLES_ID,
+        INTERRUPT_SETTLES_TITLE,
+        `thread/stop failed: ${JSON.stringify(stopResponse.error)}`
+      )
+    ];
+  }
+  const responseIndex = client.log.indexOf(stopResponse);
+  const completedIndex = client.events.find(
+    (entry) => entry.threadId === threadId && entry.event.type === "turn/completed" && getThreadEventScopeTurnId(entry.event.scope) === bbTurnId
+  )?.logIndex ?? -1;
+  if (completedIndex === -1) {
+    return [
+      fail(
+        INTERRUPT_SETTLES_ID,
+        INTERRUPT_SETTLES_TITLE,
+        "the interrupted turn never reached turn/completed"
+      )
+    ];
+  }
+  if (completedIndex > responseIndex) {
+    return [
+      fail(
+        INTERRUPT_SETTLES_ID,
+        INTERRUPT_SETTLES_TITLE,
+        "turn/completed arrived after the thread/stop response; the runtime had already detached the thread"
+      )
+    ];
+  }
+  return [pass(INTERRUPT_SETTLES_ID, INTERRUPT_SETTLES_TITLE)];
+}
+var SESSION_ARCHIVED_RECOVERY_ID = "recovery/session-archived";
+var SESSION_ARCHIVED_RECOVERY_TITLE = "resuming an archived session is rejected with a sessionArchived hint";
+async function runArchivedResumeRecoveryScenario(context, threadId) {
+  const { client, fixture } = context;
+  const providerThreadId = context.providerThreadId;
+  if (providerThreadId === void 0) {
+    return [
+      skipped(
+        SESSION_ARCHIVED_RECOVERY_ID,
+        SESSION_ARCHIVED_RECOVERY_TITLE,
+        "prerequisite session/start-identity failed"
+      )
+    ];
+  }
+  const archiveId = client.request(BRIDGE_REQUEST_METHODS.threadArchive, {
+    threadId,
+    providerThreadId
+  });
+  const archiveResponse = await client.waitForResponse(archiveId);
+  if (archiveResponse === null) {
+    return [
+      fail(
+        SESSION_ARCHIVED_RECOVERY_ID,
+        SESSION_ARCHIVED_RECOVERY_TITLE,
+        "thread/archive was not answered"
+      )
+    ];
+  }
+  if (archiveResponse.error !== void 0) {
+    return [];
+  }
+  const resumeParams = {
+    threadId,
+    cwd: fixture.cwd,
+    providerThreadId,
+    options: defaultOptions(fixture),
+    instructionMode: "append"
+  };
+  const resumeId = client.request(
+    BRIDGE_REQUEST_METHODS.threadResume,
+    resumeParams
+  );
+  const resumeResponse = await client.waitForResponse(resumeId);
+  const unarchiveId = client.request(BRIDGE_REQUEST_METHODS.threadUnarchive, {
+    threadId,
+    providerThreadId
+  });
+  await client.waitForResponse(unarchiveId);
+  if (resumeResponse === null) {
+    return [
+      fail(
+        SESSION_ARCHIVED_RECOVERY_ID,
+        SESSION_ARCHIVED_RECOVERY_TITLE,
+        "thread/resume of the archived session was not answered"
+      )
+    ];
+  }
+  if (resumeResponse.error === void 0) {
+    const resumed = threadIdentityResultSchema.safeParse(resumeResponse.result);
+    if (!resumed.success) {
+      return [
+        fail(
+          SESSION_ARCHIVED_RECOVERY_ID,
+          SESSION_ARCHIVED_RECOVERY_TITLE,
+          `the archived session was resumed with a result the runtime cannot adopt: ${identityProblem(resumed, resumeResponse.result)}`
+        )
+      ];
+    }
+    context.providerThreadId = resumed.data.providerThreadId;
+    return [];
+  }
+  const reResumeId = client.request(
+    BRIDGE_REQUEST_METHODS.threadResume,
+    resumeParams
+  );
+  const reResumeResponse = await client.waitForResponse(reResumeId);
+  const data = bridgeErrorDataSchema.safeParse(resumeResponse.error.data);
+  const kind = data.success ? data.data.recovery?.kind : void 0;
+  if (kind !== "sessionArchived") {
+    return [
+      fail(
+        SESSION_ARCHIVED_RECOVERY_ID,
+        SESSION_ARCHIVED_RECOVERY_TITLE,
+        `the rejection carried ${kind === void 0 ? "no recovery hint" : `kind "${kind}"`}: ${JSON.stringify(resumeResponse.error)}`
+      )
+    ];
+  }
+  const notBack = (detail) => [
+    fail(
+      SESSION_ARCHIVED_RECOVERY_ID,
+      SESSION_ARCHIVED_RECOVERY_TITLE,
+      `the session did not come back: ${detail}`
+    )
+  ];
+  if (reResumeResponse === null) {
+    return notBack("thread/resume after thread/unarchive was not answered");
+  }
+  if (reResumeResponse.error !== void 0) {
+    return notBack(
+      `thread/resume after thread/unarchive failed: ${JSON.stringify(reResumeResponse.error)}`
+    );
+  }
+  const reResumed = threadIdentityResultSchema.safeParse(
+    reResumeResponse.result
+  );
+  if (!reResumed.success) {
+    return notBack(identityProblem(reResumed, reResumeResponse.result));
+  }
+  context.providerThreadId = reResumed.data.providerThreadId;
+  return [pass(SESSION_ARCHIVED_RECOVERY_ID, SESSION_ARCHIVED_RECOVERY_TITLE)];
+}
 var SETTLES_WITHOUT_ACTIVITY_ID = "turn/settles-without-activity";
 var SETTLES_WITHOUT_ACTIVITY_TITLE = "a turn the provider completes without activity still settles";
 async function runZeroWorkTurnScenario(context, threadId) {
@@ -5543,20 +6219,127 @@ async function runZeroWorkTurnScenario(context, threadId) {
   }
   return [pass(SETTLES_WITHOUT_ACTIVITY_ID, SETTLES_WITHOUT_ACTIVITY_TITLE)];
 }
+function openTurnStart(context, threadId) {
+  const events = threadEvents(context, threadId);
+  const completedTurnIds = new Set(
+    events.filter((event) => event.type === "turn/completed").map((event) => getThreadEventScopeTurnId(event.scope))
+  );
+  return [...events].reverse().find(
+    (event) => event.type === "turn/started" && !completedTurnIds.has(getThreadEventScopeTurnId(event.scope))
+  );
+}
+
+// ../provider-bridge-protocol/src/conformance/recorded.ts
+var RECORDED_CONFORMANCE_CELLS = [
+  "turn-tools",
+  "steer",
+  "stop-interrupt",
+  "approval-allow",
+  "approval-deny",
+  "user-question",
+  "resume",
+  "fork"
+];
+function result(id, title, detail) {
+  return detail === null ? { id, title, status: "pass", detail: "" } : { id, title, status: "fail", detail };
+}
+function countTurns(events) {
+  let started = 0;
+  let completed = 0;
+  for (const event of events) {
+    if (event.type === "turn/started") started += 1;
+    if (event.type === "turn/completed") completed += 1;
+  }
+  return { started, completed };
+}
+function checkRecordedCellReplay(replay) {
+  const prefix = `recorded/${replay.cell}`;
+  const results = [];
+  const recordedTurns = countTurns(replay.recordedEvents);
+  const liveTurns = countTurns(replay.events);
+  results.push(
+    result(
+      `${prefix}/replays`,
+      "the bridge answers every recorded runtime request and the replay needs no help",
+      replay.stalls.length === 0 ? null : replay.stalls.join("; ")
+    )
+  );
+  results.push(
+    result(
+      `${prefix}/events-schema-valid`,
+      "every assembled event is a valid ThreadEvent",
+      (() => {
+        for (const [index, event] of replay.events.entries()) {
+          const parsed = threadEventSchema.safeParse(event);
+          if (!parsed.success) {
+            return `event ${index} (${event.type}) failed: ${parsed.error.issues[0]?.message ?? "invalid"}`;
+          }
+        }
+        return null;
+      })()
+    )
+  );
+  results.push(
+    result(
+      `${prefix}/grammar`,
+      "the event stream breaks no thread-event grammar rule",
+      (() => {
+        const grammar = new ThreadEventGrammar();
+        for (const event of replay.events) {
+          const verdict = grammar.observe(event);
+          if (verdict.kind === "violation") {
+            return `${verdict.rule} on ${event.type}: ${verdict.reason}`;
+          }
+        }
+        return null;
+      })()
+    )
+  );
+  results.push(
+    result(
+      `${prefix}/turn-lifecycle`,
+      "the replay opens and settles as many turns as the recording did",
+      liveTurns.started === recordedTurns.started && liveTurns.completed === recordedTurns.completed && liveTurns.started === liveTurns.completed ? null : `replay ${liveTurns.started} started/${liveTurns.completed} completed, recording ${recordedTurns.started}/${recordedTurns.completed}`
+    )
+  );
+  results.push(
+    result(
+      `${prefix}/not-empty`,
+      "a recorded session that produced events still does",
+      replay.recordedEvents.length === 0 || replay.events.length > 0 ? null : `the recording assembled ${replay.recordedEvents.length} events, the replay none`
+    )
+  );
+  return results;
+}
+
+// ../provider-bridge-protocol/src/conformance/types.ts
+var CONFORMANCE_ASSEMBLED_EVENT_METHOD = "conformance/assembledEvent";
+function reportPassed(results) {
+  return results.every((result2) => result2.status === "pass");
+}
 
 // ../provider-bridge-protocol/src/conformance/index.ts
 async function runBridgeConformance(options) {
+  const collector = createBridgeDeltaEventCollector(options.providerId);
   const client = new ConformanceClient(
     options.transport,
-    options.timeoutMs ?? 5e3
+    options.timeoutMs ?? 5e3,
+    collector
   );
   const results = [];
   results.push(...await runRpcHygieneScenarios(client));
-  results.push(...await runHandshakeScenario(client));
+  const handshake = await runHandshakeScenario(client);
+  results.push(...handshake.results);
   results.push(
     ...await runSessionLifecycleScenarios({
       client,
-      fixture: options.session
+      fixture: options.session,
+      // The same reverse mapping the runtime applies when it names a turn
+      // to the bridge: the assembler's provider↔bb turn-id map.
+      resolveProviderTurnId: (threadId, bbTurnId) => collector.assembler.getProviderTurnId(threadId, bbTurnId),
+      // A failed handshake reads as the definite absences the schema
+      // defaults to: no fork, so the fork rule is not attempted.
+      fork: handshake.capabilities?.fork ?? "none"
     })
   );
   await options.transport.close?.();
@@ -5564,36 +6347,36 @@ async function runBridgeConformance(options) {
 }
 function formatConformanceReport(report) {
   return report.results.map(
-    (result) => `${result.status.padEnd(7)} ${result.id}${result.detail === "" ? "" : ` \u2014 ${result.detail}`}`
+    (result2) => `${result2.status.padEnd(7)} ${result2.id}${result2.detail === "" ? "" : ` \u2014 ${result2.detail}`}`
   ).join("\n");
 }
 
 // ../provider-bridge-protocol/src/testing/bridge-json-rpc-test-helpers.ts
-import { z as z24 } from "zod";
-var bridgeJsonRpcValueSchema = z24.lazy(
-  () => z24.union([
-    z24.string(),
-    z24.number(),
-    z24.boolean(),
-    z24.null(),
-    z24.array(bridgeJsonRpcValueSchema),
-    z24.record(z24.string(), bridgeJsonRpcValueSchema)
+import { z as z26 } from "zod";
+var bridgeJsonRpcValueSchema = z26.lazy(
+  () => z26.union([
+    z26.string(),
+    z26.number(),
+    z26.boolean(),
+    z26.null(),
+    z26.array(bridgeJsonRpcValueSchema),
+    z26.record(z26.string(), bridgeJsonRpcValueSchema)
   ])
 );
-var bridgeJsonRpcOutputSchema = z24.object({
-  jsonrpc: z24.literal("2.0"),
-  id: z24.union([z24.string(), z24.number()]).optional(),
-  method: z24.string().optional(),
+var bridgeJsonRpcOutputSchema = z26.object({
+  jsonrpc: z26.literal("2.0"),
+  id: z26.union([z26.string(), z26.number()]).optional(),
+  method: z26.string().optional(),
   params: bridgeJsonRpcValueSchema.optional(),
   result: bridgeJsonRpcValueSchema.optional(),
-  error: z24.object({
-    code: z24.number(),
-    message: z24.string(),
+  error: z26.object({
+    code: z26.number(),
+    message: z26.string(),
     data: bridgeJsonRpcValueSchema.optional()
   }).optional()
 });
 function waitForNextBridgeTick() {
-  return new Promise((resolve2) => setTimeout(resolve2, 0));
+  return new Promise((resolve3) => setTimeout(resolve3, 0));
 }
 function captureBridgeJsonRpcOutput() {
   const messages = [];
@@ -5608,8 +6391,14 @@ function captureBridgeJsonRpcOutput() {
     return true;
   };
   process.stdout.write = capturingWrite;
+  let drained = 0;
   return {
     messages,
+    takeMessages() {
+      const fresh = messages.slice(drained);
+      drained = messages.length;
+      return fresh;
+    },
     restore() {
       if (process.stdout.write === capturingWrite) {
         process.stdout.write = originalWrite;
@@ -5647,6 +6436,7 @@ function createBridgeJsonRpcTestHarness(handleLine) {
   const output = captureBridgeJsonRpcOutput();
   return {
     messages: output.messages,
+    takeMessages: output.takeMessages,
     flushWork: waitForNextBridgeTick,
     hasResponse(id) {
       return bridgeJsonRpcResponseExists({ id, output });
@@ -5663,49 +6453,6 @@ function createBridgeJsonRpcTestHarness(handleLine) {
   };
 }
 
-// ../provider-bridge-protocol/src/testing/bridge-delta-assembly.ts
-function createBridgeDeltaEventCollector(providerId = "pi") {
-  const assembler = createDeltaAssembler({ providerId, textDeltaFlushMs: 0 });
-  return {
-    assembler,
-    assembleMessage(message) {
-      if (message.method !== THREAD_DELTA_NOTIFICATION_METHOD) {
-        return [];
-      }
-      const parsed = threadDeltaNotificationParamsSchema.safeParse(
-        message.params
-      );
-      if (!parsed.success) {
-        throw new Error(
-          `Invalid thread/delta notification: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(
-            "; "
-          )} (params: ${JSON.stringify(message.params)?.slice(0, 400)})`
-        );
-      }
-      return assembler.assemble({
-        threadId: parsed.data.threadId,
-        deltas: parsed.data.deltas
-      });
-    }
-  };
-}
-function assembleCapturedThreadEvents(messages, providerId = "pi") {
-  const collector = createBridgeDeltaEventCollector(providerId);
-  return messages.flatMap((message) => collector.assembleMessage(message));
-}
-function toConformanceMessages(message, collector) {
-  if (message.method !== THREAD_DELTA_NOTIFICATION_METHOD) {
-    return [message];
-  }
-  const threadId = typeof message.params?.threadId === "string" ? message.params.threadId : "";
-  return collector.assembleMessage(message).map((event) => ({
-    jsonrpc: "2.0",
-    method: CONFORMANCE_ASSEMBLED_EVENT_METHOD,
-    // ThreadEvents are JSON data; the capture type demands JsonValue.
-    params: JSON.parse(JSON.stringify({ threadId, event }))
-  }));
-}
-
 // ../provider-bridge-protocol/src/testing/calibration-diff.ts
 var DEFAULT_INTERNED_ID_FIELDS = [
   "turnId",
@@ -5760,6 +6507,38 @@ function normalizeCalibrationEvents(events, options = {}) {
   const list = Array.isArray(wireShaped) ? wireShaped : [];
   return list.map((event) => normalizeValue(event, interner, idFields));
 }
+function diffCalibrationStreams(legacy, bridge) {
+  const left = legacy.map((event) => JSON.stringify(event));
+  const right = bridge.map((event) => JSON.stringify(event));
+  const lengths = Array.from(
+    { length: left.length + 1 },
+    () => new Array(right.length + 1).fill(0)
+  );
+  for (let i2 = left.length - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = right.length - 1; j2 >= 0; j2 -= 1) {
+      lengths[i2][j2] = left[i2] === right[j2] ? lengths[i2 + 1][j2 + 1] + 1 : Math.max(lengths[i2 + 1][j2], lengths[i2][j2 + 1]);
+    }
+  }
+  const onlyInLegacy = [];
+  const onlyInBridge = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (left[i] === right[j]) {
+      i += 1;
+      j += 1;
+    } else if (lengths[i + 1][j] >= lengths[i][j + 1]) {
+      onlyInLegacy.push(legacy[i]);
+      i += 1;
+    } else {
+      onlyInBridge.push(bridge[j]);
+      j += 1;
+    }
+  }
+  onlyInLegacy.push(...legacy.slice(i));
+  onlyInBridge.push(...bridge.slice(j));
+  return { onlyInLegacy, onlyInBridge };
+}
 function describeCalibrationEvents(events) {
   return events.map((event) => {
     if (event === null || typeof event !== "object") {
@@ -5776,35 +6555,840 @@ function describeCalibrationEvents(events) {
 }
 
 // ../provider-bridge-protocol/src/testing/parity.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join as join2, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../provider-bridge-protocol/src/bridge-kit/bounded-line-reader.ts
+import { StringDecoder } from "node:string_decoder";
 var MAX_JSON_RPC_LINE_BYTES = 64 * 1024 * 1024;
+function readBoundedLines(args) {
+  const maxLineBytes = args.maxLineBytes ?? MAX_JSON_RPC_LINE_BYTES;
+  const decoder = new StringDecoder("utf8");
+  let pending = "";
+  let discarding = false;
+  let discardedBytes = 0;
+  args.input.on("data", (chunk) => {
+    const text = typeof chunk === "string" ? chunk : decoder.write(chunk);
+    let start = 0;
+    for (; ; ) {
+      const newlineIndex = text.indexOf("\n", start);
+      if (newlineIndex === -1) {
+        break;
+      }
+      if (discarding) {
+        discarding = false;
+        args.onOverflow(discardedBytes);
+        discardedBytes = 0;
+      } else {
+        emit(pending + text.slice(start, newlineIndex));
+      }
+      pending = "";
+      start = newlineIndex + 1;
+    }
+    const tail = text.slice(start);
+    if (discarding) {
+      discardedBytes += Buffer.byteLength(tail);
+      return;
+    }
+    pending += tail;
+    if (Buffer.byteLength(pending) > maxLineBytes) {
+      discarding = true;
+      discardedBytes = Buffer.byteLength(pending);
+      pending = "";
+    }
+  });
+  args.input.on("end", () => {
+    if (!discarding && pending.length > 0) {
+      emit(pending);
+    }
+    pending = "";
+    args.onClose?.();
+  });
+  function emit(line) {
+    args.onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+  }
+}
 
 // ../provider-bridge-protocol/src/testing/recording.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+
+// ../provider-bridge-protocol/src/bridge-kit/bridge-recorder.ts
+var BRIDGE_RECORDING_DIRECTIONS = [
+  "runtime\u2192bridge",
+  "bridge\u2192runtime",
+  "provider\u2192bridge",
+  "bridge\u2192provider"
+];
+function bridgeRecordingFileName(direction) {
+  return `${direction}.ndjson`;
+}
+
+// ../provider-bridge-protocol/src/testing/recording.ts
 var COMMITTED_RECORDINGS_ROOT = fileURLToPath(
   new URL("../../recordings", import.meta.url)
 );
 var RECORDINGS_CHECKOUT_ROOT = resolve(COMMITTED_RECORDINGS_ROOT, "../../..");
+function compareRecordingEntries(left, right) {
+  return left.run - right.run || left.seq - right.seq;
+}
+function parseEntry(raw, file, lineNumber) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `${file}:${lineNumber}: not JSON (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.line !== "string" || typeof parsed.seq !== "number" || typeof parsed.dir !== "string") {
+    throw new Error(`${file}:${lineNumber}: not a recording entry`);
+  }
+  const entry = parsed;
+  return { ...entry, run: typeof entry.run === "number" ? entry.run : 0 };
+}
+function readBridgeRecordingLane(dir, direction) {
+  const file = join(dir, bridgeRecordingFileName(direction));
+  if (!existsSync(file)) {
+    return [];
+  }
+  const entries = [];
+  const lines = readFileSync(file, "utf8").split("\n");
+  for (const [index, raw] of lines.entries()) {
+    if (raw.length === 0) continue;
+    const entry = parseEntry(raw, file, index + 1);
+    if (entry.dir !== direction) {
+      throw new Error(`${file}:${index + 1}: entry direction ${entry.dir} in the ${direction} lane`);
+    }
+    entries.push(entry);
+  }
+  return entries;
+}
+var CURRENT_BRIDGE_LANE_FILE = "bridge\u2192runtime.current.ndjson";
+function readCurrentBridgeLane(dir) {
+  const file = join(dir, CURRENT_BRIDGE_LANE_FILE);
+  if (!existsSync(file)) {
+    return null;
+  }
+  const entries = [];
+  const lines = readFileSync(file, "utf8").split("\n");
+  for (const [index, raw] of lines.entries()) {
+    if (raw.length === 0) continue;
+    const entry = parseEntry(raw, file, index + 1);
+    if (entry.dir !== "bridge\u2192runtime") {
+      throw new Error(`${file}:${index + 1}: entry direction ${entry.dir} in the current bridge lane`);
+    }
+    entries.push(entry);
+  }
+  return entries;
+}
+function withCurrentBridgeLane(recording) {
+  const current = readCurrentBridgeLane(recording.dir);
+  if (current === null) {
+    return recording;
+  }
+  const entries = [
+    ...recording.entries.filter((entry) => entry.dir !== "bridge\u2192runtime"),
+    ...current
+  ];
+  entries.sort(compareRecordingEntries);
+  return { ...recording, entries };
+}
+function readBridgeRecording(dir) {
+  const manifestPath = join(dir, "manifest.json");
+  const manifest = existsSync(manifestPath) ? JSON.parse(readFileSync(manifestPath, "utf8")) : null;
+  const entries = [];
+  for (const direction of BRIDGE_RECORDING_DIRECTIONS) {
+    entries.push(...readBridgeRecordingLane(dir, direction));
+  }
+  entries.sort(compareRecordingEntries);
+  return { dir, manifest, entries };
+}
+function listRecordedCells(root) {
+  const cells = [];
+  if (!existsSync(root)) {
+    return cells;
+  }
+  for (const provider of readdirSync(root).sort()) {
+    const providerDir = join(root, provider);
+    if (!statSync(providerDir).isDirectory()) continue;
+    for (const cell of readdirSync(providerDir).sort()) {
+      const dir = join(providerDir, cell);
+      if (!statSync(dir).isDirectory()) continue;
+      const hasLane = BRIDGE_RECORDING_DIRECTIONS.some(
+        (direction) => existsSync(join(dir, bridgeRecordingFileName(direction)))
+      );
+      if (hasLane) {
+        cells.push({ provider, cell, dir });
+      }
+    }
+  }
+  return cells;
+}
 
 // ../provider-bridge-protocol/src/testing/parity.ts
+var SOURCE_BOOTSTRAP = fileURLToPath2(new URL("../bridge-worker-entry.ts", import.meta.url));
+var BUNDLED_BOOTSTRAP = fileURLToPath2(new URL("./provider-bridge-worker-entry.mjs", import.meta.url));
+function resolveProviderBridgeBootstrapPath() {
+  if (existsSync2(SOURCE_BOOTSTRAP)) return SOURCE_BOOTSTRAP;
+  if (existsSync2(BUNDLED_BOOTSTRAP)) return BUNDLED_BOOTSTRAP;
+  throw new Error(
+    `provider-bridge bootstrap not found at ${SOURCE_BOOTSTRAP} or ${BUNDLED_BOOTSTRAP}`
+  );
+}
+function isTypeScriptPath(path) {
+  return /\.[cm]?tsx?$/u.test(path);
+}
+function tsxSpecifier() {
+  return import.meta.resolve("tsx");
+}
+function defaultNodeArgs(bootstrapPath, modulePath) {
+  if (isTypeScriptPath(bootstrapPath)) {
+    return ["--conditions=source", "--import", tsxSpecifier()];
+  }
+  return isTypeScriptPath(modulePath) ? ["--import", tsxSpecifier()] : [];
+}
+function resolveProviderBridgeLaunch(options) {
+  if (!isAbsolute(options.modulePath)) {
+    throw new Error(`bridge module path must be absolute: ${options.modulePath}`);
+  }
+  const bootstrapPath = options.bootstrapPath ?? resolveProviderBridgeBootstrapPath();
+  const dataDir = options.dataDir ?? mkdtempSync(join2(tmpdir(), "bb-parity-data-"));
+  return {
+    command: process.execPath,
+    args: [
+      ...options.nodeArgs ?? defaultNodeArgs(bootstrapPath, options.modulePath),
+      bootstrapPath,
+      options.modulePath,
+      options.pluginId,
+      dataDir
+    ],
+    cwd: options.cwd ?? process.cwd(),
+    env: {}
+  };
+}
+var DEFAULT_REPLAY_PROFILE = {
+  dialect: "json-rpc",
+  env: () => ({})
+};
+function rewriteRecordedMachineFacts(line, workspaceDir) {
+  if (!line.includes('"PATH"') && !line.includes('"cwd"')) {
+    return line;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return line;
+  }
+  const params = parsed.params;
+  if (params === void 0) {
+    return line;
+  }
+  let changed = false;
+  const envVars = params.options?.envVars;
+  if (envVars !== void 0 && typeof envVars.PATH === "string") {
+    envVars.PATH = process.env.PATH ?? envVars.PATH;
+    changed = true;
+  }
+  if (typeof params.cwd === "string") {
+    params.cwd = workspaceDir;
+    changed = true;
+  }
+  return changed ? JSON.stringify(parsed) : line;
+}
+function recordedWorkspaceDir(recording) {
+  for (const entry of recording.entries) {
+    if (entry.dir !== "runtime\u2192bridge") continue;
+    const message = parseWire(entry.line);
+    const cwd = message?.params?.cwd;
+    if (typeof cwd === "string" && cwd.length > 0) return cwd;
+  }
+  return null;
+}
+function parseWire(line) {
+  try {
+    const parsed = JSON.parse(line);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isRequest(message) {
+  return message.id !== void 0 && typeof message.method === "string";
+}
+function isResponse(message) {
+  return message.id !== void 0 && message.method === void 0;
+}
+function countTurnBoundaries(events) {
+  let started = 0;
+  let completed = 0;
+  for (const event of events) {
+    if (event.type === "turn/started") started += 1;
+    if (event.type === "turn/completed") completed += 1;
+  }
+  return { started, completed };
+}
+function planRuntimeSteps(recording, assembler) {
+  const steps = [];
+  const assembled = [];
+  for (const entry of recording.entries) {
+    if (entry.dir === "bridge\u2192runtime") {
+      const message = parseWire(entry.line);
+      if (message !== null && message.method === THREAD_DELTA_NOTIFICATION_METHOD) {
+        try {
+          assembled.push(...assembler.assembleMessage(message));
+        } catch {
+        }
+      }
+      continue;
+    }
+    if (entry.dir !== "runtime\u2192bridge") {
+      continue;
+    }
+    steps.push({
+      entry,
+      message: parseWire(entry.line),
+      gate: countTurnBoundaries(assembled),
+      eventsBefore: assembled.length
+    });
+  }
+  return steps;
+}
+function methodOfRecordedBridgeRequest(recording, response, id) {
+  for (const entry of recording.entries) {
+    if (entry.dir !== "bridge\u2192runtime" || entry.run !== response.run) continue;
+    const message = parseWire(entry.line);
+    if (message !== null && isRequest(message) && String(message.id) === String(id)) {
+      return message.method;
+    }
+  }
+  return void 0;
+}
 var REPLAY_CHILD_PATH = fileURLToPath2(new URL("./replay-provider-child.mjs", import.meta.url));
+var PARITY_INITIALIZE_ID = "parity-initialize";
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+async function replayRecording(options) {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const orderTimeoutMs = options.orderTimeoutMs ?? 5e3;
+  const settleMs = options.settleMs ?? 750;
+  const drainMs = options.drainMs ?? 300;
+  const providerId = options.providerId;
+  const profile = options.profile ?? DEFAULT_REPLAY_PROFILE;
+  const recording = readBridgeRecording(options.recordingDir);
+  const stateDir = mkdtempSync(join2(tmpdir(), "bb-parity-replay-"));
+  const workspaceDir = mkdtempSync(join2(tmpdir(), "bb-parity-ws-"));
+  const replayCommand = [
+    process.execPath,
+    REPLAY_CHILD_PATH,
+    "--recording",
+    resolve2(options.recordingDir),
+    "--dialect",
+    profile.dialect,
+    "--state",
+    stateDir
+  ];
+  const cursorPath = join2(stateDir, "cursor");
+  const setCursor = (position) => {
+    writeFileSync(
+      cursorPath,
+      position === "end" ? "end" : `${position.run} ${position.seq}`
+    );
+  };
+  const wrapperPath = join2(stateDir, "replay-provider.mjs");
+  writeFileSync(
+    wrapperPath,
+    [
+      "#!/usr/bin/env node",
+      `process.argv.splice(2, 0, ${JSON.stringify(replayCommand.slice(2)).slice(1, -1)});`,
+      `await import(${JSON.stringify(REPLAY_CHILD_PATH)});`,
+      ""
+    ].join("\n"),
+    { mode: 493 }
+  );
+  profile.prepareState?.({ recording, stateDir, workspaceDir });
+  const launch = options.bridge;
+  const child = spawn(launch.command, launch.args, {
+    cwd: launch.cwd,
+    env: {
+      ...process.env,
+      ...launch.env,
+      ...profile.env({ replayCommand, wrapperPath, stateDir })
+    },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const recordedCwd = recordedWorkspaceDir(recording);
+  const restoreRecordedWorkspace = (line) => recordedCwd === null || recordedCwd === workspaceDir ? line : line.split(workspaceDir).join(recordedCwd);
+  const initializeId = PARITY_INITIALIZE_ID;
+  const startedAt = Date.now();
+  const lines = [];
+  const lineTimes = [];
+  const lineAfter = [];
+  let lastSentRuntimeEntry = null;
+  const events = [];
+  const grammarViolations = [];
+  const stalls = [];
+  let stderr = "";
+  const grammar = new ThreadEventGrammar();
+  const liveAssembler = options.createAssembler(providerId);
+  const planAssembler = (options.createPlanAssembler ?? options.createAssembler)(providerId);
+  const exactPlan = options.planFromCurrentLane === true;
+  const steps = planRuntimeSteps(
+    exactPlan ? withCurrentBridgeLane(recording) : recording,
+    planAssembler
+  );
+  const answeredIds = /* @__PURE__ */ new Set();
+  const pendingBridgeRequests = [];
+  const recordedAnswers = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    if (step.message !== null && isResponse(step.message)) {
+      const method = methodOfRecordedBridgeRequest(recording, step.entry, step.message.id) ?? "?";
+      const queue = recordedAnswers.get(method) ?? [];
+      queue.push(step.message);
+      recordedAnswers.set(method, queue);
+    }
+  }
+  let lastOutputAt = Date.now();
+  const exited = new Promise((resolveExit) => {
+    child.on("exit", (code) => resolveExit(code));
+  });
+  child.stderr?.setEncoding("utf8").on("data", (chunk) => {
+    stderr += chunk;
+    options.onStderr?.(chunk);
+  });
+  function write(line) {
+    if (child.stdin?.writable) {
+      child.stdin.write(`${line}
+`);
+    }
+  }
+  function answerBridgeRequest(message) {
+    const method = message.method ?? "?";
+    const queue = recordedAnswers.get(method);
+    const recorded = queue?.shift();
+    if (recorded === void 0) {
+      stalls.push(`no recorded answer for bridge request ${method} (${String(message.id)})`);
+      write(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: message.id,
+          error: { code: -32e3, message: "parity replay: no recorded answer" }
+        })
+      );
+      return;
+    }
+    write(JSON.stringify({ ...recorded, id: message.id }));
+  }
+  readBoundedLines({
+    input: child.stdout,
+    onLine: (rawLine) => {
+      const line = restoreRecordedWorkspace(rawLine);
+      lastOutputAt = Date.now();
+      lines.push(line);
+      lineTimes.push(lastOutputAt - startedAt);
+      lineAfter.push(lastSentRuntimeEntry);
+      const message = parseWire(line);
+      if (message === null) return;
+      if (isResponse(message)) {
+        answeredIds.add(String(message.id));
+        return;
+      }
+      if (isRequest(message)) {
+        pendingBridgeRequests.push({ id: message.id, method: message.method });
+        answerBridgeRequest(message);
+        return;
+      }
+      if (message.method === THREAD_DELTA_NOTIFICATION_METHOD) {
+        let assembled;
+        try {
+          assembled = liveAssembler.assembleMessage(message);
+        } catch (error) {
+          stalls.push(`invalid thread/delta: ${error instanceof Error ? error.message : String(error)}`);
+          return;
+        }
+        for (const event of assembled) {
+          const result2 = grammar.observe(event);
+          if (result2.kind === "violation") {
+            grammarViolations.push({ rule: result2.rule, reason: result2.reason, eventType: event.type });
+            continue;
+          }
+          events.push(event);
+        }
+      }
+    },
+    onOverflow: (bytes) => {
+      stalls.push(`oversized bridge line (${bytes} bytes)`);
+    }
+  });
+  async function waitFor(label, predicate, limitMs = timeoutMs, reportStall = true) {
+    const deadline = Date.now() + limitMs;
+    while (!predicate()) {
+      if (child.exitCode !== null) {
+        stalls.push(`bridge exited while waiting for ${label}`);
+        return;
+      }
+      if (Date.now() > deadline) {
+        if (reportStall) stalls.push(`timed out waiting for ${label}`);
+        return;
+      }
+      await sleep(10);
+    }
+  }
+  const firstStep = steps.find((step) => step.message !== null && isRequest(step.message));
+  setCursor(firstStep === void 0 ? "end" : { run: firstStep.entry.run, seq: firstStep.entry.seq });
+  write(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: initializeId,
+      method: "initialize",
+      params: {
+        protocolVersion: PROVIDER_BRIDGE_PROTOCOL_VERSION,
+        client: { name: "bb-parity", version: "0" }
+      }
+    })
+  );
+  await waitFor("initialize response", () => answeredIds.has(initializeId));
+  const sentRequestIds = [];
+  for (const step of steps) {
+    if (step.message === null || !isRequest(step.message)) {
+      if (step.message !== null && !isResponse(step.message)) {
+        lastSentRuntimeEntry = { run: step.entry.run, seq: step.entry.seq, ts: step.entry.ts };
+        write(step.entry.line);
+      }
+      continue;
+    }
+    const request = step.message;
+    const method = request.method;
+    await waitFor(
+      `earlier requests before ${method}`,
+      () => sentRequestIds.every((id) => answeredIds.has(id))
+    );
+    await waitFor(
+      `${step.gate.started} turn/started and ${step.gate.completed} turn/completed before ${method}`,
+      () => {
+        const live = countTurnBoundaries(events);
+        return live.started >= step.gate.started && live.completed >= step.gate.completed;
+      }
+    );
+    await waitFor(
+      `${step.eventsBefore} events before ${method}`,
+      () => events.length >= step.eventsBefore || !exactPlan && Date.now() - lastOutputAt >= orderTimeoutMs,
+      timeoutMs,
+      exactPlan
+    );
+    await waitFor(
+      `the stream to drain before ${method}`,
+      () => Date.now() - lastOutputAt >= drainMs,
+      timeoutMs,
+      false
+    );
+    if (child.exitCode !== null) break;
+    if (method === "thread/stop" && typeof request.params === "object" && request.params !== null && request.params.intent === "release") {
+      const threadId = request.params.threadId;
+      if (typeof threadId === "string") grammar.clearThread(threadId);
+    }
+    const rewritten = rewriteRecordedMachineFacts(step.entry.line, workspaceDir);
+    const line = profile.rewriteRuntimeLine === void 0 ? rewritten : profile.rewriteRuntimeLine(rewritten, { replayCommand });
+    lastSentRuntimeEntry = { run: step.entry.run, seq: step.entry.seq, ts: step.entry.ts };
+    write(line);
+    sentRequestIds.push(String(request.id));
+    const nextStep = steps.slice(steps.indexOf(step) + 1).find((candidate) => candidate.message !== null && isRequest(candidate.message));
+    setCursor(nextStep === void 0 ? "end" : { run: nextStep.entry.run, seq: nextStep.entry.seq });
+  }
+  setCursor("end");
+  await waitFor("the last responses", () => sentRequestIds.every((id) => answeredIds.has(id)));
+  await waitFor("the stream to settle", () => Date.now() - lastOutputAt >= settleMs);
+  child.stdin?.end();
+  const exitCode = await Promise.race([
+    exited,
+    sleep(timeoutMs).then(() => {
+      stalls.push("bridge did not exit after stdin closed; killed");
+      child.kill("SIGKILL");
+      return null;
+    })
+  ]);
+  rmSync(stateDir, { recursive: true, force: true });
+  rmSync(workspaceDir, { recursive: true, force: true });
+  return {
+    providerId,
+    recordingDir: options.recordingDir,
+    lines,
+    lineTimes,
+    lineAfter,
+    events,
+    grammarViolations,
+    stalls,
+    stderr,
+    exitCode
+  };
+}
+function assembleRecordedEvents(recording, createAssembler, providerId) {
+  const assembler = createAssembler(providerId);
+  const grammar = new ThreadEventGrammar();
+  const events = [];
+  const grammarViolations = [];
+  const invalidDeltas = [];
+  for (const entry of recording.entries) {
+    if (entry.dir === "runtime\u2192bridge") {
+      const message2 = parseWire(entry.line);
+      if (message2 !== null && message2.method === "thread/stop" && typeof message2.params === "object" && message2.params !== null && message2.params.intent === "release") {
+        const threadId = message2.params.threadId;
+        if (typeof threadId === "string") grammar.clearThread(threadId);
+      }
+      continue;
+    }
+    if (entry.dir !== "bridge\u2192runtime") continue;
+    const message = parseWire(entry.line);
+    if (message === null || message.method !== THREAD_DELTA_NOTIFICATION_METHOD) continue;
+    let assembled;
+    try {
+      assembled = assembler.assembleMessage(message);
+    } catch (error) {
+      invalidDeltas.push(error instanceof Error ? error.message : String(error));
+      continue;
+    }
+    for (const event of assembled) {
+      const result2 = grammar.observe(event);
+      if (result2.kind === "violation") {
+        grammarViolations.push({ rule: result2.rule, reason: result2.reason, eventType: event.type });
+        continue;
+      }
+      events.push(event);
+    }
+  }
+  return { events, grammarViolations, invalidDeltas };
+}
+var TIME_FIELDS = /* @__PURE__ */ new Set([
+  "createdAt",
+  "updatedAt",
+  "startedAt",
+  "completedAt",
+  "startedAtMs",
+  "completedAtMs",
+  "timestamp",
+  "ts",
+  "resetsAtMs",
+  "resetsAt",
+  "expiresAt"
+]);
+function blankTimeFields(value) {
+  if (Array.isArray(value)) {
+    return value.map(blankTimeFields);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = TIME_FIELDS.has(key) && (typeof entry === "number" || typeof entry === "string") ? 0 : blankTimeFields(entry);
+    }
+    return out;
+  }
+  return value;
+}
+var ROW_ID_FIELDS = [
+  "turnId",
+  "itemId",
+  "id",
+  "parentToolCallId",
+  "toolCallId",
+  "callId",
+  "requestId",
+  "messageId",
+  "rowId",
+  "agentId",
+  "taskId",
+  "backgroundTaskId",
+  "sourceItemId",
+  "interactionId"
+];
+function normalizeParityEvents(events) {
+  return blankTimeFields(normalizeCalibrationEvents(events));
+}
+function normalizeParityRows(rows) {
+  return blankTimeFields(
+    normalizeCalibrationEvents(rows, {
+      internedIdFields: ROW_ID_FIELDS
+    })
+  );
+}
+function pointerSegments(path) {
+  return path.split("/").filter((segment) => segment.length > 0);
+}
+function maskPath(value, path) {
+  const segments = pointerSegments(path);
+  if (segments.length === 0) {
+    if (!Array.isArray(value)) return 0;
+    const removed2 = value.length;
+    value.length = 0;
+    return removed2;
+  }
+  let removed = 0;
+  const visit = (node, index) => {
+    if (index >= segments.length || node === null || typeof node !== "object") {
+      return;
+    }
+    const segment = segments[index];
+    const last = index === segments.length - 1;
+    if (segment === "**") {
+      visit(node, index + 1);
+      for (const child of Object.values(node)) {
+        visit(child, index);
+      }
+      return;
+    }
+    const keys = segment === "*" ? Object.keys(node) : Object.hasOwn(node, segment) ? [segment] : [];
+    for (const key of keys) {
+      if (last) {
+        if (Array.isArray(node)) {
+          node[Number(key)] = null;
+        } else {
+          delete node[key];
+        }
+        removed += 1;
+      } else {
+        visit(node[key], index + 1);
+      }
+    }
+  };
+  visit(value, 0);
+  return removed;
+}
+function entryApplies(entry, provider, cell) {
+  return (entry.provider === "*" || entry.provider === provider) && (entry.cell === "*" || entry.cell === cell);
+}
+function compareParity(oldRun, newRun, allowlist, scope) {
+  const layers = {
+    events: [normalizeParityEvents(oldRun.events), normalizeParityEvents(newRun.events)],
+    rows: [normalizeParityRows(oldRun.rows), normalizeParityRows(newRun.rows)]
+  };
+  const staleAllowlist = [];
+  for (const entry of allowlist) {
+    if (!entryApplies(entry, scope.provider, scope.cell)) continue;
+    const [oldSide, newSide] = layers[entry.layer];
+    const removed = maskPath(oldSide, entry.path) + maskPath(newSide, entry.path);
+    if (removed === 0) {
+      staleAllowlist.push(entry);
+    }
+  }
+  const events = diffLayer(layers.events[0], layers.events[1]);
+  const rows = diffLayer(layers.rows[0], layers.rows[1]);
+  const grammar = diffLayer(
+    (oldRun.grammarViolations ?? []).map((violation2) => `${violation2.rule}:${violation2.eventType}`),
+    (newRun.grammarViolations ?? []).map((violation2) => `${violation2.rule}:${violation2.eventType}`)
+  );
+  const clean = (diff) => diff.onlyInOld.length === 0 && diff.onlyInNew.length === 0;
+  return {
+    provider: scope.provider,
+    cell: scope.cell,
+    events,
+    rows,
+    grammar,
+    staleAllowlist,
+    passed: clean(events) && clean(rows) && clean(grammar) && staleAllowlist.length === 0
+  };
+}
+function diffLayer(oldSide, newSide) {
+  const diff = diffCalibrationStreams(oldSide, newSide);
+  return { onlyInOld: diff.onlyInLegacy, onlyInNew: diff.onlyInBridge };
+}
+
+// ../provider-bridge-protocol/src/testing/rerecord.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var BRIDGE_TO_RUNTIME = "bridge\u2192runtime";
+function parseWireLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function rerecordCurrentBridgeLane(options) {
+  const recording = readBridgeRecording(options.recordingDir);
+  const run = await replayRecording({ ...options, planFromCurrentLane: false });
+  if (run.stalls.length > 0) {
+    return { file: null, lines: 0, events: run.events.length, stalls: run.stalls };
+  }
+  const firstRuntime = recording.entries.find(
+    (entry) => entry.dir === "runtime\u2192bridge"
+  );
+  const recordedRequestIds = /* @__PURE__ */ new Map();
+  for (const entry of recording.entries) {
+    if (entry.dir !== BRIDGE_TO_RUNTIME) continue;
+    const message = parseWireLine(entry.line);
+    if (message?.method === void 0 || message.id === void 0) continue;
+    const queue = recordedRequestIds.get(message.method) ?? [];
+    queue.push(message.id);
+    recordedRequestIds.set(message.method, queue);
+  }
+  const entries = [];
+  const perAnchor = /* @__PURE__ */ new Map();
+  run.lines.forEach((rawLine, index) => {
+    let line = rawLine;
+    const message = parseWireLine(rawLine);
+    if (message?.id === PARITY_INITIALIZE_ID) {
+      return;
+    }
+    if (message?.method !== void 0 && message.id !== void 0) {
+      const recordedId = recordedRequestIds.get(message.method)?.shift();
+      if (recordedId !== void 0 && recordedId !== message.id) {
+        line = JSON.stringify({ ...message, id: recordedId });
+      }
+    }
+    const anchor = run.lineAfter[index] ?? (firstRuntime ? {
+      run: firstRuntime.run,
+      seq: firstRuntime.seq - 1,
+      ts: firstRuntime.ts
+    } : { run: 0, seq: 0, ts: 0 });
+    const anchorKey = `${anchor.run}:${anchor.seq}`;
+    const ordinal = (perAnchor.get(anchorKey) ?? 0) + 1;
+    perAnchor.set(anchorKey, ordinal);
+    entries.push({
+      ts: anchor.ts + ordinal,
+      run: anchor.run,
+      // Fractional: after the anchoring runtime entry, before the next one.
+      seq: anchor.seq + ordinal / (run.lines.length + 1),
+      dir: BRIDGE_TO_RUNTIME,
+      line
+    });
+  });
+  const file = join3(options.recordingDir, CURRENT_BRIDGE_LANE_FILE);
+  writeFileSync2(
+    file,
+    entries.map((entry) => JSON.stringify(entry)).join("\n") + (entries.length > 0 ? "\n" : "")
+  );
+  return { file, lines: entries.length, events: run.events.length, stalls: [] };
+}
 export {
   ASSEMBLER_GRAMMAR_VERSIONS,
   CONFORMANCE_ASSEMBLED_EVENT_METHOD,
-  ConformanceClient as experimental_ConformanceClient,
+  CURRENT_BRIDGE_LANE_FILE,
+  DEFAULT_REPLAY_PROFILE,
+  PARITY_INITIALIZE_ID,
+  RECORDED_CONFORMANCE_CELLS,
   assembleCapturedThreadEvents as experimental_assembleCapturedThreadEvents,
+  assembleRecordedEvents as experimental_assembleRecordedEvents,
   captureBridgeJsonRpcOutput as experimental_captureBridgeJsonRpcOutput,
-  checkItemOpensBeforeDelta as experimental_checkItemOpensBeforeDelta,
+  checkRecordedCellReplay as experimental_checkRecordedCellReplay,
+  compareParity as experimental_compareParity,
   createBridgeDeltaEventCollector as experimental_createBridgeDeltaEventCollector,
   createBridgeJsonRpcTestHarness as experimental_createBridgeJsonRpcTestHarness,
   createDeltaAssembler as experimental_createDeltaAssembler,
   describeCalibrationEvents as experimental_describeCalibrationEvents,
-  diffCumulativeText as experimental_diffCumulativeText,
   formatConformanceReport as experimental_formatConformanceReport,
+  listRecordedCells as experimental_listRecordedCells,
   normalizeCalibrationEvents as experimental_normalizeCalibrationEvents,
+  readBridgeRecording as experimental_readBridgeRecording,
+  replayRecording as experimental_replayRecording,
+  rerecordCurrentBridgeLane as experimental_rerecordCurrentBridgeLane,
+  resolveProviderBridgeLaunch as experimental_resolveProviderBridgeLaunch,
   runBridgeConformance as experimental_runBridgeConformance,
-  toConformanceMessages as experimental_toConformanceMessages
+  toConformanceMessages as experimental_toConformanceMessages,
+  withCurrentBridgeLane as experimental_withCurrentBridgeLane
 };