@agentknight/sdk 0.9.43 → 0.9.45

package/dist/chunks/{chunk-7QOBDG6R.js → chunk-DUMC5F2D.js}

@@ -1703,34 +1703,53 @@ var A2aRelayResponseSchema = z16.object({
   body: z16.string().max(A2A_BODY_MAX_LENGTH)
 }).strict();
 
-// ../protocol/dist/sessions/session-communication.js
+// ../protocol/dist/transport/browser-open-url.js
 import { z as z17 } from "zod";
+var BROWSER_OPEN_URL_MAX_LENGTH = 8192;
+var BrowserOpenUrlParamsSchema = z17.strictObject({
+  url: z17.string().min(1).max(BROWSER_OPEN_URL_MAX_LENGTH).refine((value) => {
+    if (!/^https?:\/\//i.test(value) || /[\s\p{Cc}\\]/u.test(value) || /%(?![0-9a-f]{2})/i.test(value))
+      return false;
+    const authority = value.split(/[/?#]/)[2];
+    if (!authority || /[@%]|[^\x21-\x7e]/.test(authority))
+      return false;
+    try {
+      return new URL(value).hostname.length > 0;
+    } catch {
+      return false;
+    }
+  }, "Expected an absolute HTTP(S) URL without credentials or whitespace")
+});
+var BrowserOpenUrlResultSchema = z17.strictObject({ opened: z17.literal(true) });
+
+// ../protocol/dist/sessions/session-communication.js
+import { z as z18 } from "zod";
 var SESSION_COMMUNICATION_CAPABILITY = "session.communication.v1";
-var SessionCommunicationIdSchema = z17.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
+var SessionCommunicationIdSchema = z18.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
 var SessionCommunicationIdentityShape = {
   requestId: SessionCommunicationIdSchema,
   machineId: SessionCommunicationIdSchema,
   sessionId: SessionCommunicationIdSchema,
-  operation: z17.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
-  version: z17.number().int().positive().max(2147483647)
+  operation: z18.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
+  version: z18.number().int().positive().max(2147483647)
 };
-var SessionCommunicationDataSchema = z17.record(z17.string(), z17.json());
-var SessionCommunicationRequestSchema = z17.object({
+var SessionCommunicationDataSchema = z18.record(z18.string(), z18.json());
+var SessionCommunicationRequestSchema = z18.object({
   ...SessionCommunicationIdentityShape,
-  kind: z17.literal("request"),
+  kind: z18.literal("request"),
   data: SessionCommunicationDataSchema
 }).strict();
-var SessionCommunicationResponseSchema = z17.object({
+var SessionCommunicationResponseSchema = z18.object({
   ...SessionCommunicationIdentityShape,
-  kind: z17.literal("response"),
+  kind: z18.literal("response"),
   data: SessionCommunicationDataSchema
 }).strict();
-var SessionCommunicationErrorSchema = z17.object({
+var SessionCommunicationErrorSchema = z18.object({
   ...SessionCommunicationIdentityShape,
-  kind: z17.literal("error"),
+  kind: z18.literal("error"),
   error: ProtocolFailureSchema
 }).strict();
-var SessionCommunicationSchema = z17.discriminatedUnion("kind", [
+var SessionCommunicationSchema = z18.discriminatedUnion("kind", [
   SessionCommunicationRequestSchema,
   SessionCommunicationResponseSchema,
   SessionCommunicationErrorSchema
@@ -1744,7 +1763,7 @@ function sessionCommunicationError(request, error) {
 }
 
 // ../protocol/dist/sessions/session-workspace.js
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var SESSION_PROJECT_IDENTITY_OPERATION = "session.project.identity";
 var SESSION_PROJECT_IDENTITY_VERSION = 1;
 var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
@@ -1796,47 +1815,47 @@ function isSafeSessionDirectoryPath(path) {
   const segments = path.split("/");
   return segments.length <= SESSION_DIRECTORY_MAX_DEPTH && segments.every((segment) => segment.length > 0 && segment.length <= 255 && segment !== "." && segment !== ".." && !/[\\:<>"|?*\u0000-\u001f\u007f]/u.test(segment) && !/[. ]$/u.test(segment) && !/~[0-9]/u.test(segment) && !/^(?:con|prn|aux|nul|com[0-9¹²³]|lpt[0-9¹²³])(?:[ .]|$)/iu.test(segment) && !/^(?:conin\$|conout\$)$/iu.test(segment));
 }
-var SessionDirectoryListRequestSchema = z18.object({
+var SessionDirectoryListRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  path: z18.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
+  path: z19.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
 }).strict();
-var SessionDirectoryEntrySchema = z18.object({
-  name: z18.string().min(1).max(255),
-  kind: z18.enum(["directory", "file", "blocked"])
+var SessionDirectoryEntrySchema = z19.object({
+  name: z19.string().min(1).max(255),
+  kind: z19.enum(["directory", "file", "blocked"])
 }).strict();
 var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
-var SessionDirectoryListResultDataSchema = z18.object({
-  path: z18.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
-  rootRevision: z18.string().min(1).max(128),
-  entries: z18.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
+var SessionDirectoryListResultDataSchema = z19.object({
+  path: z19.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
+  rootRevision: z19.string().min(1).max(128),
+  entries: z19.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
 }).strict();
 var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
-  rootRevision: z18.string().min(1).max(128).optional(),
-  entries: z18.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
+  rootRevision: z19.string().min(1).max(128).optional(),
+  entries: z19.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
   error: ProtocolFailureSchema.optional()
 }).superRefine((response, context) => {
   if (response.error === void 0 ? response.entries === void 0 || response.rootRevision === void 0 : response.entries !== void 0 || response.rootRevision !== void 0) {
     context.addIssue({ code: "custom", message: "Expected directory success or failure" });
   }
 });
-var SessionFileReadDataSchema = z18.object({
-  path: z18.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
-  rootRevision: z18.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+var SessionFileReadDataSchema = z19.object({
+  path: z19.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
+  rootRevision: z19.string().regex(/^[A-Za-z0-9_-]{43}$/u)
 }).strict();
 function fileResultSchema(mediaTypes, extended) {
   const maxOriginal = extended ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
   const maxTransfer = extended ? SESSION_FILE_V2_MAX_TRANSFER_BYTES : SESSION_FILE_MAX_TRANSFER_BYTES;
-  return z18.object({
+  return z19.object({
     path: SessionFileReadDataSchema.shape.path,
     rootRevision: SessionFileReadDataSchema.shape.rootRevision,
-    mediaType: z18.enum(mediaTypes),
-    originalByteLength: z18.number().int().min(0).max(maxOriginal),
+    mediaType: z19.enum(mediaTypes),
+    originalByteLength: z19.number().int().min(0).max(maxOriginal),
     // Canonical length after decompression, not the length of the transport bytes.
-    byteLength: z18.number().int().min(0).max(maxOriginal),
-    encoding: z18.enum(["identity", "gzip"]),
-    data: z18.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
+    byteLength: z19.number().int().min(0).max(maxOriginal),
+    encoding: z19.enum(["identity", "gzip"]),
+    data: z19.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
   }).strict().superRefine((result, context) => {
     const invalid = () => context.addIssue({ code: "custom", message: "Invalid file content" });
     if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_FILE_GZIP_THRESHOLD_BYTES)
@@ -1856,22 +1875,23 @@ var SessionFileReadResultDataSchema = fileResultSchema(SESSION_FILE_MEDIA_TYPES,
 var SessionFileReadV2ResultDataSchema = fileResultSchema(SESSION_FILE_V2_MEDIA_TYPES, true);
 var SessionFileDownloadDataSchema = SessionFileReadDataSchema;
 var SessionFileDownloadResultDataSchema = fileResultSchema(["application/octet-stream"], true);
-var SessionGitProjectSchema = z18.object({
-  localRepositoryKey: z18.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
-  worktreeRoot: z18.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
-  mainWorktreeRoot: z18.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
-  gitRemoteUrl: z18.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
-}).strict();
-var SessionProjectIdentityRequestDataSchema = z18.object({}).strict();
-var SessionProjectIdentityResultDataSchema = z18.object({
+var SessionGitProjectSchema = z19.object({
+  localRepositoryKey: z19.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
+  worktreeRoot: z19.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
+  mainWorktreeRoot: z19.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
+  gitRemoteUrl: z19.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
+}).strict();
+var SessionProjectIdentityRequestDataSchema = z19.object({}).strict();
+var SessionProjectIdentityResultDataSchema = z19.object({
   project: SessionGitProjectSchema.optional()
 }).strict();
 
 // ../protocol/dist/sessions/session-git-diff.js
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var SESSION_GIT_DIFF_OPERATION = "session.git.diff";
 var SESSION_GIT_DIFF_VERSION = 1;
 var SESSION_GIT_DIFF_GZIP_VERSION = 2;
+var SESSION_GIT_DIFF_PARTIAL_VERSION = 3;
 var SESSION_GIT_DIFF_GZIP_MIN_BYTES = 2 * 1024;
 var SESSION_GIT_DIFF_MAX_FILES = 500;
 var SESSION_GIT_DIFF_MAX_PATCH_BYTES = 128 * 1024;
@@ -1879,24 +1899,24 @@ var SESSION_GIT_DIFF_MAX_RESPONSE_BYTES = 512 * 1024;
 var SESSION_GIT_DIFF_MAX_TRANSFER_BYTES = SESSION_GIT_DIFF_MAX_RESPONSE_BYTES + 1024;
 var SESSION_GIT_DIFF_MAX_BASE64_LENGTH = Math.ceil(SESSION_GIT_DIFF_MAX_TRANSFER_BYTES / 3) * 4;
 var SESSION_GIT_DIFF_MAX_GZIP_RESPONSE_BYTES = SESSION_GIT_DIFF_MAX_BASE64_LENGTH + 1024;
-var commitSchema = z19.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
-var SessionGitDiffDataSchema = z19.object({
+var commitSchema = z20.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
+var SessionGitDiffDataSchema = z20.object({
   rootRevision: SessionFileReadDataSchema.shape.rootRevision,
   path: SessionFileReadDataSchema.shape.path.optional(),
   baseCommit: commitSchema.optional()
 }).strict().refine((value) => value.path === void 0 === (value.baseCommit === void 0), "A file diff must identify its listed base commit");
-var SessionGitDiffEntrySchema = z19.object({
+var SessionGitDiffEntrySchema = z20.object({
   path: SessionFileReadDataSchema.shape.path,
-  status: z19.enum(["added", "modified", "deleted", "untracked"])
+  status: z20.enum(["added", "modified", "deleted", "untracked"])
 }).strict();
-var SessionGitDiffResultDataSchema = z19.object({
+var SessionGitDiffResultDataSchema = z20.object({
   rootRevision: SessionFileReadDataSchema.shape.rootRevision,
-  baseRef: z19.enum(["origin/main", "main"]),
+  baseRef: z20.enum(["origin/main", "main"]),
   baseCommit: commitSchema,
-  files: z19.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
+  files: z20.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
   path: SessionFileReadDataSchema.shape.path.optional(),
-  patch: z19.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
-  binary: z19.boolean().optional()
+  patch: z20.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
+  binary: z20.boolean().optional()
 }).strict().superRefine((value, context) => {
   const encoder = new TextEncoder();
   if (value.patch !== void 0 && encoder.encode(value.patch).length > SESSION_GIT_DIFF_MAX_PATCH_BYTES || encoder.encode(JSON.stringify(value)).length > SESSION_GIT_DIFF_MAX_RESPONSE_BYTES) {
@@ -1910,10 +1930,26 @@ var SessionGitDiffResultDataSchema = z19.object({
     context.addIssue({ code: "custom", message: "Expected a text patch or an explicit binary change" });
   }
 });
-var SessionGitDiffGzipResultDataSchema = z19.object({
-  encoding: z19.literal("gzip"),
-  byteLength: z19.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
-  data: z19.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
+var SessionGitDiffFileErrorSchema = z20.object({
+  code: z20.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
+  message: z20.string().min(1).max(512)
+}).strict();
+var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
+  // Error paths are display-only: they must never be used for file requests.
+  path: z20.string().min(1).max(32768).refine((value) => !value.includes("\0")),
+  error: SessionGitDiffFileErrorSchema.optional()
+}).superRefine((value, context) => {
+  if (value.error === void 0 && !SessionGitDiffEntrySchema.shape.path.safeParse(value.path).success) {
+    context.addIssue({ code: "custom", message: "A readable diff entry must have a safe path" });
+  }
+});
+var SessionGitDiffPartialResultDataSchema = SessionGitDiffResultDataSchema.safeExtend({
+  files: z20.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
+});
+var SessionGitDiffGzipResultDataSchema = z20.object({
+  encoding: z20.literal("gzip"),
+  byteLength: z20.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
+  data: z20.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
 }).strict().superRefine((value, context) => {
   const padding = value.data.endsWith("==") ? 2 : value.data.endsWith("=") ? 1 : 0;
   const bytes = value.data.length / 4 * 3 - padding;
@@ -1923,13 +1959,13 @@ var SessionGitDiffGzipResultDataSchema = z19.object({
     context.addIssue({ code: "custom", message: "Invalid gzip transfer" });
   }
 });
-var SessionGitDiffV2ResultDataSchema = z19.union([
+var SessionGitDiffV2ResultDataSchema = z20.union([
   SessionGitDiffResultDataSchema,
   SessionGitDiffGzipResultDataSchema
 ]);
 
 // ../protocol/dist/sessions/session-resource.js
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var SESSION_RESOURCE_READ_OPERATION = "session.resource.read";
 var SESSION_RESOURCE_READ_VERSION = 1;
 var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
@@ -1945,18 +1981,18 @@ var SESSION_RESOURCE_MEDIA_TYPES = [
   "text/css",
   "text/javascript"
 ];
-var SessionResourceReadDataSchema = z20.object({
-  path: z20.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
-  rootRevision: z20.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+var SessionResourceReadDataSchema = z21.object({
+  path: z21.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
+  rootRevision: z21.string().regex(/^[A-Za-z0-9_-]{43}$/u)
 }).strict();
-var SessionResourceReadResultDataSchema = z20.object({
+var SessionResourceReadResultDataSchema = z21.object({
   path: SessionResourceReadDataSchema.shape.path,
   rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
-  mediaType: z20.enum(SESSION_RESOURCE_MEDIA_TYPES),
-  originalByteLength: z20.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
-  byteLength: z20.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
-  encoding: z20.enum(["identity", "gzip"]),
-  data: z20.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
+  mediaType: z21.enum(SESSION_RESOURCE_MEDIA_TYPES),
+  originalByteLength: z21.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
+  byteLength: z21.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
+  encoding: z21.enum(["identity", "gzip"]),
+  data: z21.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
 }).strict().superRefine((result, context) => {
   const invalid = () => context.addIssue({ code: "custom", message: "Invalid resource content" });
   if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_RESOURCE_GZIP_THRESHOLD_BYTES || result.byteLength !== result.originalByteLength || result.mediaType.startsWith("image/") && result.byteLength === 0)
@@ -1969,112 +2005,112 @@ var SessionResourceReadResultDataSchema = z20.object({
 });
 
 // ../protocol/dist/sessions/session-images.js
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var SESSION_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
 var SESSION_IMAGE_MAX_PIXELS = 16 * 1024 * 1024;
 var SESSION_IMAGE_API_PATH = "/api/v3/session-images";
 var TIMELINE_IMAGE_BLOB_OPERATION = "session.image.blob";
 var TIMELINE_IMAGE_BLOB_VERSION = 1;
-var SessionImageIdSchema = z21.uuid();
-var SessionImageTransferModeSchema = z21.enum(["direct", "proxy"]);
-var DirectUrlSchema = z21.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
+var SessionImageIdSchema = z22.uuid();
+var SessionImageTransferModeSchema = z22.enum(["direct", "proxy"]);
+var DirectUrlSchema = z22.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
   if (!URL.canParse(raw))
     return false;
   const url = new URL(raw);
   return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
 }, "Direct transfers require HTTPS without userinfo, fragments or unsafe characters");
-var ProxyUrlSchema = z21.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
-var SessionImageTransferHeadersSchema = z21.record(z21.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z21.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
-var SessionImageUploadRequestSchema = z21.object({
+var ProxyUrlSchema = z22.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
+var SessionImageTransferHeadersSchema = z22.record(z22.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z22.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
+var SessionImageUploadRequestSchema = z22.object({
   machineId: IdSchema,
   sessionId: IdSchema,
-  sizeBytes: z21.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
+  sizeBytes: z22.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
 }).strict();
-var SessionImageScopeSchema = z21.object({
+var SessionImageScopeSchema = z22.object({
   machineId: IdSchema,
   sessionId: IdSchema
 }).strict();
 var UploadResultFields = {
   imageId: SessionImageIdSchema,
-  uploadExpiresAt: z21.number().int().positive(),
-  method: z21.literal("PUT"),
-  contentType: z21.literal("image/webp"),
+  uploadExpiresAt: z22.number().int().positive(),
+  method: z22.literal("PUT"),
+  contentType: z22.literal("image/webp"),
   headers: SessionImageTransferHeadersSchema.refine((headers) => headers["content-type"] === "image/webp")
 };
-var SessionImageUploadResultSchema = z21.discriminatedUnion("mode", [
-  z21.object({ ...UploadResultFields, mode: z21.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
-  z21.object({ ...UploadResultFields, mode: z21.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
+var SessionImageUploadResultSchema = z22.discriminatedUnion("mode", [
+  z22.object({ ...UploadResultFields, mode: z22.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
+  z22.object({ ...UploadResultFields, mode: z22.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
 ]);
-var SessionImageCommitResultSchema = z21.object({
+var SessionImageCommitResultSchema = z22.object({
   imageId: SessionImageIdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  sizeBytes: z21.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
-  width: z21.number().int().positive(),
-  height: z21.number().int().positive(),
-  sha256: z21.string().regex(/^[a-f0-9]{64}$/u),
-  expiresAt: z21.number().int().positive()
+  sizeBytes: z22.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
+  width: z22.number().int().positive(),
+  height: z22.number().int().positive(),
+  sha256: z22.string().regex(/^[a-f0-9]{64}$/u),
+  expiresAt: z22.number().int().positive()
 }).strict();
 var DownloadResultFields = {
   image: SessionImageCommitResultSchema,
-  downloadExpiresAt: z21.number().int().positive(),
-  method: z21.literal("GET"),
+  downloadExpiresAt: z22.number().int().positive(),
+  method: z22.literal("GET"),
   headers: SessionImageTransferHeadersSchema
 };
-var SessionImageDownloadResultSchema = z21.discriminatedUnion("mode", [
-  z21.object({ ...DownloadResultFields, mode: z21.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
-  z21.object({ ...DownloadResultFields, mode: z21.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
+var SessionImageDownloadResultSchema = z22.discriminatedUnion("mode", [
+  z22.object({ ...DownloadResultFields, mode: z22.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
+  z22.object({ ...DownloadResultFields, mode: z22.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
 ]);
-var TimelineImageBlobRequestSchema = z21.object({
-  sha256: z21.string().regex(/^[a-f0-9]{64}$/u)
+var TimelineImageBlobRequestSchema = z22.object({
+  sha256: z22.string().regex(/^[a-f0-9]{64}$/u)
 }).strict();
-var TimelineImageBlobResultSchema = z21.object({
+var TimelineImageBlobResultSchema = z22.object({
   sha256: TimelineImageBlobRequestSchema.shape.sha256,
   image: SessionImageCommitResultSchema
 }).strict();
 
 // ../protocol/dist/sessions/session-rename.js
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var SESSION_RENAME_OPERATION = "session.rename";
 var SESSION_RENAME_VERSION = 1;
 var SESSION_RENAME_CAPABILITY = sessionCommunicationOperationCapability(SESSION_RENAME_OPERATION, SESSION_RENAME_VERSION);
 var SESSION_NAME_MAX_LENGTH = 100;
-var SessionNameSchema = z22.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
-var SessionRenameDataSchema = z22.object({ name: SessionNameSchema }).strict();
-var SessionRenameResultDataSchema = z22.object({ name: SessionNameSchema }).strict();
+var SessionNameSchema = z23.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
+var SessionRenameDataSchema = z23.object({ name: SessionNameSchema }).strict();
+var SessionRenameResultDataSchema = z23.object({ name: SessionNameSchema }).strict();
 
 // ../protocol/dist/sessions/group-chat.js
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var GROUP_CHAT_CREATE_OPERATION = "group-chat.create";
 var GROUP_CHAT_CREATE_VERSION = 1;
 var GROUP_CHAT_CREATE_CAPABILITY = sessionCommunicationOperationCapability(GROUP_CHAT_CREATE_OPERATION, GROUP_CHAT_CREATE_VERSION);
-var GroupChatCreateDataSchema = z23.object({
+var GroupChatCreateDataSchema = z24.object({
   peerSessionId: IdSchema
 }).strict();
-var GroupChatCreateResultDataSchema = z23.object({
+var GroupChatCreateResultDataSchema = z24.object({
   session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
 }).strict();
 
 // ../protocol/dist/sessions/prompts.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var SESSION_FILE_ATTACHMENTS_CAPABILITY = "session-file-attachments";
 var SESSION_PROMPT_SUBMISSION_TIME_CAPABILITY = "session-prompt-submission-time";
 var SESSION_AVATAR_PERSONA_CAPABILITY = "session-avatar-persona";
-var SessionAvatarPersonaSchema = z24.object({
-  role: z24.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
-  displayName: z24.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
+var SessionAvatarPersonaSchema = z25.object({
+  role: z25.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
+  displayName: z25.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
 }).strict().refine((value) => value.role === "default" ? value.displayName === void 0 : value.displayName !== void 0, { message: "A role requires a display name; default must not include one" });
 var MAX_PROMPT_IMAGE_BYTES = 3 * 1024 * 1024;
-var SessionPromptRequestSchema = z24.object({
+var SessionPromptRequestSchema = z25.object({
   requestId: IdSchema,
   operationId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  prompt: z24.string().trim().max(1e5),
-  attachments: z24.array(PromptImageAttachmentSchema).max(4).optional(),
-  fileAttachments: z24.array(PromptFileAttachmentSchema).max(4).optional(),
+  prompt: z25.string().trim().max(1e5),
+  attachments: z25.array(PromptImageAttachmentSchema).max(4).optional(),
+  fileAttachments: z25.array(PromptFileAttachmentSchema).max(4).optional(),
   avatarPersona: SessionAvatarPersonaSchema.optional(),
-  mode: z24.enum(["enqueue", "immediate"]).default("enqueue")
+  mode: z25.enum(["enqueue", "immediate"]).default("enqueue")
 }).strict().superRefine((request, context) => {
   if (request.prompt.length === 0 && (request.attachments?.length ?? 0) === 0 && (request.fileAttachments?.length ?? 0) === 0) {
     context.addIssue({
@@ -2100,22 +2136,22 @@ var SessionPromptRequestSchema = z24.object({
     });
   }
 });
-var SessionPromptResultSchema = z24.discriminatedUnion("ok", [
-  z24.object({
-    ok: z24.literal(true),
+var SessionPromptResultSchema = z25.discriminatedUnion("ok", [
+  z25.object({
+    ok: z25.literal(true),
     requestId: IdSchema,
     operationId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     messageId: IdSchema,
-    mode: z24.enum(["enqueue", "immediate"]),
-    deliveryState: z24.enum(["queued", "processing"]),
+    mode: z25.enum(["enqueue", "immediate"]),
+    deliveryState: z25.enum(["queued", "processing"]),
     // Negotiated lower bound from the native event clock. Exact text and history
     // ownership checks still apply; this is not an identity or proof of persistence.
     submittedAt: IsoDateSchema.optional()
   }),
-  z24.object({
-    ok: z24.literal(false),
+  z25.object({
+    ok: z25.literal(false),
     requestId: IdSchema,
     operationId: IdSchema,
     machineId: IdSchema,
@@ -2123,29 +2159,29 @@ var SessionPromptResultSchema = z24.discriminatedUnion("ok", [
     error: ProtocolFailureSchema
   })
 ]);
-var SessionActivityUpdateSchema = z24.object({
+var SessionActivityUpdateSchema = z25.object({
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  state: z24.enum(["working", "idle"]),
+  state: z25.enum(["working", "idle"]),
   occurredAt: IsoDateSchema,
   assistantPreview: SessionAssistantPreviewSchema.optional(),
   userPreview: SessionUserPreviewSchema.optional()
 });
-var SessionAbortRequestSchema = z24.object({
+var SessionAbortRequestSchema = z25.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema
 });
-var SessionAbortResultSchema = z24.discriminatedUnion("ok", [
-  z24.object({
-    ok: z24.literal(true),
+var SessionAbortResultSchema = z25.discriminatedUnion("ok", [
+  z25.object({
+    ok: z25.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema
   }),
-  z24.object({
-    ok: z24.literal(false),
+  z25.object({
+    ok: z25.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
@@ -2154,7 +2190,7 @@ var SessionAbortResultSchema = z24.discriminatedUnion("ok", [
 ]);
 
 // ../protocol/dist/conversation/timeline-sync.js
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var TIMELINE_SYNC_OPERATION = "session.timeline.sync";
 var TIMELINE_IMAGE_OPERATION = "session.image.read";
 var TIMELINE_SYNC_VERSION = 1;
@@ -2162,37 +2198,37 @@ var TIMELINE_SYNC_MAX_EVENTS = 128;
 var TIMELINE_SYNC_MAX_BYTES = 6 * 1024 * 1024;
 var TIMELINE_IMAGE_CHUNK_BYTES = 48 * 1024;
 var TIMELINE_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
-var identity = z25.string().min(1).max(256);
-var sequence = z25.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
-var hash = z25.string().regex(/^[a-f0-9]{64}$/u);
-var TimelineWatermarkSchema = z25.object({
+var identity = z26.string().min(1).max(256);
+var sequence = z26.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var hash = z26.string().regex(/^[a-f0-9]{64}$/u);
+var TimelineWatermarkSchema = z26.object({
   epoch: identity,
   sequence
 }).strict();
-var TimelineSyncRequestSchema = z25.object({
+var TimelineSyncRequestSchema = z26.object({
   watermark: TimelineWatermarkSchema.optional(),
-  waitMs: z25.number().int().min(0).max(2e4).optional(),
-  resume: z25.boolean().optional()
+  waitMs: z26.number().int().min(0).max(2e4).optional(),
+  resume: z26.boolean().optional()
 }).strict();
-var TimelineTextAppendSchema = z25.object({
+var TimelineTextAppendSchema = z26.object({
   itemId: identity,
-  baseRevision: z25.number().int().positive(),
-  revision: z25.number().int().positive(),
-  appendText: z25.string().min(1).max(5e5),
-  sourceEventIds: z25.array(identity).min(1).max(1e3).optional(),
-  sourceMessageIds: z25.array(identity).min(1).max(1e3).optional(),
-  sourceInteractionIds: z25.array(identity).min(1).max(1e3).optional()
-}).strict();
-var TimelineSyncEventSchema = z25.discriminatedUnion("kind", [
-  z25.object({ kind: z25.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
-  z25.object({ kind: z25.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
-  z25.object({
-    kind: z25.literal("step"),
+  baseRevision: z26.number().int().positive(),
+  revision: z26.number().int().positive(),
+  appendText: z26.string().min(1).max(5e5),
+  sourceEventIds: z26.array(identity).min(1).max(1e3).optional(),
+  sourceMessageIds: z26.array(identity).min(1).max(1e3).optional(),
+  sourceInteractionIds: z26.array(identity).min(1).max(1e3).optional()
+}).strict();
+var TimelineSyncEventSchema = z26.discriminatedUnion("kind", [
+  z26.object({ kind: z26.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
+  z26.object({ kind: z26.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
+  z26.object({
+    kind: z26.literal("step"),
     sequence,
     upsert: ConversationActivityStepUpsertSchema
   }).strict()
 ]);
-var TimelineResyncReasonSchema = z25.enum([
+var TimelineResyncReasonSchema = z26.enum([
   "initial",
   "epoch-changed",
   "evicted",
@@ -2201,36 +2237,36 @@ var TimelineResyncReasonSchema = z25.enum([
   "rewind",
   "oversized"
 ]);
-var TimelineSyncResponseSchema = z25.discriminatedUnion("status", [
-  z25.object({
-    status: z25.literal("snapshot"),
+var TimelineSyncResponseSchema = z26.discriminatedUnion("status", [
+  z26.object({
+    status: z26.literal("snapshot"),
     watermark: TimelineWatermarkSchema,
     page: SessionTimelinePageSchema
   }).strict(),
-  z25.object({
-    status: z25.literal("replay"),
+  z26.object({
+    status: z26.literal("replay"),
     watermark: TimelineWatermarkSchema,
     afterSequence: sequence,
-    events: z25.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
-    hasMore: z25.boolean()
+    events: z26.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
+    hasMore: z26.boolean()
   }).strict(),
-  z25.object({
-    status: z25.literal("resync"),
+  z26.object({
+    status: z26.literal("resync"),
     epoch: identity,
     reason: TimelineResyncReasonSchema
   }).strict()
 ]);
-var TimelineImageRequestSchema = z25.object({
+var TimelineImageRequestSchema = z26.object({
   sha256: hash,
-  offset: z25.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
+  offset: z26.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
 }).strict();
-var TimelineImageChunkSchema = z25.object({
+var TimelineImageChunkSchema = z26.object({
   sha256: hash,
-  offset: z25.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
-  totalBytes: z25.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
-  mimeType: z25.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
-  data: z25.string().min(4).max(Math.ceil(TIMELINE_IMAGE_CHUNK_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u),
-  eof: z25.boolean()
+  offset: z26.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
+  totalBytes: z26.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
+  mimeType: z26.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
+  data: z26.string().min(4).max(Math.ceil(TIMELINE_IMAGE_CHUNK_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u),
+  eof: z26.boolean()
 }).strict().superRefine((chunk, context) => {
   const padding = chunk.data.endsWith("==") ? 2 : chunk.data.endsWith("=") ? 1 : 0;
   const length = chunk.data.length / 4 * 3 - padding;
@@ -2241,10 +2277,10 @@ var TimelineImageChunkSchema = z25.object({
 });
 
 // ../protocol/dist/workbench.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // ../protocol/dist/schedules.js
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var SCHEDULES_CAPABILITY = "session-schedules-v1";
 var SCHEDULE_OPERATIONS = [
   "schedule.snapshot",
@@ -2253,90 +2289,90 @@ var SCHEDULE_OPERATIONS = [
   "schedule.draft.dismiss",
   "schedule.resume"
 ];
-var Id = z26.string().min(1).max(256);
-var NativeId = z26.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-var Time = z26.iso.datetime({ offset: true });
-var WorkbenchScheduleRuleSchema = z26.discriminatedUnion("kind", [
-  z26.object({ kind: z26.literal("once"), at: Time }).strict(),
-  z26.object({
-    kind: z26.literal("interval"),
-    seconds: z26.number().int().min(10).max(86400),
-    recurring: z26.boolean().optional()
+var Id = z27.string().min(1).max(256);
+var NativeId = z27.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var Time = z27.iso.datetime({ offset: true });
+var WorkbenchScheduleRuleSchema = z27.discriminatedUnion("kind", [
+  z27.object({ kind: z27.literal("once"), at: Time }).strict(),
+  z27.object({
+    kind: z27.literal("interval"),
+    seconds: z27.number().int().min(10).max(86400),
+    recurring: z27.boolean().optional()
   }).strict(),
-  z26.object({
-    kind: z26.literal("cron"),
-    expression: z26.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
-    timezone: z26.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
+  z27.object({
+    kind: z27.literal("cron"),
+    expression: z27.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
+    timezone: z27.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
   }).strict()
 ]);
 var Content = {
   rule: WorkbenchScheduleRuleSchema,
-  prompt: z26.string().max(16e3).describe("The execution prompt, or ONLY the user's exact arguments when skill is set. Do not include the skill name, slash prefix, scheduling instructions, or extra explanation in skill arguments."),
-  skill: z26.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).optional().describe("A genuine callable skill name from this session, without the leading slash. Set this field when the user requests a skill; put only its exact arguments in prompt.")
+  prompt: z27.string().max(16e3).describe("The execution prompt, or ONLY the user's exact arguments when skill is set. Do not include the skill name, slash prefix, scheduling instructions, or extra explanation in skill arguments."),
+  skill: z27.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).optional().describe("A genuine callable skill name from this session, without the leading slash. Set this field when the user requests a skill; put only its exact arguments in prompt.")
 };
-var WorkbenchScheduleProposalSchema = z26.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
-var WorkbenchScheduleDraftSchema = z26.object({
-  id: z26.uuid(),
+var WorkbenchScheduleProposalSchema = z27.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
+var WorkbenchScheduleDraftSchema = z27.object({
+  id: z27.uuid(),
   createdAt: Time,
   ...Content
 }).strict();
-var WorkbenchScheduleEntrySchema = z26.object({
+var WorkbenchScheduleEntrySchema = z27.object({
   id: NativeId,
-  prompt: z26.string().max(1e5),
-  displayPrompt: z26.string().max(1e5).optional(),
-  recurring: z26.boolean(),
+  prompt: z27.string().max(1e5),
+  displayPrompt: z27.string().max(1e5).optional(),
+  recurring: z27.boolean(),
   nextRunAt: Time,
-  intervalMs: z26.number().int().positive().optional(),
-  cron: z26.string().max(256).optional(),
-  timezone: z26.string().max(128).optional(),
+  intervalMs: z27.number().int().positive().optional(),
+  cron: z27.string().max(256).optional(),
+  timezone: z27.string().max(128).optional(),
   at: Time.optional()
 }).strict();
-var WorkbenchScheduleResultSchema = z26.object({
+var WorkbenchScheduleResultSchema = z27.object({
   id: Id,
   scheduleId: NativeId,
   triggerEventId: Id,
   time: Time,
-  prompt: z26.string().max(16e3),
-  status: z26.enum(["reply", "error", "merged", "pending", "unknown"]),
-  reply: z26.string().max(16e3).optional(),
+  prompt: z27.string().max(16e3),
+  status: z27.enum(["reply", "error", "merged", "pending", "unknown"]),
+  reply: z27.string().max(16e3).optional(),
   replyEventId: Id.optional(),
-  error: z26.string().max(1024).optional()
-}).strict();
-var WorkbenchScheduleSnapshotSchema = z26.object({
-  state: z26.enum(["active", "needs-resume"]),
-  workingDirectory: z26.string().max(32768).optional(),
-  timezone: z26.string().max(128).optional(),
-  entries: z26.array(WorkbenchScheduleEntrySchema).max(256),
-  drafts: z26.array(WorkbenchScheduleDraftSchema).max(100),
-  results: z26.array(WorkbenchScheduleResultSchema).max(100),
-  historyTruncated: z26.boolean(),
+  error: z27.string().max(1024).optional()
+}).strict();
+var WorkbenchScheduleSnapshotSchema = z27.object({
+  state: z27.enum(["active", "needs-resume"]),
+  workingDirectory: z27.string().max(32768).optional(),
+  timezone: z27.string().max(128).optional(),
+  entries: z27.array(WorkbenchScheduleEntrySchema).max(256),
+  drafts: z27.array(WorkbenchScheduleDraftSchema).max(100),
+  results: z27.array(WorkbenchScheduleResultSchema).max(100),
+  historyTruncated: z27.boolean(),
   sampledAt: Time
 }).strict();
 var Submission = {
-  operationId: z26.uuid(),
-  operationCreatedAt: z26.iso.datetime(),
+  operationId: z27.uuid(),
+  operationCreatedAt: z27.iso.datetime(),
   expectedAgentRunId: Id
 };
-var WorkbenchScheduleCreateRequestSchema = z26.object({
+var WorkbenchScheduleCreateRequestSchema = z27.object({
   ...Submission,
   ...Content,
-  draftId: z26.uuid().optional()
+  draftId: z27.uuid().optional()
 }).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
-var WorkbenchScheduleCreateResultSchema = z26.object({
+var WorkbenchScheduleCreateResultSchema = z27.object({
   snapshot: WorkbenchScheduleSnapshotSchema,
-  verified: z26.boolean()
+  verified: z27.boolean()
 }).strict();
-var WorkbenchScheduleDeleteRequestSchema = z26.object({
+var WorkbenchScheduleDeleteRequestSchema = z27.object({
   ...Submission,
   id: NativeId
 }).strict();
-var WorkbenchScheduleDeleteResultSchema = z26.object({
+var WorkbenchScheduleDeleteResultSchema = z27.object({
   snapshot: WorkbenchScheduleSnapshotSchema,
-  removed: z26.boolean()
+  removed: z27.boolean()
 }).strict();
-var WorkbenchScheduleDraftDismissRequestSchema = z26.object({
+var WorkbenchScheduleDraftDismissRequestSchema = z27.object({
   ...Submission,
-  draftId: z26.uuid()
+  draftId: z27.uuid()
 }).strict();
 var ScheduleAndroidSchemas = {
   WorkbenchScheduleRule: WorkbenchScheduleRuleSchema,
@@ -2353,10 +2389,10 @@ var ScheduleAndroidSchemas = {
 };
 
 // ../protocol/dist/workbench.js
-var Id2 = z27.string().trim().min(1).max(256);
-var Text = z27.string().max(1e5);
-var Count = z27.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var Failure = z27.object({ code: Id2, message: z27.string().min(1).max(1024) }).strict();
+var Id2 = z28.string().trim().min(1).max(256);
+var Text = z28.string().max(1e5);
+var Count = z28.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var Failure = z28.object({ code: Id2, message: z28.string().min(1).max(1024) }).strict();
 var WORKBENCH_VERSION = 1;
 var RESEARCH_CHAT_CAPABILITY = "research-chat-v1";
 var WORKBENCH_OPERATIONS = [
@@ -2378,104 +2414,104 @@ var WORKBENCH_OPERATIONS = [
 ];
 var workbenchCapability = (operation) => `${operation}.v${WORKBENCH_VERSION}`;
 var Submission2 = {
-  operationId: z27.uuid(),
-  operationCreatedAt: z27.iso.datetime(),
+  operationId: z28.uuid(),
+  operationCreatedAt: z28.iso.datetime(),
   expectedAgentRunId: Id2
 };
-var WorkbenchOperationGetSchema = z27.object({ operationId: z27.uuid() }).strict();
-var WorkbenchOperationStatusSchema = z27.object({
-  operationId: z27.uuid(),
-  operation: z27.enum(WORKBENCH_OPERATIONS),
+var WorkbenchOperationGetSchema = z28.object({ operationId: z28.uuid() }).strict();
+var WorkbenchOperationStatusSchema = z28.object({
+  operationId: z28.uuid(),
+  operation: z28.enum(WORKBENCH_OPERATIONS),
   agentRunId: Id2,
-  state: z27.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
-  result: z27.record(z27.string(), z27.json()).optional(),
+  state: z28.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
+  result: z28.record(z28.string(), z28.json()).optional(),
   error: Failure.optional()
 }).strict().superRefine((value, context) => {
   if (value.state === "succeeded" !== (value.result !== void 0) || (value.state === "failed" || value.state === "uncertain") !== (value.error !== void 0)) {
     context.addIssue({ code: "custom", message: "Invalid operation state payload" });
   }
 });
-var WorkbenchAskRequestSchema = z27.object({
+var WorkbenchAskRequestSchema = z28.object({
   ...Submission2,
-  question: z27.string().trim().min(1).max(16e3)
+  question: z28.string().trim().min(1).max(16e3)
 }).strict();
-var WorkbenchAskResultSchema = z27.object({ answer: Text }).strict();
-var WorkbenchEmptyRequestSchema = z27.object({}).strict();
-var WorkbenchSubmitRequestSchema = z27.object(Submission2).strict();
-var WorkbenchResearchCreateRequestSchema = z27.object({
+var WorkbenchAskResultSchema = z28.object({ answer: Text }).strict();
+var WorkbenchEmptyRequestSchema = z28.object({}).strict();
+var WorkbenchSubmitRequestSchema = z28.object(Submission2).strict();
+var WorkbenchResearchCreateRequestSchema = z28.object({
   ...Submission2,
-  title: z27.string().trim().min(1).max(120),
-  question: z27.string().trim().min(1).max(16e3),
+  title: z28.string().trim().min(1).max(120),
+  question: z28.string().trim().min(1).max(16e3),
   sourceItemId: Id2.optional(),
-  deferInitialPrompt: z27.literal(true).optional()
+  deferInitialPrompt: z28.literal(true).optional()
 }).strict();
-var WorkbenchResearchThreadSchema = z27.object({
+var WorkbenchResearchThreadSchema = z28.object({
   sessionId: Id2,
   parentSessionId: Id2,
-  title: z27.string().min(1).max(120),
-  createdAt: z27.iso.datetime(),
+  title: z28.string().min(1).max(120),
+  createdAt: z28.iso.datetime(),
   contextAnchor: Id2.optional(),
-  contextTruncated: z27.boolean(),
-  detached: z27.boolean(),
-  state: z27.enum(["creating", "ready", "failed"])
+  contextTruncated: z28.boolean(),
+  detached: z28.boolean(),
+  state: z28.enum(["creating", "ready", "failed"])
 }).strict();
-var WorkbenchResearchCreateResultSchema = z27.object({
+var WorkbenchResearchCreateResultSchema = z28.object({
   thread: WorkbenchResearchThreadSchema
 }).strict();
-var WorkbenchResearchListResultSchema = z27.object({
-  threads: z27.array(WorkbenchResearchThreadSchema).max(100)
+var WorkbenchResearchListResultSchema = z28.object({
+  threads: z28.array(WorkbenchResearchThreadSchema).max(100)
 }).strict();
-var WorkbenchResearchTimelineRequestSchema = z27.object({
+var WorkbenchResearchTimelineRequestSchema = z28.object({
   cursor: Id2.optional()
 }).strict();
-var WorkbenchResearchSendRequestSchema = z27.object({
+var WorkbenchResearchSendRequestSchema = z28.object({
   ...Submission2,
-  prompt: z27.string().trim().min(1).max(16e3)
-}).strict();
-var WorkbenchResearchSendResultSchema = z27.object({ messageId: Id2 }).strict();
-var WorkbenchCompletedResultSchema = z27.object({ completed: z27.boolean() }).strict();
-var WorkbenchCommandSchema = z27.object({
-  name: z27.string().min(1).max(260),
-  description: z27.string().max(4096),
-  argumentHint: z27.string().max(1024).optional(),
-  kind: z27.enum(["builtin", "skill", "client"]),
-  allowDuringExecution: z27.boolean(),
-  supported: z27.boolean(),
-  reason: z27.string().max(1024).optional()
-}).strict();
-var WorkbenchCommandListResultSchema = z27.object({
-  commands: z27.array(WorkbenchCommandSchema).max(512)
-}).strict();
-var WorkbenchCommandInvokeRequestSchema = z27.object({
+  prompt: z28.string().trim().min(1).max(16e3)
+}).strict();
+var WorkbenchResearchSendResultSchema = z28.object({ messageId: Id2 }).strict();
+var WorkbenchCompletedResultSchema = z28.object({ completed: z28.boolean() }).strict();
+var WorkbenchCommandSchema = z28.object({
+  name: z28.string().min(1).max(260),
+  description: z28.string().max(4096),
+  argumentHint: z28.string().max(1024).optional(),
+  kind: z28.enum(["builtin", "skill", "client"]),
+  allowDuringExecution: z28.boolean(),
+  supported: z28.boolean(),
+  reason: z28.string().max(1024).optional()
+}).strict();
+var WorkbenchCommandListResultSchema = z28.object({
+  commands: z28.array(WorkbenchCommandSchema).max(512)
+}).strict();
+var WorkbenchCommandInvokeRequestSchema = z28.object({
   ...Submission2,
-  name: z27.string().trim().min(1).max(260),
-  input: z27.string().max(16e3)
-}).strict();
-var WorkbenchCommandChoiceSchema = z27.object({
-  name: z27.string().min(1).max(260),
-  label: z27.string().min(1).max(1024),
-  input: z27.string().max(16e3)
-}).strict();
-var WorkbenchCommandResultSchema = z27.discriminatedUnion("kind", [
-  z27.object({ kind: z27.literal("text"), text: Text }).strict(),
-  z27.object({ kind: z27.literal("completed") }).strict(),
-  z27.object({ kind: z27.literal("sent"), messageId: Id2 }).strict(),
-  z27.object({
-    kind: z27.literal("select-subcommand"),
-    choices: z27.array(WorkbenchCommandChoiceSchema).min(1).max(100)
+  name: z28.string().trim().min(1).max(260),
+  input: z28.string().max(16e3)
+}).strict();
+var WorkbenchCommandChoiceSchema = z28.object({
+  name: z28.string().min(1).max(260),
+  label: z28.string().min(1).max(1024),
+  input: z28.string().max(16e3)
+}).strict();
+var WorkbenchCommandResultSchema = z28.discriminatedUnion("kind", [
+  z28.object({ kind: z28.literal("text"), text: Text }).strict(),
+  z28.object({ kind: z28.literal("completed") }).strict(),
+  z28.object({ kind: z28.literal("sent"), messageId: Id2 }).strict(),
+  z28.object({
+    kind: z28.literal("select-subcommand"),
+    choices: z28.array(WorkbenchCommandChoiceSchema).min(1).max(100)
   }).strict()
 ]);
-var WorkbenchQueueItemSchema = z27.object({
+var WorkbenchQueueItemSchema = z28.object({
   id: Id2,
-  kind: z27.string().min(1).max(64),
-  texts: z27.array(z27.string().max(1e5)).min(1).max(100),
-  actions: z27.array(z27.enum(["edit", "remove", "move", "send-now"])).max(4)
+  kind: z28.string().min(1).max(64),
+  texts: z28.array(z28.string().max(1e5)).min(1).max(100),
+  actions: z28.array(z28.enum(["edit", "remove", "move", "send-now"])).max(4)
 }).strict();
-var WorkbenchQueueSnapshotSchema = z27.object({
+var WorkbenchQueueSnapshotSchema = z28.object({
   generation: Id2,
   revision: Id2,
-  items: z27.array(WorkbenchQueueItemSchema).max(512),
-  steeringMessages: z27.array(z27.string().max(1e5)).max(512)
+  items: z28.array(WorkbenchQueueItemSchema).max(512),
+  steeringMessages: z28.array(z28.string().max(1e5)).max(512)
 }).strict();
 var QueueMutation = {
   ...Submission2,
@@ -2483,48 +2519,48 @@ var QueueMutation = {
   revision: Id2,
   id: Id2
 };
-var WorkbenchQueueMutationRequestSchema = z27.discriminatedUnion("action", [
-  z27.object({ ...QueueMutation, action: z27.literal("edit"), prompt: z27.string().trim().min(1).max(1e5) }).strict(),
-  z27.object({ ...QueueMutation, action: z27.literal("remove") }).strict(),
-  z27.object({ ...QueueMutation, action: z27.literal("move"), toPosition: z27.number().int().min(0).max(511) }).strict(),
-  z27.object({ ...QueueMutation, action: z27.literal("send-now") }).strict()
-]);
-var WorkbenchQueueMutationResultSchema = z27.object({
-  changed: z27.boolean(),
+var WorkbenchQueueMutationRequestSchema = z28.discriminatedUnion("action", [
+  z28.object({ ...QueueMutation, action: z28.literal("edit"), prompt: z28.string().trim().min(1).max(1e5) }).strict(),
+  z28.object({ ...QueueMutation, action: z28.literal("remove") }).strict(),
+  z28.object({ ...QueueMutation, action: z28.literal("move"), toPosition: z28.number().int().min(0).max(511) }).strict(),
+  z28.object({ ...QueueMutation, action: z28.literal("send-now") }).strict()
+]);
+var WorkbenchQueueMutationResultSchema = z28.object({
+  changed: z28.boolean(),
   snapshot: WorkbenchQueueSnapshotSchema
 }).strict();
-var WorkbenchTokenMetricSchema = z27.object({
-  kind: z27.string().min(1).max(128),
+var WorkbenchTokenMetricSchema = z28.object({
+  kind: z28.string().min(1).max(128),
   count: Count
 }).strict();
-var WorkbenchModelUsageSchema = z27.object({
+var WorkbenchModelUsageSchema = z28.object({
   model: Id2,
   requests: Count,
-  premiumRequestCost: z27.number().finite().nonnegative(),
-  tokens: z27.array(WorkbenchTokenMetricSchema).max(32)
+  premiumRequestCost: z28.number().finite().nonnegative(),
+  tokens: z28.array(WorkbenchTokenMetricSchema).max(32)
 }).strict();
-var WorkbenchContextSchema = z27.object({
+var WorkbenchContextSchema = z28.object({
   currentTokens: Count,
   tokenLimit: Count,
   systemTokens: Count.optional(),
   conversationTokens: Count.optional(),
   toolTokens: Count.optional()
 }).strict();
-var WorkbenchInsightsSchema = z27.object({
-  sampledAt: z27.iso.datetime(),
+var WorkbenchInsightsSchema = z28.object({
+  sampledAt: z28.iso.datetime(),
   generation: Id2,
   model: Id2.optional(),
   totalUserRequests: Count,
-  premiumRequestCost: z27.number().finite().nonnegative(),
-  nanoAiu: z27.string().regex(/^\d+$/).max(40).optional(),
-  tokens: z27.array(WorkbenchTokenMetricSchema).max(32),
-  models: z27.array(WorkbenchModelUsageSchema).max(100),
+  premiumRequestCost: z28.number().finite().nonnegative(),
+  nanoAiu: z28.string().regex(/^\d+$/).max(40).optional(),
+  tokens: z28.array(WorkbenchTokenMetricSchema).max(32),
+  models: z28.array(WorkbenchModelUsageSchema).max(100),
   context: WorkbenchContextSchema.optional(),
-  canCompact: z27.boolean(),
-  compactUnavailableReason: z27.string().max(1024).optional()
+  canCompact: z28.boolean(),
+  compactUnavailableReason: z28.string().max(1024).optional()
 }).strict();
-var WorkbenchCompactResultSchema = z27.object({
-  success: z27.boolean(),
+var WorkbenchCompactResultSchema = z28.object({
+  success: z28.boolean(),
   tokensRemoved: Count,
   messagesRemoved: Count
 }).strict();
@@ -2560,6 +2596,8 @@ var WorkbenchAndroidSchemas = {
 
 // ../protocol/dist/codegen/android-schemas.js
 var AndroidProtocolSchemas = {
+  BrowserOpenUrlParams: BrowserOpenUrlParamsSchema,
+  BrowserOpenUrlResult: BrowserOpenUrlResultSchema,
   TimelineImageBlobRequest: TimelineImageBlobRequestSchema,
   TimelineImageBlobResult: TimelineImageBlobResultSchema,
   SessionImageUploadRequest: SessionImageUploadRequestSchema,
@@ -2571,8 +2609,9 @@ var AndroidProtocolSchemas = {
   ...ScheduleAndroidSchemas,
   SessionCommunication: SessionCommunicationSchema,
   SessionGitDiffData: SessionGitDiffDataSchema,
-  SessionGitDiffEntry: SessionGitDiffEntrySchema,
-  SessionGitDiffResultData: SessionGitDiffResultDataSchema,
+  SessionGitDiffEntry: SessionGitDiffPartialEntrySchema,
+  SessionGitDiffResultData: SessionGitDiffPartialResultDataSchema,
+  SessionGitDiffFileError: SessionGitDiffFileErrorSchema,
   SessionGitDiffGzipResultData: SessionGitDiffGzipResultDataSchema,
   SessionRenameData: SessionRenameDataSchema,
   SessionRenameResultData: SessionRenameResultDataSchema,
@@ -2733,12 +2772,14 @@ export {
   SESSION_GIT_DIFF_OPERATION,
   SESSION_GIT_DIFF_VERSION,
   SESSION_GIT_DIFF_GZIP_VERSION,
+  SESSION_GIT_DIFF_PARTIAL_VERSION,
   SESSION_GIT_DIFF_GZIP_MIN_BYTES,
   SESSION_GIT_DIFF_MAX_FILES,
   SESSION_GIT_DIFF_MAX_PATCH_BYTES,
   SESSION_GIT_DIFF_MAX_RESPONSE_BYTES,
   SessionGitDiffDataSchema,
   SessionGitDiffResultDataSchema,
+  SessionGitDiffPartialResultDataSchema,
   SessionGitDiffGzipResultDataSchema,
   SESSION_RESOURCE_READ_OPERATION,
   SESSION_RESOURCE_READ_VERSION,