@get-bb/plugin-sdk 0.4.84 → 0.4.87

package/dist/provider-bridge.js

@@ -963,7 +963,6 @@ function createBridgeRecorder(args) {
     }
   }
   return {
-    dir,
     record,
     recordRuntimeLine,
     recordChildIo,
@@ -1017,260 +1016,37 @@ function withoutBridgeRuntimeEnv(env) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/bridge-tool-calls.ts
+import { z as z21 } from "zod";
+
+// ../domain/src/context-snapshot.ts
 import { z as z3 } from "zod";
-var providerToolCallResponseSchema = z3.object({
-  success: z3.boolean(),
-  contentItems: z3.array(
-    z3.discriminatedUnion("type", [
-      z3.object({
-        type: z3.literal("inputText"),
-        text: z3.string()
-      }),
-      z3.object({
-        type: z3.literal("inputImage"),
-        imageUrl: z3.string().min(1)
-      })
-    ])
-  )
-});
-var bridgeRequestEnvelopeSchema = z3.object({
-  jsonrpc: z3.literal("2.0"),
-  id: z3.union([z3.string(), z3.number()]),
-  method: z3.string(),
-  params: z3.record(z3.string(), z3.unknown()).optional()
-});
-var jsonRpcErrorSchema = z3.object({
-  code: z3.number(),
-  message: z3.string().optional(),
-  data: z3.unknown().optional()
-});
-var jsonRpcSuccessResponseSchema = z3.object({
-  jsonrpc: z3.literal("2.0"),
-  id: z3.union([z3.string(), z3.number()]),
-  result: z3.unknown()
-});
-var jsonRpcErrorResponseSchema = z3.object({
-  jsonrpc: z3.literal("2.0"),
-  id: z3.union([z3.string(), z3.number()]),
-  error: jsonRpcErrorSchema
+var tokenCountSchema = z3.number().int().nonnegative();
+var contextEntrySchema = z3.object({
+  id: z3.string().min(1),
+  label: z3.string().min(1),
+  tokens: tokenCountSchema
+});
+var contextCategorySchema = z3.object({
+  id: z3.string().min(1),
+  label: z3.string().min(1),
+  kind: z3.enum(["used", "free", "reserved", "deferred"]),
+  tokens: tokenCountSchema,
+  entries: z3.array(contextEntrySchema)
+});
+var contextSnapshotSchema = z3.object({
+  capturedAt: z3.iso.datetime(),
+  providerSessionId: z3.string().min(1),
+  providerTurnId: z3.string().min(1).nullable(),
+  model: z3.string().min(1),
+  usedTokens: tokenCountSchema,
+  contextWindowTokens: z3.number().int().positive(),
+  autoCompactAtTokens: z3.number().int().positive().nullable(),
+  estimated: z3.boolean(),
+  categories: z3.array(contextCategorySchema)
 });
-function isJsonRpcRequest(input) {
-  return typeof input === "object" && input !== null && "method" in input && input.method !== void 0;
-}
-function decodeBridgeJsonRpcResponse(input) {
-  if (isJsonRpcRequest(input)) return null;
-  const error = jsonRpcErrorResponseSchema.safeParse(input);
-  if (error.success) return error.data;
-  const success = jsonRpcSuccessResponseSchema.safeParse(input);
-  return success.success ? success.data : null;
-}
-var IMAGE_DATA_URL = /^data:(.+);base64,(.+)$/s;
-function decodeImageDataUrl(imageUrl) {
-  const match = IMAGE_DATA_URL.exec(imageUrl);
-  if (match === null) {
-    return null;
-  }
-  const [, mimeType, data] = match;
-  if (data.length === 0) {
-    return null;
-  }
-  return { data, mimeType };
-}
-function decodeToolCallResponsePayload(result) {
-  const parsed = providerToolCallResponseSchema.safeParse(result);
-  if (!parsed.success) {
-    return {
-      content: "Invalid tool call response",
-      contentBlocks: [{ type: "text", text: "Invalid tool call response" }],
-      images: [],
-      isError: true
-    };
-  }
-  const texts = [];
-  const contentBlocks = [];
-  const images = [];
-  for (const item of parsed.data.contentItems) {
-    if (item.type === "inputText") {
-      texts.push(item.text);
-      if (item.text !== "") {
-        contentBlocks.push({ type: "text", text: item.text });
-      }
-      continue;
-    }
-    const image = decodeImageDataUrl(item.imageUrl);
-    if (image === null) {
-      texts.push(item.imageUrl);
-      contentBlocks.push({ type: "text", text: item.imageUrl });
-      continue;
-    }
-    images.push(image);
-    contentBlocks.push({ type: "image", ...image });
-  }
-  const text = texts.join("\n");
-  const isError = !parsed.data.success;
-  if (contentBlocks.length === 0) {
-    const fallback = isError ? "Tool call failed" : "OK";
-    return {
-      content: fallback,
-      contentBlocks: [{ type: "text", text: fallback }],
-      images,
-      isError
-    };
-  }
-  return {
-    content: text,
-    contentBlocks,
-    images,
-    isError
-  };
-}
-function buildBridgeToolCallContent(result) {
-  if (result.contentBlocks !== void 0) {
-    return result.contentBlocks;
-  }
-  const blocks = [];
-  if (result.content !== "") {
-    blocks.push({ type: "text", text: result.content });
-  }
-  for (const image of result.images ?? []) {
-    blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
-  }
-  return blocks;
-}
-
-// ../provider-bridge-protocol/src/bridge-kit/json-rpc-envelope.ts
-import { z as z4 } from "zod";
-var recordSchema = z4.record(z4.string(), z4.unknown());
-var jsonRpcEnvelopeSchema = z4.object({
-  jsonrpc: z4.literal("2.0"),
-  method: z4.string(),
-  params: recordSchema.optional()
-}).passthrough();
-var sdkMessageEnvelopeSchema = z4.object({
-  jsonrpc: z4.literal("2.0"),
-  method: z4.literal("sdk/message"),
-  params: z4.object({
-    message: z4.unknown(),
-    threadId: z4.string().optional(),
-    parent_tool_use_id: z4.string().optional()
-  }).passthrough()
-}).passthrough();
-var threadIdentityEnvelopeSchema = z4.object({
-  jsonrpc: z4.literal("2.0"),
-  method: z4.literal("thread/identity"),
-  params: z4.object({
-    threadId: z4.string().optional(),
-    providerThreadId: z4.string().optional()
-  }).passthrough()
-}).passthrough();
-var threadContextWindowUsageEnvelopeSchema = z4.object({
-  jsonrpc: z4.literal("2.0"),
-  method: z4.literal("thread/contextWindowUsage/updated"),
-  params: z4.object({
-    threadId: z4.string().optional(),
-    contextWindowUsage: z4.object({
-      usedTokens: z4.number().nullable(),
-      modelContextWindow: z4.number().nullable(),
-      estimated: z4.boolean()
-    })
-  }).passthrough()
-}).passthrough();
-var errorEnvelopeSchema = z4.object({
-  jsonrpc: z4.literal("2.0"),
-  method: z4.literal("error"),
-  params: z4.object({
-    message: z4.string().optional()
-  }).passthrough().optional()
-}).passthrough();
-
-// ../provider-bridge-protocol/src/bridge-kit/mime-types.ts
-import { extname } from "node:path";
-function mimeTypeFromExtension(filePath) {
-  switch (extname(filePath).toLowerCase()) {
-    case ".png":
-      return "image/png";
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg";
-    case ".gif":
-      return "image/gif";
-    case ".webp":
-      return "image/webp";
-    case ".svg":
-      return "image/svg+xml";
-    default:
-      return "image/png";
-  }
-}
-
-// ../provider-bridge-protocol/src/bridge-kit/pending-tool-call-tracker.ts
-function createPendingToolCallTracker(options) {
-  const pendingToolCalls = /* @__PURE__ */ new Map();
-  let requestIdCounter = 0;
-  return {
-    forwardToolCall: (args) => {
-      return new Promise((resolve2) => {
-        requestIdCounter += 1;
-        const requestId = requestIdCounter;
-        pendingToolCalls.set(requestId, { resolve: resolve2, scope: args.scope });
-        try {
-          options.sendToolCall({
-            jsonrpc: "2.0",
-            id: requestId,
-            method: "item/tool/call",
-            params: {
-              threadId: args.threadId,
-              providerThreadId: args.providerThreadId,
-              turnId: null,
-              callId: `call-${requestId}`,
-              tool: args.toolName,
-              arguments: args.arguments
-            }
-          });
-        } catch (error) {
-          pendingToolCalls.delete(requestId);
-          resolve2({
-            content: error instanceof Error ? error.message : String(error),
-            isError: true
-          });
-        }
-      });
-    },
-    handleToolCallResponse: (response) => {
-      const pending = pendingToolCalls.get(response.id);
-      if (!pending) {
-        return false;
-      }
-      pendingToolCalls.delete(response.id);
-      if ("error" in response) {
-        pending.resolve({
-          content: response.error.message ?? "Tool call failed",
-          isError: true
-        });
-      } else {
-        pending.resolve(decodeToolCallResponsePayload(response.result));
-      }
-      return true;
-    },
-    resolvePendingToolCalls: (scope, message) => {
-      for (const [requestId, pending] of pendingToolCalls) {
-        if (pending.scope !== scope) {
-          continue;
-        }
-        pendingToolCalls.delete(requestId);
-        pending.resolve({ content: message, isError: true });
-      }
-    }
-  };
-}
-
-// ../provider-bridge-protocol/src/bridge-kit/permission-policy.ts
-function shouldAutoDenyInteractiveRequest(policy) {
-  return policy.permissionEscalation === "deny";
-}
 
 // ../domain/src/acp-cli.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // ../domain/src/provider-skill-roots.ts
 function isAbsoluteProviderSkillRootPath(value) {
@@ -1294,22 +1070,22 @@ function isRelativeProviderSkillRootPath(value) {
 }
 
 // ../domain/src/shared-types.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 
 // ../domain/src/json-value.ts
-import { z as z5 } from "zod";
-var jsonValueSchema = z5.lazy(
-  () => z5.union([
-    z5.string(),
-    z5.number(),
-    z5.boolean(),
-    z5.null(),
-    z5.array(jsonValueSchema),
-    z5.record(z5.string(), jsonValueSchema)
+import { z as z4 } from "zod";
+var jsonValueSchema = z4.lazy(
+  () => z4.union([
+    z4.string(),
+    z4.number(),
+    z4.boolean(),
+    z4.null(),
+    z4.array(jsonValueSchema),
+    z4.record(z4.string(), jsonValueSchema)
   ])
 );
-var jsonObjectSchema = z5.record(
-  z5.string(),
+var jsonObjectSchema = z4.record(
+  z4.string(),
   jsonValueSchema
 );
 
@@ -1324,42 +1100,42 @@ var reasoningLevelValues = [
   "max",
   "ultra"
 ];
-var reasoningLevelSchema = z6.enum(reasoningLevelValues);
-var serviceTierSchema = z6.enum(["fast", "default"]);
+var reasoningLevelSchema = z5.enum(reasoningLevelValues);
+var serviceTierSchema = z5.enum(["fast", "default"]);
 var instructionModeValues = ["append", "replace"];
-var instructionModeSchema = z6.enum(instructionModeValues);
+var instructionModeSchema = z5.enum(instructionModeValues);
 var permissionModeValues = ["accept-edits", "auto", "full"];
-var permissionModeSchema = z6.enum(permissionModeValues);
-var permissionModeInputSchema = z6.union([permissionModeSchema, z6.literal("workspace-write")]).transform(
+var permissionModeSchema = z5.enum(permissionModeValues);
+var permissionModeInputSchema = z5.union([permissionModeSchema, z5.literal("workspace-write")]).transform(
   (permissionMode) => permissionMode === "workspace-write" ? "accept-edits" : permissionMode
 );
 var legacyRecordedPermissionModeValues = [
   "workspace-write",
   "readonly"
 ];
-var recordedPermissionModeSchema = z6.enum([
+var recordedPermissionModeSchema = z5.enum([
   ...permissionModeValues,
   ...legacyRecordedPermissionModeValues
 ]);
 var permissionEscalationValues = ["ask", "deny"];
-var permissionEscalationSchema = z6.enum(permissionEscalationValues);
+var permissionEscalationSchema = z5.enum(permissionEscalationValues);
 var promptInputVisibilityValues = ["agent-only"];
-var promptInputVisibilitySchema = z6.enum(promptInputVisibilityValues);
+var promptInputVisibilitySchema = z5.enum(promptInputVisibilityValues);
 var promptInputVisibilityFields = {
   visibility: promptInputVisibilitySchema.optional()
 };
 var promptMentionPathSourceValues = ["workspace", "thread-storage"];
-var promptMentionPathSourceSchema = z6.enum(promptMentionPathSourceValues);
+var promptMentionPathSourceSchema = z5.enum(promptMentionPathSourceValues);
 var promptMentionPathEntryKindValues = ["file", "directory"];
-var promptMentionPathEntryKindSchema = z6.enum(
+var promptMentionPathEntryKindSchema = z5.enum(
   promptMentionPathEntryKindValues
 );
 var promptMentionCommandTriggerValues = ["/"];
-var promptMentionCommandTriggerSchema = z6.enum(
+var promptMentionCommandTriggerSchema = z5.enum(
   promptMentionCommandTriggerValues
 );
 var promptMentionCommandSourceValues = ["skill", "command"];
-var promptMentionCommandSourceSchema = z6.enum(
+var promptMentionCommandSourceSchema = z5.enum(
   promptMentionCommandSourceValues
 );
 var promptMentionCommandOriginValues = [
@@ -1367,48 +1143,48 @@ var promptMentionCommandOriginValues = [
   "project",
   "user"
 ];
-var promptMentionCommandOriginSchema = z6.enum(
+var promptMentionCommandOriginSchema = z5.enum(
   promptMentionCommandOriginValues
 );
-var canonicalPromptMentionResourceSchema = z6.discriminatedUnion("kind", [
-  z6.object({
-    kind: z6.literal("thread"),
-    threadId: z6.string(),
-    projectId: z6.string().optional(),
-    label: z6.string()
+var canonicalPromptMentionResourceSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("thread"),
+    threadId: z5.string(),
+    projectId: z5.string().optional(),
+    label: z5.string()
   }),
-  z6.object({
-    kind: z6.literal("project"),
-    projectId: z6.string(),
-    label: z6.string()
+  z5.object({
+    kind: z5.literal("project"),
+    projectId: z5.string(),
+    label: z5.string()
   }),
-  z6.object({
-    kind: z6.literal("section"),
-    sectionId: z6.string(),
-    label: z6.string()
+  z5.object({
+    kind: z5.literal("section"),
+    sectionId: z5.string(),
+    label: z5.string()
   }),
-  z6.object({
-    kind: z6.literal("path"),
+  z5.object({
+    kind: z5.literal("path"),
     source: promptMentionPathSourceSchema,
     entryKind: promptMentionPathEntryKindSchema,
-    path: z6.string(),
-    label: z6.string()
+    path: z5.string(),
+    label: z5.string()
   }),
-  z6.object({
-    kind: z6.literal("command"),
+  z5.object({
+    kind: z5.literal("command"),
     trigger: promptMentionCommandTriggerSchema,
-    name: z6.string(),
+    name: z5.string(),
     source: promptMentionCommandSourceSchema,
     origin: promptMentionCommandOriginSchema,
-    label: z6.string(),
-    argumentHint: z6.string().nullable()
+    label: z5.string(),
+    argumentHint: z5.string().nullable()
   }),
-  z6.object({
-    kind: z6.literal("plugin"),
-    pluginId: z6.string(),
-    icon: z6.string().nullable().optional(),
-    itemId: z6.string(),
-    label: z6.string()
+  z5.object({
+    kind: z5.literal("plugin"),
+    pluginId: z5.string(),
+    icon: z5.string().nullable().optional(),
+    itemId: z5.string(),
+    label: z5.string()
   })
 ]);
 function normalizeLegacyPromptMentionResource(value) {
@@ -1422,38 +1198,38 @@ function normalizeLegacyPromptMentionResource(value) {
   const { folderId, ...rest } = record;
   return { ...rest, kind: "section", sectionId: folderId };
 }
-var promptMentionResourceSchema = z6.preprocess(
+var promptMentionResourceSchema = z5.preprocess(
   normalizeLegacyPromptMentionResource,
   canonicalPromptMentionResourceSchema
 );
-var promptTextMentionSchema = z6.object({
-  start: z6.number().int().nonnegative(),
-  end: z6.number().int().nonnegative(),
+var promptTextMentionSchema = z5.object({
+  start: z5.number().int().nonnegative(),
+  end: z5.number().int().nonnegative(),
   resource: promptMentionResourceSchema
 });
-var promptInputSchema = z6.discriminatedUnion("type", [
-  z6.object({
-    type: z6.literal("text"),
-    text: z6.string(),
-    mentions: z6.array(promptTextMentionSchema).default([]),
+var promptInputSchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("text"),
+    text: z5.string(),
+    mentions: z5.array(promptTextMentionSchema).default([]),
     ...promptInputVisibilityFields
   }),
-  z6.object({
-    type: z6.literal("image"),
-    url: z6.string().url(),
+  z5.object({
+    type: z5.literal("image"),
+    url: z5.string().url(),
     ...promptInputVisibilityFields
   }),
-  z6.object({
-    type: z6.literal("localImage"),
-    path: z6.string(),
+  z5.object({
+    type: z5.literal("localImage"),
+    path: z5.string(),
     ...promptInputVisibilityFields
   }),
-  z6.object({
-    type: z6.literal("localFile"),
-    path: z6.string(),
-    name: z6.string().optional(),
-    sizeBytes: z6.number().int().nonnegative().optional(),
-    mimeType: z6.string().optional(),
+  z5.object({
+    type: z5.literal("localFile"),
+    path: z5.string(),
+    name: z5.string().optional(),
+    sizeBytes: z5.number().int().nonnegative().optional(),
+    mimeType: z5.string().optional(),
     ...promptInputVisibilityFields
   })
 ]);
@@ -1531,7 +1307,7 @@ function removeCommandMentionsFromPromptInput(input, selector) {
     (item) => item.type === "text" ? removeCommandMentionsFromTextInput(item, selector) : item
   );
 }
-var threadExecutionSourceSchema = z6.enum([
+var threadExecutionSourceSchema = z5.enum([
   "client/thread/start",
   "client/turn/requested",
   "client/turn/start"
@@ -1540,19 +1316,19 @@ var callerExecutionInputSourceValues = [
   "explicit",
   "client-preference"
 ];
-var callerExecutionInputSourceSchema = z6.enum(
+var callerExecutionInputSourceSchema = z5.enum(
   callerExecutionInputSourceValues
 );
-var threadExecutionOptionsSchema = z6.object({
-  model: z6.string().optional(),
+var threadExecutionOptionsSchema = z5.object({
+  model: z5.string().optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
   permissionMode: permissionModeSchema.optional(),
   source: threadExecutionSourceSchema.optional(),
-  seq: z6.number().int().optional()
+  seq: z5.number().int().optional()
 });
 var resolvedThreadExecutionOptionsSchema = threadExecutionOptionsSchema.extend({
-  model: z6.string().min(1),
+  model: z5.string().min(1),
   serviceTier: serviceTierSchema,
   reasoningLevel: reasoningLevelSchema,
   permissionMode: permissionModeSchema,
@@ -1562,53 +1338,53 @@ var recordedThreadExecutionOptionsSchema = resolvedThreadExecutionOptionsSchema.
   permissionMode: recordedPermissionModeSchema
 });
 var runtimePermissionScopeValues = ["workspace", "full"];
-var runtimePermissionScopeSchema = z6.enum(runtimePermissionScopeValues);
-var runtimePermissionPolicySchema = z6.discriminatedUnion(
+var runtimePermissionScopeSchema = z5.enum(runtimePermissionScopeValues);
+var runtimePermissionPolicySchema = z5.discriminatedUnion(
   "permissionMode",
   [
-    z6.object({
-      permissionMode: z6.literal("accept-edits"),
-      permissionScope: z6.literal("workspace"),
-      approvalReviewer: z6.literal("user"),
+    z5.object({
+      permissionMode: z5.literal("accept-edits"),
+      permissionScope: z5.literal("workspace"),
+      approvalReviewer: z5.literal("user"),
       permissionEscalation: permissionEscalationSchema
     }),
-    z6.object({
-      permissionMode: z6.literal("auto"),
-      permissionScope: z6.literal("workspace"),
-      approvalReviewer: z6.literal("automatic"),
+    z5.object({
+      permissionMode: z5.literal("auto"),
+      permissionScope: z5.literal("workspace"),
+      approvalReviewer: z5.literal("automatic"),
       permissionEscalation: permissionEscalationSchema
     }),
-    z6.object({
-      permissionMode: z6.literal("full"),
-      permissionScope: z6.literal("full"),
-      approvalReviewer: z6.null(),
-      permissionEscalation: z6.null()
+    z5.object({
+      permissionMode: z5.literal("full"),
+      permissionScope: z5.literal("full"),
+      approvalReviewer: z5.null(),
+      permissionEscalation: z5.null()
     })
   ]
 );
-var promptModeSchema = z6.literal("plan");
-var runtimeThreadExecutionBaseOptionsSchema = z6.object({
-  model: z6.string().min(1),
+var promptModeSchema = z5.literal("plan");
+var runtimeThreadExecutionBaseOptionsSchema = z5.object({
+  model: z5.string().min(1),
   serviceTier: serviceTierSchema,
   reasoningLevel: reasoningLevelSchema,
   promptMode: promptModeSchema.optional(),
   providerOptions: jsonObjectSchema
 });
 var runtimeThreadExecutionOptionsSchema = runtimeThreadExecutionBaseOptionsSchema.and(runtimePermissionPolicySchema);
-var projectExecutionDefaultsSchema = z6.object({
-  providerId: z6.string().min(1),
-  model: z6.string().min(1),
+var projectExecutionDefaultsSchema = z5.object({
+  providerId: z5.string().min(1),
+  model: z5.string().min(1),
   serviceTier: serviceTierSchema,
   reasoningLevel: reasoningLevelSchema,
   permissionMode: permissionModeSchema
 });
 
 // ../domain/src/acp-cli.ts
-var providerSkillRootPathSchema = z7.string().min(1).refine(
+var providerSkillRootPathSchema = z6.string().min(1).refine(
   isRelativeProviderSkillRootPath,
   "Skill roots must be relative paths without dot segments"
 );
-var uniqueProviderSkillRootPathsSchema = z7.array(providerSkillRootPathSchema).superRefine((paths, context) => {
+var uniqueProviderSkillRootPathsSchema = z6.array(providerSkillRootPathSchema).superRefine((paths, context) => {
   if (new Set(paths).size !== paths.length) {
     context.addIssue({
       code: "custom",
@@ -1616,17 +1392,17 @@ var uniqueProviderSkillRootPathsSchema = z7.array(providerSkillRootPathSchema).s
     });
   }
 });
-var providerNativeSkillRootsSchema = z7.object({
+var providerNativeSkillRootsSchema = z6.object({
   user: uniqueProviderSkillRootPathsSchema.default([]),
   project: uniqueProviderSkillRootPathsSchema.default([])
 }).strict();
-var acpReasoningCliLevelValueOverridesSchema = z7.partialRecord(
+var acpReasoningCliLevelValueOverridesSchema = z6.partialRecord(
   reasoningLevelSchema,
-  z7.string().min(1)
+  z6.string().min(1)
 );
-var acpReasoningCliSchema = z7.object({
-  flag: z7.string().min(1),
-  supportedLevels: z7.array(reasoningLevelSchema).min(1),
+var acpReasoningCliSchema = z6.object({
+  flag: z6.string().min(1),
+  supportedLevels: z6.array(reasoningLevelSchema).min(1),
   levelValues: acpReasoningCliLevelValueOverridesSchema.optional(),
   defaultLevel: reasoningLevelSchema.optional()
 }).strict().superRefine((reasoningCli, context) => {
@@ -1646,9 +1422,9 @@ var acpReasoningCliSchema = z7.object({
     });
   }
 });
-var acpNativeReasoningSchema = z7.object({
-  configId: z7.string().min(1),
-  supportedLevels: z7.array(reasoningLevelSchema).min(1),
+var acpNativeReasoningSchema = z6.object({
+  configId: z6.string().min(1),
+  supportedLevels: z6.array(reasoningLevelSchema).min(1),
   levelValues: acpReasoningCliLevelValueOverridesSchema.optional(),
   defaultLevel: reasoningLevelSchema.optional()
 }).strict().superRefine((nativeReasoning, context) => {
@@ -1668,12 +1444,12 @@ var acpNativeReasoningSchema = z7.object({
     });
   }
 });
-var acpPermissionCliArgsSchema = z7.array(z7.string().min(1)).min(1);
-var acpPermissionCliSchema = z7.object({
+var acpPermissionCliArgsSchema = z6.array(z6.string().min(1)).min(1);
+var acpPermissionCliSchema = z6.object({
   full: acpPermissionCliArgsSchema.optional(),
   workspaceWrite: acpPermissionCliArgsSchema.optional(),
   readonly: acpPermissionCliArgsSchema.optional(),
-  insertAfterArgs: z7.number().int().min(0).optional()
+  insertAfterArgs: z6.number().int().min(0).optional()
 }).strict().superRefine((permissionCli, context) => {
   if (permissionCli.full === void 0 && permissionCli.workspaceWrite === void 0 && permissionCli.readonly === void 0) {
     context.addIssue({
@@ -1684,36 +1460,36 @@ var acpPermissionCliSchema = z7.object({
 });
 
 // ../domain/src/native-roots.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var PROVIDER_NATIVE_ROOTS_MAX = 32;
 var PROVIDER_NATIVE_ROOT_NAME_PREFIX_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,62}:$/u;
-var nativeRootNamePrefixSchema = z8.string().refine(
+var nativeRootNamePrefixSchema = z7.string().refine(
   (value) => value === "" || PROVIDER_NATIVE_ROOT_NAME_PREFIX_PATTERN.test(value),
   "A root name prefix is a plugin-name-like token ending in ':'"
 );
-var nativeRootManifestPathSchema = z8.string().min(1).refine(
+var nativeRootManifestPathSchema = z7.string().min(1).refine(
   isRelativeProviderSkillRootPath,
   "A manifest marker is a relative path without dot segments"
 );
-var relativeNativeRootPathSchema = z8.string().min(1).refine(
+var relativeNativeRootPathSchema = z7.string().min(1).refine(
   isRelativeProviderSkillRootPath,
   "Roots must be relative paths without dot segments"
 );
-var absoluteNativeRootPathSchema = z8.string().min(1).refine(
+var absoluteNativeRootPathSchema = z7.string().min(1).refine(
   isAbsoluteProviderSkillRootPath,
   "Absolute roots must be absolute paths without dot segments"
 );
-var providerNativeRootInputSchema = z8.union([
-  z8.string().min(1),
-  z8.object({
-    path: z8.string().min(1),
+var providerNativeRootInputSchema = z7.union([
+  z7.string().min(1),
+  z7.object({
+    path: z7.string().min(1),
     /** Skills nest in subdirectories (the agent scans recursively). */
-    recursive: z8.boolean().optional(),
+    recursive: z7.boolean().optional(),
     /**
      * Scan the same relative directory in every ancestor of the workspace
      * up to the repository root (`project` roots only).
      */
-    ancestors: z8.boolean().optional(),
+    ancestors: z7.boolean().optional(),
     /**
      * Prepended to every name under the root, a vendor plugin's
      * `plugin-name:`; a prefixed root is listed as a plugin root.
@@ -1728,14 +1504,14 @@ var providerNativeRootInputSchema = z8.union([
     skipIfManifest: nativeRootManifestPathSchema.optional()
   }).strict()
 ]);
-var providerNativeRootsInputSchema = z8.object({
-  user: z8.array(providerNativeRootInputSchema).optional(),
-  project: z8.array(providerNativeRootInputSchema).optional()
+var providerNativeRootsInputSchema = z7.object({
+  user: z7.array(providerNativeRootInputSchema).optional(),
+  project: z7.array(providerNativeRootInputSchema).optional()
 }).strict();
-var providerNativeRootSchema = z8.object({
-  path: z8.string().min(1),
-  recursive: z8.boolean(),
-  ancestors: z8.boolean(),
+var providerNativeRootSchema = z7.object({
+  path: z7.string().min(1),
+  recursive: z7.boolean(),
+  ancestors: z7.boolean(),
   namePrefix: nativeRootNamePrefixSchema,
   /** Absent: every skill-shaped directory under the root is a skill. */
   skipIfManifest: nativeRootManifestPathSchema.optional()
@@ -1744,7 +1520,7 @@ function uniqueByPath(roots) {
   return new Set(roots.map((root) => root.path)).size === roots.length;
 }
 function nativeRootSideSchema(side) {
-  return z8.array(
+  return z7.array(
     providerNativeRootSchema.extend({ path: relativeNativeRootPathSchema }).superRefine((root, context) => {
       if (root.ancestors && side !== "project") {
         context.addIssue({
@@ -1755,7 +1531,7 @@ function nativeRootSideSchema(side) {
     })
   ).max(PROVIDER_NATIVE_ROOTS_MAX).refine(uniqueByPath, "Roots must not repeat a path");
 }
-var providerNativeRootsSchema = z8.object({
+var providerNativeRootsSchema = z7.object({
   user: nativeRootSideSchema("user"),
   project: nativeRootSideSchema("project")
 }).strict();
@@ -1781,19 +1557,19 @@ function normalizeProviderNativeRoots(roots) {
     project: (roots?.project ?? []).map(normalizeProviderNativeRoot)
   };
 }
-var providerResolvedNativeRootShapeSchema = z8.enum([
+var providerResolvedNativeRootShapeSchema = z7.enum([
   "skills",
   "skill",
   "skill-file",
   "commands",
   "command-file"
 ]);
-var resolvedNativeRootFieldsSchema = z8.object({
+var resolvedNativeRootFieldsSchema = z7.object({
   path: absoluteNativeRootPathSchema,
-  origin: z8.enum(["user", "project"]),
-  recursive: z8.boolean(),
+  origin: z7.enum(["user", "project"]),
+  recursive: z7.boolean(),
   /** Only with origin `project`, for a path inside the workspace. */
-  ancestors: z8.boolean(),
+  ancestors: z7.boolean(),
   namePrefix: nativeRootNamePrefixSchema,
   shape: providerResolvedNativeRootShapeSchema,
   /**
@@ -1801,7 +1577,7 @@ var resolvedNativeRootFieldsSchema = z8.object({
    * none. A vendor plugin's root SKILL.md takes the plugin's name; absent
    * means the parent directory's name.
    */
-  fallbackName: z8.string().min(1).optional(),
+  fallbackName: z7.string().min(1).optional(),
   /**
    * `skills` only: a file, relative to a skill directory under this root,
    * that marks the directory as a vendor plugin rather than a skill; the
@@ -1845,14 +1621,14 @@ var resolvedCommandShapes = /* @__PURE__ */ new Set([
   "command-file"
 ]);
 var PROVIDER_RESOLVED_NATIVE_ROOTS_MAX = 256;
-var providerResolvedNativeRootsSchema = z8.object({
-  skills: z8.array(
+var providerResolvedNativeRootsSchema = z7.object({
+  skills: z7.array(
     providerResolvedNativeRootSchema.refine(
       (root) => resolvedSkillShapes.has(root.shape),
       "A skills root needs a skill shape"
     )
   ).max(PROVIDER_RESOLVED_NATIVE_ROOTS_MAX),
-  commands: z8.array(
+  commands: z7.array(
     providerResolvedNativeRootSchema.refine(
       (root) => resolvedCommandShapes.has(root.shape),
       "A commands root needs a command shape"
@@ -1863,14 +1639,14 @@ var EMPTY_PROVIDER_RESOLVED_NATIVE_ROOTS = Object.freeze({
   skills: Object.freeze([]),
   commands: Object.freeze([])
 });
-var providerNativeRootSetSchema = z8.object({
+var providerNativeRootSetSchema = z7.object({
   skills: providerNativeRootsSchema,
   commands: providerNativeRootsSchema,
   resolved: providerResolvedNativeRootsSchema
 }).strict();
 
 // ../domain/src/background-task.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var LOCAL_WORKFLOW_TASK_TYPE = "local_workflow";
 var LOCAL_BASH_TASK_TYPE = "local_bash";
 var LOCAL_AGENT_TASK_TYPE = "local_agent";
@@ -1887,7 +1663,7 @@ var backgroundTaskStatusValues = [
   "killed",
   "stopped"
 ];
-var backgroundTaskStatusSchema = z9.enum(backgroundTaskStatusValues);
+var backgroundTaskStatusSchema = z8.enum(backgroundTaskStatusValues);
 var workflowAgentStateValues = [
   "queued",
   "running",
@@ -1895,43 +1671,43 @@ var workflowAgentStateValues = [
   "failed",
   "skipped"
 ];
-var workflowAgentStateSchema = z9.enum(workflowAgentStateValues);
-var workflowAgentSnapshotSchema = z9.object({
-  index: z9.number().int().positive(),
-  label: z9.string(),
+var workflowAgentStateSchema = z8.enum(workflowAgentStateValues);
+var workflowAgentSnapshotSchema = z8.object({
+  index: z8.number().int().positive(),
+  label: z8.string(),
   state: workflowAgentStateSchema,
-  model: z9.string(),
-  attempt: z9.number().int().positive(),
-  cached: z9.boolean(),
-  lastProgressAt: z9.number(),
-  phaseIndex: z9.number().int().positive().optional(),
-  phaseTitle: z9.string().optional(),
-  agentType: z9.string().optional(),
-  isolation: z9.string().optional(),
-  queuedAt: z9.number().optional(),
-  startedAt: z9.number().optional(),
-  lastToolName: z9.string().optional(),
-  lastToolSummary: z9.string().optional(),
-  promptPreview: z9.string().optional(),
-  resultPreview: z9.string().optional(),
-  error: z9.string().optional(),
-  tokens: z9.number().optional(),
-  toolCalls: z9.number().optional(),
-  durationMs: z9.number().optional()
-});
-var workflowPhaseSnapshotSchema = z9.object({
-  index: z9.number().int().positive(),
-  title: z9.string(),
-  kind: z9.string().optional()
-});
-var workflowProgressSnapshotSchema = z9.object({
-  phases: z9.array(workflowPhaseSnapshotSchema),
-  agents: z9.array(workflowAgentSnapshotSchema)
-});
-var backgroundTaskUsageSchema = z9.object({
-  totalTokens: z9.number(),
-  toolUses: z9.number(),
-  durationMs: z9.number()
+  model: z8.string(),
+  attempt: z8.number().int().positive(),
+  cached: z8.boolean(),
+  lastProgressAt: z8.number(),
+  phaseIndex: z8.number().int().positive().optional(),
+  phaseTitle: z8.string().optional(),
+  agentType: z8.string().optional(),
+  isolation: z8.string().optional(),
+  queuedAt: z8.number().optional(),
+  startedAt: z8.number().optional(),
+  lastToolName: z8.string().optional(),
+  lastToolSummary: z8.string().optional(),
+  promptPreview: z8.string().optional(),
+  resultPreview: z8.string().optional(),
+  error: z8.string().optional(),
+  tokens: z8.number().optional(),
+  toolCalls: z8.number().optional(),
+  durationMs: z8.number().optional()
+});
+var workflowPhaseSnapshotSchema = z8.object({
+  index: z8.number().int().positive(),
+  title: z8.string(),
+  kind: z8.string().optional()
+});
+var workflowProgressSnapshotSchema = z8.object({
+  phases: z8.array(workflowPhaseSnapshotSchema),
+  agents: z8.array(workflowAgentSnapshotSchema)
+});
+var backgroundTaskUsageSchema = z8.object({
+  totalTokens: z8.number(),
+  toolUses: z8.number(),
+  durationMs: z8.number()
 });
 function backgroundTaskItemStatus(taskStatus) {
   switch (taskStatus) {
@@ -1953,13 +1729,13 @@ function isSettledBackgroundTaskStatus(taskStatus) {
 }
 
 // ../domain/src/provider-event.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 
 // ../domain/src/thread-events.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 
 // ../domain/src/pending-interactions.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 
 // ../domain/src/plugin-interaction-limits.ts
 var PLUGIN_INTERACTION_MAX_TITLE_LENGTH = 160;
@@ -1969,223 +1745,223 @@ function jsonByteLength(value) {
 }
 
 // ../domain/src/item-presentation.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH = 280;
-var threadEventItemPresentationLabelSchema = z10.object({
-  pending: z10.string().min(1),
-  completed: z10.string().min(1)
+var threadEventItemPresentationLabelSchema = z9.object({
+  pending: z9.string().min(1),
+  completed: z9.string().min(1)
 });
-var threadEventItemPresentationIconSchema = z10.object({
-  glyph: z10.string().min(1)
+var threadEventItemPresentationIconSchema = z9.object({
+  glyph: z9.string().min(1)
 });
-var threadEventItemPresentationTintSchema = z10.object({
-  light: z10.string().min(1),
-  dark: z10.string().min(1)
+var threadEventItemPresentationTintSchema = z9.object({
+  light: z9.string().min(1),
+  dark: z9.string().min(1)
 });
 var THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH = 80;
-var threadEventItemPresentationBadgeSchema = z10.object({
-  glyph: z10.string().min(1),
-  label: z10.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
-  hint: z10.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
-  tone: z10.enum(["neutral", "destructive"])
+var threadEventItemPresentationBadgeSchema = z9.object({
+  glyph: z9.string().min(1),
+  label: z9.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  hint: z9.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  tone: z9.enum(["neutral", "destructive"])
 });
-var threadEventItemPresentationSchema = z10.object({
+var threadEventItemPresentationSchema = z9.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
-  title: z10.string().optional(),
-  detail: z10.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
-  suppress: z10.boolean().optional(),
+  title: z9.string().optional(),
+  detail: z9.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
+  suppress: z9.boolean().optional(),
   tint: threadEventItemPresentationTintSchema.optional(),
   badge: threadEventItemPresentationBadgeSchema.optional()
 });
 
 // ../domain/src/provider-extension-kind.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var EXTENSION_KIND_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
 function isExtensionKind(value) {
   return EXTENSION_KIND_PATTERN.test(value);
 }
-var extensionKindSchema = z11.string().refine(isExtensionKind, {
+var extensionKindSchema = z10.string().refine(isExtensionKind, {
   message: 'extension kinds are "<pluginId>/<name>" (lowercase letters, digits, and "-")'
 });
 
 // ../domain/src/pending-interactions.ts
-var pendingInteractionStatusSchema = z12.enum([
+var pendingInteractionStatusSchema = z11.enum([
   "pending",
   "resolving",
   "resolved",
   "interrupted"
 ]);
-var pendingInteractionCommandActionSchema = z12.discriminatedUnion(
+var pendingInteractionCommandActionSchema = z11.discriminatedUnion(
   "type",
   [
-    z12.object({
-      type: z12.literal("read"),
-      command: z12.string(),
-      name: z12.string(),
-      path: z12.string()
+    z11.object({
+      type: z11.literal("read"),
+      command: z11.string(),
+      name: z11.string(),
+      path: z11.string()
     }),
-    z12.object({
-      type: z12.literal("listFiles"),
-      command: z12.string(),
-      path: z12.string().nullable()
+    z11.object({
+      type: z11.literal("listFiles"),
+      command: z11.string(),
+      path: z11.string().nullable()
     }),
-    z12.object({
-      type: z12.literal("search"),
-      command: z12.string(),
-      query: z12.string().nullable(),
-      path: z12.string().nullable()
+    z11.object({
+      type: z11.literal("search"),
+      command: z11.string(),
+      query: z11.string().nullable(),
+      path: z11.string().nullable()
     }),
-    z12.object({
-      type: z12.literal("unknown"),
-      command: z12.string()
+    z11.object({
+      type: z11.literal("unknown"),
+      command: z11.string()
     })
   ]
 );
-var pendingInteractionNetworkPermissionsSchema = z12.object({
-  enabled: z12.boolean().nullable()
+var pendingInteractionNetworkPermissionsSchema = z11.object({
+  enabled: z11.boolean().nullable()
 });
-var pendingInteractionFileSystemPermissionsSchema = z12.object({
-  read: z12.array(z12.string()),
-  write: z12.array(z12.string())
+var pendingInteractionFileSystemPermissionsSchema = z11.object({
+  read: z11.array(z11.string()),
+  write: z11.array(z11.string())
 });
-var pendingInteractionMacOsPreferencesPermissionSchema = z12.enum([
+var pendingInteractionMacOsPreferencesPermissionSchema = z11.enum([
   "none",
   "read_only",
   "read_write"
 ]);
-var pendingInteractionMacOsContactsPermissionSchema = z12.enum([
+var pendingInteractionMacOsContactsPermissionSchema = z11.enum([
   "none",
   "read_only",
   "read_write"
 ]);
-var pendingInteractionMacOsAutomationPermissionSchema = z12.union([
-  z12.literal("none"),
-  z12.literal("all"),
-  z12.object({
-    kind: z12.literal("bundle_ids"),
-    bundleIds: z12.array(z12.string())
+var pendingInteractionMacOsAutomationPermissionSchema = z11.union([
+  z11.literal("none"),
+  z11.literal("all"),
+  z11.object({
+    kind: z11.literal("bundle_ids"),
+    bundleIds: z11.array(z11.string())
   })
 ]);
-var pendingInteractionMacOsPermissionsSchema = z12.object({
+var pendingInteractionMacOsPermissionsSchema = z11.object({
   preferences: pendingInteractionMacOsPreferencesPermissionSchema,
   automations: pendingInteractionMacOsAutomationPermissionSchema,
-  launchServices: z12.boolean(),
-  accessibility: z12.boolean(),
-  calendar: z12.boolean(),
-  reminders: z12.boolean(),
+  launchServices: z11.boolean(),
+  accessibility: z11.boolean(),
+  calendar: z11.boolean(),
+  reminders: z11.boolean(),
   contacts: pendingInteractionMacOsContactsPermissionSchema
 });
-var pendingInteractionRequestedPermissionProfileSchema = z12.object({
+var pendingInteractionRequestedPermissionProfileSchema = z11.object({
   network: pendingInteractionNetworkPermissionsSchema.nullable(),
   fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable(),
   macos: pendingInteractionMacOsPermissionsSchema.nullable()
 });
-var pendingInteractionGrantablePermissionProfileSchema = z12.object({
+var pendingInteractionGrantablePermissionProfileSchema = z11.object({
   network: pendingInteractionNetworkPermissionsSchema.nullable(),
   fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable()
 }).strict();
 var pendingInteractionGrantedPermissionProfileSchema = pendingInteractionGrantablePermissionProfileSchema;
-var pendingInteractionApprovalDecisionSchema = z12.enum([
+var pendingInteractionApprovalDecisionSchema = z11.enum([
   "allow_once",
   "allow_for_session",
   "deny"
 ]);
-var pendingInteractionFileChangeWriteScopeSchema = z12.string().min(1);
-var pendingInteractionCommandApprovalSubjectSchema = z12.object({
-  kind: z12.literal("command"),
-  itemId: z12.string().min(1),
-  command: z12.string().min(1),
-  cwd: z12.string().nullable(),
-  actions: z12.array(pendingInteractionCommandActionSchema),
+var pendingInteractionFileChangeWriteScopeSchema = z11.string().min(1);
+var pendingInteractionCommandApprovalSubjectSchema = z11.object({
+  kind: z11.literal("command"),
+  itemId: z11.string().min(1),
+  command: z11.string().min(1),
+  cwd: z11.string().nullable(),
+  actions: z11.array(pendingInteractionCommandActionSchema),
   sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()
 });
-var pendingInteractionFileChangeApprovalSubjectSchema = z12.object({
-  kind: z12.literal("file_change"),
-  itemId: z12.string().min(1),
+var pendingInteractionFileChangeApprovalSubjectSchema = z11.object({
+  kind: z11.literal("file_change"),
+  itemId: z11.string().min(1),
   writeScope: pendingInteractionFileChangeWriteScopeSchema.nullable(),
   sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()
 });
-var pendingInteractionPermissionGrantApprovalSubjectSchema = z12.object({
-  kind: z12.literal("permission_grant"),
-  itemId: z12.string().min(1),
-  toolName: z12.string().nullable(),
+var pendingInteractionPermissionGrantApprovalSubjectSchema = z11.object({
+  kind: z11.literal("permission_grant"),
+  itemId: z11.string().min(1),
+  toolName: z11.string().nullable(),
   permissions: pendingInteractionGrantablePermissionProfileSchema
 });
-var pendingInteractionPlanApprovalSubjectSchema = z12.object({
-  kind: z12.literal("plan"),
-  itemId: z12.string().min(1),
-  plan: z12.string().min(1),
-  planFilePath: z12.string().min(1).nullable()
+var pendingInteractionPlanApprovalSubjectSchema = z11.object({
+  kind: z11.literal("plan"),
+  itemId: z11.string().min(1),
+  plan: z11.string().min(1),
+  planFilePath: z11.string().min(1).nullable()
 });
-var pendingInteractionToolUseApprovalSubjectSchema = z12.object({
-  kind: z12.literal("tool_use"),
-  itemId: z12.string().min(1),
-  tool: z12.string().min(1),
+var pendingInteractionToolUseApprovalSubjectSchema = z11.object({
+  kind: z11.literal("tool_use"),
+  itemId: z11.string().min(1),
+  tool: z11.string().min(1),
   presentation: threadEventItemPresentationSchema
 });
-var pendingInteractionApprovalSubjectSchema = z12.discriminatedUnion("kind", [
+var pendingInteractionApprovalSubjectSchema = z11.discriminatedUnion("kind", [
   pendingInteractionCommandApprovalSubjectSchema,
   pendingInteractionFileChangeApprovalSubjectSchema,
   pendingInteractionPermissionGrantApprovalSubjectSchema,
   pendingInteractionPlanApprovalSubjectSchema,
   pendingInteractionToolUseApprovalSubjectSchema
 ]);
-var approvalPendingInteractionPayloadSchema = z12.object({
-  kind: z12.literal("approval"),
+var approvalPendingInteractionPayloadSchema = z11.object({
+  kind: z11.literal("approval"),
   subject: pendingInteractionApprovalSubjectSchema,
-  reason: z12.string().nullable(),
-  availableDecisions: z12.array(pendingInteractionApprovalDecisionSchema).min(1)
+  reason: z11.string().nullable(),
+  availableDecisions: z11.array(pendingInteractionApprovalDecisionSchema).min(1)
 });
 var USER_QUESTION_MAX_QUESTIONS = 4;
 var USER_QUESTION_MAX_OPTIONS = 4;
 var USER_QUESTION_MAX_SELECTED = 4;
 var USER_QUESTION_MAX_FREE_TEXT_LENGTH = 4096;
-var pendingInteractionUserQuestionIdSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionIdSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question ids cannot be blank"
 });
-var pendingInteractionUserQuestionPromptSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionPromptSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question prompts cannot be blank"
 });
-var pendingInteractionUserQuestionShortLabelSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionShortLabelSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question short labels cannot be blank"
 });
-var pendingInteractionUserQuestionOptionValueSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionValueSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option values cannot be blank"
 });
-var pendingInteractionUserQuestionOptionLabelSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionLabelSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option labels cannot be blank"
 });
-var pendingInteractionUserQuestionOptionDescriptionSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionDescriptionSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option descriptions cannot be blank"
 });
-var pendingInteractionUserQuestionFreeTextSchema = z12.string().min(1).max(
+var pendingInteractionUserQuestionFreeTextSchema = z11.string().min(1).max(
   USER_QUESTION_MAX_FREE_TEXT_LENGTH,
   `User question free text cannot exceed ${USER_QUESTION_MAX_FREE_TEXT_LENGTH} characters`
 ).refine((value) => value.trim().length > 0, {
   message: "User question free text cannot be blank"
 });
-var pendingInteractionUserQuestionOptionSchema = z12.object({
+var pendingInteractionUserQuestionOptionSchema = z11.object({
   value: pendingInteractionUserQuestionOptionValueSchema,
   label: pendingInteractionUserQuestionOptionLabelSchema,
   description: pendingInteractionUserQuestionOptionDescriptionSchema.optional()
 });
-var pendingInteractionUserQuestionQuestionSchema = z12.object({
+var pendingInteractionUserQuestionQuestionSchema = z11.object({
   id: pendingInteractionUserQuestionIdSchema,
   prompt: pendingInteractionUserQuestionPromptSchema,
   shortLabel: pendingInteractionUserQuestionShortLabelSchema.optional(),
-  multiSelect: z12.boolean(),
-  options: z12.array(pendingInteractionUserQuestionOptionSchema).max(
+  multiSelect: z11.boolean(),
+  options: z11.array(pendingInteractionUserQuestionOptionSchema).max(
     USER_QUESTION_MAX_OPTIONS,
     `User questions cannot include more than ${USER_QUESTION_MAX_OPTIONS} options`
   ).optional(),
-  allowFreeText: z12.boolean()
+  allowFreeText: z11.boolean()
 }).superRefine((question, context) => {
   const optionValues = /* @__PURE__ */ new Set();
   question.options?.forEach((option, index) => {
     if (optionValues.has(option.value)) {
       context.addIssue({
-        code: z12.ZodIssueCode.custom,
+        code: z11.ZodIssueCode.custom,
         message: "User question option values must be unique",
         path: ["options", index, "value"]
       });
@@ -2200,9 +1976,9 @@ var pendingInteractionUserQuestionQuestionSchema = z12.object({
     path: ["options"]
   }
 );
-var userQuestionPendingInteractionPayloadSchema = z12.object({
-  kind: z12.literal("user_question"),
-  questions: z12.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(
+var userQuestionPendingInteractionPayloadSchema = z11.object({
+  kind: z11.literal("user_question"),
+  questions: z11.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(
     USER_QUESTION_MAX_QUESTIONS,
     `User questions cannot include more than ${USER_QUESTION_MAX_QUESTIONS} questions`
   )
@@ -2211,7 +1987,7 @@ var userQuestionPendingInteractionPayloadSchema = z12.object({
   payload.questions.forEach((question, index) => {
     if (questionIds.has(question.id)) {
       context.addIssue({
-        code: z12.ZodIssueCode.custom,
+        code: z11.ZodIssueCode.custom,
         message: "User question ids must be unique",
         path: ["questions", index, "id"]
       });
@@ -2220,24 +1996,24 @@ var userQuestionPendingInteractionPayloadSchema = z12.object({
     questionIds.add(question.id);
   });
 });
-var pluginPendingInteractionPayloadSchema = z12.object({
-  kind: z12.literal("plugin"),
-  title: z12.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
+var pluginPendingInteractionPayloadSchema = z11.object({
+  kind: z11.literal("plugin"),
+  title: z11.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
   data: jsonValueSchema
 });
-var pluginExtensionInteractionRequestPayloadSchema = z12.object({
+var pluginExtensionInteractionRequestPayloadSchema = z11.object({
   kind: extensionKindSchema,
-  title: z12.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
+  title: z11.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
   data: jsonValueSchema.refine(
     (value) => jsonByteLength(value) <= PLUGIN_INTERACTION_MAX_PAYLOAD_BYTES,
     { message: "Plugin request data exceeds 64 KiB" }
   )
 });
-var interactionRequestPayloadSchema = z12.union([
+var interactionRequestPayloadSchema = z11.union([
   userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
 ]);
-var pendingInteractionPayloadSchema = z12.union([
+var pendingInteractionPayloadSchema = z11.union([
   approvalPendingInteractionPayloadSchema,
   userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
@@ -2249,42 +2025,42 @@ function isUserQuestionPendingInteractionPayload(payload) {
   return payload.kind === "user_question";
 }
 var approvalDecisionDiscriminatorError = "Invalid discriminator value. Expected 'allow_once' | 'allow_for_session' | 'deny'";
-var approvalPendingInteractionResolutionSchema = z12.discriminatedUnion(
+var approvalPendingInteractionResolutionSchema = z11.discriminatedUnion(
   "decision",
   [
-    z12.object({
-      decision: z12.literal("allow_once"),
+    z11.object({
+      decision: z11.literal("allow_once"),
       grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()
     }),
-    z12.object({
-      decision: z12.literal("allow_for_session"),
+    z11.object({
+      decision: z11.literal("allow_for_session"),
       grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()
     }),
-    z12.object({
-      decision: z12.literal("deny")
+    z11.object({
+      decision: z11.literal("deny")
     })
   ],
   approvalDecisionDiscriminatorError
 );
-var pendingInteractionUserAnswerSchema = z12.object({
-  selected: z12.array(z12.string().min(1)).max(
+var pendingInteractionUserAnswerSchema = z11.object({
+  selected: z11.array(z11.string().min(1)).max(
     USER_QUESTION_MAX_SELECTED,
     `User question selected choices cannot exceed ${USER_QUESTION_MAX_SELECTED}`
   ),
   freeText: pendingInteractionUserQuestionFreeTextSchema.optional()
 });
-var userQuestionPendingInteractionResolutionSchema = z12.object({
-  kind: z12.literal("user_answer"),
-  answers: z12.record(z12.string().min(1), pendingInteractionUserAnswerSchema)
+var userQuestionPendingInteractionResolutionSchema = z11.object({
+  kind: z11.literal("user_answer"),
+  answers: z11.record(z11.string().min(1), pendingInteractionUserAnswerSchema)
 });
-var pluginPendingInteractionResolutionSchema = z12.object({
-  kind: z12.literal("plugin_submitted")
+var pluginPendingInteractionResolutionSchema = z11.object({
+  kind: z11.literal("plugin_submitted")
 });
-var pluginExtensionInteractionResolutionSchema = z12.object({
-  kind: z12.literal("request_answer"),
+var pluginExtensionInteractionResolutionSchema = z11.object({
+  kind: z11.literal("request_answer"),
   value: jsonValueSchema
 });
-var pendingInteractionResolutionSchema = z12.union(
+var pendingInteractionResolutionSchema = z11.union(
   [
     approvalPendingInteractionResolutionSchema,
     userQuestionPendingInteractionResolutionSchema,
@@ -2299,19 +2075,19 @@ function isApprovalPendingInteractionResolution(resolution) {
 function isUserQuestionPendingInteractionResolution(resolution) {
   return "kind" in resolution && resolution.kind === "user_answer";
 }
-var approvalInteractionOutcomeSchema = z12.object({
+var approvalInteractionOutcomeSchema = z11.object({
   payload: approvalPendingInteractionPayloadSchema,
   resolution: approvalPendingInteractionResolutionSchema
 });
-var userQuestionInteractionOutcomeSchema = z12.object({
+var userQuestionInteractionOutcomeSchema = z11.object({
   payload: userQuestionPendingInteractionPayloadSchema,
   resolution: userQuestionPendingInteractionResolutionSchema
 });
-var pluginExtensionInteractionOutcomeSchema = z12.object({
+var pluginExtensionInteractionOutcomeSchema = z11.object({
   payload: pluginExtensionInteractionRequestPayloadSchema,
   resolution: pluginExtensionInteractionResolutionSchema
 });
-var providerInteractionOutcomeSchema = z12.union([
+var providerInteractionOutcomeSchema = z11.union([
   approvalInteractionOutcomeSchema,
   userQuestionInteractionOutcomeSchema,
   pluginExtensionInteractionOutcomeSchema
@@ -2319,39 +2095,39 @@ var providerInteractionOutcomeSchema = z12.union([
 function isApprovalInteractionOutcome(outcome) {
   return outcome.payload.kind === "approval";
 }
-var pendingInteractionProviderOriginSchema = z12.object({
-  kind: z12.literal("provider"),
-  providerId: z12.string().min(1),
-  providerThreadId: z12.string().min(1),
-  providerRequestId: z12.string().min(1)
-});
-var pendingInteractionPluginOriginSchema = z12.object({
-  kind: z12.literal("plugin"),
-  pluginId: z12.string().min(1),
-  rendererId: z12.string().min(1)
-});
-var pendingInteractionCreateSchema = z12.object({
-  threadId: z12.string().min(1),
-  turnId: z12.string().min(1),
-  providerId: z12.string().min(1),
-  providerThreadId: z12.string().min(1),
-  providerRequestId: z12.string().min(1),
+var pendingInteractionProviderOriginSchema = z11.object({
+  kind: z11.literal("provider"),
+  providerId: z11.string().min(1),
+  providerThreadId: z11.string().min(1),
+  providerRequestId: z11.string().min(1)
+});
+var pendingInteractionPluginOriginSchema = z11.object({
+  kind: z11.literal("plugin"),
+  pluginId: z11.string().min(1),
+  rendererId: z11.string().min(1)
+});
+var pendingInteractionCreateSchema = z11.object({
+  threadId: z11.string().min(1),
+  turnId: z11.string().min(1),
+  providerId: z11.string().min(1),
+  providerThreadId: z11.string().min(1),
+  providerRequestId: z11.string().min(1),
   payload: pendingInteractionPayloadSchema
 });
-var pendingInteractionBaseSchema = z12.object({
-  id: z12.string().min(1),
-  threadId: z12.string().min(1),
+var pendingInteractionBaseSchema = z11.object({
+  id: z11.string().min(1),
+  threadId: z11.string().min(1),
   status: pendingInteractionStatusSchema,
-  statusReason: z12.string().nullable(),
-  createdAt: z12.number().int().nonnegative(),
-  expiresAt: z12.number().int().nonnegative().nullable().optional(),
-  resolvedAt: z12.number().int().nonnegative().nullable()
+  statusReason: z11.string().nullable(),
+  createdAt: z11.number().int().nonnegative(),
+  expiresAt: z11.number().int().nonnegative().nullable().optional(),
+  resolvedAt: z11.number().int().nonnegative().nullable()
 });
 var providerPendingInteractionBaseSchema = pendingInteractionBaseSchema.extend({
-  turnId: z12.string().min(1),
-  providerId: z12.string().min(1),
-  providerThreadId: z12.string().min(1),
-  providerRequestId: z12.string().min(1),
+  turnId: z11.string().min(1),
+  providerId: z11.string().min(1),
+  providerThreadId: z11.string().min(1),
+  providerRequestId: z11.string().min(1),
   origin: pendingInteractionProviderOriginSchema.optional()
 });
 var approvalPendingInteractionSchema = providerPendingInteractionBaseSchema.extend({
@@ -2366,30 +2142,30 @@ var pluginExtensionPendingInteractionSchema = providerPendingInteractionBaseSche
   payload: pluginExtensionInteractionRequestPayloadSchema,
   resolution: pluginExtensionInteractionResolutionSchema.nullable()
 });
-var providerPendingInteractionSchema = z12.union([
+var providerPendingInteractionSchema = z11.union([
   approvalPendingInteractionSchema,
   userQuestionPendingInteractionSchema,
   pluginExtensionPendingInteractionSchema
 ]);
 var pluginPendingInteractionSchema = pendingInteractionBaseSchema.extend({
-  turnId: z12.string().min(1).nullable(),
+  turnId: z11.string().min(1).nullable(),
   origin: pendingInteractionPluginOriginSchema,
   payload: pluginPendingInteractionPayloadSchema,
   resolution: pluginPendingInteractionResolutionSchema.nullable()
 });
-var pendingInteractionSchema = z12.union([
+var pendingInteractionSchema = z11.union([
   providerPendingInteractionSchema,
   pluginPendingInteractionSchema
 ]);
-var interactionLifecycleRecordBaseSchema = z12.object({
-  id: z12.string().min(1),
+var interactionLifecycleRecordBaseSchema = z11.object({
+  id: z11.string().min(1),
   status: pendingInteractionStatusSchema,
-  statusReason: z12.string().nullable()
+  statusReason: z11.string().nullable()
 });
-var interactionLifecycleProviderOriginSchema = z12.object({
-  kind: z12.literal("provider"),
-  providerId: z12.string().min(1),
-  providerRequestId: z12.string().min(1)
+var interactionLifecycleProviderOriginSchema = z11.object({
+  kind: z11.literal("provider"),
+  providerId: z11.string().min(1),
+  providerRequestId: z11.string().min(1)
 });
 var approvalInteractionLifecycleRecordPayloadSchema = approvalPendingInteractionPayloadSchema.omit({ availableDecisions: true });
 var approvalInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
@@ -2414,7 +2190,7 @@ var pluginExtensionInteractionLifecycleSchema = interactionLifecycleRecordBaseSc
   }),
   resolution: pluginExtensionInteractionResolutionSchema.omit({ value: true }).nullable()
 });
-var interactionLifecycleSchema = z12.union([
+var interactionLifecycleSchema = z11.union([
   approvalInteractionLifecycleSchema,
   userQuestionInteractionLifecycleSchema,
   pluginInteractionLifecycleSchema,
@@ -2422,11 +2198,11 @@ var interactionLifecycleSchema = z12.union([
 ]);
 
 // ../domain/src/protocol-ids.ts
-import { z as z13 } from "zod";
-var clientTurnRequestIdSchema = z13.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
+import { z as z12 } from "zod";
+var clientTurnRequestIdSchema = z12.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
 
 // ../domain/src/system-message.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var systemMessageKindValues = [
   "ownership-assigned",
   "ownership-removed",
@@ -2437,16 +2213,16 @@ var systemMessageKindValues = [
   "child-outcome-batch",
   "unlabeled"
 ];
-var systemMessageKindSchema = z14.enum(systemMessageKindValues);
-var systemMessageSubjectSchema = z14.discriminatedUnion("kind", [
-  z14.object({
-    kind: z14.literal("thread"),
-    threadId: z14.string(),
-    threadName: z14.string()
+var systemMessageKindSchema = z13.enum(systemMessageKindValues);
+var systemMessageSubjectSchema = z13.discriminatedUnion("kind", [
+  z13.object({
+    kind: z13.literal("thread"),
+    threadId: z13.string(),
+    threadName: z13.string()
   }),
-  z14.object({
-    kind: z14.literal("thread-batch"),
-    count: z14.number()
+  z13.object({
+    kind: z13.literal("thread-batch"),
+    count: z13.number()
   })
 ]);
 
@@ -2469,31 +2245,31 @@ var systemEventTypeValues = [
   "system/provider-turn-watchdog"
 ];
 var threadTurnInitiatorValues = ["user", "agent", "system"];
-var threadTurnInitiatorSchema = z15.enum(threadTurnInitiatorValues);
+var threadTurnInitiatorSchema = z14.enum(threadTurnInitiatorValues);
 var turnRequestOptionsSchema = recordedThreadExecutionOptionsSchema;
-var turnRequestTargetSchema = z15.discriminatedUnion("kind", [
-  z15.object({ kind: z15.literal("thread-start") }),
-  z15.object({ kind: z15.literal("new-turn") }),
-  z15.object({
-    kind: z15.literal("auto"),
-    expectedTurnId: z15.string().nullable()
+var turnRequestTargetSchema = z14.discriminatedUnion("kind", [
+  z14.object({ kind: z14.literal("thread-start") }),
+  z14.object({ kind: z14.literal("new-turn") }),
+  z14.object({
+    kind: z14.literal("auto"),
+    expectedTurnId: z14.string().nullable()
   }),
-  z15.object({
-    kind: z15.literal("steer"),
-    expectedTurnId: z15.string().nullable()
+  z14.object({
+    kind: z14.literal("steer"),
+    expectedTurnId: z14.string().nullable()
   })
 ]);
-var clientTurnLifecycleEventDataSchema = z15.object({
-  direction: z15.literal("outbound"),
-  source: z15.enum(["spawn", "tell"]),
+var clientTurnLifecycleEventDataSchema = z14.object({
+  direction: z14.literal("outbound"),
+  source: z14.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  request: z15.object({
-    method: z15.enum(["thread/start", "turn/start"]),
-    params: z15.record(z15.string(), z15.unknown())
+  request: z14.object({
+    method: z14.enum(["thread/start", "turn/start"]),
+    params: z14.record(z14.string(), z14.unknown())
   })
 });
-var turnRequestEventDataSchema = z15.object({
-  direction: z15.literal("outbound"),
+var turnRequestEventDataSchema = z14.object({
+  direction: z14.literal("outbound"),
   requestId: clientTurnRequestIdSchema,
   // Retry provenance, written only when a `turn.failed` gate's retry row
   // dispatches. Both fields are present together or not at all: absence means
@@ -2503,45 +2279,45 @@ var turnRequestEventDataSchema = z15.object({
   /** 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: z15.number().int().min(2).optional(),
-  source: z15.enum(["spawn", "tell"]),
+  retryAttempt: z14.number().int().min(2).optional(),
+  source: z14.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  senderThreadId: z15.string().nullable(),
+  senderThreadId: z14.string().nullable(),
   systemMessageKind: systemMessageKindSchema.optional(),
   systemMessageSubject: systemMessageSubjectSchema.nullable().optional(),
-  input: z15.array(promptInputSchema),
-  inputGroups: z15.array(z15.array(promptInputSchema).min(1)).min(1).optional(),
+  input: z14.array(promptInputSchema),
+  inputGroups: z14.array(z14.array(promptInputSchema).min(1)).min(1).optional(),
   target: turnRequestTargetSchema,
-  request: z15.object({
-    method: z15.enum(["thread/start", "turn/start"]),
-    params: z15.record(z15.string(), z15.unknown())
+  request: z14.object({
+    method: z14.enum(["thread/start", "turn/start"]),
+    params: z14.record(z14.string(), z14.unknown())
   }),
   execution: turnRequestOptionsSchema
 });
-var turnRequestRejectedEventDataSchema = z15.object({
+var turnRequestRejectedEventDataSchema = z14.object({
   requestId: clientTurnRequestIdSchema,
-  reason: z15.string().min(1),
-  message: z15.string().min(1)
-});
-var systemErrorEventDataSchema = z15.object({
-  code: z15.string().optional(),
-  message: z15.string(),
-  detail: z15.string().optional(),
-  reconnectAttempt: z15.number().int().positive().optional(),
-  reconnectTotal: z15.number().int().positive().optional()
+  reason: z14.string().min(1),
+  message: z14.string().min(1)
+});
+var systemErrorEventDataSchema = z14.object({
+  code: z14.string().optional(),
+  message: z14.string(),
+  detail: z14.string().optional(),
+  reconnectAttempt: z14.number().int().positive().optional(),
+  reconnectTotal: z14.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: z15.ZodIssueCode.custom,
+      code: z14.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: z15.ZodIssueCode.custom,
+      code: z14.ZodIssueCode.custom,
       message: "system/error reconnectAttempt cannot be greater than reconnectTotal"
     });
   }
@@ -2551,42 +2327,42 @@ var ownershipChangeOperationActionValues = [
   "release",
   "transfer"
 ];
-var ownershipChangeOperationActionSchema = z15.enum(
+var ownershipChangeOperationActionSchema = z14.enum(
   ownershipChangeOperationActionValues
 );
-var ownershipChangeOperationMetadataSchema = z15.object({
+var ownershipChangeOperationMetadataSchema = z14.object({
   action: ownershipChangeOperationActionSchema,
-  nextParentThreadId: z15.string().nullable(),
-  nextParentThreadTitle: z15.string().nullable(),
-  previousParentThreadId: z15.string().nullable(),
-  previousParentThreadTitle: z15.string().nullable()
-});
-var systemOperationEventDataSchema = z15.object({
-  operation: z15.string(),
-  status: z15.string(),
-  message: z15.string(),
-  operationId: z15.string(),
-  metadata: z15.record(z15.string(), jsonValueSchema).optional()
-});
-var systemInteractionLifecycleEventDataSchema = z15.object({
+  nextParentThreadId: z14.string().nullable(),
+  nextParentThreadTitle: z14.string().nullable(),
+  previousParentThreadId: z14.string().nullable(),
+  previousParentThreadTitle: z14.string().nullable()
+});
+var systemOperationEventDataSchema = z14.object({
+  operation: z14.string(),
+  status: z14.string(),
+  message: z14.string(),
+  operationId: z14.string(),
+  metadata: z14.record(z14.string(), jsonValueSchema).optional()
+});
+var systemInteractionLifecycleEventDataSchema = z14.object({
   interaction: interactionLifecycleSchema
 });
-var systemPermissionGrantLifecycleEventDataSchema = z15.object({
-  interactionId: z15.string(),
-  providerId: z15.string(),
-  providerRequestId: z15.string(),
+var systemPermissionGrantLifecycleEventDataSchema = z14.object({
+  interactionId: z14.string(),
+  providerId: z14.string(),
+  providerRequestId: z14.string(),
   status: pendingInteractionStatusSchema,
   resolution: approvalPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z15.string().nullable().default(null),
+  statusReason: z14.string().nullable().default(null),
   subject: pendingInteractionPermissionGrantApprovalSubjectSchema
 });
-var systemUserQuestionLifecycleEventDataSchema = z15.object({
-  interactionId: z15.string(),
-  providerId: z15.string(),
-  providerRequestId: z15.string(),
+var systemUserQuestionLifecycleEventDataSchema = z14.object({
+  interactionId: z14.string(),
+  providerId: z14.string(),
+  providerRequestId: z14.string(),
   status: pendingInteractionStatusSchema,
   resolution: userQuestionPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z15.string().nullable().default(null),
+  statusReason: z14.string().nullable().default(null),
   payload: userQuestionPendingInteractionPayloadSchema
 });
 var systemThreadInterruptedReasonValues = [
@@ -2594,20 +2370,20 @@ var systemThreadInterruptedReasonValues = [
   "host-daemon-restarted",
   "provider-turn-idle"
 ];
-var systemThreadInterruptedReasonSchema = z15.enum(
+var systemThreadInterruptedReasonSchema = z14.enum(
   systemThreadInterruptedReasonValues
 );
-var systemThreadInterruptedEventDataSchema = z15.object({
+var systemThreadInterruptedEventDataSchema = z14.object({
   reason: systemThreadInterruptedReasonSchema,
-  cause: z15.literal("host-connection-lost").optional()
+  cause: z14.literal("host-connection-lost").optional()
 });
-var provisioningTranscriptEntrySchema = z15.object({
-  type: z15.enum(["step", "output"]),
-  key: z15.string(),
-  text: z15.string(),
-  startedAt: z15.number().optional(),
-  status: z15.enum(["started", "completed", "failed"]).optional(),
-  metadata: z15.record(z15.string(), z15.unknown()).optional()
+var provisioningTranscriptEntrySchema = z14.object({
+  type: z14.enum(["step", "output"]),
+  key: z14.string(),
+  text: z14.string(),
+  startedAt: z14.number().optional(),
+  status: z14.enum(["started", "completed", "failed"]).optional(),
+  metadata: z14.record(z14.string(), z14.unknown()).optional()
 });
 var systemThreadProvisioningStatusValues = [
   "active",
@@ -2615,48 +2391,48 @@ var systemThreadProvisioningStatusValues = [
   "failed",
   "cancelled"
 ];
-var systemThreadProvisioningStatusSchema = z15.enum(
+var systemThreadProvisioningStatusSchema = z14.enum(
   systemThreadProvisioningStatusValues
 );
-var systemThreadProvisioningEventDataSchema = z15.object({
-  provisioningId: z15.string(),
+var systemThreadProvisioningEventDataSchema = z14.object({
+  provisioningId: z14.string(),
   status: systemThreadProvisioningStatusSchema,
-  environmentId: z15.string().nullable(),
-  entries: z15.array(provisioningTranscriptEntrySchema)
-});
-var systemLegacyUserMessageEventDataSchema = z15.object({
-  text: z15.string(),
-  toolCallId: z15.string().optional(),
-  turnId: z15.string().optional()
-});
-var systemProviderTurnWatchdogEventDataSchema = z15.object({
-  reason: z15.literal("provider-turn-idle"),
-  thresholdMs: z15.number().int().positive(),
-  elapsedMs: z15.number().int().nonnegative(),
-  activeTurnId: z15.string().min(1),
-  activeTurnStartedAt: z15.number().int().nonnegative(),
-  lastActivityEventSequence: z15.number().int().positive(),
-  lastActivityEventType: z15.string().min(1),
-  lastActivityEventAt: z15.number().int().nonnegative(),
-  providerId: z15.string().min(1),
-  providerThreadId: z15.string().min(1).nullable(),
-  firedAt: z15.number().int().nonnegative()
+  environmentId: z14.string().nullable(),
+  entries: z14.array(provisioningTranscriptEntrySchema)
+});
+var systemLegacyUserMessageEventDataSchema = z14.object({
+  text: z14.string(),
+  toolCallId: z14.string().optional(),
+  turnId: z14.string().optional()
+});
+var systemProviderTurnWatchdogEventDataSchema = z14.object({
+  reason: z14.literal("provider-turn-idle"),
+  thresholdMs: z14.number().int().positive(),
+  elapsedMs: z14.number().int().nonnegative(),
+  activeTurnId: z14.string().min(1),
+  activeTurnStartedAt: z14.number().int().nonnegative(),
+  lastActivityEventSequence: z14.number().int().positive(),
+  lastActivityEventType: z14.string().min(1),
+  lastActivityEventAt: z14.number().int().nonnegative(),
+  providerId: z14.string().min(1),
+  providerThreadId: z14.string().min(1).nullable(),
+  firedAt: z14.number().int().nonnegative()
 });
 
 // ../domain/src/thread-event-scope.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 var threadEventScopeKindValues = ["thread", "turn"];
-var threadEventScopeKindSchema = z16.enum(threadEventScopeKindValues);
-var threadEventScopeSchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("thread") }),
-  z16.object({ kind: z16.literal("turn"), turnId: z16.string().min(1) })
+var threadEventScopeKindSchema = z15.enum(threadEventScopeKindValues);
+var threadEventScopeSchema = z15.discriminatedUnion("kind", [
+  z15.object({ kind: z15.literal("thread") }),
+  z15.object({ kind: z15.literal("turn"), turnId: z15.string().min(1) })
 ]);
 var threadEventScopePolicyValues = [
   "thread",
   "turn",
   "thread-or-turn"
 ];
-var threadEventScopePolicySchema = z16.enum(threadEventScopePolicyValues);
+var threadEventScopePolicySchema = z15.enum(threadEventScopePolicyValues);
 var threadEventScopeDefinitionByType = {
   "thread/started": {
     policy: "thread",
@@ -2799,9 +2575,6 @@ function getThreadEventScopePolicyDefinitionEntries() {
     })
   );
 }
-function getThreadEventTypesForScopePolicy(policy) {
-  return getThreadEventScopePolicyDefinitionEntries().filter((entry) => entry.definition.policy === policy).map((entry) => entry.type);
-}
 function buildThreadEventScopePolicyByType() {
   const policies = {};
   for (const entry of getThreadEventScopePolicyDefinitionEntries()) {
@@ -2809,20 +2582,7 @@ function buildThreadEventScopePolicyByType() {
   }
   return policies;
 }
-function buildThreadScopeRationaleByType() {
-  const rationales = {};
-  for (const entry of getThreadEventScopePolicyDefinitionEntries()) {
-    if (entry.definition.rationale) {
-      rationales[entry.type] = entry.definition.rationale;
-    }
-  }
-  return rationales;
-}
-var turnOnlyThreadEventTypes = getThreadEventTypesForScopePolicy("turn");
-var threadOnlyThreadEventTypes = getThreadEventTypesForScopePolicy("thread");
-var threadOrTurnThreadEventTypes = getThreadEventTypesForScopePolicy("thread-or-turn");
 var threadEventScopePolicyByType = buildThreadEventScopePolicyByType();
-var threadScopeRationaleByType = buildThreadScopeRationaleByType();
 function validateThreadEventScope(args) {
   const policy = threadEventScopePolicyByType[args.type];
   if (policy === "thread-or-turn") {
@@ -2838,32 +2598,32 @@ function validateThreadEventScope(args) {
 }
 
 // ../domain/src/thread-timeline-goal.ts
-import { z as z17 } from "zod";
-var threadTimelineGoalStatusSchema = z17.enum([
+import { z as z16 } from "zod";
+var threadTimelineGoalStatusSchema = z16.enum([
   "active",
   "paused",
   "budgetLimited",
   "complete"
 ]);
-var threadTimelineGoalSchema = z17.object({
-  sourceSeq: z17.number().int().nonnegative(),
-  updatedAt: z17.number(),
-  objective: z17.string(),
+var threadTimelineGoalSchema = z16.object({
+  sourceSeq: z16.number().int().nonnegative(),
+  updatedAt: z16.number(),
+  objective: z16.string(),
   status: threadTimelineGoalStatusSchema,
-  tokenBudget: z17.number().nullable(),
-  tokensUsed: z17.number(),
-  timeUsedSeconds: z17.number()
+  tokenBudget: z16.number().nullable(),
+  tokensUsed: z16.number(),
+  timeUsedSeconds: z16.number()
 });
 
 // ../domain/src/provider-event.ts
-var threadEventItemStatusSchema = z18.enum([
+var threadEventItemStatusSchema = z17.enum([
   "pending",
   "completed",
   "failed",
   "interrupted"
 ]);
-var threadEventItemApprovalStatusSchema = z18.enum(["waiting_for_approval", "denied"]).nullable();
-var threadEventTurnStatusSchema = z18.enum([
+var threadEventItemApprovalStatusSchema = z17.enum(["waiting_for_approval", "denied"]).nullable();
+var threadEventTurnStatusSchema = z17.enum([
   "completed",
   "failed",
   "interrupted"
@@ -2889,259 +2649,260 @@ var providerErrorCategoryValues = [
   "unauthorized",
   "unknown"
 ];
-var providerErrorCategorySchema = z18.enum(providerErrorCategoryValues);
-var providerErrorInfoSchema = z18.object({
+var providerErrorCategorySchema = z17.enum(providerErrorCategoryValues);
+var providerErrorInfoSchema = z17.object({
   category: providerErrorCategorySchema,
-  providerCode: z18.string().nullable(),
-  httpStatusCode: z18.number().nullable()
+  providerCode: z17.string().nullable(),
+  httpStatusCode: z17.number().nullable()
 });
-var providerRateLimitStatusSchema = z18.enum([
+var providerRateLimitStatusSchema = z17.enum([
   "allowed",
   "warning",
   "blocked",
   "unknown"
 ]);
-var providerRateLimitWindowSchema = z18.object({
-  providerKey: z18.string().min(1).nullable(),
-  label: z18.string().min(1).nullable(),
+var providerRateLimitWindowSchema = z17.object({
+  providerKey: z17.string().min(1).nullable(),
+  label: z17.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
-  resetsAtMs: z18.number().int().nonnegative().nullable()
+  resetsAtMs: z17.number().int().nonnegative().nullable()
 });
-var providerRateLimitStateSchema = z18.object({
-  providerId: z18.string().min(1),
+var providerRateLimitStateSchema = z17.object({
+  providerId: z17.string().min(1),
   status: providerRateLimitStatusSchema,
-  kind: z18.enum(["subscription-window", "credits", "spend-control", "unknown"]),
-  windows: z18.array(providerRateLimitWindowSchema),
-  reachedReason: z18.string().min(1).nullable(),
-  overageStatus: z18.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
-  overageReason: z18.string().min(1).nullable()
-});
-var threadEventFileChangeKindSchema = z18.enum(["add", "delete", "update"]);
-var threadEventFileChangeSchema = z18.object({
-  path: z18.string(),
+  kind: z17.enum(["subscription-window", "credits", "spend-control", "unknown"]),
+  windows: z17.array(providerRateLimitWindowSchema),
+  reachedReason: z17.string().min(1).nullable(),
+  overageStatus: z17.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
+  overageReason: z17.string().min(1).nullable()
+});
+var threadEventFileChangeKindSchema = z17.enum(["add", "delete", "update"]);
+var threadEventFileChangeSchema = z17.object({
+  path: z17.string(),
   kind: threadEventFileChangeKindSchema,
-  movePath: z18.string().optional(),
-  diff: z18.string().optional()
+  movePath: z17.string().optional(),
+  diff: z17.string().optional()
 });
-var threadEventPlanStepStatusSchema = z18.enum([
+var threadEventPlanStepStatusSchema = z17.enum([
   "pending",
   "active",
   "completed",
   "failed"
 ]);
-var threadEventPlanStepSchema = z18.object({
-  step: z18.string(),
+var threadEventPlanStepSchema = z17.object({
+  step: z17.string(),
   status: threadEventPlanStepStatusSchema.optional()
 });
 var itemPresentationField = {
   presentation: threadEventItemPresentationSchema.optional()
 };
-var threadEventWebSearchItemSchema = z18.object({
-  type: z18.literal("webSearch"),
-  id: z18.string(),
-  queries: z18.array(z18.string()).min(1),
-  resultText: z18.string().nullable(),
+var threadEventWebSearchItemSchema = z17.object({
+  type: z17.literal("webSearch"),
+  id: z17.string(),
+  queries: z17.array(z17.string()).min(1),
+  resultText: z17.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
-});
-var threadEventWebFetchItemSchema = z18.object({
-  type: z18.literal("webFetch"),
-  id: z18.string(),
-  url: z18.string(),
-  prompt: z18.string().nullable(),
-  pattern: z18.string().nullable(),
-  resultText: z18.string().nullable(),
+  parentToolCallId: z17.string().optional()
+});
+var threadEventWebFetchItemSchema = z17.object({
+  type: z17.literal("webFetch"),
+  id: z17.string(),
+  url: z17.string(),
+  prompt: z17.string().nullable(),
+  pattern: z17.string().nullable(),
+  resultText: z17.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventImageViewItemSchema = z18.object({
-  type: z18.literal("imageView"),
-  id: z18.string(),
-  path: z18.string(),
+var threadEventImageViewItemSchema = z17.object({
+  type: z17.literal("imageView"),
+  id: z17.string(),
+  path: z17.string(),
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventFileReadItemSchema = z18.object({
-  type: z18.literal("fileRead"),
-  id: z18.string(),
-  path: z18.string(),
-  cmd: z18.string().optional(),
+var threadEventFileReadItemSchema = z17.object({
+  type: z17.literal("fileRead"),
+  id: z17.string(),
+  path: z17.string(),
+  cmd: z17.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventSearchModeSchema = z18.enum(["content", "path", "list"]);
-var threadEventSearchItemSchema = z18.object({
-  type: z18.literal("search"),
-  id: z18.string(),
+var threadEventSearchModeSchema = z17.enum(["content", "path", "list"]);
+var threadEventSearchItemSchema = z17.object({
+  type: z17.literal("search"),
+  id: z17.string(),
   mode: threadEventSearchModeSchema,
-  query: z18.string(),
-  path: z18.string().optional(),
-  cmd: z18.string().optional(),
+  query: z17.string(),
+  path: z17.string().optional(),
+  cmd: z17.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventDelegationItemSchema = z18.object({
-  type: z18.literal("delegation"),
-  id: z18.string(),
-  childRef: z18.string().min(1),
-  label: z18.string(),
+var threadEventDelegationItemSchema = z17.object({
+  type: z17.literal("delegation"),
+  id: z17.string(),
+  childRef: z17.string().min(1),
+  label: z17.string(),
   status: threadEventItemStatusSchema,
-  background: z18.boolean(),
-  summary: z18.string().optional(),
+  background: z17.boolean(),
+  summary: z17.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventPlanStepsItemSchema = z18.object({
-  type: z18.literal("planSteps"),
-  id: z18.string(),
-  steps: z18.array(threadEventPlanStepSchema),
-  explanation: z18.string().optional(),
+var threadEventPlanStepsItemSchema = z17.object({
+  type: z17.literal("planSteps"),
+  id: z17.string(),
+  steps: z17.array(threadEventPlanStepSchema),
+  explanation: z17.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventExtensionItemSchema = z18.object({
-  type: z18.literal("extension"),
-  id: z18.string(),
+var threadEventExtensionItemSchema = z17.object({
+  type: z17.literal("extension"),
+  id: z17.string(),
   kind: extensionKindSchema,
   payload: jsonValueSchema,
   status: threadEventItemStatusSchema,
   presentation: threadEventItemPresentationSchema,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventTextTruncationSchema = z18.object({
-  originalLength: z18.number(),
-  retainedHeadLength: z18.number(),
-  retainedTailLength: z18.number(),
-  truncatedAt: z18.number()
+var threadEventTextTruncationSchema = z17.object({
+  originalLength: z17.number(),
+  retainedHeadLength: z17.number(),
+  retainedTailLength: z17.number(),
+  truncatedAt: z17.number()
 });
-var threadEventItemTruncationSchema = z18.object({
+var threadEventItemTruncationSchema = z17.object({
   aggregatedOutput: threadEventTextTruncationSchema.optional(),
   result: threadEventTextTruncationSchema.optional(),
   resultText: threadEventTextTruncationSchema.optional()
 });
-var threadEventImageGenerationItemSchema = z18.object({
-  type: z18.literal("imageGeneration"),
-  id: z18.string(),
+var threadEventImageGenerationItemSchema = z17.object({
+  type: z17.literal("imageGeneration"),
+  id: z17.string(),
   status: threadEventItemStatusSchema,
-  prompt: z18.string().nullable(),
-  path: z18.string().nullable(),
-  result: z18.string().optional(),
-  error: z18.string().nullable(),
-  transparentBackground: z18.boolean(),
+  prompt: z17.string().nullable(),
+  path: z17.string().nullable(),
+  result: z17.string().optional(),
+  error: z17.string().nullable(),
+  transparentBackground: z17.boolean(),
   truncation: threadEventItemTruncationSchema.optional(),
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventUserContentSchema = z18.discriminatedUnion("type", [
-  z18.object({ type: z18.literal("text"), text: z18.string() }),
-  z18.object({ type: z18.literal("image"), url: z18.string() }),
-  z18.object({ type: z18.literal("localImage"), path: z18.string() }),
-  z18.object({ type: z18.literal("localFile"), path: z18.string() })
+var threadEventUserContentSchema = z17.discriminatedUnion("type", [
+  z17.object({ type: z17.literal("text"), text: z17.string() }),
+  z17.object({ type: z17.literal("image"), url: z17.string() }),
+  z17.object({ type: z17.literal("localImage"), path: z17.string() }),
+  z17.object({ type: z17.literal("localFile"), path: z17.string() })
 ]);
-var threadEventTokenUsageBreakdownSchema = z18.object({
-  totalTokens: z18.number(),
-  inputTokens: z18.number(),
-  cachedInputTokens: z18.number(),
-  outputTokens: z18.number(),
-  reasoningOutputTokens: z18.number()
-});
-var threadEventContextWindowUsageSchema = z18.object({
-  usedTokens: z18.number().nullable(),
-  modelContextWindow: z18.number().nullable(),
-  estimated: z18.boolean()
-});
-var threadEventTokenUsageSchema = z18.object({
+var threadEventTokenUsageBreakdownSchema = z17.object({
+  totalTokens: z17.number(),
+  inputTokens: z17.number(),
+  cachedInputTokens: z17.number(),
+  outputTokens: z17.number(),
+  reasoningOutputTokens: z17.number()
+});
+var threadEventContextWindowUsageSchema = z17.object({
+  snapshot: contextSnapshotSchema.optional(),
+  usedTokens: z17.number().nullable(),
+  modelContextWindow: z17.number().nullable(),
+  estimated: z17.boolean()
+});
+var threadEventTokenUsageSchema = z17.object({
   total: threadEventTokenUsageBreakdownSchema,
   last: threadEventTokenUsageBreakdownSchema,
-  modelContextWindow: z18.number().nullable()
+  modelContextWindow: z17.number().nullable()
 });
-var threadEventWarningCategorySchema = z18.enum([
+var threadEventWarningCategorySchema = z17.enum([
   "deprecation",
   "config",
   "general",
   "compaction-skipped"
 ]);
-var providerRawEventSchema = z18.object({
-  jsonrpc: z18.literal("2.0"),
-  id: z18.union([z18.string(), z18.number()]).optional(),
-  method: z18.string(),
+var providerRawEventSchema = z17.object({
+  jsonrpc: z17.literal("2.0"),
+  id: z17.union([z17.string(), z17.number()]).optional(),
+  method: z17.string(),
   params: jsonValueSchema.optional()
 });
-var providerUnhandledEventSchema = z18.object({
-  type: z18.literal("provider/unhandled"),
-  threadId: z18.string(),
-  providerThreadId: z18.string(),
-  providerId: z18.string(),
-  rawType: z18.string(),
+var providerUnhandledEventSchema = z17.object({
+  type: z17.literal("provider/unhandled"),
+  threadId: z17.string(),
+  providerThreadId: z17.string(),
+  providerId: z17.string(),
+  rawType: z17.string(),
   rawEvent: providerRawEventSchema,
-  parentToolCallId: z18.string().optional()
-});
-var toolCallProgressEventSchema = z18.object({
-  type: z18.literal("item/toolCall/progress"),
-  threadId: z18.string(),
-  providerThreadId: z18.string(),
-  itemId: z18.string(),
-  message: z18.string().optional(),
-  parentToolCallId: z18.string().optional()
-});
-var threadEventBackgroundTaskItemSchema = z18.object({
-  type: z18.literal("backgroundTask"),
-  id: z18.string(),
-  familyId: z18.string().optional(),
-  taskType: z18.string(),
-  description: z18.string(),
+  parentToolCallId: z17.string().optional()
+});
+var toolCallProgressEventSchema = z17.object({
+  type: z17.literal("item/toolCall/progress"),
+  threadId: z17.string(),
+  providerThreadId: z17.string(),
+  itemId: z17.string(),
+  message: z17.string().optional(),
+  parentToolCallId: z17.string().optional()
+});
+var threadEventBackgroundTaskItemSchema = z17.object({
+  type: z17.literal("backgroundTask"),
+  id: z17.string(),
+  familyId: z17.string().optional(),
+  taskType: z17.string(),
+  description: z17.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z18.boolean(),
-  workflowName: z18.string().optional(),
+  skipTranscript: z17.boolean(),
+  workflowName: z17.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z18.string().optional(),
-  error: z18.string().optional(),
-  outputFile: z18.string().optional(),
+  summary: z17.string().optional(),
+  error: z17.string().optional(),
+  outputFile: z17.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z18.string().optional()
+  parentToolCallId: z17.string().optional()
 });
-var threadEventItemSchema = z18.discriminatedUnion("type", [
-  z18.object({
-    type: z18.literal("userMessage"),
-    id: z18.string(),
-    content: z18.array(threadEventUserContentSchema),
+var threadEventItemSchema = z17.discriminatedUnion("type", [
+  z17.object({
+    type: z17.literal("userMessage"),
+    id: z17.string(),
+    content: z17.array(threadEventUserContentSchema),
     clientRequestId: clientTurnRequestIdSchema.optional(),
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }).strict(),
-  z18.object({
-    type: z18.literal("agentMessage"),
-    id: z18.string(),
-    text: z18.string(),
+  z17.object({
+    type: z17.literal("agentMessage"),
+    id: z17.string(),
+    text: z17.string(),
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("commandExecution"),
-    id: z18.string(),
-    command: z18.string(),
-    cwd: z18.string(),
+  z17.object({
+    type: z17.literal("commandExecution"),
+    id: z17.string(),
+    command: z17.string(),
+    cwd: z17.string(),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
-    aggregatedOutput: z18.string().optional(),
-    exitCode: z18.number().optional(),
-    durationMs: z18.number().optional(),
+    aggregatedOutput: z17.string().optional(),
+    exitCode: z17.number().optional(),
+    durationMs: z17.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("fileChange"),
-    id: z18.string(),
-    changes: z18.array(threadEventFileChangeSchema),
+  z17.object({
+    type: z17.literal("fileChange"),
+    id: z17.string(),
+    changes: z17.array(threadEventFileChangeSchema),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
   threadEventWebSearchItemSchema,
   threadEventWebFetchItemSchema,
@@ -3149,289 +2910,264 @@ var threadEventItemSchema = z18.discriminatedUnion("type", [
   threadEventImageGenerationItemSchema,
   threadEventFileReadItemSchema,
   threadEventSearchItemSchema,
-  z18.object({
-    type: z18.literal("toolCall"),
-    id: z18.string(),
-    server: z18.string().optional(),
-    tool: z18.string(),
-    arguments: z18.record(z18.string(), z18.unknown()).optional(),
+  z17.object({
+    type: z17.literal("toolCall"),
+    id: z17.string(),
+    server: z17.string().optional(),
+    tool: z17.string(),
+    arguments: z17.record(z17.string(), z17.unknown()).optional(),
     status: threadEventItemStatusSchema,
-    result: z18.unknown().optional(),
-    error: z18.string().optional(),
-    durationMs: z18.number().optional(),
+    result: z17.unknown().optional(),
+    error: z17.string().optional(),
+    durationMs: z17.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("reasoning"),
-    id: z18.string(),
-    summary: z18.array(z18.string()),
-    content: z18.array(z18.string()),
+  z17.object({
+    type: z17.literal("reasoning"),
+    id: z17.string(),
+    summary: z17.array(z17.string()),
+    content: z17.array(z17.string()),
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("plan"),
-    id: z18.string(),
-    text: z18.string(),
+  z17.object({
+    type: z17.literal("plan"),
+    id: z17.string(),
+    text: z17.string(),
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
   threadEventPlanStepsItemSchema,
-  z18.object({
-    type: z18.literal("contextCompaction"),
-    id: z18.string(),
+  z17.object({
+    type: z17.literal("contextCompaction"),
+    id: z17.string(),
     ...itemPresentationField,
-    parentToolCallId: z18.string().optional()
+    parentToolCallId: z17.string().optional()
   }),
   threadEventBackgroundTaskItemSchema,
   threadEventDelegationItemSchema,
   threadEventExtensionItemSchema
 ]);
-var unscopedProviderEventSchema = z18.discriminatedUnion("type", [
-  z18.object({
-    type: z18.literal("thread/started"),
-    threadId: z18.string()
+function itemTextDeltaEventSchema(type) {
+  return z17.object({
+    type: z17.literal(type),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    itemId: z17.string(),
+    delta: z17.string(),
+    parentToolCallId: z17.string().optional()
+  });
+}
+var unscopedProviderEventSchema = z17.discriminatedUnion("type", [
+  z17.object({
+    type: z17.literal("thread/started"),
+    threadId: z17.string()
   }),
-  z18.object({
-    type: z18.literal("thread/identity"),
-    threadId: z18.string(),
-    providerThreadId: z18.string()
+  z17.object({
+    type: z17.literal("thread/identity"),
+    threadId: z17.string(),
+    providerThreadId: z17.string()
   }),
-  z18.object({
-    type: z18.literal("turn/started"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    parentToolCallId: z18.string().optional()
+  z17.object({
+    type: z17.literal("turn/started"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    parentToolCallId: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("turn/completed"),
-    threadId: z18.string(),
-    providerThreadId: z18.string().nullable(),
+  z17.object({
+    type: z17.literal("turn/completed"),
+    threadId: z17.string(),
+    providerThreadId: z17.string().nullable(),
     status: threadEventTurnStatusSchema,
-    error: z18.object({ message: z18.string() }).optional(),
-    providerCheckpointId: z18.string().min(1).optional()
+    error: z17.object({ message: z17.string() }).optional(),
+    providerCheckpointId: z17.string().min(1).optional()
   }),
-  z18.object({
-    type: z18.literal("turn/input/accepted"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("turn/input/accepted"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     clientRequestId: clientTurnRequestIdSchema,
     scope: threadEventScopeSchema
   }).strict(),
-  z18.object({
-    type: z18.literal("thread/name/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    threadName: z18.string()
+  z17.object({
+    type: z17.literal("thread/name/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    threadName: z17.string()
   }),
-  z18.object({
-    type: z18.literal("thread/compacted"),
-    threadId: z18.string(),
-    providerThreadId: z18.string()
+  z17.object({
+    type: z17.literal("thread/compacted"),
+    threadId: z17.string(),
+    providerThreadId: z17.string()
   }),
-  z18.object({
-    type: z18.literal("thread/context/cleared"),
-    threadId: z18.string(),
-    providerThreadId: z18.string()
+  z17.object({
+    type: z17.literal("thread/context/cleared"),
+    threadId: z17.string(),
+    providerThreadId: z17.string()
   }),
-  z18.object({
-    type: z18.literal("thread/goal/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    objective: z18.string(),
+  z17.object({
+    type: z17.literal("thread/goal/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    objective: z17.string(),
     status: threadTimelineGoalStatusSchema,
-    tokenBudget: z18.number().nullable(),
-    tokensUsed: z18.number(),
-    timeUsedSeconds: z18.number()
+    tokenBudget: z17.number().nullable(),
+    tokensUsed: z17.number(),
+    timeUsedSeconds: z17.number()
   }),
-  z18.object({
-    type: z18.literal("thread/goal/cleared"),
-    threadId: z18.string(),
-    providerThreadId: z18.string()
+  z17.object({
+    type: z17.literal("thread/goal/cleared"),
+    threadId: z17.string(),
+    providerThreadId: z17.string()
   }),
-  z18.object({
-    type: z18.literal("item/started"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("item/started"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     item: threadEventItemSchema
   }),
-  z18.object({
-    type: z18.literal("item/completed"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("item/completed"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     item: threadEventItemSchema
   }),
-  z18.object({
-    type: z18.literal("item/agentMessage/delta"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    delta: z18.string(),
-    parentToolCallId: z18.string().optional()
-  }),
-  z18.object({
-    type: z18.literal("item/commandExecution/outputDelta"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    delta: z18.string(),
-    reset: z18.boolean().optional(),
-    parentToolCallId: z18.string().optional()
-  }),
-  z18.object({
-    type: z18.literal("item/fileChange/outputDelta"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    delta: z18.string(),
-    parentToolCallId: z18.string().optional()
-  }),
-  z18.object({
-    type: z18.literal("item/reasoning/summaryTextDelta"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    delta: z18.string(),
-    parentToolCallId: z18.string().optional()
+  itemTextDeltaEventSchema("item/agentMessage/delta"),
+  z17.object({
+    type: z17.literal("item/commandExecution/outputDelta"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    itemId: z17.string(),
+    delta: z17.string(),
+    reset: z17.boolean().optional(),
+    parentToolCallId: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("item/reasoning/textDelta"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    delta: z18.string(),
-    parentToolCallId: z18.string().optional()
-  }),
-  z18.object({
-    type: z18.literal("item/plan/delta"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    delta: z18.string(),
-    parentToolCallId: z18.string().optional()
-  }),
-  z18.object({
-    type: z18.literal("item/mcpToolCall/progress"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    itemId: z18.string(),
-    message: z18.string().optional(),
-    parentToolCallId: z18.string().optional()
+  itemTextDeltaEventSchema("item/fileChange/outputDelta"),
+  itemTextDeltaEventSchema("item/reasoning/summaryTextDelta"),
+  itemTextDeltaEventSchema("item/reasoning/textDelta"),
+  itemTextDeltaEventSchema("item/plan/delta"),
+  z17.object({
+    type: z17.literal("item/mcpToolCall/progress"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    itemId: z17.string(),
+    message: z17.string().optional(),
+    parentToolCallId: z17.string().optional()
   }),
   toolCallProgressEventSchema,
-  z18.object({
-    type: z18.literal("item/backgroundTask/progress"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("item/backgroundTask/progress"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z18.object({
-    type: z18.literal("item/backgroundTask/completed"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("item/backgroundTask/completed"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z18.object({
-    type: z18.literal("item/delegation/progress"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("item/delegation/progress"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     item: threadEventDelegationItemSchema
   }),
-  z18.object({
-    type: z18.literal("item/delegation/completed"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("item/delegation/completed"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     item: threadEventDelegationItemSchema
   }),
-  z18.object({
-    type: z18.literal("thread/tokenUsage/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("thread/tokenUsage/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     tokenUsage: threadEventTokenUsageSchema
   }),
-  z18.object({
-    type: z18.literal("thread/contextWindowUsage/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("thread/contextWindowUsage/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     contextWindowUsage: threadEventContextWindowUsageSchema
   }),
-  z18.object({
-    type: z18.literal("turn/plan/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    plan: z18.array(threadEventPlanStepSchema),
-    explanation: z18.string().optional()
+  z17.object({
+    type: z17.literal("turn/plan/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    plan: z17.array(threadEventPlanStepSchema),
+    explanation: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("turn/diff/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    diff: z18.string().optional()
+  z17.object({
+    type: z17.literal("turn/diff/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    diff: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("provider/error"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    message: z18.string(),
-    detail: z18.string().optional(),
-    willRetry: z18.boolean().optional(),
+  z17.object({
+    type: z17.literal("provider/error"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    message: z17.string(),
+    detail: z17.string().optional(),
+    willRetry: z17.boolean().optional(),
     errorInfo: providerErrorInfoSchema.optional()
   }),
-  z18.object({
-    type: z18.literal("provider/rateLimits/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("provider/rateLimits/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     rateLimits: providerRateLimitStateSchema
   }),
-  z18.object({
-    type: z18.literal("provider.env-resolved"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    entries: z18.array(
-      z18.object({
-        name: z18.string(),
-        source: z18.union([
-          z18.literal("shell"),
-          z18.object({ plugin: z18.string() }).strict(),
-          z18.object({ core: z18.enum(["machine-git", "machine-environment"]) }).strict()
+  z17.object({
+    type: z17.literal("provider.env-resolved"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    entries: z17.array(
+      z17.object({
+        name: z17.string(),
+        source: z17.union([
+          z17.literal("shell"),
+          z17.object({ plugin: z17.string() }).strict(),
+          z17.object({ core: z17.enum(["machine-git", "machine-environment"]) }).strict()
         ]),
-        value: z18.union([
-          z18.string(),
-          z18.object({ masked: z18.literal(true) }).strict()
+        value: z17.union([
+          z17.string(),
+          z17.object({ masked: z17.literal(true) }).strict()
         ]),
-        reason: z18.string().optional()
+        reason: z17.string().optional()
       }).strict()
     )
   }),
-  z18.object({
-    type: z18.literal("thread/extensionState/updated"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("thread/extensionState/updated"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     kind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z18.object({
-    type: z18.literal("provider/warning"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
+  z17.object({
+    type: z17.literal("provider/warning"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
     category: threadEventWarningCategorySchema,
-    summary: z18.string().optional(),
-    details: z18.string().optional()
+    summary: z17.string().optional(),
+    details: z17.string().optional()
   }),
-  z18.object({
-    type: z18.literal("provider/modelFallback"),
-    threadId: z18.string(),
-    providerThreadId: z18.string(),
-    originalModel: z18.string().min(1),
-    fallbackModel: z18.string().min(1),
-    reason: z18.enum(["refusal", "provider"]),
-    message: z18.string()
+  z17.object({
+    type: z17.literal("provider/modelFallback"),
+    threadId: z17.string(),
+    providerThreadId: z17.string(),
+    originalModel: z17.string().min(1),
+    fallbackModel: z17.string().min(1),
+    reason: z17.enum(["refusal", "provider"]),
+    message: z17.string()
   }),
   providerUnhandledEventSchema
 ]);
-var scopedEventDataSchema = z18.object({
+var scopedEventDataSchema = z17.object({
   scope: threadEventScopeSchema
 });
 var providerEventSchema = unscopedProviderEventSchema.and(
@@ -3440,58 +3176,58 @@ var providerEventSchema = unscopedProviderEventSchema.and(
 var providerEventTypeValues = unscopedProviderEventSchema.options.map(
   (option) => option.shape.type.value
 );
-var unscopedSystemEventSchema = z18.discriminatedUnion("type", [
-  z18.object({
-    type: z18.literal("client/thread/start"),
-    threadId: z18.string()
+var unscopedSystemEventSchema = z17.discriminatedUnion("type", [
+  z17.object({
+    type: z17.literal("client/thread/start"),
+    threadId: z17.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z18.object({
-    type: z18.literal("client/turn/requested"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("client/turn/requested"),
+    threadId: z17.string()
   }).merge(turnRequestEventDataSchema),
-  z18.object({
-    type: z18.literal("client/turn/rejected"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("client/turn/rejected"),
+    threadId: z17.string()
   }).merge(turnRequestRejectedEventDataSchema),
-  z18.object({
-    type: z18.literal("client/turn/start"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("client/turn/start"),
+    threadId: z17.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z18.object({
-    type: z18.literal("system/error"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/error"),
+    threadId: z17.string()
   }).merge(systemErrorEventDataSchema),
-  z18.object({
-    type: z18.literal("system/manager/user_message"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/manager/user_message"),
+    threadId: z17.string()
   }).merge(systemLegacyUserMessageEventDataSchema),
-  z18.object({
-    type: z18.literal("system/thread/interrupted"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/thread/interrupted"),
+    threadId: z17.string()
   }).merge(systemThreadInterruptedEventDataSchema),
-  z18.object({
-    type: z18.literal("system/operation"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/operation"),
+    threadId: z17.string()
   }).merge(systemOperationEventDataSchema),
-  z18.object({
-    type: z18.literal("system/interaction/lifecycle"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/interaction/lifecycle"),
+    threadId: z17.string()
   }).merge(systemInteractionLifecycleEventDataSchema),
-  z18.object({
-    type: z18.literal("system/permissionGrant/lifecycle"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/permissionGrant/lifecycle"),
+    threadId: z17.string()
   }).merge(systemPermissionGrantLifecycleEventDataSchema),
-  z18.object({
-    type: z18.literal("system/userQuestion/lifecycle"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/userQuestion/lifecycle"),
+    threadId: z17.string()
   }).merge(systemUserQuestionLifecycleEventDataSchema),
-  z18.object({
-    type: z18.literal("system/thread-provisioning"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/thread-provisioning"),
+    threadId: z17.string()
   }).merge(systemThreadProvisioningEventDataSchema),
-  z18.object({
-    type: z18.literal("system/provider-turn-watchdog"),
-    threadId: z18.string()
+  z17.object({
+    type: z17.literal("system/provider-turn-watchdog"),
+    threadId: z17.string()
   }).merge(systemProviderTurnWatchdogEventDataSchema)
 ]);
 var systemEventSchema = unscopedSystemEventSchema.and(scopedEventDataSchema);
@@ -3499,13 +3235,13 @@ var legacyClientRequestKey = ["clientRequest", "Sequence"].join("");
 function isEventPropertyBag(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var rejectLegacyClientRequestSequenceSchema = z18.unknown().superRefine((value, ctx) => {
+var rejectLegacyClientRequestSequenceSchema = z17.unknown().superRefine((value, ctx) => {
   if (!isEventPropertyBag(value)) {
     return;
   }
   if (Object.hasOwn(value, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z18.ZodIssueCode.custom,
+      code: z17.ZodIssueCode.custom,
       message: "legacy request sequence field is no longer accepted",
       path: [legacyClientRequestKey]
     });
@@ -3513,21 +3249,21 @@ var rejectLegacyClientRequestSequenceSchema = z18.unknown().superRefine((value,
   const item = value.item;
   if (isEventPropertyBag(item) && item.type === "userMessage" && Object.hasOwn(item, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z18.ZodIssueCode.custom,
+      code: z17.ZodIssueCode.custom,
       message: "legacy user-message request sequence field is no longer accepted",
       path: ["item", legacyClientRequestKey]
     });
   }
 });
 var threadEventSchema = rejectLegacyClientRequestSequenceSchema.pipe(
-  z18.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
+  z17.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
     const result = validateThreadEventScope({
       type: event.type,
       scope: event.scope
     });
     if (!result.valid) {
       ctx.addIssue({
-        code: z18.ZodIssueCode.custom,
+        code: z17.ZodIssueCode.custom,
         message: result.message ?? "Invalid thread event scope",
         path: ["scope"]
       });
@@ -3540,7 +3276,7 @@ var threadEventTypeValues = [
   ...systemEventTypeValues
 ];
 var threadEventTypeSet = new Set(threadEventTypeValues);
-var threadEventTypeSchema = z18.string().refine(
+var threadEventTypeSchema = z17.string().refine(
   (value) => threadEventTypeSet.has(value),
   "Invalid thread event type"
 );
@@ -3551,95 +3287,95 @@ function toPositiveNumber(value) {
 }
 
 // ../domain/src/provider-fork.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
-var providerForkSchema = z19.enum(PROVIDER_FORK_VALUES);
+var providerForkSchema = z18.enum(PROVIDER_FORK_VALUES);
 
 // ../domain/src/provider-types.ts
-import { z as z20 } from "zod";
-var modelReasoningEffortSchema = z20.object({
+import { z as z19 } from "zod";
+var modelReasoningEffortSchema = z19.object({
   reasoningEffort: reasoningLevelSchema,
-  description: z20.string()
-});
-var availableModelSchema = z20.object({
-  id: z20.string(),
-  model: z20.string(),
-  displayName: z20.string(),
-  routeProviderId: z20.string().min(1).optional(),
-  description: z20.string(),
-  supportedReasoningEfforts: z20.array(modelReasoningEffortSchema),
+  description: z19.string()
+});
+var availableModelSchema = z19.object({
+  id: z19.string(),
+  model: z19.string(),
+  displayName: z19.string(),
+  routeProviderId: z19.string().min(1).optional(),
+  description: z19.string(),
+  supportedReasoningEfforts: z19.array(modelReasoningEffortSchema),
   defaultReasoningEffort: reasoningLevelSchema,
-  isDefault: z20.boolean()
-});
-var providerModelCatalogScopeSchema = z20.enum(["host", "workspace"]);
-var providerCapabilitiesSchema = z20.object({
-  supportsThreadArchive: z20.boolean(),
-  supportsThreadRename: z20.boolean(),
-  supportsServiceTier: z20.boolean(),
-  supportsNativeUserQuestion: z20.boolean(),
-  supportsFork: z20.boolean(),
-  supportsSessionRewind: z20.boolean(),
-  permissionModes: z20.array(permissionModeSchema).min(1),
+  isDefault: z19.boolean()
+});
+var providerModelCatalogScopeSchema = z19.enum(["host", "workspace"]);
+var providerCapabilitiesSchema = z19.object({
+  supportsThreadArchive: z19.boolean(),
+  supportsThreadRename: z19.boolean(),
+  supportsServiceTier: z19.boolean(),
+  supportsNativeUserQuestion: z19.boolean(),
+  supportsFork: z19.boolean(),
+  supportsSessionRewind: z19.boolean(),
+  permissionModes: z19.array(permissionModeSchema).min(1),
   modelCatalogScope: providerModelCatalogScopeSchema
 });
-var providerComposerCommandSchema = z20.object({
+var providerComposerCommandSchema = z19.object({
   trigger: promptMentionCommandTriggerSchema,
-  name: z20.string().min(1).regex(/^[^\s/$]+$/u),
-  trailingText: z20.string().regex(/^\s*$/u)
+  name: z19.string().min(1).regex(/^[^\s/$]+$/u),
+  trailingText: z19.string().regex(/^\s*$/u)
 });
-var providerComposerActionSchema = z20.discriminatedUnion("kind", [
-  z20.object({
-    kind: z20.literal("skills"),
+var providerComposerActionSchema = z19.discriminatedUnion("kind", [
+  z19.object({
+    kind: z19.literal("skills"),
     trigger: promptMentionCommandTriggerSchema
   }),
-  z20.object({
-    kind: z20.literal("plan"),
+  z19.object({
+    kind: z19.literal("plan"),
     command: providerComposerCommandSchema
   }),
-  z20.object({
-    kind: z20.literal("goal"),
+  z19.object({
+    kind: z19.literal("goal"),
     command: providerComposerCommandSchema
   })
 ]);
-var providerStringsSchema = z20.object({
-  signInHint: z20.string().min(1),
-  expiredHint: z20.string().min(1),
-  installUrl: z20.string().min(1),
-  brandPrefix: z20.string().min(1).optional(),
-  planModeCopy: z20.string().min(1).optional(),
-  iconTint: z20.object({ light: z20.string().min(1), dark: z20.string().min(1) }).optional()
-});
-var providerOptionDescriptorSchema = z20.object({
-  id: z20.string().min(1),
-  label: z20.string().min(1),
-  description: z20.string().min(1).optional()
-});
-var providerExtensionKindInfoSchema = z20.object({
-  item: z20.boolean(),
-  state: z20.boolean()
-});
-var providerExtensionKindsSchema = z20.record(
+var providerStringsSchema = z19.object({
+  signInHint: z19.string().min(1),
+  expiredHint: z19.string().min(1),
+  installUrl: z19.string().min(1),
+  brandPrefix: z19.string().min(1).optional(),
+  planModeCopy: z19.string().min(1).optional(),
+  iconTint: z19.object({ light: z19.string().min(1), dark: z19.string().min(1) }).optional()
+});
+var providerOptionDescriptorSchema = z19.object({
+  id: z19.string().min(1),
+  label: z19.string().min(1),
+  description: z19.string().min(1).optional()
+});
+var providerExtensionKindInfoSchema = z19.object({
+  item: z19.boolean(),
+  state: z19.boolean()
+});
+var providerExtensionKindsSchema = z19.record(
   extensionKindSchema,
   providerExtensionKindInfoSchema
 );
-var providerInfoSchema = z20.object({
-  id: z20.string(),
-  pluginId: z20.string().min(1),
-  displayName: z20.string(),
-  family: z20.string().min(1).optional(),
-  icon: z20.object({ glyph: z20.string().min(1) }).optional(),
-  logoUrl: z20.string().min(1).nullable(),
-  maintenance: z20.object({
-    health: z20.boolean(),
-    usage: z20.boolean(),
-    installation: z20.boolean()
+var providerInfoSchema = z19.object({
+  id: z19.string(),
+  pluginId: z19.string().min(1),
+  displayName: z19.string(),
+  family: z19.string().min(1).optional(),
+  icon: z19.object({ glyph: z19.string().min(1) }).optional(),
+  logoUrl: z19.string().min(1).nullable(),
+  maintenance: z19.object({
+    health: z19.boolean(),
+    usage: z19.boolean(),
+    installation: z19.boolean()
   }),
   capabilities: providerCapabilitiesSchema,
-  composerActions: z20.array(providerComposerActionSchema),
-  available: z20.boolean(),
+  composerActions: z19.array(providerComposerActionSchema),
+  available: z19.boolean(),
   strings: providerStringsSchema.optional(),
-  serviceTiers: z20.array(providerOptionDescriptorSchema).optional(),
-  reasoningLevels: z20.array(providerOptionDescriptorSchema).optional(),
+  serviceTiers: z19.array(providerOptionDescriptorSchema).optional(),
+  reasoningLevels: z19.array(providerOptionDescriptorSchema).optional(),
   extensionKinds: providerExtensionKindsSchema.optional()
 });
 var providerRecoveryKindValues = [
@@ -3649,34 +3385,34 @@ var providerRecoveryKindValues = [
   "staleTurn",
   "rateLimited"
 ];
-var providerRecoveryKindSchema = z20.enum(providerRecoveryKindValues);
-var toolCallOutputItemSchema = z20.discriminatedUnion("type", [
-  z20.object({
-    type: z20.literal("inputText"),
-    text: z20.string()
+var providerRecoveryKindSchema = z19.enum(providerRecoveryKindValues);
+var toolCallOutputItemSchema = z19.discriminatedUnion("type", [
+  z19.object({
+    type: z19.literal("inputText"),
+    text: z19.string()
   }),
-  z20.object({
-    type: z20.literal("inputImage"),
-    imageUrl: z20.string()
+  z19.object({
+    type: z19.literal("inputImage"),
+    imageUrl: z19.string()
   })
 ]);
-var toolCallRequestSchema = z20.object({
-  requestId: z20.union([z20.string().min(1), z20.number()]),
-  threadId: z20.string().min(1),
-  providerThreadId: z20.string().min(1),
-  turnId: z20.string().min(1),
-  callId: z20.string().min(1),
-  tool: z20.string().min(1),
-  arguments: z20.unknown().optional()
-});
-var toolCallResponseSchema = z20.object({
-  contentItems: z20.array(toolCallOutputItemSchema),
-  success: z20.boolean()
-});
-var dynamicToolSchema = z20.object({
-  name: z20.string(),
-  description: z20.string(),
-  inputSchema: z20.unknown(),
+var toolCallRequestSchema = z19.object({
+  requestId: z19.union([z19.string().min(1), z19.number()]),
+  threadId: z19.string().min(1),
+  providerThreadId: z19.string().min(1),
+  turnId: z19.string().min(1),
+  callId: z19.string().min(1),
+  tool: z19.string().min(1),
+  arguments: z19.unknown().optional()
+});
+var toolCallResponseSchema = z19.object({
+  contentItems: z19.array(toolCallOutputItemSchema),
+  success: z19.boolean()
+});
+var dynamicToolSchema = z19.object({
+  name: z19.string(),
+  description: z19.string(),
+  inputSchema: z19.unknown(),
   presentation: threadEventItemPresentationSchema.optional()
 });
 
@@ -3727,6 +3463,278 @@ function reasoningEffortsForLevels(levels) {
   return levels.map((level) => ({ ...REASONING_EFFORT_BY_LEVEL[level] }));
 }
 
+// ../provider-bridge-protocol/src/bridge-requests.ts
+import { z as z20 } from "zod";
+var BRIDGE_INBOUND_REQUEST_METHODS = {
+  toolCall: "item/tool/call",
+  interactionRequest: "interaction/request"
+};
+var toolCallRequestParamsSchema = z20.object({
+  providerThreadId: z20.string().min(1),
+  threadId: z20.string().min(1).optional(),
+  turnId: z20.union([z20.string().min(1), z20.null()]),
+  callId: z20.string().min(1),
+  tool: z20.string().min(1),
+  arguments: z20.unknown(),
+  providerNativeIds: z20.boolean().optional()
+}).passthrough();
+var toolCallResultSchema = z20.object({
+  success: z20.boolean(),
+  contentItems: z20.array(
+    z20.discriminatedUnion("type", [
+      z20.object({ type: z20.literal("inputText"), text: z20.string() }),
+      z20.object({
+        type: z20.literal("inputImage"),
+        imageUrl: z20.string().min(1)
+      })
+    ])
+  )
+}).passthrough();
+var interactionRequestParamsSchema = z20.object({
+  providerThreadId: z20.string().min(1),
+  threadId: z20.string().min(1).optional(),
+  turnId: z20.union([z20.string().min(1), z20.null()]),
+  payload: pendingInteractionPayloadSchema,
+  providerNativeIds: z20.boolean().optional()
+}).passthrough();
+
+// ../provider-bridge-protocol/src/bridge-kit/bridge-tool-calls.ts
+var bridgeRequestEnvelopeSchema = z21.object({
+  jsonrpc: z21.literal("2.0"),
+  id: z21.union([z21.string(), z21.number()]),
+  method: z21.string(),
+  params: z21.record(z21.string(), z21.unknown()).optional()
+});
+var jsonRpcErrorSchema = z21.object({
+  code: z21.number(),
+  message: z21.string().optional(),
+  data: z21.unknown().optional()
+});
+var jsonRpcSuccessResponseSchema = z21.object({
+  jsonrpc: z21.literal("2.0"),
+  id: z21.union([z21.string(), z21.number()]),
+  result: z21.unknown()
+});
+var jsonRpcErrorResponseSchema = z21.object({
+  jsonrpc: z21.literal("2.0"),
+  id: z21.union([z21.string(), z21.number()]),
+  error: jsonRpcErrorSchema
+});
+function isJsonRpcRequest(input) {
+  return typeof input === "object" && input !== null && "method" in input && input.method !== void 0;
+}
+function decodeBridgeJsonRpcResponse(input) {
+  if (isJsonRpcRequest(input)) return null;
+  const error = jsonRpcErrorResponseSchema.safeParse(input);
+  if (error.success) return error.data;
+  const success = jsonRpcSuccessResponseSchema.safeParse(input);
+  return success.success ? success.data : null;
+}
+var IMAGE_DATA_URL = /^data:(.+);base64,(.+)$/s;
+function decodeImageDataUrl(imageUrl) {
+  const match = IMAGE_DATA_URL.exec(imageUrl);
+  if (match === null) {
+    return null;
+  }
+  const [, mimeType, data] = match;
+  if (data.length === 0) {
+    return null;
+  }
+  return { data, mimeType };
+}
+function decodeToolCallResponsePayload(result) {
+  const parsed = toolCallResultSchema.safeParse(result);
+  if (!parsed.success) {
+    return {
+      content: "Invalid tool call response",
+      contentBlocks: [{ type: "text", text: "Invalid tool call response" }],
+      images: [],
+      isError: true
+    };
+  }
+  const texts = [];
+  const contentBlocks = [];
+  const images = [];
+  for (const item of parsed.data.contentItems) {
+    if (item.type === "inputText") {
+      texts.push(item.text);
+      if (item.text !== "") {
+        contentBlocks.push({ type: "text", text: item.text });
+      }
+      continue;
+    }
+    const image = decodeImageDataUrl(item.imageUrl);
+    if (image === null) {
+      texts.push(item.imageUrl);
+      contentBlocks.push({ type: "text", text: item.imageUrl });
+      continue;
+    }
+    images.push(image);
+    contentBlocks.push({ type: "image", ...image });
+  }
+  const text = texts.join("\n");
+  const isError = !parsed.data.success;
+  if (contentBlocks.length === 0) {
+    const fallback = isError ? "Tool call failed" : "OK";
+    return {
+      content: fallback,
+      contentBlocks: [{ type: "text", text: fallback }],
+      images,
+      isError
+    };
+  }
+  return {
+    content: text,
+    contentBlocks,
+    images,
+    isError
+  };
+}
+function buildBridgeToolCallContent(result) {
+  if (result.contentBlocks !== void 0) {
+    return result.contentBlocks;
+  }
+  const blocks = [];
+  if (result.content !== "") {
+    blocks.push({ type: "text", text: result.content });
+  }
+  for (const image of result.images ?? []) {
+    blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+  }
+  return blocks;
+}
+
+// ../provider-bridge-protocol/src/bridge-kit/json-rpc-envelope.ts
+import { z as z22 } from "zod";
+var recordSchema = z22.record(z22.string(), z22.unknown());
+var jsonRpcEnvelopeSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  method: z22.string(),
+  params: recordSchema.optional()
+}).passthrough();
+var sdkMessageEnvelopeSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  method: z22.literal("sdk/message"),
+  params: z22.object({
+    message: z22.unknown(),
+    threadId: z22.string().optional(),
+    parent_tool_use_id: z22.string().optional()
+  }).passthrough()
+}).passthrough();
+var threadIdentityEnvelopeSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  method: z22.literal("thread/identity"),
+  params: z22.object({
+    threadId: z22.string().optional(),
+    providerThreadId: z22.string().optional()
+  }).passthrough()
+}).passthrough();
+var threadContextWindowUsageEnvelopeSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  method: z22.literal("thread/contextWindowUsage/updated"),
+  params: z22.object({
+    threadId: z22.string().optional(),
+    contextWindowUsage: z22.object({
+      usedTokens: z22.number().nullable(),
+      modelContextWindow: z22.number().nullable(),
+      estimated: z22.boolean()
+    })
+  }).passthrough()
+}).passthrough();
+var errorEnvelopeSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  method: z22.literal("error"),
+  params: z22.object({
+    message: z22.string().optional()
+  }).passthrough().optional()
+}).passthrough();
+
+// ../provider-bridge-protocol/src/bridge-kit/mime-types.ts
+import { extname } from "node:path";
+function mimeTypeFromExtension(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".svg":
+      return "image/svg+xml";
+    default:
+      return "image/png";
+  }
+}
+
+// ../provider-bridge-protocol/src/bridge-kit/pending-tool-call-tracker.ts
+function createPendingToolCallTracker(options) {
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  let requestIdCounter = 0;
+  return {
+    forwardToolCall: (args) => {
+      return new Promise((resolve2) => {
+        requestIdCounter += 1;
+        const requestId = requestIdCounter;
+        pendingToolCalls.set(requestId, { resolve: resolve2, scope: args.scope });
+        try {
+          options.sendToolCall({
+            jsonrpc: "2.0",
+            id: requestId,
+            method: "item/tool/call",
+            params: {
+              threadId: args.threadId,
+              providerThreadId: args.providerThreadId,
+              turnId: null,
+              callId: `call-${requestId}`,
+              tool: args.toolName,
+              arguments: args.arguments
+            }
+          });
+        } catch (error) {
+          pendingToolCalls.delete(requestId);
+          resolve2({
+            content: error instanceof Error ? error.message : String(error),
+            isError: true
+          });
+        }
+      });
+    },
+    handleToolCallResponse: (response) => {
+      const pending = pendingToolCalls.get(response.id);
+      if (!pending) {
+        return false;
+      }
+      pendingToolCalls.delete(response.id);
+      if ("error" in response) {
+        pending.resolve({
+          content: response.error.message ?? "Tool call failed",
+          isError: true
+        });
+      } else {
+        pending.resolve(decodeToolCallResponsePayload(response.result));
+      }
+      return true;
+    },
+    resolvePendingToolCalls: (scope, message) => {
+      for (const [requestId, pending] of pendingToolCalls) {
+        if (pending.scope !== scope) {
+          continue;
+        }
+        pendingToolCalls.delete(requestId);
+        pending.resolve({ content: message, isError: true });
+      }
+    }
+  };
+}
+
+// ../provider-bridge-protocol/src/bridge-kit/permission-policy.ts
+function shouldAutoDenyInteractiveRequest(policy) {
+  return policy.permissionEscalation === "deny";
+}
+
 // ../provider-bridge-protocol/src/bridge-kit/presentation.ts
 var PRESENTATION_TITLE_MAX_LENGTH = 160;
 function presentationTitle(text) {
@@ -3823,7 +3831,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 z21 } from "zod";
+import { z as z23 } from "zod";
 var execFileAsync = promisify(execFile);
 var CLI_PROBE_TIMEOUT_MS = 5e3;
 var INSTALLATION_CHECK_TIMEOUT_MS = 15e3;
@@ -3928,8 +3936,8 @@ function firstLine(value) {
 function npmGlobalPackageVersion(value, npmPackage) {
   if (value === null) return null;
   try {
-    const parsed = z21.object({
-      dependencies: z21.record(z21.string(), z21.object({ version: z21.string().min(1) })).default({})
+    const parsed = z23.object({
+      dependencies: z23.record(z23.string(), z23.object({ version: z23.string().min(1) })).default({})
     }).safeParse(JSON.parse(value));
     return parsed.success ? parsed.data.dependencies[npmPackage]?.version ?? null : null;
   } catch {
@@ -3965,18 +3973,6 @@ function clampPercent(value) {
   );
 }
 
-// ../provider-bridge-protocol/src/bridge-kit/provider-tool-call-contract.ts
-import { z as z22 } from "zod";
-var normalizedToolCallRequestSchema = z22.object({
-  providerThreadId: z22.string().min(1),
-  threadId: z22.string().min(1).optional(),
-  turnId: z22.union([z22.string().min(1), z22.null()]),
-  callId: z22.string().min(1),
-  tool: z22.string().min(1),
-  arguments: z22.unknown(),
-  providerNativeIds: z22.boolean().optional()
-});
-
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility.ts
 function createProviderVisibilityMetadata(args) {
   return {
@@ -3989,10 +3985,10 @@ function createProviderVisibilityMetadata(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // ../provider-bridge-protocol/src/errors.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var BRIDGE_JSON_RPC_ERRORS = {
   INVALID_PARAMS: -32602,
   METHOD_NOT_FOUND: -32601,
@@ -4001,12 +3997,12 @@ var BRIDGE_JSON_RPC_ERRORS = {
   SESSION_NOT_RESTORABLE: -32002,
   FORK_CHECKPOINT_UNSUPPORTED: -32003
 };
-var providerRecoveryHintSchema = z23.object({
+var providerRecoveryHintSchema = z24.object({
   kind: providerRecoveryKindSchema,
-  message: z23.string().min(1),
-  retryable: z23.boolean()
+  message: z24.string().min(1),
+  retryable: z24.boolean()
 });
-var bridgeErrorDataSchema = z23.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
+var bridgeErrorDataSchema = z24.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
 var JSON_RPC_INVALID_PARAMS_CODE = -32602;
@@ -4024,7 +4020,7 @@ var ProviderResponseEncodeError = class extends Error {
     this.name = "ProviderResponseEncodeError";
   }
 };
-var ignoredJsonRpcResultSchema = z24.unknown();
+var ignoredJsonRpcResultSchema = z25.unknown();
 
 // ../provider-bridge-protocol/src/version.ts
 var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
@@ -4032,66 +4028,66 @@ var THREAD_DELTA_GRAMMAR_V2 = PROVIDER_BRIDGE_PROTOCOL_VERSION;
 var THREAD_DELTA_GRAMMAR_V3 = 3;
 
 // ../provider-bridge-protocol/src/handshake.ts
-import { z as z25 } from "zod";
-var bridgeGrammarVersionsSchema = z25.tuple([z25.number().int().positive(), z25.number().int().positive()]).refine(([min, max]) => min <= max, {
+import { z as z26 } from "zod";
+var bridgeGrammarVersionsSchema = z26.tuple([z26.number().int().positive(), z26.number().int().positive()]).refine(([min, max]) => min <= max, {
   message: "grammarVersions must be an ascending [min, max] range"
 });
-var bridgeSteerModeSchema = z25.enum(["inject", "queue"]);
-var bridgeCapabilitiesSchema = z25.object({
-  sessionRestore: z25.boolean().default(false),
-  threadArchive: z25.boolean().default(false),
-  threadRename: z25.boolean().default(false),
-  threadGoalClear: z25.boolean().default(false),
+var bridgeSteerModeSchema = z26.enum(["inject", "queue"]);
+var bridgeCapabilitiesSchema = z26.object({
+  sessionRestore: z26.boolean().default(false),
+  threadArchive: z26.boolean().default(false),
+  threadRename: z26.boolean().default(false),
+  threadGoalClear: z26.boolean().default(false),
   fork: providerForkSchema.default("none"),
-  approvalEnforcedBy: z25.enum(["runtime", "provider"]).default("runtime"),
+  approvalEnforcedBy: z26.enum(["runtime", "provider"]).default("runtime"),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ]),
   steerMode: bridgeSteerModeSchema.default("queue"),
-  skills: z25.object({ configure: z25.boolean().default(false) }).default({ configure: false })
+  skills: z26.object({ configure: z26.boolean().default(false) }).default({ configure: false })
 }).passthrough();
-var initializeParamsSchema = z25.object({
-  protocolVersion: z25.number().int().positive(),
-  client: z25.object({ name: z25.string().min(1), version: z25.string().min(1) }),
+var initializeParamsSchema = z26.object({
+  protocolVersion: z26.number().int().positive(),
+  client: z26.object({ name: z26.string().min(1), version: z26.string().min(1) }),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ])
 }).passthrough();
-var initializeResultSchema = z25.object({
-  protocolVersion: z25.number().int().positive(),
-  capabilities: z25.preprocess(
+var initializeResultSchema = z26.object({
+  protocolVersion: z26.number().int().positive(),
+  capabilities: z26.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
   )
 }).passthrough();
 
 // ../provider-bridge-protocol/src/execution-options.ts
-import { z as z26 } from "zod";
-var bridgeExecutionOptionsSchema = z26.object({
-  model: z26.string().min(1).optional(),
+import { z as z27 } from "zod";
+var bridgeExecutionOptionsSchema = z27.object({
+  model: z27.string().min(1).optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
   promptMode: promptModeSchema.optional(),
-  instructions: z26.string().optional(),
-  envVars: z26.record(z26.string(), z26.string()).optional(),
-  providerOptions: z26.record(z26.string(), z26.unknown()).optional()
+  instructions: z27.string().optional(),
+  envVars: z27.record(z27.string(), z27.string()).optional(),
+  providerOptions: z27.record(z27.string(), z27.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
 // ../provider-bridge-protocol/src/provider-maintenance.ts
-import { z as z27 } from "zod";
-var providerMaintenanceParamsSchema = z27.object({
-  providerId: z27.string().min(1),
-  cwd: z27.string().min(1).optional(),
-  providerOptions: z27.record(z27.string(), z27.unknown()).optional()
+import { z as z28 } from "zod";
+var providerMaintenanceParamsSchema = z28.object({
+  providerId: z28.string().min(1),
+  cwd: z28.string().min(1).optional(),
+  providerOptions: z28.record(z28.string(), z28.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z27.enum(["thread_rewind"]);
+var providerInstallationRequirementSchema = z28.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
-var providerHealthSchema = z27.object({
-  status: z27.enum([
+var providerHealthSchema = z28.object({
+  status: z28.enum([
     "ready",
     "not_installed",
     "unauthenticated",
@@ -4099,114 +4095,114 @@ var providerHealthSchema = z27.object({
     "unsupported_version",
     "unknown"
   ]),
-  statusMessage: z27.string().min(1).nullable(),
-  accountEmail: z27.string().nullable(),
-  planLabel: z27.string().min(1).nullable(),
-  installedVersion: z27.string().min(1).nullable(),
-  minimumSupportedVersion: z27.string().min(1).nullable(),
-  canInstall: z27.boolean(),
-  canUpdate: z27.boolean(),
-  loginCommand: z27.string().min(1).nullable()
+  statusMessage: z28.string().min(1).nullable(),
+  accountEmail: z28.string().nullable(),
+  planLabel: z28.string().min(1).nullable(),
+  installedVersion: z28.string().min(1).nullable(),
+  minimumSupportedVersion: z28.string().min(1).nullable(),
+  canInstall: z28.boolean(),
+  canUpdate: z28.boolean(),
+  loginCommand: z28.string().min(1).nullable()
 }).passthrough();
-var providerUsageWindowSchema = z27.object({
-  label: z27.string().min(1),
-  usedPercent: z27.number().min(0).max(100),
-  resetsAt: z27.string().min(1).nullable(),
-  cost: z27.object({
-    usedUsdCents: z27.number().int().nonnegative(),
-    limitUsdCents: z27.number().int().positive()
+var providerUsageWindowSchema = z28.object({
+  label: z28.string().min(1),
+  usedPercent: z28.number().min(0).max(100),
+  resetsAt: z28.string().min(1).nullable(),
+  cost: z28.object({
+    usedUsdCents: z28.number().int().nonnegative(),
+    limitUsdCents: z28.number().int().positive()
   }).optional()
 }).passthrough();
-var providerUsageSchema = z27.discriminatedUnion("status", [
-  z27.object({
-    status: z27.literal("ok"),
-    accountEmail: z27.string().email().nullable(),
-    planLabel: z27.string().min(1).nullable(),
-    windows: z27.array(providerUsageWindowSchema)
+var providerUsageSchema = z28.discriminatedUnion("status", [
+  z28.object({
+    status: z28.literal("ok"),
+    accountEmail: z28.string().email().nullable(),
+    planLabel: z28.string().min(1).nullable(),
+    windows: z28.array(providerUsageWindowSchema)
   }).passthrough(),
-  z27.object({ status: z27.literal("not_installed") }).passthrough(),
-  z27.object({ status: z27.literal("unauthenticated") }).passthrough(),
-  z27.object({ status: z27.literal("expired") }).passthrough(),
-  z27.object({
-    status: z27.literal("error"),
-    message: z27.string().min(1),
-    planLabel: z27.string().min(1).nullable().default(null),
-    accountEmail: z27.string().nullable().default(null)
+  z28.object({ status: z28.literal("not_installed") }).passthrough(),
+  z28.object({ status: z28.literal("unauthenticated") }).passthrough(),
+  z28.object({ status: z28.literal("expired") }).passthrough(),
+  z28.object({
+    status: z28.literal("error"),
+    message: z28.string().min(1),
+    planLabel: z28.string().min(1).nullable().default(null),
+    accountEmail: z28.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z27.discriminatedUnion("supported", [
-  z27.object({ supported: z27.literal(false) }).passthrough(),
-  z27.object({
-    supported: z27.literal(true),
+var providerHealthResultSchema = z28.discriminatedUnion("supported", [
+  z28.object({ supported: z28.literal(false) }).passthrough(),
+  z28.object({
+    supported: z28.literal(true),
     health: providerHealthSchema
   }).passthrough()
 ]);
-var providerUsageResultSchema = z27.discriminatedUnion("supported", [
-  z27.object({ supported: z27.literal(false) }).passthrough(),
-  z27.object({
-    supported: z27.literal(true),
+var providerUsageResultSchema = z28.discriminatedUnion("supported", [
+  z28.object({ supported: z28.literal(false) }).passthrough(),
+  z28.object({
+    supported: z28.literal(true),
     usage: providerUsageSchema
   }).passthrough()
 ]);
-var providerInstallationActionKindSchema = z27.enum([
+var providerInstallationActionKindSchema = z28.enum([
   "install",
   "update"
 ]);
-var providerInstallationActionSchema = z27.object({
+var providerInstallationActionSchema = z28.object({
   kind: providerInstallationActionKindSchema,
-  label: z27.enum(["Install", "Update"]),
-  command: z27.string().min(1)
+  label: z28.enum(["Install", "Update"]),
+  command: z28.string().min(1)
 }).passthrough();
-var providerInstallationSourceSchema = z27.enum([
+var providerInstallationSourceSchema = z28.enum([
   "notInstalled",
   "npmGlobal",
   "external"
 ]);
-var providerInstallationStatusSchema = z27.object({
-  executableName: z27.string().min(1),
-  executablePath: z27.string().min(1).nullable(),
-  installed: z27.boolean(),
+var providerInstallationStatusSchema = z28.object({
+  executableName: z28.string().min(1),
+  executablePath: z28.string().min(1).nullable(),
+  installed: z28.boolean(),
   installSource: providerInstallationSourceSchema,
-  currentVersion: z27.string().min(1).nullable(),
-  latestVersion: z27.string().min(1).nullable(),
-  minimumSupportedVersion: z27.string().min(1).nullable(),
-  npmPackageName: z27.string().min(1).nullable(),
-  npmGlobalPackageVersion: z27.string().min(1).nullable(),
+  currentVersion: z28.string().min(1).nullable(),
+  latestVersion: z28.string().min(1).nullable(),
+  minimumSupportedVersion: z28.string().min(1).nullable(),
+  npmPackageName: z28.string().min(1).nullable(),
+  npmGlobalPackageVersion: z28.string().min(1).nullable(),
   installAction: providerInstallationActionSchema.nullable(),
-  needsUpdate: z27.boolean(),
-  versionUnsupported: z27.boolean()
+  needsUpdate: z28.boolean(),
+  versionUnsupported: z28.boolean()
 }).passthrough();
 var providerInstallationRunParamsSchema = providerMaintenanceParamsSchema.extend({
   action: providerInstallationActionKindSchema
 });
-var providerInstallationCommandSchema = z27.object({
-  command: z27.string().min(1),
-  args: z27.array(z27.string()).max(64),
-  displayCommand: z27.string().min(1)
+var providerInstallationCommandSchema = z28.object({
+  command: z28.string().min(1),
+  args: z28.array(z28.string()).max(64),
+  displayCommand: z28.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z27.discriminatedUnion(
+var providerInstallationVerificationSchema = z28.discriminatedUnion(
   "kind",
   [
-    z27.object({ kind: z27.literal("installed") }).passthrough(),
-    z27.object({
-      kind: z27.literal("version_changed"),
-      previousVersion: z27.string().min(1)
+    z28.object({ kind: z28.literal("installed") }).passthrough(),
+    z28.object({
+      kind: z28.literal("version_changed"),
+      previousVersion: z28.string().min(1)
     }).passthrough(),
-    z27.object({
-      kind: z27.literal("version_at_least"),
-      version: z27.string().min(1)
+    z28.object({
+      kind: z28.literal("version_at_least"),
+      version: z28.string().min(1)
     }).passthrough()
   ]
 );
-var providerInstallationRunResultSchema = z27.discriminatedUnion(
+var providerInstallationRunResultSchema = z28.discriminatedUnion(
   "available",
   [
-    z27.object({
-      available: z27.literal(false),
-      message: z27.string().min(1)
+    z28.object({
+      available: z28.literal(false),
+      message: z28.string().min(1)
     }).passthrough(),
-    z27.object({
-      available: z27.literal(true),
+    z28.object({
+      available: z28.literal(true),
       command: providerInstallationCommandSchema,
       verification: providerInstallationVerificationSchema
     }).passthrough()
@@ -4214,7 +4210,7 @@ var providerInstallationRunResultSchema = z27.discriminatedUnion(
 );
 
 // ../provider-bridge-protocol/src/requests.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var BRIDGE_REQUEST_METHODS = {
   initialize: "initialize",
   modelList: "model/list",
@@ -4236,82 +4232,78 @@ var BRIDGE_REQUEST_METHODS = {
   skillsConfigure: "skills/configure"
 };
 var sessionConstructionFields = {
-  threadId: z28.string().min(1),
-  cwd: z28.string().min(1),
+  threadId: z29.string().min(1),
+  cwd: z29.string().min(1),
   options: bridgeExecutionOptionsSchema,
-  dynamicTools: z28.array(dynamicToolSchema).optional(),
-  disallowedTools: z28.array(z28.string().min(1)).optional(),
+  dynamicTools: z29.array(dynamicToolSchema).optional(),
+  disallowedTools: z29.array(z29.string().min(1)).optional(),
   instructionMode: instructionModeSchema
 };
-var modelListParamsSchema = z28.object({ cwd: z28.string().min(1).optional() }).passthrough();
-var threadStartParamsSchema = z28.object({
+var modelListParamsSchema = z29.object({ cwd: z29.string().min(1).optional() }).passthrough();
+var threadStartParamsSchema = z29.object({
   ...sessionConstructionFields,
-  input: z28.array(promptInputSchema).optional()
+  input: z29.array(promptInputSchema).optional()
 }).passthrough();
-var threadResumeParamsSchema = z28.object({
+var threadResumeParamsSchema = z29.object({
   ...sessionConstructionFields,
-  providerThreadId: z28.string().min(1)
+  providerThreadId: z29.string().min(1)
 }).passthrough();
-var threadForkParamsSchema = z28.object({
+var threadForkParamsSchema = z29.object({
   ...sessionConstructionFields,
-  sourceProviderThreadId: z28.string().min(1),
-  sourceProviderCheckpointId: z28.string().min(1).optional()
+  sourceProviderThreadId: z29.string().min(1),
+  sourceProviderCheckpointId: z29.string().min(1).optional()
 }).passthrough();
-var threadStopParamsSchema = z28.object({
-  threadId: z28.string().min(1),
-  providerThreadId: z28.string().min(1),
-  intent: z28.enum(["interrupt", "release"]),
-  activeTurnId: z28.string().min(1).nullable()
+var threadStopParamsSchema = z29.object({
+  threadId: z29.string().min(1),
+  providerThreadId: z29.string().min(1),
+  intent: z29.enum(["interrupt", "release"]),
+  activeTurnId: z29.string().min(1).nullable()
 }).passthrough();
-var threadRefParams = z28.object({
-  threadId: z28.string().min(1),
-  providerThreadId: z28.string().min(1)
+var threadRefParams = z29.object({
+  threadId: z29.string().min(1),
+  providerThreadId: z29.string().min(1)
 }).passthrough();
 var threadDiscardParamsSchema = threadRefParams;
 var threadArchiveParamsSchema = threadRefParams;
 var threadUnarchiveParamsSchema = threadRefParams;
 var threadGoalClearParamsSchema = threadRefParams;
-var threadNameSetParamsSchema = z28.object({
-  threadId: z28.string().min(1),
-  providerThreadId: z28.string().min(1),
-  title: z28.string().min(1)
+var threadNameSetParamsSchema = z29.object({
+  threadId: z29.string().min(1),
+  providerThreadId: z29.string().min(1),
+  title: z29.string().min(1)
 }).passthrough();
 var turnInputFields = {
-  threadId: z28.string().min(1),
-  providerThreadId: z28.string().min(1),
-  input: z28.array(promptInputSchema),
+  threadId: z29.string().min(1),
+  providerThreadId: z29.string().min(1),
+  input: z29.array(promptInputSchema),
   clientRequestId: clientTurnRequestIdSchema,
   options: bridgeExecutionOptionsSchema
 };
-var turnStartParamsSchema = z28.object(turnInputFields).passthrough();
-var turnSteerParamsSchema = z28.object({
+var turnStartParamsSchema = z29.object(turnInputFields).passthrough();
+var turnSteerParamsSchema = z29.object({
   ...turnInputFields,
-  expectedTurnId: z28.string().min(1)
+  expectedTurnId: z29.string().min(1)
 }).passthrough();
-var skillsConfigureRootSchema = z28.object({
-  id: z28.string().min(1),
-  path: z28.string().min(1),
-  skills: z28.array(
-    z28.object({
-      name: z28.string().min(1),
-      description: z28.string()
+var skillsConfigureRootSchema = z29.object({
+  id: z29.string().min(1),
+  path: z29.string().min(1),
+  skills: z29.array(
+    z29.object({
+      name: z29.string().min(1),
+      description: z29.string()
     }).passthrough()
   )
 }).passthrough();
-var skillsConfigureParamsSchema = z28.object({
-  roots: z28.array(skillsConfigureRootSchema)
+var skillsConfigureParamsSchema = z29.object({
+  roots: z29.array(skillsConfigureRootSchema)
 }).passthrough();
-var threadIdentityResultSchema = z28.object({
-  providerThreadId: z28.string().min(1),
-  sessionRestorable: z28.boolean().optional()
-}).passthrough();
-var modelListResultSchema = z28.object({
-  models: z28.array(availableModelSchema),
-  selectedOnlyModels: z28.array(availableModelSchema).default([])
+var threadIdentityResultSchema = z29.object({
+  providerThreadId: z29.string().min(1),
+  sessionRestorable: z29.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var BRIDGE_NOTIFICATION_METHODS = {
   threadIdentity: "thread/identity",
   sessionReplaced: "session/replaced",
@@ -4319,64 +4311,26 @@ var BRIDGE_NOTIFICATION_METHODS = {
   providerRecovery: "provider/recovery",
   error: "error"
 };
-var threadIdentityNotificationSchema = z29.object({
-  threadId: z29.string().min(1),
-  providerThreadId: z29.string().min(1),
-  sessionRestorable: z29.boolean().optional()
-}).passthrough();
-var sessionReplacedNotificationSchema = z29.object({
-  threadId: z29.string().min(1),
-  providerThreadId: z29.string().min(1).nullable(),
-  reason: z29.string().min(1),
-  contextLost: z29.boolean().default(false),
-  showRuntimeNote: z29.boolean().default(false)
-}).passthrough();
-var providerRawNotificationSchema = z29.object({
-  threadId: z29.string().min(1).optional(),
-  coverage: z29.enum(["noise", "unknown"]),
-  payload: z29.unknown()
-}).passthrough();
-var providerRecoveryNotificationSchema = z29.object({
-  threadId: z29.string().min(1).optional(),
-  ...providerRecoveryHintSchema.shape
+var threadIdentityNotificationSchema = z30.object({
+  threadId: z30.string().min(1),
+  providerThreadId: z30.string().min(1),
+  sessionRestorable: z30.boolean().optional()
 }).passthrough();
-var errorNotificationSchema = z29.object({
-  threadId: z29.string().min(1).optional(),
-  message: z29.string().min(1)
+var sessionReplacedNotificationSchema = z30.object({
+  threadId: z30.string().min(1),
+  providerThreadId: z30.string().min(1).nullable(),
+  reason: z30.string().min(1),
+  contextLost: z30.boolean().default(false),
+  showRuntimeNote: z30.boolean().default(false)
 }).passthrough();
-
-// ../provider-bridge-protocol/src/bridge-requests.ts
-import { z as z30 } from "zod";
-var BRIDGE_INBOUND_REQUEST_METHODS = {
-  toolCall: "item/tool/call",
-  interactionRequest: "interaction/request"
-};
-var toolCallRequestParamsSchema = z30.object({
-  providerThreadId: z30.string().min(1),
+var providerRecoveryNotificationSchema = z30.object({
   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()
-}).passthrough();
-var toolCallResultSchema = z30.object({
-  success: z30.boolean(),
-  contentItems: z30.array(
-    z30.discriminatedUnion("type", [
-      z30.object({ type: z30.literal("inputText"), text: z30.string() }),
-      z30.object({
-        type: z30.literal("inputImage"),
-        imageUrl: z30.string().min(1)
-      })
-    ])
-  )
+  ...providerRecoveryHintSchema.shape
 }).passthrough();
-var interactionRequestParamsSchema = z30.object({
-  providerThreadId: z30.string().min(1),
+var errorNotificationSchema = z30.object({
   threadId: z30.string().min(1).optional(),
-  turnId: z30.union([z30.string().min(1), z30.null()]),
-  payload: pendingInteractionPayloadSchema,
-  providerNativeIds: z30.boolean().optional()
+  providerThreadId: z30.string().min(1).optional(),
+  message: z30.string().min(1)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/thread-delta.ts
@@ -4621,6 +4575,7 @@ var threadDeltaSchema = z31.discriminatedUnion("kind", [
   }),
   z31.object({
     kind: z31.literal("contextWindow"),
+    snapshot: contextSnapshotSchema.optional(),
     used: z31.number().nullable(),
     size: z31.number().nullable().optional(),
     estimated: z31.boolean(),
@@ -4853,6 +4808,7 @@ export {
   buildShellEnvOverrides,
   claudeTaskToolNameSchema,
   claudeTaskToolOutputSchema,
+  contextSnapshotSchema,
   createBridgeIo,
   createBridgeLineHandler,
   createPendingToolCallTracker,