@get-bb/plugin-sdk 0.4.30 → 0.4.35

package/dist/provider-bridge-acp.js

@@ -655,10 +655,10 @@ var backgroundTaskUsageSchema = z5.object({
 });
 
 // ../domain/src/provider-event.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // ../domain/src/thread-events.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // ../domain/src/pending-interactions.ts
 import { z as z8 } from "zod";
@@ -1110,24 +1110,8 @@ var interactionLifecycleSchema = z8.union([
 import { z as z9 } from "zod";
 var clientTurnRequestIdSchema = z9.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
 
-// ../domain/src/thread-events.ts
-var systemEventTypeValues = [
-  "client/thread/start",
-  "client/turn/requested",
-  "client/turn/rejected",
-  "client/turn/start",
-  "system/error",
-  "system/manager/user_message",
-  "system/thread/interrupted",
-  "system/operation",
-  "system/interaction/lifecycle",
-  "system/permissionGrant/lifecycle",
-  "system/userQuestion/lifecycle",
-  "system/thread-provisioning",
-  "system/provider-turn-watchdog"
-];
-var threadTurnInitiatorValues = ["user", "agent", "system"];
-var threadTurnInitiatorSchema = z10.enum(threadTurnInitiatorValues);
+// ../domain/src/system-message.ts
+import { z as z10 } from "zod";
 var systemMessageKindValues = [
   "ownership-assigned",
   "ownership-removed",
@@ -1150,70 +1134,99 @@ var systemMessageSubjectSchema = z10.discriminatedUnion("kind", [
     count: z10.number()
   })
 ]);
+
+// ../domain/src/thread-events.ts
+var systemEventTypeValues = [
+  "client/thread/start",
+  "client/turn/requested",
+  "client/turn/rejected",
+  "client/turn/start",
+  "system/error",
+  "system/manager/user_message",
+  "system/thread/interrupted",
+  "system/operation",
+  "system/interaction/lifecycle",
+  "system/permissionGrant/lifecycle",
+  "system/userQuestion/lifecycle",
+  "system/thread-provisioning",
+  // Legacy persisted watchdog diagnostic; retained for read/decode/render
+  // only, with no current producer.
+  "system/provider-turn-watchdog"
+];
+var threadTurnInitiatorValues = ["user", "agent", "system"];
+var threadTurnInitiatorSchema = z11.enum(threadTurnInitiatorValues);
 var turnRequestOptionsSchema = recordedThreadExecutionOptionsSchema;
-var turnRequestTargetSchema = z10.discriminatedUnion("kind", [
-  z10.object({ kind: z10.literal("thread-start") }),
-  z10.object({ kind: z10.literal("new-turn") }),
-  z10.object({
-    kind: z10.literal("auto"),
-    expectedTurnId: z10.string().nullable()
+var turnRequestTargetSchema = z11.discriminatedUnion("kind", [
+  z11.object({ kind: z11.literal("thread-start") }),
+  z11.object({ kind: z11.literal("new-turn") }),
+  z11.object({
+    kind: z11.literal("auto"),
+    expectedTurnId: z11.string().nullable()
   }),
-  z10.object({
-    kind: z10.literal("steer"),
-    expectedTurnId: z10.string().nullable()
+  z11.object({
+    kind: z11.literal("steer"),
+    expectedTurnId: z11.string().nullable()
   })
 ]);
-var clientTurnLifecycleEventDataSchema = z10.object({
-  direction: z10.literal("outbound"),
-  source: z10.enum(["spawn", "tell"]),
+var clientTurnLifecycleEventDataSchema = z11.object({
+  direction: z11.literal("outbound"),
+  source: z11.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  request: z10.object({
-    method: z10.enum(["thread/start", "turn/start"]),
-    params: z10.record(z10.string(), z10.unknown())
+  request: z11.object({
+    method: z11.enum(["thread/start", "turn/start"]),
+    params: z11.record(z11.string(), z11.unknown())
   })
 });
-var turnRequestEventDataSchema = z10.object({
-  direction: z10.literal("outbound"),
+var turnRequestEventDataSchema = z11.object({
+  direction: z11.literal("outbound"),
   requestId: clientTurnRequestIdSchema,
-  continuationOfRequestId: clientTurnRequestIdSchema.optional(),
-  source: z10.enum(["spawn", "tell"]),
+  // Retry provenance, written only when a `turn.failed` gate's retry row
+  // dispatches. Both fields are present together or not at all: absence means
+  // "this is an original dispatch", which is the overwhelmingly common case.
+  // (Supersedes the pre-plugin `continuationOfRequestId` key, which the removed
+  // core rate-limit recovery wrote and nothing ever read.)
+  /** The original request this attempt re-submits, unchanged across attempts. */
+  retryOfRequestId: clientTurnRequestIdSchema.optional(),
+  /** Which attempt this is: 2 is the first retry of the original request. */
+  retryAttempt: z11.number().int().min(2).optional(),
+  source: z11.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  senderThreadId: z10.string().nullable(),
+  senderThreadId: z11.string().nullable(),
   systemMessageKind: systemMessageKindSchema.optional(),
   systemMessageSubject: systemMessageSubjectSchema.nullable().optional(),
-  input: z10.array(promptInputSchema),
-  inputGroups: z10.array(z10.array(promptInputSchema).min(1)).min(1).optional(),
+  input: z11.array(promptInputSchema),
+  inputGroups: z11.array(z11.array(promptInputSchema).min(1)).min(1).optional(),
   target: turnRequestTargetSchema,
-  request: z10.object({
-    method: z10.enum(["thread/start", "turn/start"]),
-    params: z10.record(z10.string(), z10.unknown())
+  request: z11.object({
+    method: z11.enum(["thread/start", "turn/start"]),
+    params: z11.record(z11.string(), z11.unknown())
   }),
   execution: turnRequestOptionsSchema
 });
-var turnRequestRejectedEventDataSchema = z10.object({
+var turnRequestRejectedEventDataSchema = z11.object({
   requestId: clientTurnRequestIdSchema,
-  reason: z10.string().min(1),
-  message: z10.string().min(1)
-});
-var systemErrorEventDataSchema = z10.object({
-  code: z10.string().optional(),
-  message: z10.string(),
-  detail: z10.string().optional(),
-  reconnectAttempt: z10.number().int().positive().optional(),
-  reconnectTotal: z10.number().int().positive().optional()
+  reason: z11.string().min(1),
+  message: z11.string().min(1)
+});
+var systemErrorEventDataSchema = z11.object({
+  code: z11.string().optional(),
+  message: z11.string(),
+  detail: z11.string().optional(),
+  reconnectAttempt: z11.number().int().positive().optional(),
+  reconnectTotal: z11.number().int().positive().optional()
 }).superRefine((value, ctx) => {
   const hasReconnectAttempt = value.reconnectAttempt !== void 0;
   const hasReconnectTotal = value.reconnectTotal !== void 0;
   if (hasReconnectAttempt !== hasReconnectTotal) {
     ctx.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.ZodIssueCode.custom,
       message: "system/error reconnectAttempt and reconnectTotal must be provided together"
     });
     return;
   }
   if (value.reconnectAttempt !== void 0 && value.reconnectTotal !== void 0 && value.reconnectAttempt > value.reconnectTotal) {
     ctx.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z11.ZodIssueCode.custom,
       message: "system/error reconnectAttempt cannot be greater than reconnectTotal"
     });
   }
@@ -1223,42 +1236,42 @@ var ownershipChangeOperationActionValues = [
   "release",
   "transfer"
 ];
-var ownershipChangeOperationActionSchema = z10.enum(
+var ownershipChangeOperationActionSchema = z11.enum(
   ownershipChangeOperationActionValues
 );
-var ownershipChangeOperationMetadataSchema = z10.object({
+var ownershipChangeOperationMetadataSchema = z11.object({
   action: ownershipChangeOperationActionSchema,
-  nextParentThreadId: z10.string().nullable(),
-  nextParentThreadTitle: z10.string().nullable(),
-  previousParentThreadId: z10.string().nullable(),
-  previousParentThreadTitle: z10.string().nullable()
-});
-var systemOperationEventDataSchema = z10.object({
-  operation: z10.string(),
-  status: z10.string(),
-  message: z10.string(),
-  operationId: z10.string(),
-  metadata: z10.record(z10.string(), jsonValueSchema).optional()
-});
-var systemInteractionLifecycleEventDataSchema = z10.object({
+  nextParentThreadId: z11.string().nullable(),
+  nextParentThreadTitle: z11.string().nullable(),
+  previousParentThreadId: z11.string().nullable(),
+  previousParentThreadTitle: z11.string().nullable()
+});
+var systemOperationEventDataSchema = z11.object({
+  operation: z11.string(),
+  status: z11.string(),
+  message: z11.string(),
+  operationId: z11.string(),
+  metadata: z11.record(z11.string(), jsonValueSchema).optional()
+});
+var systemInteractionLifecycleEventDataSchema = z11.object({
   interaction: interactionLifecycleSchema
 });
-var systemPermissionGrantLifecycleEventDataSchema = z10.object({
-  interactionId: z10.string(),
-  providerId: z10.string(),
-  providerRequestId: z10.string(),
+var systemPermissionGrantLifecycleEventDataSchema = z11.object({
+  interactionId: z11.string(),
+  providerId: z11.string(),
+  providerRequestId: z11.string(),
   status: pendingInteractionStatusSchema,
   resolution: approvalPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z10.string().nullable().default(null),
+  statusReason: z11.string().nullable().default(null),
   subject: pendingInteractionPermissionGrantApprovalSubjectSchema
 });
-var systemUserQuestionLifecycleEventDataSchema = z10.object({
-  interactionId: z10.string(),
-  providerId: z10.string(),
-  providerRequestId: z10.string(),
+var systemUserQuestionLifecycleEventDataSchema = z11.object({
+  interactionId: z11.string(),
+  providerId: z11.string(),
+  providerRequestId: z11.string(),
   status: pendingInteractionStatusSchema,
   resolution: userQuestionPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z10.string().nullable().default(null),
+  statusReason: z11.string().nullable().default(null),
   payload: userQuestionPendingInteractionPayloadSchema
 });
 var systemThreadInterruptedReasonValues = [
@@ -1266,20 +1279,20 @@ var systemThreadInterruptedReasonValues = [
   "host-daemon-restarted",
   "provider-turn-idle"
 ];
-var systemThreadInterruptedReasonSchema = z10.enum(
+var systemThreadInterruptedReasonSchema = z11.enum(
   systemThreadInterruptedReasonValues
 );
-var systemThreadInterruptedEventDataSchema = z10.object({
+var systemThreadInterruptedEventDataSchema = z11.object({
   reason: systemThreadInterruptedReasonSchema,
-  cause: z10.literal("host-connection-lost").optional()
+  cause: z11.literal("host-connection-lost").optional()
 });
-var provisioningTranscriptEntrySchema = z10.object({
-  type: z10.enum(["step", "output"]),
-  key: z10.string(),
-  text: z10.string(),
-  startedAt: z10.number().optional(),
-  status: z10.enum(["started", "completed", "failed"]).optional(),
-  metadata: z10.record(z10.string(), z10.unknown()).optional()
+var provisioningTranscriptEntrySchema = z11.object({
+  type: z11.enum(["step", "output"]),
+  key: z11.string(),
+  text: z11.string(),
+  startedAt: z11.number().optional(),
+  status: z11.enum(["started", "completed", "failed"]).optional(),
+  metadata: z11.record(z11.string(), z11.unknown()).optional()
 });
 var systemThreadProvisioningStatusValues = [
   "active",
@@ -1287,48 +1300,48 @@ var systemThreadProvisioningStatusValues = [
   "failed",
   "cancelled"
 ];
-var systemThreadProvisioningStatusSchema = z10.enum(
+var systemThreadProvisioningStatusSchema = z11.enum(
   systemThreadProvisioningStatusValues
 );
-var systemThreadProvisioningEventDataSchema = z10.object({
-  provisioningId: z10.string(),
+var systemThreadProvisioningEventDataSchema = z11.object({
+  provisioningId: z11.string(),
   status: systemThreadProvisioningStatusSchema,
-  environmentId: z10.string(),
-  entries: z10.array(provisioningTranscriptEntrySchema)
-});
-var systemLegacyUserMessageEventDataSchema = z10.object({
-  text: z10.string(),
-  toolCallId: z10.string().optional(),
-  turnId: z10.string().optional()
-});
-var systemProviderTurnWatchdogEventDataSchema = z10.object({
-  reason: z10.literal("provider-turn-idle"),
-  thresholdMs: z10.number().int().positive(),
-  elapsedMs: z10.number().int().nonnegative(),
-  activeTurnId: z10.string().min(1),
-  activeTurnStartedAt: z10.number().int().nonnegative(),
-  lastActivityEventSequence: z10.number().int().positive(),
-  lastActivityEventType: z10.string().min(1),
-  lastActivityEventAt: z10.number().int().nonnegative(),
-  providerId: z10.string().min(1),
-  providerThreadId: z10.string().min(1).nullable(),
-  firedAt: z10.number().int().nonnegative()
+  environmentId: z11.string(),
+  entries: z11.array(provisioningTranscriptEntrySchema)
+});
+var systemLegacyUserMessageEventDataSchema = z11.object({
+  text: z11.string(),
+  toolCallId: z11.string().optional(),
+  turnId: z11.string().optional()
+});
+var systemProviderTurnWatchdogEventDataSchema = z11.object({
+  reason: z11.literal("provider-turn-idle"),
+  thresholdMs: z11.number().int().positive(),
+  elapsedMs: z11.number().int().nonnegative(),
+  activeTurnId: z11.string().min(1),
+  activeTurnStartedAt: z11.number().int().nonnegative(),
+  lastActivityEventSequence: z11.number().int().positive(),
+  lastActivityEventType: z11.string().min(1),
+  lastActivityEventAt: z11.number().int().nonnegative(),
+  providerId: z11.string().min(1),
+  providerThreadId: z11.string().min(1).nullable(),
+  firedAt: z11.number().int().nonnegative()
 });
 
 // ../domain/src/thread-event-scope.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var threadEventScopeKindValues = ["thread", "turn"];
-var threadEventScopeKindSchema = z11.enum(threadEventScopeKindValues);
-var threadEventScopeSchema = z11.discriminatedUnion("kind", [
-  z11.object({ kind: z11.literal("thread") }),
-  z11.object({ kind: z11.literal("turn"), turnId: z11.string().min(1) })
+var threadEventScopeKindSchema = z12.enum(threadEventScopeKindValues);
+var threadEventScopeSchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("thread") }),
+  z12.object({ kind: z12.literal("turn"), turnId: z12.string().min(1) })
 ]);
 var threadEventScopePolicyValues = [
   "thread",
   "turn",
   "thread-or-turn"
 ];
-var threadEventScopePolicySchema = z11.enum(threadEventScopePolicyValues);
+var threadEventScopePolicySchema = z12.enum(threadEventScopePolicyValues);
 var threadEventScopeDefinitionByType = {
   "thread/started": {
     policy: "thread",
@@ -1506,32 +1519,32 @@ function validateThreadEventScope(args) {
 }
 
 // ../domain/src/thread-timeline-goal.ts
-import { z as z12 } from "zod";
-var threadTimelineGoalStatusSchema = z12.enum([
+import { z as z13 } from "zod";
+var threadTimelineGoalStatusSchema = z13.enum([
   "active",
   "paused",
   "budgetLimited",
   "complete"
 ]);
-var threadTimelineGoalSchema = z12.object({
-  sourceSeq: z12.number().int().nonnegative(),
-  updatedAt: z12.number(),
-  objective: z12.string(),
+var threadTimelineGoalSchema = z13.object({
+  sourceSeq: z13.number().int().nonnegative(),
+  updatedAt: z13.number(),
+  objective: z13.string(),
   status: threadTimelineGoalStatusSchema,
-  tokenBudget: z12.number().nullable(),
-  tokensUsed: z12.number(),
-  timeUsedSeconds: z12.number()
+  tokenBudget: z13.number().nullable(),
+  tokensUsed: z13.number(),
+  timeUsedSeconds: z13.number()
 });
 
 // ../domain/src/provider-event.ts
-var threadEventItemStatusSchema = z13.enum([
+var threadEventItemStatusSchema = z14.enum([
   "pending",
   "completed",
   "failed",
   "interrupted"
 ]);
-var threadEventItemApprovalStatusSchema = z13.enum(["waiting_for_approval", "denied"]).nullable();
-var threadEventTurnStatusSchema = z13.enum([
+var threadEventItemApprovalStatusSchema = z14.enum(["waiting_for_approval", "denied"]).nullable();
+var threadEventTurnStatusSchema = z14.enum([
   "completed",
   "failed",
   "interrupted"
@@ -1557,515 +1570,515 @@ var providerErrorCategoryValues = [
   "unauthorized",
   "unknown"
 ];
-var providerErrorCategorySchema = z13.enum(providerErrorCategoryValues);
-var providerErrorInfoSchema = z13.object({
+var providerErrorCategorySchema = z14.enum(providerErrorCategoryValues);
+var providerErrorInfoSchema = z14.object({
   category: providerErrorCategorySchema,
-  providerCode: z13.string().nullable(),
-  httpStatusCode: z13.number().nullable()
+  providerCode: z14.string().nullable(),
+  httpStatusCode: z14.number().nullable()
 });
-var providerRateLimitStatusSchema = z13.enum([
+var providerRateLimitStatusSchema = z14.enum([
   "allowed",
   "warning",
   "blocked",
   "unknown"
 ]);
-var providerRateLimitWindowSchema = z13.object({
-  providerKey: z13.string().min(1).nullable(),
-  label: z13.string().min(1).nullable(),
+var providerRateLimitWindowSchema = z14.object({
+  providerKey: z14.string().min(1).nullable(),
+  label: z14.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
-  resetsAtMs: z13.number().int().nonnegative().nullable()
+  resetsAtMs: z14.number().int().nonnegative().nullable()
 });
-var providerRateLimitStateSchema = z13.object({
-  providerId: z13.string().min(1),
+var providerRateLimitStateSchema = z14.object({
+  providerId: z14.string().min(1),
   status: providerRateLimitStatusSchema,
-  kind: z13.enum(["subscription-window", "credits", "spend-control", "unknown"]),
-  windows: z13.array(providerRateLimitWindowSchema),
-  reachedReason: z13.string().min(1).nullable(),
-  overageStatus: z13.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
-  overageReason: z13.string().min(1).nullable()
-});
-var threadEventFileChangeKindSchema = z13.enum(["add", "delete", "update"]);
-var threadEventFileChangeSchema = z13.object({
-  path: z13.string(),
+  kind: z14.enum(["subscription-window", "credits", "spend-control", "unknown"]),
+  windows: z14.array(providerRateLimitWindowSchema),
+  reachedReason: z14.string().min(1).nullable(),
+  overageStatus: z14.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
+  overageReason: z14.string().min(1).nullable()
+});
+var threadEventFileChangeKindSchema = z14.enum(["add", "delete", "update"]);
+var threadEventFileChangeSchema = z14.object({
+  path: z14.string(),
   kind: threadEventFileChangeKindSchema,
-  movePath: z13.string().optional(),
-  diff: z13.string().optional()
+  movePath: z14.string().optional(),
+  diff: z14.string().optional()
 });
-var threadEventPlanStepStatusSchema = z13.enum([
+var threadEventPlanStepStatusSchema = z14.enum([
   "pending",
   "active",
   "completed",
   "failed"
 ]);
-var threadEventPlanStepSchema = z13.object({
-  step: z13.string(),
+var threadEventPlanStepSchema = z14.object({
+  step: z14.string(),
   status: threadEventPlanStepStatusSchema.optional()
 });
 var itemPresentationField = {
   presentation: threadEventItemPresentationSchema.optional()
 };
-var threadEventWebSearchItemSchema = z13.object({
-  type: z13.literal("webSearch"),
-  id: z13.string(),
-  queries: z13.array(z13.string()).min(1),
-  resultText: z13.string().nullable(),
+var threadEventWebSearchItemSchema = z14.object({
+  type: z14.literal("webSearch"),
+  id: z14.string(),
+  queries: z14.array(z14.string()).min(1),
+  resultText: z14.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
-});
-var threadEventWebFetchItemSchema = z13.object({
-  type: z13.literal("webFetch"),
-  id: z13.string(),
-  url: z13.string(),
-  prompt: z13.string().nullable(),
-  pattern: z13.string().nullable(),
-  resultText: z13.string().nullable(),
+  parentToolCallId: z14.string().optional()
+});
+var threadEventWebFetchItemSchema = z14.object({
+  type: z14.literal("webFetch"),
+  id: z14.string(),
+  url: z14.string(),
+  prompt: z14.string().nullable(),
+  pattern: z14.string().nullable(),
+  resultText: z14.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventImageViewItemSchema = z13.object({
-  type: z13.literal("imageView"),
-  id: z13.string(),
-  path: z13.string(),
+var threadEventImageViewItemSchema = z14.object({
+  type: z14.literal("imageView"),
+  id: z14.string(),
+  path: z14.string(),
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventFileReadItemSchema = z13.object({
-  type: z13.literal("fileRead"),
-  id: z13.string(),
-  path: z13.string(),
-  cmd: z13.string().optional(),
+var threadEventFileReadItemSchema = z14.object({
+  type: z14.literal("fileRead"),
+  id: z14.string(),
+  path: z14.string(),
+  cmd: z14.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventSearchModeSchema = z13.enum(["content", "path", "list"]);
-var threadEventSearchItemSchema = z13.object({
-  type: z13.literal("search"),
-  id: z13.string(),
+var threadEventSearchModeSchema = z14.enum(["content", "path", "list"]);
+var threadEventSearchItemSchema = z14.object({
+  type: z14.literal("search"),
+  id: z14.string(),
   mode: threadEventSearchModeSchema,
-  query: z13.string(),
-  path: z13.string().optional(),
-  cmd: z13.string().optional(),
+  query: z14.string(),
+  path: z14.string().optional(),
+  cmd: z14.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventDelegationItemSchema = z13.object({
-  type: z13.literal("delegation"),
-  id: z13.string(),
-  childRef: z13.string().min(1),
-  label: z13.string(),
+var threadEventDelegationItemSchema = z14.object({
+  type: z14.literal("delegation"),
+  id: z14.string(),
+  childRef: z14.string().min(1),
+  label: z14.string(),
   status: threadEventItemStatusSchema,
-  background: z13.boolean(),
-  summary: z13.string().optional(),
+  background: z14.boolean(),
+  summary: z14.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventPlanStepsItemSchema = z13.object({
-  type: z13.literal("planSteps"),
-  id: z13.string(),
-  steps: z13.array(threadEventPlanStepSchema),
-  explanation: z13.string().optional(),
+var threadEventPlanStepsItemSchema = z14.object({
+  type: z14.literal("planSteps"),
+  id: z14.string(),
+  steps: z14.array(threadEventPlanStepSchema),
+  explanation: z14.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventExtensionItemSchema = z13.object({
-  type: z13.literal("extension"),
-  id: z13.string(),
+var threadEventExtensionItemSchema = z14.object({
+  type: z14.literal("extension"),
+  id: z14.string(),
   kind: extensionKindSchema,
   payload: jsonValueSchema,
   status: threadEventItemStatusSchema,
   presentation: threadEventItemPresentationSchema,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventTextTruncationSchema = z13.object({
-  originalLength: z13.number(),
-  retainedHeadLength: z13.number(),
-  retainedTailLength: z13.number(),
-  truncatedAt: z13.number()
+var threadEventTextTruncationSchema = z14.object({
+  originalLength: z14.number(),
+  retainedHeadLength: z14.number(),
+  retainedTailLength: z14.number(),
+  truncatedAt: z14.number()
 });
-var threadEventItemTruncationSchema = z13.object({
+var threadEventItemTruncationSchema = z14.object({
   aggregatedOutput: threadEventTextTruncationSchema.optional(),
   result: threadEventTextTruncationSchema.optional(),
   resultText: threadEventTextTruncationSchema.optional()
 });
-var threadEventUserContentSchema = z13.discriminatedUnion("type", [
-  z13.object({ type: z13.literal("text"), text: z13.string() }),
-  z13.object({ type: z13.literal("image"), url: z13.string() }),
-  z13.object({ type: z13.literal("localImage"), path: z13.string() }),
-  z13.object({ type: z13.literal("localFile"), path: z13.string() })
+var threadEventUserContentSchema = z14.discriminatedUnion("type", [
+  z14.object({ type: z14.literal("text"), text: z14.string() }),
+  z14.object({ type: z14.literal("image"), url: z14.string() }),
+  z14.object({ type: z14.literal("localImage"), path: z14.string() }),
+  z14.object({ type: z14.literal("localFile"), path: z14.string() })
 ]);
-var threadEventTokenUsageBreakdownSchema = z13.object({
-  totalTokens: z13.number(),
-  inputTokens: z13.number(),
-  cachedInputTokens: z13.number(),
-  outputTokens: z13.number(),
-  reasoningOutputTokens: z13.number()
-});
-var threadEventContextWindowUsageSchema = z13.object({
-  usedTokens: z13.number().nullable(),
-  modelContextWindow: z13.number().nullable(),
-  estimated: z13.boolean()
-});
-var threadEventTokenUsageSchema = z13.object({
+var threadEventTokenUsageBreakdownSchema = z14.object({
+  totalTokens: z14.number(),
+  inputTokens: z14.number(),
+  cachedInputTokens: z14.number(),
+  outputTokens: z14.number(),
+  reasoningOutputTokens: z14.number()
+});
+var threadEventContextWindowUsageSchema = z14.object({
+  usedTokens: z14.number().nullable(),
+  modelContextWindow: z14.number().nullable(),
+  estimated: z14.boolean()
+});
+var threadEventTokenUsageSchema = z14.object({
   total: threadEventTokenUsageBreakdownSchema,
   last: threadEventTokenUsageBreakdownSchema,
-  modelContextWindow: z13.number().nullable()
+  modelContextWindow: z14.number().nullable()
 });
-var threadEventWarningCategorySchema = z13.enum([
+var threadEventWarningCategorySchema = z14.enum([
   "deprecation",
   "config",
   "general",
   "compaction-skipped"
 ]);
-var providerRawEventSchema = z13.object({
-  jsonrpc: z13.literal("2.0"),
-  id: z13.union([z13.string(), z13.number()]).optional(),
-  method: z13.string(),
+var providerRawEventSchema = z14.object({
+  jsonrpc: z14.literal("2.0"),
+  id: z14.union([z14.string(), z14.number()]).optional(),
+  method: z14.string(),
   params: jsonValueSchema.optional()
 });
-var providerUnhandledEventSchema = z13.object({
-  type: z13.literal("provider/unhandled"),
-  threadId: z13.string(),
-  providerThreadId: z13.string(),
-  providerId: z13.string(),
-  rawType: z13.string(),
+var providerUnhandledEventSchema = z14.object({
+  type: z14.literal("provider/unhandled"),
+  threadId: z14.string(),
+  providerThreadId: z14.string(),
+  providerId: z14.string(),
+  rawType: z14.string(),
   rawEvent: providerRawEventSchema,
-  parentToolCallId: z13.string().optional()
-});
-var toolCallProgressEventSchema = z13.object({
-  type: z13.literal("item/toolCall/progress"),
-  threadId: z13.string(),
-  providerThreadId: z13.string(),
-  itemId: z13.string(),
-  message: z13.string().optional(),
-  parentToolCallId: z13.string().optional()
-});
-var threadEventBackgroundTaskItemSchema = z13.object({
-  type: z13.literal("backgroundTask"),
-  id: z13.string(),
-  familyId: z13.string().optional(),
-  taskType: z13.string(),
-  description: z13.string(),
+  parentToolCallId: z14.string().optional()
+});
+var toolCallProgressEventSchema = z14.object({
+  type: z14.literal("item/toolCall/progress"),
+  threadId: z14.string(),
+  providerThreadId: z14.string(),
+  itemId: z14.string(),
+  message: z14.string().optional(),
+  parentToolCallId: z14.string().optional()
+});
+var threadEventBackgroundTaskItemSchema = z14.object({
+  type: z14.literal("backgroundTask"),
+  id: z14.string(),
+  familyId: z14.string().optional(),
+  taskType: z14.string(),
+  description: z14.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z13.boolean(),
-  workflowName: z13.string().optional(),
+  skipTranscript: z14.boolean(),
+  workflowName: z14.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z13.string().optional(),
-  error: z13.string().optional(),
-  outputFile: z13.string().optional(),
+  summary: z14.string().optional(),
+  error: z14.string().optional(),
+  outputFile: z14.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z13.string().optional()
+  parentToolCallId: z14.string().optional()
 });
-var threadEventItemSchema = z13.discriminatedUnion("type", [
-  z13.object({
-    type: z13.literal("userMessage"),
-    id: z13.string(),
-    content: z13.array(threadEventUserContentSchema),
+var threadEventItemSchema = z14.discriminatedUnion("type", [
+  z14.object({
+    type: z14.literal("userMessage"),
+    id: z14.string(),
+    content: z14.array(threadEventUserContentSchema),
     clientRequestId: clientTurnRequestIdSchema.optional(),
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }).strict(),
-  z13.object({
-    type: z13.literal("agentMessage"),
-    id: z13.string(),
-    text: z13.string(),
+  z14.object({
+    type: z14.literal("agentMessage"),
+    id: z14.string(),
+    text: z14.string(),
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("commandExecution"),
-    id: z13.string(),
-    command: z13.string(),
-    cwd: z13.string(),
+  z14.object({
+    type: z14.literal("commandExecution"),
+    id: z14.string(),
+    command: z14.string(),
+    cwd: z14.string(),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
-    aggregatedOutput: z13.string().optional(),
-    exitCode: z13.number().optional(),
-    durationMs: z13.number().optional(),
+    aggregatedOutput: z14.string().optional(),
+    exitCode: z14.number().optional(),
+    durationMs: z14.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("fileChange"),
-    id: z13.string(),
-    changes: z13.array(threadEventFileChangeSchema),
+  z14.object({
+    type: z14.literal("fileChange"),
+    id: z14.string(),
+    changes: z14.array(threadEventFileChangeSchema),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
   threadEventWebSearchItemSchema,
   threadEventWebFetchItemSchema,
   threadEventImageViewItemSchema,
   threadEventFileReadItemSchema,
   threadEventSearchItemSchema,
-  z13.object({
-    type: z13.literal("toolCall"),
-    id: z13.string(),
-    server: z13.string().optional(),
-    tool: z13.string(),
-    arguments: z13.record(z13.string(), z13.unknown()).optional(),
+  z14.object({
+    type: z14.literal("toolCall"),
+    id: z14.string(),
+    server: z14.string().optional(),
+    tool: z14.string(),
+    arguments: z14.record(z14.string(), z14.unknown()).optional(),
     status: threadEventItemStatusSchema,
-    result: z13.unknown().optional(),
-    error: z13.string().optional(),
-    durationMs: z13.number().optional(),
+    result: z14.unknown().optional(),
+    error: z14.string().optional(),
+    durationMs: z14.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("reasoning"),
-    id: z13.string(),
-    summary: z13.array(z13.string()),
-    content: z13.array(z13.string()),
+  z14.object({
+    type: z14.literal("reasoning"),
+    id: z14.string(),
+    summary: z14.array(z14.string()),
+    content: z14.array(z14.string()),
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("plan"),
-    id: z13.string(),
-    text: z13.string(),
+  z14.object({
+    type: z14.literal("plan"),
+    id: z14.string(),
+    text: z14.string(),
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
   threadEventPlanStepsItemSchema,
-  z13.object({
-    type: z13.literal("contextCompaction"),
-    id: z13.string(),
+  z14.object({
+    type: z14.literal("contextCompaction"),
+    id: z14.string(),
     ...itemPresentationField,
-    parentToolCallId: z13.string().optional()
+    parentToolCallId: z14.string().optional()
   }),
   threadEventBackgroundTaskItemSchema,
   threadEventDelegationItemSchema,
   threadEventExtensionItemSchema
 ]);
-var unscopedProviderEventSchema = z13.discriminatedUnion("type", [
-  z13.object({
-    type: z13.literal("thread/started"),
-    threadId: z13.string()
+var unscopedProviderEventSchema = z14.discriminatedUnion("type", [
+  z14.object({
+    type: z14.literal("thread/started"),
+    threadId: z14.string()
   }),
-  z13.object({
-    type: z13.literal("thread/identity"),
-    threadId: z13.string(),
-    providerThreadId: z13.string()
+  z14.object({
+    type: z14.literal("thread/identity"),
+    threadId: z14.string(),
+    providerThreadId: z14.string()
   }),
-  z13.object({
-    type: z13.literal("turn/started"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("turn/started"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("turn/completed"),
-    threadId: z13.string(),
-    providerThreadId: z13.string().nullable(),
+  z14.object({
+    type: z14.literal("turn/completed"),
+    threadId: z14.string(),
+    providerThreadId: z14.string().nullable(),
     status: threadEventTurnStatusSchema,
-    error: z13.object({ message: z13.string() }).optional(),
-    providerCheckpointId: z13.string().min(1).optional()
+    error: z14.object({ message: z14.string() }).optional(),
+    providerCheckpointId: z14.string().min(1).optional()
   }),
-  z13.object({
-    type: z13.literal("turn/input/accepted"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("turn/input/accepted"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     clientRequestId: clientTurnRequestIdSchema,
     scope: threadEventScopeSchema
   }).strict(),
-  z13.object({
-    type: z13.literal("thread/name/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    threadName: z13.string()
+  z14.object({
+    type: z14.literal("thread/name/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    threadName: z14.string()
   }),
-  z13.object({
-    type: z13.literal("thread/compacted"),
-    threadId: z13.string(),
-    providerThreadId: z13.string()
+  z14.object({
+    type: z14.literal("thread/compacted"),
+    threadId: z14.string(),
+    providerThreadId: z14.string()
   }),
-  z13.object({
-    type: z13.literal("thread/context/cleared"),
-    threadId: z13.string(),
-    providerThreadId: z13.string()
+  z14.object({
+    type: z14.literal("thread/context/cleared"),
+    threadId: z14.string(),
+    providerThreadId: z14.string()
   }),
-  z13.object({
-    type: z13.literal("thread/goal/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    objective: z13.string(),
+  z14.object({
+    type: z14.literal("thread/goal/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    objective: z14.string(),
     status: threadTimelineGoalStatusSchema,
-    tokenBudget: z13.number().nullable(),
-    tokensUsed: z13.number(),
-    timeUsedSeconds: z13.number()
+    tokenBudget: z14.number().nullable(),
+    tokensUsed: z14.number(),
+    timeUsedSeconds: z14.number()
   }),
-  z13.object({
-    type: z13.literal("thread/goal/cleared"),
-    threadId: z13.string(),
-    providerThreadId: z13.string()
+  z14.object({
+    type: z14.literal("thread/goal/cleared"),
+    threadId: z14.string(),
+    providerThreadId: z14.string()
   }),
-  z13.object({
-    type: z13.literal("item/started"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("item/started"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     item: threadEventItemSchema
   }),
-  z13.object({
-    type: z13.literal("item/completed"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("item/completed"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     item: threadEventItemSchema
   }),
-  z13.object({
-    type: z13.literal("item/agentMessage/delta"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    delta: z13.string(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/agentMessage/delta"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    delta: z14.string(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("item/commandExecution/outputDelta"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    delta: z13.string(),
-    reset: z13.boolean().optional(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/commandExecution/outputDelta"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    delta: z14.string(),
+    reset: z14.boolean().optional(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("item/fileChange/outputDelta"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    delta: z13.string(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/fileChange/outputDelta"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    delta: z14.string(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("item/reasoning/summaryTextDelta"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    delta: z13.string(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/reasoning/summaryTextDelta"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    delta: z14.string(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("item/reasoning/textDelta"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    delta: z13.string(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/reasoning/textDelta"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    delta: z14.string(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("item/plan/delta"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    delta: z13.string(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/plan/delta"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    delta: z14.string(),
+    parentToolCallId: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("item/mcpToolCall/progress"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    itemId: z13.string(),
-    message: z13.string().optional(),
-    parentToolCallId: z13.string().optional()
+  z14.object({
+    type: z14.literal("item/mcpToolCall/progress"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    itemId: z14.string(),
+    message: z14.string().optional(),
+    parentToolCallId: z14.string().optional()
   }),
   toolCallProgressEventSchema,
-  z13.object({
-    type: z13.literal("item/backgroundTask/progress"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("item/backgroundTask/progress"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z13.object({
-    type: z13.literal("item/backgroundTask/completed"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("item/backgroundTask/completed"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z13.object({
-    type: z13.literal("item/delegation/progress"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("item/delegation/progress"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     item: threadEventDelegationItemSchema
   }),
-  z13.object({
-    type: z13.literal("item/delegation/completed"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("item/delegation/completed"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     item: threadEventDelegationItemSchema
   }),
-  z13.object({
-    type: z13.literal("thread/tokenUsage/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("thread/tokenUsage/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     tokenUsage: threadEventTokenUsageSchema
   }),
-  z13.object({
-    type: z13.literal("thread/contextWindowUsage/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("thread/contextWindowUsage/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     contextWindowUsage: threadEventContextWindowUsageSchema
   }),
-  z13.object({
-    type: z13.literal("turn/plan/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    plan: z13.array(threadEventPlanStepSchema),
-    explanation: z13.string().optional()
+  z14.object({
+    type: z14.literal("turn/plan/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    plan: z14.array(threadEventPlanStepSchema),
+    explanation: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("turn/diff/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    diff: z13.string().optional()
+  z14.object({
+    type: z14.literal("turn/diff/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    diff: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("provider/error"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    message: z13.string(),
-    detail: z13.string().optional(),
-    willRetry: z13.boolean().optional(),
+  z14.object({
+    type: z14.literal("provider/error"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    message: z14.string(),
+    detail: z14.string().optional(),
+    willRetry: z14.boolean().optional(),
     errorInfo: providerErrorInfoSchema.optional()
   }),
-  z13.object({
-    type: z13.literal("provider/rateLimits/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("provider/rateLimits/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     rateLimits: providerRateLimitStateSchema
   }),
-  z13.object({
-    type: z13.literal("thread/extensionState/updated"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("thread/extensionState/updated"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     kind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z13.object({
-    type: z13.literal("provider/warning"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
+  z14.object({
+    type: z14.literal("provider/warning"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
     category: threadEventWarningCategorySchema,
-    summary: z13.string().optional(),
-    details: z13.string().optional()
+    summary: z14.string().optional(),
+    details: z14.string().optional()
   }),
-  z13.object({
-    type: z13.literal("provider/modelFallback"),
-    threadId: z13.string(),
-    providerThreadId: z13.string(),
-    originalModel: z13.string().min(1),
-    fallbackModel: z13.string().min(1),
-    reason: z13.enum(["refusal", "provider"]),
-    message: z13.string()
+  z14.object({
+    type: z14.literal("provider/modelFallback"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    originalModel: z14.string().min(1),
+    fallbackModel: z14.string().min(1),
+    reason: z14.enum(["refusal", "provider"]),
+    message: z14.string()
   }),
   providerUnhandledEventSchema
 ]);
-var scopedEventDataSchema = z13.object({
+var scopedEventDataSchema = z14.object({
   scope: threadEventScopeSchema
 });
 var providerEventSchema = unscopedProviderEventSchema.and(
@@ -2074,58 +2087,58 @@ var providerEventSchema = unscopedProviderEventSchema.and(
 var providerEventTypeValues = unscopedProviderEventSchema.options.map(
   (option) => option.shape.type.value
 );
-var unscopedSystemEventSchema = z13.discriminatedUnion("type", [
-  z13.object({
-    type: z13.literal("client/thread/start"),
-    threadId: z13.string()
+var unscopedSystemEventSchema = z14.discriminatedUnion("type", [
+  z14.object({
+    type: z14.literal("client/thread/start"),
+    threadId: z14.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z13.object({
-    type: z13.literal("client/turn/requested"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("client/turn/requested"),
+    threadId: z14.string()
   }).merge(turnRequestEventDataSchema),
-  z13.object({
-    type: z13.literal("client/turn/rejected"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("client/turn/rejected"),
+    threadId: z14.string()
   }).merge(turnRequestRejectedEventDataSchema),
-  z13.object({
-    type: z13.literal("client/turn/start"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("client/turn/start"),
+    threadId: z14.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z13.object({
-    type: z13.literal("system/error"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/error"),
+    threadId: z14.string()
   }).merge(systemErrorEventDataSchema),
-  z13.object({
-    type: z13.literal("system/manager/user_message"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/manager/user_message"),
+    threadId: z14.string()
   }).merge(systemLegacyUserMessageEventDataSchema),
-  z13.object({
-    type: z13.literal("system/thread/interrupted"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/thread/interrupted"),
+    threadId: z14.string()
   }).merge(systemThreadInterruptedEventDataSchema),
-  z13.object({
-    type: z13.literal("system/operation"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/operation"),
+    threadId: z14.string()
   }).merge(systemOperationEventDataSchema),
-  z13.object({
-    type: z13.literal("system/interaction/lifecycle"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/interaction/lifecycle"),
+    threadId: z14.string()
   }).merge(systemInteractionLifecycleEventDataSchema),
-  z13.object({
-    type: z13.literal("system/permissionGrant/lifecycle"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/permissionGrant/lifecycle"),
+    threadId: z14.string()
   }).merge(systemPermissionGrantLifecycleEventDataSchema),
-  z13.object({
-    type: z13.literal("system/userQuestion/lifecycle"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/userQuestion/lifecycle"),
+    threadId: z14.string()
   }).merge(systemUserQuestionLifecycleEventDataSchema),
-  z13.object({
-    type: z13.literal("system/thread-provisioning"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/thread-provisioning"),
+    threadId: z14.string()
   }).merge(systemThreadProvisioningEventDataSchema),
-  z13.object({
-    type: z13.literal("system/provider-turn-watchdog"),
-    threadId: z13.string()
+  z14.object({
+    type: z14.literal("system/provider-turn-watchdog"),
+    threadId: z14.string()
   }).merge(systemProviderTurnWatchdogEventDataSchema)
 ]);
 var systemEventSchema = unscopedSystemEventSchema.and(scopedEventDataSchema);
@@ -2133,13 +2146,13 @@ var legacyClientRequestKey = ["clientRequest", "Sequence"].join("");
 function isEventPropertyBag(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var rejectLegacyClientRequestSequenceSchema = z13.unknown().superRefine((value, ctx) => {
+var rejectLegacyClientRequestSequenceSchema = z14.unknown().superRefine((value, ctx) => {
   if (!isEventPropertyBag(value)) {
     return;
   }
   if (Object.hasOwn(value, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z13.ZodIssueCode.custom,
+      code: z14.ZodIssueCode.custom,
       message: "legacy request sequence field is no longer accepted",
       path: [legacyClientRequestKey]
     });
@@ -2147,21 +2160,21 @@ var rejectLegacyClientRequestSequenceSchema = z13.unknown().superRefine((value,
   const item = value.item;
   if (isEventPropertyBag(item) && item.type === "userMessage" && Object.hasOwn(item, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z13.ZodIssueCode.custom,
+      code: z14.ZodIssueCode.custom,
       message: "legacy user-message request sequence field is no longer accepted",
       path: ["item", legacyClientRequestKey]
     });
   }
 });
 var threadEventSchema = rejectLegacyClientRequestSequenceSchema.pipe(
-  z13.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
+  z14.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
     const result = validateThreadEventScope({
       type: event.type,
       scope: event.scope
     });
     if (!result.valid) {
       ctx.addIssue({
-        code: z13.ZodIssueCode.custom,
+        code: z14.ZodIssueCode.custom,
         message: result.message ?? "Invalid thread event scope",
         path: ["scope"]
       });
@@ -2174,101 +2187,101 @@ var threadEventTypeValues = [
   ...systemEventTypeValues
 ];
 var threadEventTypeSet = new Set(threadEventTypeValues);
-var threadEventTypeSchema = z13.string().refine(
+var threadEventTypeSchema = z14.string().refine(
   (value) => threadEventTypeSet.has(value),
   "Invalid thread event type"
 );
 
 // ../domain/src/provider-fork.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
-var providerForkSchema = z14.enum(PROVIDER_FORK_VALUES);
+var providerForkSchema = z15.enum(PROVIDER_FORK_VALUES);
 
 // ../domain/src/provider-types.ts
-import { z as z15 } from "zod";
-var modelReasoningEffortSchema = z15.object({
+import { z as z16 } from "zod";
+var modelReasoningEffortSchema = z16.object({
   reasoningEffort: reasoningLevelSchema,
-  description: z15.string()
-});
-var availableModelSchema = z15.object({
-  id: z15.string(),
-  model: z15.string(),
-  displayName: z15.string(),
-  routeProviderId: z15.string().min(1).optional(),
-  description: z15.string(),
-  supportedReasoningEfforts: z15.array(modelReasoningEffortSchema),
+  description: z16.string()
+});
+var availableModelSchema = z16.object({
+  id: z16.string(),
+  model: z16.string(),
+  displayName: z16.string(),
+  routeProviderId: z16.string().min(1).optional(),
+  description: z16.string(),
+  supportedReasoningEfforts: z16.array(modelReasoningEffortSchema),
   defaultReasoningEffort: reasoningLevelSchema,
-  isDefault: z15.boolean()
-});
-var providerModelCatalogScopeSchema = z15.enum(["host", "workspace"]);
-var providerCapabilitiesSchema = z15.object({
-  supportsThreadArchive: z15.boolean(),
-  supportsThreadRename: z15.boolean(),
-  supportsServiceTier: z15.boolean(),
-  supportsNativeUserQuestion: z15.boolean(),
-  supportsFork: z15.boolean(),
-  supportsSessionRewind: z15.boolean(),
-  permissionModes: z15.array(permissionModeSchema).min(1),
+  isDefault: z16.boolean()
+});
+var providerModelCatalogScopeSchema = z16.enum(["host", "workspace"]);
+var providerCapabilitiesSchema = z16.object({
+  supportsThreadArchive: z16.boolean(),
+  supportsThreadRename: z16.boolean(),
+  supportsServiceTier: z16.boolean(),
+  supportsNativeUserQuestion: z16.boolean(),
+  supportsFork: z16.boolean(),
+  supportsSessionRewind: z16.boolean(),
+  permissionModes: z16.array(permissionModeSchema).min(1),
   modelCatalogScope: providerModelCatalogScopeSchema
 });
-var providerComposerCommandSchema = z15.object({
+var providerComposerCommandSchema = z16.object({
   trigger: promptMentionCommandTriggerSchema,
-  name: z15.string().min(1).regex(/^[^\s/$]+$/u),
-  trailingText: z15.string().regex(/^\s*$/u)
+  name: z16.string().min(1).regex(/^[^\s/$]+$/u),
+  trailingText: z16.string().regex(/^\s*$/u)
 });
-var providerComposerActionSchema = z15.discriminatedUnion("kind", [
-  z15.object({
-    kind: z15.literal("skills"),
+var providerComposerActionSchema = z16.discriminatedUnion("kind", [
+  z16.object({
+    kind: z16.literal("skills"),
     trigger: promptMentionCommandTriggerSchema
   }),
-  z15.object({
-    kind: z15.literal("plan"),
+  z16.object({
+    kind: z16.literal("plan"),
     command: providerComposerCommandSchema
   }),
-  z15.object({
-    kind: z15.literal("goal"),
+  z16.object({
+    kind: z16.literal("goal"),
     command: providerComposerCommandSchema
   })
 ]);
-var providerStringsSchema = z15.object({
-  signInHint: z15.string().min(1),
-  expiredHint: z15.string().min(1),
-  installUrl: z15.string().min(1),
-  brandPrefix: z15.string().min(1).optional(),
-  planModeCopy: z15.string().min(1).optional(),
-  iconTint: z15.object({ light: z15.string().min(1), dark: z15.string().min(1) }).optional()
-});
-var providerOptionDescriptorSchema = z15.object({
-  id: z15.string().min(1),
-  label: z15.string().min(1),
-  description: z15.string().min(1).optional()
-});
-var providerExtensionKindInfoSchema = z15.object({
-  item: z15.boolean(),
-  state: z15.boolean()
-});
-var providerExtensionKindsSchema = z15.record(
+var providerStringsSchema = z16.object({
+  signInHint: z16.string().min(1),
+  expiredHint: z16.string().min(1),
+  installUrl: z16.string().min(1),
+  brandPrefix: z16.string().min(1).optional(),
+  planModeCopy: z16.string().min(1).optional(),
+  iconTint: z16.object({ light: z16.string().min(1), dark: z16.string().min(1) }).optional()
+});
+var providerOptionDescriptorSchema = z16.object({
+  id: z16.string().min(1),
+  label: z16.string().min(1),
+  description: z16.string().min(1).optional()
+});
+var providerExtensionKindInfoSchema = z16.object({
+  item: z16.boolean(),
+  state: z16.boolean()
+});
+var providerExtensionKindsSchema = z16.record(
   extensionKindSchema,
   providerExtensionKindInfoSchema
 );
-var providerInfoSchema = z15.object({
-  id: z15.string(),
-  pluginId: z15.string().min(1),
-  displayName: z15.string(),
-  family: z15.string().min(1).optional(),
-  icon: z15.object({ glyph: z15.string().min(1) }).optional(),
-  logoUrl: z15.string().min(1).nullable(),
-  maintenance: z15.object({
-    health: z15.boolean(),
-    usage: z15.boolean(),
-    installation: z15.boolean()
+var providerInfoSchema = z16.object({
+  id: z16.string(),
+  pluginId: z16.string().min(1),
+  displayName: z16.string(),
+  family: z16.string().min(1).optional(),
+  icon: z16.object({ glyph: z16.string().min(1) }).optional(),
+  logoUrl: z16.string().min(1).nullable(),
+  maintenance: z16.object({
+    health: z16.boolean(),
+    usage: z16.boolean(),
+    installation: z16.boolean()
   }),
   capabilities: providerCapabilitiesSchema,
-  composerActions: z15.array(providerComposerActionSchema),
-  available: z15.boolean(),
+  composerActions: z16.array(providerComposerActionSchema),
+  available: z16.boolean(),
   strings: providerStringsSchema.optional(),
-  serviceTiers: z15.array(providerOptionDescriptorSchema).optional(),
-  reasoningLevels: z15.array(providerOptionDescriptorSchema).optional(),
+  serviceTiers: z16.array(providerOptionDescriptorSchema).optional(),
+  reasoningLevels: z16.array(providerOptionDescriptorSchema).optional(),
   extensionKinds: providerExtensionKindsSchema.optional()
 });
 var providerRecoveryKindValues = [
@@ -2278,34 +2291,34 @@ var providerRecoveryKindValues = [
   "staleTurn",
   "rateLimited"
 ];
-var providerRecoveryKindSchema = z15.enum(providerRecoveryKindValues);
-var toolCallOutputItemSchema = z15.discriminatedUnion("type", [
-  z15.object({
-    type: z15.literal("inputText"),
-    text: z15.string()
+var providerRecoveryKindSchema = z16.enum(providerRecoveryKindValues);
+var toolCallOutputItemSchema = z16.discriminatedUnion("type", [
+  z16.object({
+    type: z16.literal("inputText"),
+    text: z16.string()
   }),
-  z15.object({
-    type: z15.literal("inputImage"),
-    imageUrl: z15.string()
+  z16.object({
+    type: z16.literal("inputImage"),
+    imageUrl: z16.string()
   })
 ]);
-var toolCallRequestSchema = z15.object({
-  requestId: z15.union([z15.string().min(1), z15.number()]),
-  threadId: z15.string().min(1),
-  providerThreadId: z15.string().min(1),
-  turnId: z15.string().min(1),
-  callId: z15.string().min(1),
-  tool: z15.string().min(1),
-  arguments: z15.unknown().optional()
-});
-var toolCallResponseSchema = z15.object({
-  contentItems: z15.array(toolCallOutputItemSchema),
-  success: z15.boolean()
-});
-var dynamicToolSchema = z15.object({
-  name: z15.string(),
-  description: z15.string(),
-  inputSchema: z15.unknown(),
+var toolCallRequestSchema = z16.object({
+  requestId: z16.union([z16.string().min(1), z16.number()]),
+  threadId: z16.string().min(1),
+  providerThreadId: z16.string().min(1),
+  turnId: z16.string().min(1),
+  callId: z16.string().min(1),
+  tool: z16.string().min(1),
+  arguments: z16.unknown().optional()
+});
+var toolCallResponseSchema = z16.object({
+  contentItems: z16.array(toolCallOutputItemSchema),
+  success: z16.boolean()
+});
+var dynamicToolSchema = z16.object({
+  name: z16.string(),
+  description: z16.string(),
+  inputSchema: z16.unknown(),
   presentation: threadEventItemPresentationSchema.optional()
 });
 
@@ -2357,10 +2370,10 @@ function reasoningEffortsForLevels(levels) {
 }
 
 // ../provider-bridge-acp/src/launch-spec.ts
-import { z as z16 } from "zod";
-var acpNativeSkillRootsSchema = z16.object({
-  user: z16.array(providerNativeRootInputSchema).default([]),
-  project: z16.array(providerNativeRootInputSchema).default([])
+import { z as z17 } from "zod";
+var acpNativeSkillRootsSchema = z17.object({
+  user: z17.array(providerNativeRootInputSchema).default([]),
+  project: z17.array(providerNativeRootInputSchema).default([])
 }).strict().superRefine((roots, context) => {
   const normalized = providerNativeRootsSchema.safeParse(
     normalizeProviderNativeRoots(roots)
@@ -2376,16 +2389,16 @@ var acpNativeSkillRootsSchema = z16.object({
     });
   }
 });
-var acpLaunchSpecSchema = z16.object({
-  displayName: z16.string().min(1),
-  command: z16.string().min(1),
-  args: z16.array(z16.string()),
-  env: z16.record(z16.string().min(1), z16.string()),
-  cwd: z16.string().min(1).optional(),
-  modelCli: z16.object({
-    listArgs: z16.array(z16.string()),
-    selectFlag: z16.string().min(1).optional(),
-    primaryModels: z16.array(z16.string())
+var acpLaunchSpecSchema = z17.object({
+  displayName: z17.string().min(1),
+  command: z17.string().min(1),
+  args: z17.array(z17.string()),
+  env: z17.record(z17.string().min(1), z17.string()),
+  cwd: z17.string().min(1).optional(),
+  modelCli: z17.object({
+    listArgs: z17.array(z17.string()),
+    selectFlag: z17.string().min(1).optional(),
+    primaryModels: z17.array(z17.string())
   }).strict().transform(
     (modelCli) => modelCli.listArgs.length > 0 ? modelCli : void 0
   ).optional(),
@@ -2400,66 +2413,66 @@ var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
 var THREAD_DELTA_GRAMMAR_V3 = 3;
 
 // ../provider-bridge-protocol/src/handshake.ts
-import { z as z17 } from "zod";
-var bridgeGrammarVersionsSchema = z17.tuple([z17.number().int().positive(), z17.number().int().positive()]).refine(([min, max]) => min <= max, {
+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"
 });
-var bridgeSteerModeSchema = z17.enum(["inject", "queue"]);
-var bridgeCapabilitiesSchema = z17.object({
-  sessionRestore: z17.boolean().default(false),
-  threadArchive: z17.boolean().default(false),
-  threadRename: z17.boolean().default(false),
-  threadGoalClear: z17.boolean().default(false),
+var bridgeSteerModeSchema = z18.enum(["inject", "queue"]);
+var bridgeCapabilitiesSchema = z18.object({
+  sessionRestore: z18.boolean().default(false),
+  threadArchive: z18.boolean().default(false),
+  threadRename: z18.boolean().default(false),
+  threadGoalClear: z18.boolean().default(false),
   fork: providerForkSchema.default("none"),
-  approvalEnforcedBy: z17.enum(["runtime", "provider"]).default("runtime"),
+  approvalEnforcedBy: z18.enum(["runtime", "provider"]).default("runtime"),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ]),
   steerMode: bridgeSteerModeSchema.default("queue"),
-  skills: z17.object({ configure: z17.boolean().default(false) }).default({ configure: false })
+  skills: z18.object({ configure: z18.boolean().default(false) }).default({ configure: false })
 }).passthrough();
-var initializeParamsSchema = z17.object({
-  protocolVersion: z17.number().int().positive(),
-  client: z17.object({ name: z17.string().min(1), version: z17.string().min(1) }),
+var initializeParamsSchema = z18.object({
+  protocolVersion: z18.number().int().positive(),
+  client: z18.object({ name: z18.string().min(1), version: z18.string().min(1) }),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ])
 }).passthrough();
-var initializeResultSchema = z17.object({
-  protocolVersion: z17.number().int().positive(),
-  capabilities: z17.preprocess(
+var initializeResultSchema = z18.object({
+  protocolVersion: z18.number().int().positive(),
+  capabilities: z18.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
   )
 }).passthrough();
 
 // ../provider-bridge-protocol/src/execution-options.ts
-import { z as z18 } from "zod";
-var bridgeExecutionOptionsSchema = z18.object({
-  model: z18.string().min(1).optional(),
+import { z as z19 } from "zod";
+var bridgeExecutionOptionsSchema = z19.object({
+  model: z19.string().min(1).optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
   promptMode: promptModeSchema.optional(),
-  instructions: z18.string().optional(),
-  envVars: z18.record(z18.string(), z18.string()).optional(),
-  providerOptions: z18.record(z18.string(), z18.unknown()).optional()
+  instructions: z19.string().optional(),
+  envVars: z19.record(z19.string(), z19.string()).optional(),
+  providerOptions: z19.record(z19.string(), z19.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
 // ../provider-bridge-protocol/src/provider-maintenance.ts
-import { z as z19 } from "zod";
-var providerMaintenanceParamsSchema = z19.object({
-  providerId: z19.string().min(1),
-  cwd: z19.string().min(1).optional(),
-  providerOptions: z19.record(z19.string(), z19.unknown()).optional()
+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 = z19.enum(["thread_rewind"]);
+var providerInstallationRequirementSchema = z20.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
-var providerHealthSchema = z19.object({
-  status: z19.enum([
+var providerHealthSchema = z20.object({
+  status: z20.enum([
     "ready",
     "not_installed",
     "unauthenticated",
@@ -2467,114 +2480,114 @@ var providerHealthSchema = z19.object({
     "unsupported_version",
     "unknown"
   ]),
-  statusMessage: z19.string().min(1).nullable(),
-  accountEmail: z19.string().nullable(),
-  planLabel: z19.string().min(1).nullable(),
-  installedVersion: z19.string().min(1).nullable(),
-  minimumSupportedVersion: z19.string().min(1).nullable(),
-  canInstall: z19.boolean(),
-  canUpdate: z19.boolean(),
-  loginCommand: z19.string().min(1).nullable()
+  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 = z19.object({
-  label: z19.string().min(1),
-  usedPercent: z19.number().min(0).max(100),
-  resetsAt: z19.string().min(1).nullable(),
-  cost: z19.object({
-    usedUsdCents: z19.number().int().nonnegative(),
-    limitUsdCents: z19.number().int().positive()
+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 = z19.discriminatedUnion("status", [
-  z19.object({
-    status: z19.literal("ok"),
-    accountEmail: z19.string().email().nullable(),
-    planLabel: z19.string().min(1).nullable(),
-    windows: z19.array(providerUsageWindowSchema)
+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(),
-  z19.object({ status: z19.literal("not_installed") }).passthrough(),
-  z19.object({ status: z19.literal("unauthenticated") }).passthrough(),
-  z19.object({ status: z19.literal("expired") }).passthrough(),
-  z19.object({
-    status: z19.literal("error"),
-    message: z19.string().min(1),
-    planLabel: z19.string().min(1).nullable().default(null),
-    accountEmail: z19.string().nullable().default(null)
+  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 = z19.discriminatedUnion("supported", [
-  z19.object({ supported: z19.literal(false) }).passthrough(),
-  z19.object({
-    supported: z19.literal(true),
+var providerHealthResultSchema = z20.discriminatedUnion("supported", [
+  z20.object({ supported: z20.literal(false) }).passthrough(),
+  z20.object({
+    supported: z20.literal(true),
     health: providerHealthSchema
   }).passthrough()
 ]);
-var providerUsageResultSchema = z19.discriminatedUnion("supported", [
-  z19.object({ supported: z19.literal(false) }).passthrough(),
-  z19.object({
-    supported: z19.literal(true),
+var providerUsageResultSchema = z20.discriminatedUnion("supported", [
+  z20.object({ supported: z20.literal(false) }).passthrough(),
+  z20.object({
+    supported: z20.literal(true),
     usage: providerUsageSchema
   }).passthrough()
 ]);
-var providerInstallationActionKindSchema = z19.enum([
+var providerInstallationActionKindSchema = z20.enum([
   "install",
   "update"
 ]);
-var providerInstallationActionSchema = z19.object({
+var providerInstallationActionSchema = z20.object({
   kind: providerInstallationActionKindSchema,
-  label: z19.enum(["Install", "Update"]),
-  command: z19.string().min(1)
+  label: z20.enum(["Install", "Update"]),
+  command: z20.string().min(1)
 }).passthrough();
-var providerInstallationSourceSchema = z19.enum([
+var providerInstallationSourceSchema = z20.enum([
   "notInstalled",
   "npmGlobal",
   "external"
 ]);
-var providerInstallationStatusSchema = z19.object({
-  executableName: z19.string().min(1),
-  executablePath: z19.string().min(1).nullable(),
-  installed: z19.boolean(),
+var providerInstallationStatusSchema = z20.object({
+  executableName: z20.string().min(1),
+  executablePath: z20.string().min(1).nullable(),
+  installed: z20.boolean(),
   installSource: providerInstallationSourceSchema,
-  currentVersion: z19.string().min(1).nullable(),
-  latestVersion: z19.string().min(1).nullable(),
-  minimumSupportedVersion: z19.string().min(1).nullable(),
-  npmPackageName: z19.string().min(1).nullable(),
-  npmGlobalPackageVersion: z19.string().min(1).nullable(),
+  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: z19.boolean(),
-  versionUnsupported: z19.boolean()
+  needsUpdate: z20.boolean(),
+  versionUnsupported: z20.boolean()
 }).passthrough();
 var providerInstallationRunParamsSchema = providerMaintenanceParamsSchema.extend({
   action: providerInstallationActionKindSchema
 });
-var providerInstallationCommandSchema = z19.object({
-  command: z19.string().min(1),
-  args: z19.array(z19.string()).max(64),
-  displayCommand: z19.string().min(1)
+var providerInstallationCommandSchema = z20.object({
+  command: z20.string().min(1),
+  args: z20.array(z20.string()).max(64),
+  displayCommand: z20.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z19.discriminatedUnion(
+var providerInstallationVerificationSchema = z20.discriminatedUnion(
   "kind",
   [
-    z19.object({ kind: z19.literal("installed") }).passthrough(),
-    z19.object({
-      kind: z19.literal("version_changed"),
-      previousVersion: z19.string().min(1)
+    z20.object({ kind: z20.literal("installed") }).passthrough(),
+    z20.object({
+      kind: z20.literal("version_changed"),
+      previousVersion: z20.string().min(1)
     }).passthrough(),
-    z19.object({
-      kind: z19.literal("version_at_least"),
-      version: z19.string().min(1)
+    z20.object({
+      kind: z20.literal("version_at_least"),
+      version: z20.string().min(1)
     }).passthrough()
   ]
 );
-var providerInstallationRunResultSchema = z19.discriminatedUnion(
+var providerInstallationRunResultSchema = z20.discriminatedUnion(
   "available",
   [
-    z19.object({
-      available: z19.literal(false),
-      message: z19.string().min(1)
+    z20.object({
+      available: z20.literal(false),
+      message: z20.string().min(1)
     }).passthrough(),
-    z19.object({
-      available: z19.literal(true),
+    z20.object({
+      available: z20.literal(true),
       command: providerInstallationCommandSchema,
       verification: providerInstallationVerificationSchema
     }).passthrough()
@@ -2582,84 +2595,84 @@ var providerInstallationRunResultSchema = z19.discriminatedUnion(
 );
 
 // ../provider-bridge-protocol/src/requests.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var sessionConstructionFields = {
-  threadId: z20.string().min(1),
-  cwd: z20.string().min(1),
+  threadId: z21.string().min(1),
+  cwd: z21.string().min(1),
   options: bridgeExecutionOptionsSchema,
-  dynamicTools: z20.array(dynamicToolSchema).optional(),
-  disallowedTools: z20.array(z20.string().min(1)).optional(),
+  dynamicTools: z21.array(dynamicToolSchema).optional(),
+  disallowedTools: z21.array(z21.string().min(1)).optional(),
   instructionMode: instructionModeSchema
 };
-var modelListParamsSchema = z20.object({ cwd: z20.string().min(1).optional() }).passthrough();
-var threadStartParamsSchema = z20.object({
+var modelListParamsSchema = z21.object({ cwd: z21.string().min(1).optional() }).passthrough();
+var threadStartParamsSchema = z21.object({
   ...sessionConstructionFields,
-  input: z20.array(promptInputSchema).optional()
+  input: z21.array(promptInputSchema).optional()
 }).passthrough();
-var threadResumeParamsSchema = z20.object({
+var threadResumeParamsSchema = z21.object({
   ...sessionConstructionFields,
-  providerThreadId: z20.string().min(1)
+  providerThreadId: z21.string().min(1)
 }).passthrough();
-var threadForkParamsSchema = z20.object({
+var threadForkParamsSchema = z21.object({
   ...sessionConstructionFields,
-  sourceProviderThreadId: z20.string().min(1),
-  sourceProviderCheckpointId: z20.string().min(1).optional()
+  sourceProviderThreadId: z21.string().min(1),
+  sourceProviderCheckpointId: z21.string().min(1).optional()
 }).passthrough();
-var threadStopParamsSchema = z20.object({
-  threadId: z20.string().min(1),
-  providerThreadId: z20.string().min(1),
-  intent: z20.enum(["interrupt", "release"]),
-  activeTurnId: z20.string().min(1).nullable()
+var threadStopParamsSchema = z21.object({
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1),
+  intent: z21.enum(["interrupt", "release"]),
+  activeTurnId: z21.string().min(1).nullable()
 }).passthrough();
-var threadRefParams = z20.object({
-  threadId: z20.string().min(1),
-  providerThreadId: z20.string().min(1)
+var threadRefParams = z21.object({
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1)
 }).passthrough();
 var threadDiscardParamsSchema = threadRefParams;
-var threadNameSetParamsSchema = z20.object({
-  threadId: z20.string().min(1),
-  providerThreadId: z20.string().min(1),
-  title: z20.string().min(1)
+var threadNameSetParamsSchema = z21.object({
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1),
+  title: z21.string().min(1)
 }).passthrough();
 var turnInputFields = {
-  threadId: z20.string().min(1),
-  providerThreadId: z20.string().min(1),
-  input: z20.array(promptInputSchema),
+  threadId: z21.string().min(1),
+  providerThreadId: z21.string().min(1),
+  input: z21.array(promptInputSchema),
   clientRequestId: clientTurnRequestIdSchema,
   options: bridgeExecutionOptionsSchema
 };
-var turnStartParamsSchema = z20.object(turnInputFields).passthrough();
-var turnSteerParamsSchema = z20.object({
+var turnStartParamsSchema = z21.object(turnInputFields).passthrough();
+var turnSteerParamsSchema = z21.object({
   ...turnInputFields,
-  expectedTurnId: z20.string().min(1)
+  expectedTurnId: z21.string().min(1)
 }).passthrough();
-var skillsConfigureRootSchema = z20.object({
-  id: z20.string().min(1),
-  path: z20.string().min(1),
-  skills: z20.array(
-    z20.object({
-      name: z20.string().min(1),
-      description: z20.string()
+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 = z20.object({
-  roots: z20.array(skillsConfigureRootSchema)
+var skillsConfigureParamsSchema = z21.object({
+  roots: z21.array(skillsConfigureRootSchema)
 }).passthrough();
-var threadIdentityResultSchema = z20.object({
-  providerThreadId: z20.string().min(1),
-  sessionRestorable: z20.boolean().optional()
+var threadIdentityResultSchema = z21.object({
+  providerThreadId: z21.string().min(1),
+  sessionRestorable: z21.boolean().optional()
 }).passthrough();
-var modelListResultSchema = z20.object({
-  models: z20.array(availableModelSchema),
-  selectedOnlyModels: z20.array(availableModelSchema).default([])
+var modelListResultSchema = z21.object({
+  models: z21.array(availableModelSchema),
+  selectedOnlyModels: z21.array(availableModelSchema).default([])
 }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // ../provider-bridge-protocol/src/errors.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var BRIDGE_JSON_RPC_ERRORS = {
   INVALID_PARAMS: -32602,
   METHOD_NOT_FOUND: -32601,
@@ -2668,12 +2681,12 @@ var BRIDGE_JSON_RPC_ERRORS = {
   SESSION_NOT_RESTORABLE: -32002,
   FORK_CHECKPOINT_UNSUPPORTED: -32003
 };
-var providerRecoveryHintSchema = z21.object({
+var providerRecoveryHintSchema = z22.object({
   kind: providerRecoveryKindSchema,
-  message: z21.string().min(1),
-  retryable: z21.boolean()
+  message: z22.string().min(1),
+  retryable: z22.boolean()
 });
-var bridgeErrorDataSchema = z21.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
+var bridgeErrorDataSchema = z22.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
 var BRIDGE_NOTIFICATION_METHODS = {
@@ -2683,172 +2696,172 @@ var BRIDGE_NOTIFICATION_METHODS = {
   providerRecovery: "provider/recovery",
   error: "error"
 };
-var threadIdentityNotificationSchema = z22.object({
-  threadId: z22.string().min(1),
-  providerThreadId: z22.string().min(1),
-  sessionRestorable: z22.boolean().optional()
+var threadIdentityNotificationSchema = z23.object({
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1),
+  sessionRestorable: z23.boolean().optional()
 }).passthrough();
-var sessionReplacedNotificationSchema = z22.object({
-  threadId: z22.string().min(1),
-  providerThreadId: z22.string().min(1).nullable(),
-  reason: z22.string().min(1),
-  contextLost: z22.boolean().default(false)
+var sessionReplacedNotificationSchema = z23.object({
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1).nullable(),
+  reason: z23.string().min(1),
+  contextLost: z23.boolean().default(false)
 }).passthrough();
-var providerRawNotificationSchema = z22.object({
-  threadId: z22.string().min(1).optional(),
-  coverage: z22.enum(["noise", "unknown"]),
-  payload: z22.unknown()
+var providerRawNotificationSchema = z23.object({
+  threadId: z23.string().min(1).optional(),
+  coverage: z23.enum(["noise", "unknown"]),
+  payload: z23.unknown()
 }).passthrough();
-var providerRecoveryNotificationSchema = z22.object({
-  threadId: z22.string().min(1).optional(),
+var providerRecoveryNotificationSchema = z23.object({
+  threadId: z23.string().min(1).optional(),
   ...providerRecoveryHintSchema.shape
 }).passthrough();
-var errorNotificationSchema = z22.object({
-  threadId: z22.string().min(1).optional(),
-  message: z22.string().min(1)
+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 z23 } from "zod";
+import { z as z24 } from "zod";
 var BRIDGE_INBOUND_REQUEST_METHODS = {
   toolCall: "item/tool/call",
   interactionRequest: "interaction/request"
 };
-var toolCallRequestParamsSchema = z23.object({
-  providerThreadId: z23.string().min(1),
-  threadId: z23.string().min(1).optional(),
-  turnId: z23.union([z23.string().min(1), z23.null()]),
-  callId: z23.string().min(1),
-  tool: z23.string().min(1),
-  arguments: z23.unknown()
+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 = z23.object({
-  success: z23.boolean(),
-  contentItems: z23.array(
-    z23.discriminatedUnion("type", [
-      z23.object({ type: z23.literal("inputText"), text: z23.string() }),
-      z23.object({
-        type: z23.literal("inputImage"),
-        imageUrl: z23.string().min(1)
+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 = z23.object({
-  providerThreadId: z23.string().min(1),
-  threadId: z23.string().min(1).optional(),
-  turnId: z23.union([z23.string().min(1), z23.null()]),
+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,
-  providerNativeIds: z23.boolean().optional()
+  providerNativeIds: z24.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/thread-delta.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
 var deltaPresentationSchema = threadEventItemPresentationSchema;
 var THREAD_DELTA_KEY_SEPARATOR = "";
-var deltaKeyPartSchema = z24.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
+var deltaKeyPartSchema = z25.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
   message: "provider keys must not contain the internal key separator (\\u001f)"
 });
-var deltaItemKeySchema = z24.object({
+var deltaItemKeySchema = z25.object({
   providerItemId: deltaKeyPartSchema.optional(),
   channel: deltaKeyPartSchema.optional(),
   parentRef: deltaKeyPartSchema.optional()
 });
 var providerTurnIdSchema = deltaKeyPartSchema;
-var deltaFileChangeSchema = z24.object({
-  path: z24.string(),
-  kind: z24.enum(["add", "update", "delete"]),
-  movePath: z24.string().optional(),
-  diff: z24.string().optional(),
-  oldText: z24.string().optional(),
-  newText: z24.string().optional()
-});
-var deltaBackgroundTaskShapeSchema = z24.object({
-  type: z24.literal("backgroundTask"),
-  familyId: z24.string().min(1),
-  taskType: z24.string(),
-  description: z24.string(),
+var deltaFileChangeSchema = z25.object({
+  path: z25.string(),
+  kind: z25.enum(["add", "update", "delete"]),
+  movePath: z25.string().optional(),
+  diff: z25.string().optional(),
+  oldText: z25.string().optional(),
+  newText: z25.string().optional()
+});
+var deltaBackgroundTaskShapeSchema = z25.object({
+  type: z25.literal("backgroundTask"),
+  familyId: z25.string().min(1),
+  taskType: z25.string(),
+  description: z25.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z24.boolean(),
-  workflowName: z24.string().optional(),
+  skipTranscript: z25.boolean(),
+  workflowName: z25.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z24.string().optional(),
-  error: z24.string().optional(),
-  outputFile: z24.string().optional()
+  summary: z25.string().optional(),
+  error: z25.string().optional(),
+  outputFile: z25.string().optional()
 });
-var deltaFileReadShapeSchema = z24.object({
-  type: z24.literal("fileRead"),
-  path: z24.string(),
-  cmd: z24.string().optional()
+var deltaFileReadShapeSchema = z25.object({
+  type: z25.literal("fileRead"),
+  path: z25.string(),
+  cmd: z25.string().optional()
 });
-var deltaSearchShapeSchema = z24.object({
-  type: z24.literal("search"),
+var deltaSearchShapeSchema = z25.object({
+  type: z25.literal("search"),
   mode: threadEventSearchModeSchema,
-  query: z24.string(),
-  path: z24.string().optional(),
-  cmd: z24.string().optional()
+  query: z25.string(),
+  path: z25.string().optional(),
+  cmd: z25.string().optional()
 });
-var deltaDelegationShapeSchema = z24.object({
-  type: z24.literal("delegation"),
+var deltaDelegationShapeSchema = z25.object({
+  type: z25.literal("delegation"),
   childRef: deltaKeyPartSchema,
-  label: z24.string(),
-  background: z24.boolean(),
-  summary: z24.string().optional()
+  label: z25.string(),
+  background: z25.boolean(),
+  summary: z25.string().optional()
 });
-var deltaPlanStepsShapeSchema = z24.object({
-  type: z24.literal("planSteps"),
-  steps: z24.array(threadEventPlanStepSchema),
-  explanation: z24.string().optional()
+var deltaPlanStepsShapeSchema = z25.object({
+  type: z25.literal("planSteps"),
+  steps: z25.array(threadEventPlanStepSchema),
+  explanation: z25.string().optional()
 });
-var deltaExtensionShapeSchema = z24.object({
-  type: z24.literal("extension"),
+var deltaExtensionShapeSchema = z25.object({
+  type: z25.literal("extension"),
   kind: extensionKindSchema,
   payload: jsonValueSchema
 });
-var deltaItemShapeSchema = z24.discriminatedUnion("type", [
-  z24.object({
-    type: z24.literal("command"),
-    command: z24.string(),
-    cwd: z24.string(),
-    aggregatedOutput: z24.string().optional(),
-    exitCode: z24.number().optional(),
-    durationMs: z24.number().optional()
+var deltaItemShapeSchema = z25.discriminatedUnion("type", [
+  z25.object({
+    type: z25.literal("command"),
+    command: z25.string(),
+    cwd: z25.string(),
+    aggregatedOutput: z25.string().optional(),
+    exitCode: z25.number().optional(),
+    durationMs: z25.number().optional()
   }),
-  z24.object({
-    type: z24.literal("fileChange"),
-    changes: z24.array(deltaFileChangeSchema)
+  z25.object({
+    type: z25.literal("fileChange"),
+    changes: z25.array(deltaFileChangeSchema)
   }),
-  z24.object({
-    type: z24.literal("tool"),
-    tool: z24.string(),
-    server: z24.string().optional(),
-    args: z24.unknown().optional(),
-    result: z24.unknown().optional(),
-    error: z24.string().optional(),
-    durationMs: z24.number().optional()
+  z25.object({
+    type: z25.literal("tool"),
+    tool: z25.string(),
+    server: z25.string().optional(),
+    args: z25.unknown().optional(),
+    result: z25.unknown().optional(),
+    error: z25.string().optional(),
+    durationMs: z25.number().optional()
   }),
-  z24.object({ type: z24.literal("compaction") }),
-  z24.object({ type: z24.literal("agentMessage"), text: z24.string() }),
-  z24.object({
-    type: z24.literal("reasoning"),
-    summary: z24.array(z24.string()),
-    content: z24.array(z24.string())
+  z25.object({ type: z25.literal("compaction") }),
+  z25.object({ type: z25.literal("agentMessage"), text: z25.string() }),
+  z25.object({
+    type: z25.literal("reasoning"),
+    summary: z25.array(z25.string()),
+    content: z25.array(z25.string())
   }),
-  z24.object({ type: z24.literal("plan"), text: z24.string() }),
-  z24.object({
-    type: z24.literal("webSearch"),
-    queries: z24.array(z24.string()).min(1)
+  z25.object({ type: z25.literal("plan"), text: z25.string() }),
+  z25.object({
+    type: z25.literal("webSearch"),
+    queries: z25.array(z25.string()).min(1)
   }),
-  z24.object({
-    type: z24.literal("webFetch"),
-    url: z24.string(),
-    prompt: z24.string().nullable().optional(),
-    pattern: z24.string().nullable()
+  z25.object({
+    type: z25.literal("webFetch"),
+    url: z25.string(),
+    prompt: z25.string().nullable().optional(),
+    pattern: z25.string().nullable()
   }),
-  z24.object({ type: z24.literal("imageView"), path: z24.string() }),
+  z25.object({ type: z25.literal("imageView"), path: z25.string() }),
   deltaBackgroundTaskShapeSchema,
   deltaFileReadShapeSchema,
   deltaSearchShapeSchema,
@@ -2856,22 +2869,22 @@ var deltaItemShapeSchema = z24.discriminatedUnion("type", [
   deltaPlanStepsShapeSchema,
   deltaExtensionShapeSchema
 ]);
-var deltaProgressSnapshotSchema = z24.discriminatedUnion("type", [
+var deltaProgressSnapshotSchema = z25.discriminatedUnion("type", [
   deltaBackgroundTaskShapeSchema,
   deltaDelegationShapeSchema
 ]);
-var deltaTextChannelSchema = z24.enum([
+var deltaTextChannelSchema = z25.enum([
   "agentMessage",
   "reasoningSummary",
   "reasoningText",
   "plan"
 ]);
-var deltaOutputChannelSchema = z24.enum(["command", "fileChange"]);
-var deltaErrorSchema = z24.object({ message: z24.string() });
-var deltaAttachSchema = z24.enum(["open", "currentOrLast"]);
-var deltaNoTurnFallbackSchema = z24.object({
+var deltaOutputChannelSchema = z25.enum(["command", "fileChange"]);
+var deltaErrorSchema = z25.object({ message: z25.string() });
+var deltaAttachSchema = z25.enum(["open", "currentOrLast"]);
+var deltaNoTurnFallbackSchema = z25.object({
   raw: providerRawEventSchema,
-  rawType: z24.string()
+  rawType: z25.string()
 });
 function requireExtensionPresentation(delta, ctx) {
   if (delta.item.type === "extension" && delta.presentation === void 0) {
@@ -2882,32 +2895,32 @@ function requireExtensionPresentation(delta, ctx) {
     });
   }
 }
-var threadDeltaSchema = z24.discriminatedUnion("kind", [
-  z24.object({
-    kind: z24.literal("input.accepted"),
+var threadDeltaSchema = z25.discriminatedUnion("kind", [
+  z25.object({
+    kind: z25.literal("input.accepted"),
     clientRequestId: clientTurnRequestIdSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("input.provider"),
-    text: z24.string().min(1),
+  z25.object({
+    kind: z25.literal("input.provider"),
+    text: z25.string().min(1),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("turn.open"),
+  z25.object({
+    kind: z25.literal("turn.open"),
     providerTurnId: providerTurnIdSchema.optional(),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("turn.boundary"),
+  z25.object({
+    kind: z25.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
     error: deltaErrorSchema.optional(),
-    providerCheckpointId: z24.string().min(1).optional(),
-    claimIfIdle: z24.boolean().optional(),
+    providerCheckpointId: z25.string().min(1).optional(),
+    claimIfIdle: z25.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("item.open"),
+  z25.object({
+    kind: z25.literal("item.open"),
     key: deltaItemKeySchema,
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
@@ -2915,153 +2928,153 @@ var threadDeltaSchema = z24.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z24.object({
-    kind: z24.literal("item.close"),
+  z25.object({
+    kind: z25.literal("item.close"),
     key: deltaItemKeySchema,
     status: threadEventItemStatusSchema,
-    resultText: z24.string().optional(),
-    exitCode: z24.number().optional(),
-    aggregatedOutput: z24.string().optional(),
-    approvalStatus: z24.literal("denied").optional(),
+    resultText: z25.string().optional(),
+    exitCode: z25.number().optional(),
+    aggregatedOutput: z25.string().optional(),
+    approvalStatus: z25.literal("denied").optional(),
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z24.object({
-    kind: z24.literal("item.progress"),
+  z25.object({
+    kind: z25.literal("item.progress"),
     key: deltaItemKeySchema,
-    message: z24.string().optional(),
+    message: z25.string().optional(),
     snapshot: deltaProgressSnapshotSchema.optional(),
-    flush: z24.boolean().optional(),
+    flush: z25.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("item.textDelta"),
+  z25.object({
+    kind: z25.literal("item.textDelta"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z24.string(),
+    text: z25.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("item.textClose"),
+  z25.object({
+    kind: z25.literal("item.textClose"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z24.string().optional(),
+    text: z25.string().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("item.outputDelta"),
+  z25.object({
+    kind: z25.literal("item.outputDelta"),
     key: deltaItemKeySchema,
     channel: deltaOutputChannelSchema,
-    text: z24.string(),
+    text: z25.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("command.outputSnapshot"),
+  z25.object({
+    kind: z25.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
-    text: z24.string(),
+    text: z25.string(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("usage"),
+  z25.object({
+    kind: z25.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
     last: threadEventTokenUsageBreakdownSchema,
-    modelContextWindow: z24.number().nullable(),
+    modelContextWindow: z25.number().nullable(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("contextWindow"),
-    used: z24.number().nullable(),
-    size: z24.number().nullable().optional(),
-    estimated: z24.boolean(),
+  z25.object({
+    kind: z25.literal("contextWindow"),
+    used: z25.number().nullable(),
+    size: z25.number().nullable().optional(),
+    estimated: z25.boolean(),
     attach: deltaAttachSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z24.object({
-    kind: z24.literal("context.compacted"),
+  z25.object({
+    kind: z25.literal("context.compacted"),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z24.object({ kind: z24.literal("context.cleared") }),
-  z24.object({
-    kind: z24.literal("turn.diff"),
-    diff: z24.string(),
+  z25.object({ kind: z25.literal("context.cleared") }),
+  z25.object({
+    kind: z25.literal("turn.diff"),
+    diff: z25.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z24.object({ kind: z24.literal("thread.started") }),
-  z24.object({
-    kind: z24.literal("thread.identity"),
-    providerThreadId: z24.string().min(1)
+  z25.object({ kind: z25.literal("thread.started") }),
+  z25.object({
+    kind: z25.literal("thread.identity"),
+    providerThreadId: z25.string().min(1)
   }),
-  z24.object({ kind: z24.literal("thread.name"), name: z24.string().min(1) }),
-  z24.object({
-    kind: z24.literal("extension.state"),
+  z25.object({ kind: z25.literal("thread.name"), name: z25.string().min(1) }),
+  z25.object({
+    kind: z25.literal("extension.state"),
     extensionKind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z24.object({
-    kind: z24.literal("provider.rateLimits"),
+  z25.object({
+    kind: z25.literal("provider.rateLimits"),
     rateLimits: providerRateLimitStateSchema
   }),
-  z24.object({
-    kind: z24.literal("provider.error"),
-    message: z24.string(),
-    detail: z24.string().optional(),
-    willRetry: z24.boolean().optional(),
+  z25.object({
+    kind: z25.literal("provider.error"),
+    message: z25.string(),
+    detail: z25.string().optional(),
+    willRetry: z25.boolean().optional(),
     category: providerErrorCategorySchema.optional(),
     errorInfo: providerErrorInfoSchema.optional(),
-    settlesTurn: z24.boolean().optional(),
+    settlesTurn: z25.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
-    threadScoped: z24.boolean().optional()
+    threadScoped: z25.boolean().optional()
   }),
-  z24.object({
-    kind: z24.literal("provider.modelFallback"),
-    originalModel: z24.string().min(1),
-    fallbackModel: z24.string().min(1),
-    reason: z24.enum(["refusal", "provider"]),
-    message: z24.string()
+  z25.object({
+    kind: z25.literal("provider.modelFallback"),
+    originalModel: z25.string().min(1),
+    fallbackModel: z25.string().min(1),
+    reason: z25.enum(["refusal", "provider"]),
+    message: z25.string()
   }),
-  z24.object({
-    kind: z24.literal("provider.warning"),
-    summary: z24.string().optional(),
-    details: z24.string().optional(),
+  z25.object({
+    kind: z25.literal("provider.warning"),
+    summary: z25.string().optional(),
+    details: z25.string().optional(),
     category: threadEventWarningCategorySchema.optional(),
-    vouchedTurn: z24.boolean().optional()
+    vouchedTurn: z25.boolean().optional()
   }),
-  z24.object({
-    kind: z24.literal("unhandled"),
+  z25.object({
+    kind: z25.literal("unhandled"),
     raw: providerRawEventSchema,
-    rawType: z24.string(),
-    vouchedTurn: z24.boolean(),
-    onlyIfNoTurn: z24.boolean().optional(),
+    rawType: z25.string(),
+    vouchedTurn: z25.boolean(),
+    onlyIfNoTurn: z25.boolean().optional(),
     parentRef: deltaKeyPartSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z24.object({ kind: z24.literal("session.ended") }),
-  z24.object({ kind: z24.literal("session.reset") })
+  z25.object({ kind: z25.literal("session.ended") }),
+  z25.object({ kind: z25.literal("session.reset") })
 ]);
-var threadDeltaNotificationParamsSchema = z24.object({
-  threadId: z24.string().min(1),
-  deltas: z24.array(threadDeltaSchema)
+var threadDeltaNotificationParamsSchema = z25.object({
+  threadId: z25.string().min(1),
+  deltas: z25.array(threadDeltaSchema)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-kit/adapter-utils.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // ../provider-bridge-protocol/src/bridge-kit/tool-arg-schemas.ts
-import { z as z25 } from "zod";
-var bashArgsSchema = z25.object({
-  command: z25.string().optional(),
-  cwd: z25.string().optional()
+import { z as z26 } from "zod";
+var bashArgsSchema = z26.object({
+  command: z26.string().optional(),
+  cwd: z26.string().optional()
 }).passthrough();
-var textBlockSchema = z25.object({
-  type: z25.literal("text"),
-  text: z25.string()
+var textBlockSchema = z26.object({
+  type: z26.literal("text"),
+  text: z26.string()
 });
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility-helpers.ts
@@ -3074,10 +3087,10 @@ function getStringProperty(value, key) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/adapter-utils.ts
-var contentWrapperSchema = z26.object({
-  content: z26.array(z26.unknown())
+var contentWrapperSchema = z27.object({
+  content: z27.array(z27.unknown())
 }).passthrough();
-var shellEnvironmentVariableKeySchema = z26.string().regex(/^[A-Z_][A-Z0-9_]*$/i);
+var shellEnvironmentVariableKeySchema = z27.string().regex(/^[A-Z_][A-Z0-9_]*$/i);
 function toOptionalString(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -3432,41 +3445,41 @@ function withoutBridgeRuntimeEnv(env) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/bridge-tool-calls.ts
-import { z as z27 } from "zod";
-var providerToolCallResponseSchema = z27.object({
-  success: z27.boolean(),
-  contentItems: z27.array(
-    z27.discriminatedUnion("type", [
-      z27.object({
-        type: z27.literal("inputText"),
-        text: z27.string()
+import { z as z28 } from "zod";
+var providerToolCallResponseSchema = z28.object({
+  success: z28.boolean(),
+  contentItems: z28.array(
+    z28.discriminatedUnion("type", [
+      z28.object({
+        type: z28.literal("inputText"),
+        text: z28.string()
       }),
-      z27.object({
-        type: z27.literal("inputImage"),
-        imageUrl: z27.string().min(1)
+      z28.object({
+        type: z28.literal("inputImage"),
+        imageUrl: z28.string().min(1)
       })
     ])
   )
 });
-var bridgeRequestEnvelopeSchema = z27.object({
-  jsonrpc: z27.literal("2.0"),
-  id: z27.union([z27.string(), z27.number()]),
-  method: z27.string(),
-  params: z27.record(z27.string(), z27.unknown()).optional()
-});
-var jsonRpcErrorSchema = z27.object({
-  code: z27.number(),
-  message: z27.string().optional(),
-  data: z27.unknown().optional()
-});
-var jsonRpcSuccessResponseSchema = z27.object({
-  jsonrpc: z27.literal("2.0"),
-  id: z27.union([z27.string(), z27.number()]),
-  result: z27.unknown()
-});
-var jsonRpcErrorResponseSchema = z27.object({
-  jsonrpc: z27.literal("2.0"),
-  id: z27.union([z27.string(), z27.number()]),
+var bridgeRequestEnvelopeSchema = z28.object({
+  jsonrpc: z28.literal("2.0"),
+  id: z28.union([z28.string(), z28.number()]),
+  method: z28.string(),
+  params: z28.record(z28.string(), z28.unknown()).optional()
+});
+var jsonRpcErrorSchema = z28.object({
+  code: z28.number(),
+  message: z28.string().optional(),
+  data: z28.unknown().optional()
+});
+var jsonRpcSuccessResponseSchema = z28.object({
+  jsonrpc: z28.literal("2.0"),
+  id: z28.union([z28.string(), z28.number()]),
+  result: z28.unknown()
+});
+var jsonRpcErrorResponseSchema = z28.object({
+  jsonrpc: z28.literal("2.0"),
+  id: z28.union([z28.string(), z28.number()]),
   error: jsonRpcErrorSchema
 });
 function isJsonRpcRequest(input) {
@@ -3554,47 +3567,47 @@ function buildBridgeToolCallContent(result) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/json-rpc-envelope.ts
-import { z as z28 } from "zod";
-var recordSchema = z28.record(z28.string(), z28.unknown());
-var jsonRpcEnvelopeSchema = z28.object({
-  jsonrpc: z28.literal("2.0"),
-  method: z28.string(),
+import { z as z29 } from "zod";
+var recordSchema = z29.record(z29.string(), z29.unknown());
+var jsonRpcEnvelopeSchema = z29.object({
+  jsonrpc: z29.literal("2.0"),
+  method: z29.string(),
   params: recordSchema.optional()
 }).passthrough();
-var sdkMessageEnvelopeSchema = z28.object({
-  jsonrpc: z28.literal("2.0"),
-  method: z28.literal("sdk/message"),
-  params: z28.object({
-    message: z28.unknown(),
-    threadId: z28.string().optional(),
-    parent_tool_use_id: z28.string().optional()
+var sdkMessageEnvelopeSchema = z29.object({
+  jsonrpc: z29.literal("2.0"),
+  method: z29.literal("sdk/message"),
+  params: z29.object({
+    message: z29.unknown(),
+    threadId: z29.string().optional(),
+    parent_tool_use_id: z29.string().optional()
   }).passthrough()
 }).passthrough();
-var threadIdentityEnvelopeSchema = z28.object({
-  jsonrpc: z28.literal("2.0"),
-  method: z28.literal("thread/identity"),
-  params: z28.object({
-    threadId: z28.string().optional(),
-    providerThreadId: z28.string().optional()
+var threadIdentityEnvelopeSchema = z29.object({
+  jsonrpc: z29.literal("2.0"),
+  method: z29.literal("thread/identity"),
+  params: z29.object({
+    threadId: z29.string().optional(),
+    providerThreadId: z29.string().optional()
   }).passthrough()
 }).passthrough();
-var threadContextWindowUsageEnvelopeSchema = z28.object({
-  jsonrpc: z28.literal("2.0"),
-  method: z28.literal("thread/contextWindowUsage/updated"),
-  params: z28.object({
-    threadId: z28.string().optional(),
-    contextWindowUsage: z28.object({
-      usedTokens: z28.number().nullable(),
-      modelContextWindow: z28.number().nullable(),
-      estimated: z28.boolean()
+var threadContextWindowUsageEnvelopeSchema = z29.object({
+  jsonrpc: z29.literal("2.0"),
+  method: z29.literal("thread/contextWindowUsage/updated"),
+  params: z29.object({
+    threadId: z29.string().optional(),
+    contextWindowUsage: z29.object({
+      usedTokens: z29.number().nullable(),
+      modelContextWindow: z29.number().nullable(),
+      estimated: z29.boolean()
     })
   }).passthrough()
 }).passthrough();
-var errorEnvelopeSchema = z28.object({
-  jsonrpc: z28.literal("2.0"),
-  method: z28.literal("error"),
-  params: z28.object({
-    message: z28.string().optional()
+var errorEnvelopeSchema = z29.object({
+  jsonrpc: z29.literal("2.0"),
+  method: z29.literal("error"),
+  params: z29.object({
+    message: z29.string().optional()
   }).passthrough().optional()
 }).passthrough();
 
@@ -3701,7 +3714,7 @@ import { constants as fsConstants } from "node:fs";
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var execFileAsync = promisify(execFile);
 var CLI_PROBE_TIMEOUT_MS = 5e3;
 async function resolveExecutablePath(command) {
@@ -3751,15 +3764,15 @@ function clampPercent(value) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-tool-call-contract.ts
-import { z as z30 } from "zod";
-var normalizedToolCallRequestSchema = z30.object({
-  providerThreadId: z30.string().min(1),
-  threadId: z30.string().min(1).optional(),
-  turnId: z30.union([z30.string().min(1), z30.null()]),
-  callId: z30.string().min(1),
-  tool: z30.string().min(1),
-  arguments: z30.unknown(),
-  providerNativeIds: z30.boolean().optional()
+import { z as z31 } from "zod";
+var normalizedToolCallRequestSchema = z31.object({
+  providerThreadId: z31.string().min(1),
+  threadId: z31.string().min(1).optional(),
+  turnId: z31.union([z31.string().min(1), z31.null()]),
+  callId: z31.string().min(1),
+  tool: z31.string().min(1),
+  arguments: z31.unknown(),
+  providerNativeIds: z31.boolean().optional()
 });
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility.ts
@@ -3774,8 +3787,8 @@ function createProviderVisibilityMetadata(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
-import { z as z31 } from "zod";
-var ignoredJsonRpcResultSchema = z31.unknown();
+import { z as z32 } from "zod";
+var ignoredJsonRpcResultSchema = z32.unknown();
 
 // ../provider-bridge-acp/src/bridge/bridge.ts
 import { execFile as execFile4 } from "node:child_process";
@@ -3784,21 +3797,21 @@ import { promises as fs2, readFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { dirname as dirname2, isAbsolute, basename as basename3, relative, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // ../provider-bridge-acp/src/wire.ts
-import { z as z32 } from "zod";
-var acpTextContentBlockSchema = z32.object({
-  type: z32.literal("text"),
-  text: z32.string()
+import { z as z33 } from "zod";
+var acpTextContentBlockSchema = z33.object({
+  type: z33.literal("text"),
+  text: z33.string()
 }).passthrough();
-var acpOtherContentBlockSchema = z32.object({
-  type: z32.string()
+var acpOtherContentBlockSchema = z33.object({
+  type: z33.string()
 }).passthrough();
-var acpContentBlockSchema = z32.union([
+var acpContentBlockSchema = z33.union([
   acpTextContentBlockSchema,
   acpOtherContentBlockSchema
 ]);
@@ -3821,7 +3834,7 @@ var ACP_TOOL_KINDS = [
   "switch_mode",
   "other"
 ];
-var acpToolKindSchema = z32.enum(ACP_TOOL_KINDS);
+var acpToolKindSchema = z33.enum(ACP_TOOL_KINDS);
 var ACP_TOOL_KIND_SET = new Set(ACP_TOOL_KINDS);
 var ACP_TOOL_CALL_STATUSES = [
   "pending",
@@ -3830,48 +3843,48 @@ var ACP_TOOL_CALL_STATUSES = [
   "failed",
   "cancelled"
 ];
-var acpToolCallStatusSchema = z32.enum(ACP_TOOL_CALL_STATUSES);
+var acpToolCallStatusSchema = z33.enum(ACP_TOOL_CALL_STATUSES);
 var ACP_TOOL_CALL_STATUS_SET = new Set(
   ACP_TOOL_CALL_STATUSES
 );
-var acpToolCallContentSchema = z32.union([
-  z32.object({
-    type: z32.literal("content"),
+var acpToolCallContentSchema = z33.union([
+  z33.object({
+    type: z33.literal("content"),
     content: acpContentBlockSchema
   }).passthrough(),
-  z32.object({
-    type: z32.literal("diff"),
-    path: z32.string(),
-    oldText: z32.string().nullable().optional(),
-    newText: z32.string()
+  z33.object({
+    type: z33.literal("diff"),
+    path: z33.string(),
+    oldText: z33.string().nullable().optional(),
+    newText: z33.string()
   }).passthrough(),
-  z32.object({
-    type: z32.literal("terminal"),
-    terminalId: z32.string()
+  z33.object({
+    type: z33.literal("terminal"),
+    terminalId: z33.string()
   }).passthrough()
 ]);
-var acpToolCallContentListSchema = z32.array(z32.unknown()).transform(
+var acpToolCallContentListSchema = z33.array(z33.unknown()).transform(
   (entries) => entries.flatMap((entry) => {
     const parsed = acpToolCallContentSchema.safeParse(entry);
     return parsed.success ? [parsed.data] : [];
   })
 );
-var acpToolCallLocationSchema = z32.object({
-  path: z32.string(),
-  line: z32.number().optional().nullable()
+var acpToolCallLocationSchema = z33.object({
+  path: z33.string(),
+  line: z33.number().optional().nullable()
 }).passthrough();
-var acpToolCallNameSchema = z32.union([z32.string(), z32.null()]).transform((value) => value ?? void 0).optional();
-var acpToolCallFieldsSchema = z32.object({
-  toolCallId: z32.string(),
-  title: z32.string().optional(),
+var acpToolCallNameSchema = z33.union([z33.string(), z33.null()]).transform((value) => value ?? void 0).optional();
+var acpToolCallFieldsSchema = z33.object({
+  toolCallId: z33.string(),
+  title: z33.string().optional(),
   name: acpToolCallNameSchema,
   kind: acpToolKindSchema.optional(),
-  rawKind: z32.string().optional(),
+  rawKind: z33.string().optional(),
   status: acpToolCallStatusSchema.optional(),
   content: acpToolCallContentListSchema.optional(),
-  locations: z32.array(acpToolCallLocationSchema).optional(),
-  rawInput: z32.unknown().optional(),
-  rawOutput: z32.unknown().optional()
+  locations: z33.array(acpToolCallLocationSchema).optional(),
+  rawInput: z33.unknown().optional(),
+  rawOutput: z33.unknown().optional()
 });
 function openAcpToolCallEnums(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -3897,43 +3910,43 @@ function openAcpToolCallEnums(value) {
   }
   return next;
 }
-var acpAgentMessageChunkUpdateSchema = z32.object({
-  sessionUpdate: z32.literal("agent_message_chunk"),
+var acpAgentMessageChunkUpdateSchema = z33.object({
+  sessionUpdate: z33.literal("agent_message_chunk"),
   content: acpContentBlockSchema
 }).passthrough();
-var acpAgentThoughtChunkUpdateSchema = z32.object({
-  sessionUpdate: z32.literal("agent_thought_chunk"),
+var acpAgentThoughtChunkUpdateSchema = z33.object({
+  sessionUpdate: z33.literal("agent_thought_chunk"),
   content: acpContentBlockSchema
 }).passthrough();
-var acpToolCallUpdateEventSchema = z32.preprocess(
+var acpToolCallUpdateEventSchema = z33.preprocess(
   openAcpToolCallEnums,
   acpToolCallFieldsSchema.extend({
-    sessionUpdate: z32.enum(["tool_call", "tool_call_update"])
+    sessionUpdate: z33.enum(["tool_call", "tool_call_update"])
   }).passthrough()
 );
-var acpPlanEntryStatusSchema = z32.enum([
+var acpPlanEntryStatusSchema = z33.enum([
   "pending",
   "in_progress",
   "completed"
 ]);
-var acpPlanUpdateSchema = z32.object({
-  sessionUpdate: z32.literal("plan"),
-  entries: z32.array(
-    z32.object({
-      content: z32.string(),
+var acpPlanUpdateSchema = z33.object({
+  sessionUpdate: z33.literal("plan"),
+  entries: z33.array(
+    z33.object({
+      content: z33.string(),
       status: acpPlanEntryStatusSchema.optional()
     }).passthrough()
   )
 }).passthrough();
-var acpUsageUpdateSchema = z32.object({
-  sessionUpdate: z32.literal("usage_update"),
-  used: z32.number().int().nonnegative(),
-  size: z32.number().int().nonnegative()
+var acpUsageUpdateSchema = z33.object({
+  sessionUpdate: z33.literal("usage_update"),
+  used: z33.number().int().nonnegative(),
+  size: z33.number().int().nonnegative()
 }).passthrough();
-var acpOtherSessionUpdateSchema = z32.object({
-  sessionUpdate: z32.string()
+var acpOtherSessionUpdateSchema = z33.object({
+  sessionUpdate: z33.string()
 }).passthrough();
-var acpSessionUpdateSchema = z32.union([
+var acpSessionUpdateSchema = z33.union([
   acpAgentMessageChunkUpdateSchema,
   acpAgentThoughtChunkUpdateSchema,
   acpToolCallUpdateEventSchema,
@@ -3941,55 +3954,55 @@ var acpSessionUpdateSchema = z32.union([
   acpUsageUpdateSchema,
   acpOtherSessionUpdateSchema
 ]);
-var acpSessionNotificationParamsSchema = z32.object({
-  sessionId: z32.string(),
+var acpSessionNotificationParamsSchema = z33.object({
+  sessionId: z33.string(),
   update: acpSessionUpdateSchema
 }).passthrough();
 var ACP_PROTOCOL_VERSION = 1;
-var acpInitializeResultSchema = z32.object({
-  protocolVersion: z32.number(),
-  agentCapabilities: z32.object({
-    loadSession: z32.boolean().optional(),
-    sessionCapabilities: z32.object({
-      fork: z32.object({}).passthrough().nullable().optional()
+var acpInitializeResultSchema = z33.object({
+  protocolVersion: z33.number(),
+  agentCapabilities: z33.object({
+    loadSession: z33.boolean().optional(),
+    sessionCapabilities: z33.object({
+      fork: z33.object({}).passthrough().nullable().optional()
     }).passthrough().optional(),
-    promptCapabilities: z32.object({
-      image: z32.boolean().optional(),
-      audio: z32.boolean().optional(),
-      embeddedContext: z32.boolean().optional()
+    promptCapabilities: z33.object({
+      image: z33.boolean().optional(),
+      audio: z33.boolean().optional(),
+      embeddedContext: z33.boolean().optional()
     }).passthrough().optional()
   }).passthrough().optional(),
-  authMethods: z32.array(z32.object({ id: z32.string() }).passthrough()).optional()
+  authMethods: z33.array(z33.object({ id: z33.string() }).passthrough()).optional()
 }).passthrough();
-var acpOptionalString = z32.union([z32.string(), z32.null()]).transform((value) => value ?? void 0).optional();
-var acpConfigOptionSelectOptionSchema = z32.object({
-  value: z32.string(),
+var acpOptionalString = z33.union([z33.string(), z33.null()]).transform((value) => value ?? void 0).optional();
+var acpConfigOptionSelectOptionSchema = z33.object({
+  value: z33.string(),
   name: acpOptionalString
 }).passthrough();
-var acpConfigOptionSchema = z32.object({
-  id: z32.string(),
+var acpConfigOptionSchema = z33.object({
+  id: z33.string(),
   name: acpOptionalString,
   category: acpOptionalString,
-  type: z32.string(),
+  type: z33.string(),
   currentValue: acpOptionalString,
-  options: z32.array(acpConfigOptionSelectOptionSchema).optional()
+  options: z33.array(acpConfigOptionSelectOptionSchema).optional()
 }).passthrough();
-var acpSessionModelSchema = z32.object({
-  modelId: z32.string(),
+var acpSessionModelSchema = z33.object({
+  modelId: z33.string(),
   name: acpOptionalString,
   description: acpOptionalString
 }).passthrough();
-var acpSessionModelsSchema = z32.object({
+var acpSessionModelsSchema = z33.object({
   currentModelId: acpOptionalString,
-  availableModels: z32.array(acpSessionModelSchema).optional()
+  availableModels: z33.array(acpSessionModelSchema).optional()
 }).passthrough();
-var acpLooseConfigOptionSchema = z32.object({
-  id: z32.string().optional(),
-  name: z32.unknown().optional(),
+var acpLooseConfigOptionSchema = z33.object({
+  id: z33.string().optional(),
+  name: z33.unknown().optional(),
   category: acpOptionalString,
-  type: z32.unknown().optional(),
-  currentValue: z32.unknown().optional(),
-  options: z32.unknown().optional()
+  type: z33.unknown().optional(),
+  currentValue: z33.unknown().optional(),
+  options: z33.unknown().optional()
 }).passthrough();
 function parseAcpConfigOptions(options, ctx) {
   if (options == null) {
@@ -4033,119 +4046,119 @@ function parseAcpConfigOptions(options, ctx) {
   }
   return parsedOptions;
 }
-var acpSessionNewResultSchema = z32.object({
-  sessionId: z32.string(),
+var acpSessionNewResultSchema = z33.object({
+  sessionId: z33.string(),
   models: acpSessionModelsSchema.optional(),
-  configOptions: z32.array(z32.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
+  configOptions: z33.array(z33.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
 }).passthrough();
-var acpConfigStateResultSchema = z32.object({
+var acpConfigStateResultSchema = z33.object({
   models: acpSessionModelsSchema.optional(),
-  configOptions: z32.array(z32.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
+  configOptions: z33.array(z33.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
 }).passthrough();
 var acpSessionForkResultSchema = acpConfigStateResultSchema.extend({
-  sessionId: z32.string()
+  sessionId: z33.string()
 });
-var acpStopReasonSchema = z32.enum([
+var acpStopReasonSchema = z33.enum([
   "end_turn",
   "max_tokens",
   "max_turn_requests",
   "refusal",
   "cancelled"
 ]);
-var acpPromptResultSchema = z32.object({
+var acpPromptResultSchema = z33.object({
   stopReason: acpStopReasonSchema
 }).passthrough();
-var acpPermissionOptionKindSchema = z32.enum([
+var acpPermissionOptionKindSchema = z33.enum([
   "allow_once",
   "allow_always",
   "reject_once",
   "reject_always"
 ]);
-var acpPermissionOptionSchema = z32.object({
-  optionId: z32.string(),
-  name: z32.string(),
+var acpPermissionOptionSchema = z33.object({
+  optionId: z33.string(),
+  name: z33.string(),
   kind: acpPermissionOptionKindSchema
 }).passthrough();
-var acpRequestPermissionParamsSchema = z32.object({
-  sessionId: z32.string(),
-  toolCall: z32.preprocess(
+var acpRequestPermissionParamsSchema = z33.object({
+  sessionId: z33.string(),
+  toolCall: z33.preprocess(
     openAcpToolCallEnums,
     acpToolCallFieldsSchema.partial().passthrough()
   ).optional(),
-  options: z32.array(acpPermissionOptionSchema).min(1)
+  options: z33.array(acpPermissionOptionSchema).min(1)
 }).passthrough();
-var acpReadTextFileParamsSchema = z32.object({
-  sessionId: z32.string(),
-  path: z32.string(),
-  line: z32.number().nullable().optional(),
-  limit: z32.number().nullable().optional()
+var acpReadTextFileParamsSchema = z33.object({
+  sessionId: z33.string(),
+  path: z33.string(),
+  line: z33.number().nullable().optional(),
+  limit: z33.number().nullable().optional()
 }).passthrough();
-var acpWriteTextFileParamsSchema = z32.object({
-  sessionId: z32.string(),
-  path: z32.string(),
-  content: z32.string()
+var acpWriteTextFileParamsSchema = z33.object({
+  sessionId: z33.string(),
+  path: z33.string(),
+  content: z33.string()
 }).passthrough();
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
 var ACP_DEFAULT_MODEL_ID = "acp-default";
 var acpModelListParamsSchema = modelListParamsSchema.extend({
-  providerOptions: z33.record(z33.string(), z33.unknown()).optional()
+  providerOptions: z34.record(z34.string(), z34.unknown()).optional()
 });
-var acpBridgeCommandSchema = z33.discriminatedUnion("method", [
-  z33.object({
-    method: z33.literal("initialize"),
+var acpBridgeCommandSchema = z34.discriminatedUnion("method", [
+  z34.object({
+    method: z34.literal("initialize"),
     params: initializeParamsSchema
   }),
-  z33.object({
-    method: z33.literal("model/list"),
+  z34.object({
+    method: z34.literal("model/list"),
     params: acpModelListParamsSchema
   }),
-  z33.object({
-    method: z33.literal("provider/health"),
+  z34.object({
+    method: z34.literal("provider/health"),
     params: providerMaintenanceParamsSchema
   }),
-  z33.object({
-    method: z33.literal("provider/usage"),
+  z34.object({
+    method: z34.literal("provider/usage"),
     params: providerMaintenanceParamsSchema
   }),
-  z33.object({
-    method: z33.literal("provider/installation/status"),
+  z34.object({
+    method: z34.literal("provider/installation/status"),
     params: providerInstallationStatusParamsSchema
   }),
-  z33.object({
-    method: z33.literal("provider/installation/run"),
+  z34.object({
+    method: z34.literal("provider/installation/run"),
     params: providerInstallationRunParamsSchema
   }),
-  z33.object({
-    method: z33.literal("thread/start"),
+  z34.object({
+    method: z34.literal("thread/start"),
     params: threadStartParamsSchema
   }),
-  z33.object({
-    method: z33.literal("thread/resume"),
+  z34.object({
+    method: z34.literal("thread/resume"),
     params: threadResumeParamsSchema
   }),
-  z33.object({
-    method: z33.literal("thread/fork"),
+  z34.object({
+    method: z34.literal("thread/fork"),
     params: threadForkParamsSchema
   }),
-  z33.object({
-    method: z33.literal("turn/start"),
+  z34.object({
+    method: z34.literal("turn/start"),
     params: turnStartParamsSchema
   }),
-  z33.object({
-    method: z33.literal("turn/steer"),
+  z34.object({
+    method: z34.literal("turn/steer"),
     params: turnSteerParamsSchema
   }),
-  z33.object({
-    method: z33.literal("thread/stop"),
+  z34.object({
+    method: z34.literal("thread/stop"),
     params: threadStopParamsSchema
   }),
-  z33.object({
-    method: z33.literal("thread/discard"),
+  z34.object({
+    method: z34.literal("thread/discard"),
     params: threadDiscardParamsSchema
   }),
-  z33.object({
-    method: z33.literal("skills/configure"),
+  z34.object({
+    method: z34.literal("skills/configure"),
     params: skillsConfigureParamsSchema
   })
 ]);
@@ -4160,48 +4173,48 @@ var ACP_UPDATE_METHOD = "acp/update";
 var ACP_FS_WRITE_METHOD = "acp/fs/write";
 var ACP_WARNING_METHOD = "acp/warning";
 var ACP_BRIDGE_NO_ACTIVE_TURN_ERROR_CODE = -32001;
-var acpTurnStartedNotificationParamsSchema = z33.object({
-  threadId: z33.string().min(1)
+var acpTurnStartedNotificationParamsSchema = z34.object({
+  threadId: z34.string().min(1)
 }).passthrough();
-var acpTurnCompletedNotificationParamsSchema = z33.object({
-  threadId: z33.string().min(1),
+var acpTurnCompletedNotificationParamsSchema = z34.object({
+  threadId: z34.string().min(1),
   stopReason: acpStopReasonSchema
 }).passthrough();
-var acpCompactionCompletedNotificationParamsSchema = z33.discriminatedUnion("status", [
-  z33.object({
-    threadId: z33.string().min(1),
-    status: z33.literal("completed")
+var acpCompactionCompletedNotificationParamsSchema = z34.discriminatedUnion("status", [
+  z34.object({
+    threadId: z34.string().min(1),
+    status: z34.literal("completed")
   }).passthrough(),
-  z33.object({
-    threadId: z33.string().min(1),
-    status: z33.literal("interrupted")
+  z34.object({
+    threadId: z34.string().min(1),
+    status: z34.literal("interrupted")
   }).passthrough(),
-  z33.object({
-    threadId: z33.string().min(1),
-    status: z33.literal("failed"),
-    error: z33.string().min(1)
+  z34.object({
+    threadId: z34.string().min(1),
+    status: z34.literal("failed"),
+    error: z34.string().min(1)
   }).passthrough()
 ]);
-var acpUpdateNotificationParamsSchema = z33.object({
-  threadId: z33.string().min(1),
+var acpUpdateNotificationParamsSchema = z34.object({
+  threadId: z34.string().min(1),
   update: acpSessionUpdateSchema
 }).passthrough();
-var acpFsWriteNotificationParamsSchema = z33.object({
-  threadId: z33.string().min(1),
-  path: z33.string().min(1),
-  kind: z33.enum(["add", "update"]),
-  oldText: z33.string().optional(),
-  content: z33.string()
+var acpFsWriteNotificationParamsSchema = z34.object({
+  threadId: z34.string().min(1),
+  path: z34.string().min(1),
+  kind: z34.enum(["add", "update"]),
+  oldText: z34.string().optional(),
+  content: z34.string()
 }).passthrough();
-var acpWarningNotificationParamsSchema = z33.object({
-  threadId: z33.string().min(1),
-  summary: z33.string().min(1),
-  details: z33.string().optional()
+var acpWarningNotificationParamsSchema = z34.object({
+  threadId: z34.string().min(1),
+  summary: z34.string().min(1),
+  details: z34.string().optional()
 }).passthrough();
 
 // ../provider-bridge-acp/src/dialect.ts
 import { basename } from "node:path";
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // ../provider-bridge-acp/src/bridge/provider-maintenance.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -4211,7 +4224,7 @@ import os from "node:os";
 import path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { promisify as promisify2 } from "node:util";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var execFileAsync2 = promisify2(execFile2);
 var USAGE_FETCH_TIMEOUT_MS = 15e3;
 var CURSOR_DASHBOARD_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService";
@@ -4249,8 +4262,8 @@ async function readKeychainAccessToken() {
     return null;
   }
 }
-var cursorFileCredentialsSchema = z34.object({
-  accessToken: z34.string().min(1).nullish()
+var cursorFileCredentialsSchema = z35.object({
+  accessToken: z35.string().min(1).nullish()
 });
 async function readAccessToken() {
   const keychain = await readKeychainAccessToken();
@@ -4297,7 +4310,7 @@ function readAccountEmail() {
     database = new DatabaseSync(databasePath);
     database.exec("PRAGMA query_only = true");
     const row = database.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/cachedEmail");
-    const parsed = z34.object({ value: z34.string().email() }).safeParse(row);
+    const parsed = z35.object({ value: z35.string().email() }).safeParse(row);
     return parsed.success ? parsed.data.value : null;
   } catch {
     return null;
@@ -4401,14 +4414,14 @@ function buildAcpProviderInstallationRun(status, args) {
     verification: { kind: "installed" }
   };
 }
-var cursorNonNegativeIntegerSchema = z34.union([
-  z34.number().int().nonnegative(),
-  z34.string().regex(/^\d+$/u).transform(Number)
+var cursorNonNegativeIntegerSchema = z35.union([
+  z35.number().int().nonnegative(),
+  z35.string().regex(/^\d+$/u).transform(Number)
 ]).refine(Number.isSafeInteger);
-var cursorUsageResponseSchema = z34.object({
+var cursorUsageResponseSchema = z35.object({
   billingCycleEnd: cursorNonNegativeIntegerSchema.nullish(),
-  planUsage: z34.object({ totalPercentUsed: z34.number().nonnegative().default(0) }).nullish(),
-  spendLimitUsage: z34.object({
+  planUsage: z35.object({ totalPercentUsed: z35.number().nonnegative().default(0) }).nullish(),
+  spendLimitUsage: z35.object({
     overallLimit: cursorNonNegativeIntegerSchema.nullish(),
     overallUsed: cursorNonNegativeIntegerSchema.nullish(),
     individualLimit: cursorNonNegativeIntegerSchema.nullish(),
@@ -4417,8 +4430,8 @@ var cursorUsageResponseSchema = z34.object({
     pooledUsed: cursorNonNegativeIntegerSchema.nullish()
   }).nullish()
 }).passthrough();
-var cursorPlanResponseSchema = z34.object({
-  planInfo: z34.object({ planName: z34.string().min(1) }).nullish()
+var cursorPlanResponseSchema = z35.object({
+  planInfo: z35.object({ planName: z35.string().min(1) }).nullish()
 }).passthrough();
 function normalizeUsage(rawUsage, rawPlan, accountEmail = null) {
   const usage = cursorUsageResponseSchema.safeParse(rawUsage);
@@ -4631,10 +4644,10 @@ function toolKindPresentation(args) {
 
 // ../provider-bridge-acp/src/dialect.ts
 var GENERIC_ACP_DIALECT = { id: "acp" };
-var grokToolMetaSchema = z35.object({
-  "x.ai/tool": z35.object({
-    name: z35.string().optional(),
-    kind: z35.string().optional()
+var grokToolMetaSchema = z36.object({
+  "x.ai/tool": z36.object({
+    name: z36.string().optional(),
+    kind: z36.string().optional()
   }).passthrough()
 }).passthrough();
 function grokToolIdentity(event) {
@@ -4650,10 +4663,10 @@ function grokToolIdentity(event) {
   };
 }
 var GROK_SPAWN_SUBAGENT_TOOL = "spawn_subagent";
-var grokSpawnSubagentInputSchema = z35.object({
-  description: z35.string().optional(),
-  prompt: z35.string().optional(),
-  subagent_type: z35.string().optional()
+var grokSpawnSubagentInputSchema = z36.object({
+  description: z36.string().optional(),
+  prompt: z36.string().optional(),
+  subagent_type: z36.string().optional()
 }).passthrough();
 function grokClassifyToolCall(event) {
   if (grokToolIdentity(event)?.name !== GROK_SPAWN_SUBAGENT_TOOL) {
@@ -4682,14 +4695,14 @@ var GROK_ACP_DIALECT = {
   classifyToolCall: grokClassifyToolCall
 };
 var CURSOR_TASK_TOOL = "task";
-var cursorTaskRawInputSchema = z35.object({ _toolName: z35.string().optional() }).passthrough();
+var cursorTaskRawInputSchema = z36.object({ _toolName: z36.string().optional() }).passthrough();
 var CURSOR_TASK_METHOD = "cursor/task";
-var cursorTaskParamsSchema = z35.object({
-  toolCallId: z35.string(),
-  description: z35.string().optional(),
-  prompt: z35.string().optional(),
-  agentId: z35.string().optional(),
-  model: z35.string().optional()
+var cursorTaskParamsSchema = z36.object({
+  toolCallId: z36.string(),
+  description: z36.string().optional(),
+  prompt: z36.string().optional(),
+  agentId: z36.string().optional(),
+  model: z36.string().optional()
 }).passthrough();
 function cursorClassifyToolCall(event) {
   const parsed = cursorTaskRawInputSchema.safeParse(event.rawInput);
@@ -4737,31 +4750,31 @@ var CURSOR_ACP_DIALECT = {
   handleClientRequest: cursorHandleClientRequest,
   maintenance: CURSOR_ACP_MAINTENANCE
 };
-var ompBashRawInputSchema = z35.object({
-  command: z35.string(),
-  async: z35.boolean().optional()
+var ompBashRawInputSchema = z36.object({
+  command: z36.string(),
+  async: z36.boolean().optional()
 }).passthrough();
-var ompBashRawOutputSchema = z35.object({
-  content: z35.array(
-    z35.object({
-      type: z35.literal("text"),
-      text: z35.string()
+var ompBashRawOutputSchema = z36.object({
+  content: z36.array(
+    z36.object({
+      type: z36.literal("text"),
+      text: z36.string()
     }).passthrough()
   ),
-  details: z35.object({
-    exitCode: z35.number().int().optional(),
-    wallTimeMs: z35.number().nonnegative().optional(),
-    timedOut: z35.boolean().optional(),
-    signal: z35.unknown().optional(),
-    async: z35.unknown().optional()
+  details: z36.object({
+    exitCode: z36.number().int().optional(),
+    wallTimeMs: z36.number().nonnegative().optional(),
+    timedOut: z36.boolean().optional(),
+    signal: z36.unknown().optional(),
+    async: z36.unknown().optional()
   }).passthrough(),
-  exitCode: z35.number().int().nullable().optional(),
-  exit_code: z35.number().int().nullable().optional(),
-  stdout: z35.string().optional(),
-  stderr: z35.string().optional(),
-  output_for_prompt: z35.string().optional(),
-  signal: z35.string().nullable().optional(),
-  timed_out: z35.boolean().optional()
+  exitCode: z36.number().int().nullable().optional(),
+  exit_code: z36.number().int().nullable().optional(),
+  stdout: z36.string().optional(),
+  stderr: z36.string().optional(),
+  output_for_prompt: z36.string().optional(),
+  signal: z36.string().nullable().optional(),
+  timed_out: z36.boolean().optional()
 }).passthrough();
 function stripOmpTrailingNotice(text, notice) {
   const suffix = `
@@ -4811,11 +4824,11 @@ var OMP_ACP_DIALECT = {
   id: "omp",
   commandResult: ompCommandResult
 };
-var openCodeCommandRawOutputSchema = z35.object({
-  output: z35.unknown().optional(),
-  metadata: z35.object({
-    exit: z35.number().int().nullable().optional(),
-    output: z35.string().optional()
+var openCodeCommandRawOutputSchema = z36.object({
+  output: z36.unknown().optional(),
+  metadata: z36.object({
+    exit: z36.number().int().nullable().optional(),
+    output: z36.string().optional()
   }).passthrough().optional()
 }).passthrough();
 function normalizeOpenCodeCommandEvent(event) {
@@ -4865,17 +4878,17 @@ function resolveAcpDialect(launch) {
 }
 
 // ../provider-bridge-acp/src/tool-classification.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // ../provider-bridge-acp/src/tool-call-operation.ts
 import path3 from "node:path";
-import { z as z36 } from "zod";
-var acpRawInputCommandSchema = z36.object({ command: z36.string() }).passthrough();
-var acpRawInputPathSchema = z36.object({
-  path: z36.string().optional(),
-  filePath: z36.string().optional(),
-  file_path: z36.string().optional(),
-  target_file: z36.string().optional()
+import { z as z37 } from "zod";
+var acpRawInputCommandSchema = z37.object({ command: z37.string() }).passthrough();
+var acpRawInputPathSchema = z37.object({
+  path: z37.string().optional(),
+  filePath: z37.string().optional(),
+  file_path: z37.string().optional(),
+  target_file: z37.string().optional()
 }).passthrough();
 function resolveAcpToolCallPath(value, options) {
   const cwd = options?.cwd;
@@ -5052,14 +5065,14 @@ function extractAcpToolCallOutputText(event) {
   ).trim();
   return rawOutputText.length > 0 ? rawOutputText : void 0;
 }
-var commandRawOutputSchema = z37.object({
-  exitCode: z37.number().int().nullable().optional(),
-  exit_code: z37.number().int().nullable().optional(),
-  stdout: z37.string().optional(),
-  stderr: z37.string().optional(),
-  output_for_prompt: z37.string().optional(),
-  signal: z37.string().nullable().optional(),
-  timed_out: z37.boolean().optional()
+var commandRawOutputSchema = z38.object({
+  exitCode: z38.number().int().nullable().optional(),
+  exit_code: z38.number().int().nullable().optional(),
+  stdout: z38.string().optional(),
+  stderr: z38.string().optional(),
+  output_for_prompt: z38.string().optional(),
+  signal: z38.string().nullable().optional(),
+  timed_out: z38.boolean().optional()
 }).passthrough();
 function emptyToUndefined(value) {
   return value === void 0 || value.length === 0 ? void 0 : value;
@@ -5128,10 +5141,10 @@ function extractAcpCommandResult(event) {
     ...output === void 0 ? {} : { output: scrubInlineImageDataUrls(output) }
   };
 }
-var optionalNonBlank = z37.string().optional().transform(
+var optionalNonBlank = z38.string().optional().transform(
   (value) => value !== void 0 && value.trim().length > 0 ? value : void 0
 );
-var searchRawInputSchema = z37.object({
+var searchRawInputSchema = z38.object({
   pattern: optionalNonBlank,
   query: optionalNonBlank,
   regex: optionalNonBlank,
@@ -5140,8 +5153,8 @@ var searchRawInputSchema = z37.object({
   path: optionalNonBlank,
   directory: optionalNonBlank
 }).passthrough();
-var fetchRawInputSchema = z37.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
-var thinkRawInputSchema = z37.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
+var fetchRawInputSchema = z38.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
+var thinkRawInputSchema = z38.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
 var SINGLE_TICKED_TOKEN_PATTERN = /^[^`]*`([^`\n]+)`[^`]*$/;
 var URL_PATTERN = /https?:\/\/[^\s`'"<>]+/g;
 function tickedTokenFromTitle(title) {
@@ -7100,7 +7113,7 @@ import { basename as basename2, dirname, join as join2, resolve as resolve2 } fr
 // ../provider-bridge-acp/src/bridge/tool-proxy-mcp.ts
 import { createConnection } from "node:net";
 import { createInterface as createInterface2 } from "node:readline";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var ACP_BRIDGE_MCP_SERVER_NAME = "bb-bridge";
 var ENV_HOST = "BB_ACP_DYNAMIC_TOOL_HOST";
 var ENV_PORT = "BB_ACP_DYNAMIC_TOOL_PORT";
@@ -7108,24 +7121,24 @@ var ENV_TOKEN = "BB_ACP_DYNAMIC_TOOL_TOKEN";
 var ENV_THREAD_ID = "BB_ACP_DYNAMIC_TOOL_THREAD_ID";
 var ENV_TOOLS = "BB_ACP_DYNAMIC_TOOLS";
 var ENV_PROGRESS_INTERVAL_MS = "BB_ACP_DYNAMIC_TOOL_PROGRESS_INTERVAL_MS";
-var bridgeToolCallResponseSchema = z38.union([
-  z38.object({
-    ok: z38.literal(true),
-    content: z38.string(),
-    contentBlocks: z38.array(
-      z38.discriminatedUnion("type", [
-        z38.object({ type: z38.literal("text"), text: z38.string() }),
-        z38.object({
-          type: z38.literal("image"),
-          data: z38.string(),
-          mimeType: z38.string()
+var bridgeToolCallResponseSchema = z39.union([
+  z39.object({
+    ok: z39.literal(true),
+    content: z39.string(),
+    contentBlocks: z39.array(
+      z39.discriminatedUnion("type", [
+        z39.object({ type: z39.literal("text"), text: z39.string() }),
+        z39.object({
+          type: z39.literal("image"),
+          data: z39.string(),
+          mimeType: z39.string()
         })
       ])
     ).optional(),
-    images: z38.array(z38.object({ data: z38.string(), mimeType: z38.string() })).default([]),
-    isError: z38.boolean().optional()
+    images: z39.array(z39.object({ data: z39.string(), mimeType: z39.string() })).default([]),
+    isError: z39.boolean().optional()
   }),
-  z38.object({ ok: z38.literal(false), error: z38.string() })
+  z39.object({ ok: z39.literal(false), error: z39.string() })
 ]);
 var nextMcpToolCallId = 0;
 var TOOL_CALL_PROGRESS_INTERVAL_MS = 15e3;
@@ -7812,20 +7825,20 @@ function applyPermissionCliArgs(agentArgs, permissionCli, permissionMode) {
     ...agentArgs.slice(insertAfterArgs)
   ];
 }
-var dynamicToolBridgeRequestSchema = z39.discriminatedUnion("kind", [
-  z39.object({
-    kind: z39.literal("initialized"),
-    threadId: z39.string().min(1),
-    token: z39.string().min(1),
-    toolCount: z39.number().int().nonnegative()
+var dynamicToolBridgeRequestSchema = z40.discriminatedUnion("kind", [
+  z40.object({
+    kind: z40.literal("initialized"),
+    threadId: z40.string().min(1),
+    token: z40.string().min(1),
+    toolCount: z40.number().int().nonnegative()
   }),
-  z39.object({
-    kind: z39.literal("toolCall"),
-    arguments: z39.record(z39.string(), z39.unknown()).default({}),
-    callId: z39.string().min(1),
-    threadId: z39.string().min(1),
-    token: z39.string().min(1),
-    tool: z39.string().min(1)
+  z40.object({
+    kind: z40.literal("toolCall"),
+    arguments: z40.record(z40.string(), z40.unknown()).default({}),
+    callId: z40.string().min(1),
+    threadId: z40.string().min(1),
+    token: z40.string().min(1),
+    tool: z40.string().min(1)
   })
 ]);
 var cachedModelCatalog = null;
@@ -7856,7 +7869,7 @@ async function authenticateAcpAgent(args) {
     await args.connection.request({
       method: "authenticate",
       params: { methodId, _meta: { headless: true } },
-      resultSchema: z39.unknown()
+      resultSchema: z40.unknown()
     });
   } catch (error) {
     throw new AcpAuthRequiredError(
@@ -8198,7 +8211,7 @@ async function selectAcpNativeModel(args) {
             configId: modelOption.id,
             value: selection.modelId
           },
-          resultSchema: z39.union([acpConfigStateResultSchema, z39.null()])
+          resultSchema: z40.union([acpConfigStateResultSchema, z40.null()])
         });
         setModel = false;
       } catch {
@@ -8209,7 +8222,7 @@ async function selectAcpNativeModel(args) {
       configState = await args.connection.request({
         method: "session/set_model",
         params: { sessionId: args.sessionId, modelId: selection.modelId },
-        resultSchema: z39.union([acpConfigStateResultSchema, z39.null()])
+        resultSchema: z40.union([acpConfigStateResultSchema, z40.null()])
       });
     }
     configOptions = configState?.configOptions ?? configOptions;
@@ -8712,7 +8725,7 @@ async function startAgentSession(request) {
             cwd: params.cwd,
             mcpServers
           },
-          resultSchema: z39.union([acpConfigStateResultSchema, z39.null()])
+          resultSchema: z40.union([acpConfigStateResultSchema, z40.null()])
         });
         loadedConfigOptions = configState?.configOptions;
         loadedModels = configState?.models;
@@ -9149,12 +9162,12 @@ function decodeLaunchSpec(providerOptions) {
   );
   return launchSpec.success ? launchSpec.data : null;
 }
-var acpProviderOptionsSchema = z39.object({
-  additionalWorkspaceWriteRoots: z39.array(z39.string()).optional(),
-  acpDialect: z39.string().min(1).optional(),
-  parameterizedModelPicker: z39.boolean().optional(),
-  primaryModels: z39.array(z39.string().min(1)).optional(),
-  reasoningProbePriorityModelIds: z39.array(z39.string().min(1)).optional()
+var acpProviderOptionsSchema = z40.object({
+  additionalWorkspaceWriteRoots: z40.array(z40.string()).optional(),
+  acpDialect: z40.string().min(1).optional(),
+  parameterizedModelPicker: z40.boolean().optional(),
+  primaryModels: z40.array(z40.string().min(1)).optional(),
+  reasoningProbePriorityModelIds: z40.array(z40.string().min(1)).optional()
 }).passthrough();
 function decodeAcpModelPickerOptions(providerOptions) {
   const parsed = acpProviderOptionsSchema.parse(providerOptions ?? {});
@@ -9467,7 +9480,7 @@ var experimental_providerBridge = experimental_defineProviderBridge({
 });
 
 // ../provider-bridge-acp/src/probe.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var PROBE_TIMEOUT_MS = 1e4;
 function describe(error) {
   if (error instanceof AcpAgentExitedError) {
@@ -9533,9 +9546,9 @@ async function probeAcpAgent(request) {
     connected.kill();
   }
 }
-var acpAgentProbeSchema = z40.union([
-  z40.object({ reachable: z40.literal(true), fork: z40.boolean() }),
-  z40.object({ reachable: z40.literal(false), reason: z40.string() })
+var acpAgentProbeSchema = z41.union([
+  z41.object({ reachable: z41.literal(true), fork: z41.boolean() }),
+  z41.object({ reachable: z41.literal(false), reason: z41.string() })
 ]);
 export {
   acpAgentProbeSchema as experimental_acpAgentProbeSchema,