@agentknight/client 0.9.44 → 0.9.46

package/dist/cli.js

@@ -484,7 +484,7 @@ ${environmentAssignment("AGENTKNIGHT_HOME", persistedHome)}
 }
 
 // src/config.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // ../../shared/protocol/dist/common/version.js
 import { z } from "zod";
@@ -1230,33 +1230,52 @@ var A2aRelayResponseSchema = z11.object({
   body: z11.string().max(A2A_BODY_MAX_LENGTH)
 }).strict();
 
-// ../../shared/protocol/dist/sessions/session-communication.js
+// ../../shared/protocol/dist/transport/browser-open-url.js
 import { z as z12 } from "zod";
-var SessionCommunicationIdSchema = z12.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
+var BROWSER_OPEN_URL_MAX_LENGTH = 8192;
+var BrowserOpenUrlParamsSchema = z12.strictObject({
+  url: z12.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 = z12.strictObject({ opened: z12.literal(true) });
+
+// ../../shared/protocol/dist/sessions/session-communication.js
+import { z as z13 } from "zod";
+var SessionCommunicationIdSchema = z13.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
 var SessionCommunicationIdentityShape = {
   requestId: SessionCommunicationIdSchema,
   machineId: SessionCommunicationIdSchema,
   sessionId: SessionCommunicationIdSchema,
-  operation: z12.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
-  version: z12.number().int().positive().max(2147483647)
+  operation: z13.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
+  version: z13.number().int().positive().max(2147483647)
 };
-var SessionCommunicationDataSchema = z12.record(z12.string(), z12.json());
-var SessionCommunicationRequestSchema = z12.object({
+var SessionCommunicationDataSchema = z13.record(z13.string(), z13.json());
+var SessionCommunicationRequestSchema = z13.object({
   ...SessionCommunicationIdentityShape,
-  kind: z12.literal("request"),
+  kind: z13.literal("request"),
   data: SessionCommunicationDataSchema
 }).strict();
-var SessionCommunicationResponseSchema = z12.object({
+var SessionCommunicationResponseSchema = z13.object({
   ...SessionCommunicationIdentityShape,
-  kind: z12.literal("response"),
+  kind: z13.literal("response"),
   data: SessionCommunicationDataSchema
 }).strict();
-var SessionCommunicationErrorSchema = z12.object({
+var SessionCommunicationErrorSchema = z13.object({
   ...SessionCommunicationIdentityShape,
-  kind: z12.literal("error"),
+  kind: z13.literal("error"),
   error: ProtocolFailureSchema
 }).strict();
-var SessionCommunicationSchema = z12.discriminatedUnion("kind", [
+var SessionCommunicationSchema = z13.discriminatedUnion("kind", [
   SessionCommunicationRequestSchema,
   SessionCommunicationResponseSchema,
   SessionCommunicationErrorSchema
@@ -1266,7 +1285,7 @@ function sessionCommunicationOperationCapability(operation, version) {
 }
 
 // ../../shared/protocol/dist/sessions/session-workspace.js
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
 var SESSION_PROJECT_IDENTITY_MAX_RESPONSE_BYTES = 640 * 1024;
 var SESSION_DIRECTORY_MAX_PATH_LENGTH = 1024;
@@ -1307,47 +1326,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 = z13.object({
+var SessionDirectoryListRequestSchema = z14.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  path: z13.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
+  path: z14.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
 }).strict();
-var SessionDirectoryEntrySchema = z13.object({
-  name: z13.string().min(1).max(255),
-  kind: z13.enum(["directory", "file", "blocked"])
+var SessionDirectoryEntrySchema = z14.object({
+  name: z14.string().min(1).max(255),
+  kind: z14.enum(["directory", "file", "blocked"])
 }).strict();
 var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
-var SessionDirectoryListResultDataSchema = z13.object({
-  path: z13.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
-  rootRevision: z13.string().min(1).max(128),
-  entries: z13.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
+var SessionDirectoryListResultDataSchema = z14.object({
+  path: z14.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
+  rootRevision: z14.string().min(1).max(128),
+  entries: z14.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
 }).strict();
 var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
-  rootRevision: z13.string().min(1).max(128).optional(),
-  entries: z13.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
+  rootRevision: z14.string().min(1).max(128).optional(),
+  entries: z14.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 = z13.object({
-  path: z13.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
-  rootRevision: z13.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+var SessionFileReadDataSchema = z14.object({
+  path: z14.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
+  rootRevision: z14.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 z13.object({
+  return z14.object({
     path: SessionFileReadDataSchema.shape.path,
     rootRevision: SessionFileReadDataSchema.shape.rootRevision,
-    mediaType: z13.enum(mediaTypes),
-    originalByteLength: z13.number().int().min(0).max(maxOriginal),
+    mediaType: z14.enum(mediaTypes),
+    originalByteLength: z14.number().int().min(0).max(maxOriginal),
     // Canonical length after decompression, not the length of the transport bytes.
-    byteLength: z13.number().int().min(0).max(maxOriginal),
-    encoding: z13.enum(["identity", "gzip"]),
-    data: z13.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
+    byteLength: z14.number().int().min(0).max(maxOriginal),
+    encoding: z14.enum(["identity", "gzip"]),
+    data: z14.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)
@@ -1367,19 +1386,19 @@ 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 = z13.object({
-  localRepositoryKey: z13.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
-  worktreeRoot: z13.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
-  mainWorktreeRoot: z13.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
-  gitRemoteUrl: z13.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
+var SessionGitProjectSchema = z14.object({
+  localRepositoryKey: z14.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
+  worktreeRoot: z14.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
+  mainWorktreeRoot: z14.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
+  gitRemoteUrl: z14.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
 }).strict();
-var SessionProjectIdentityRequestDataSchema = z13.object({}).strict();
-var SessionProjectIdentityResultDataSchema = z13.object({
+var SessionProjectIdentityRequestDataSchema = z14.object({}).strict();
+var SessionProjectIdentityResultDataSchema = z14.object({
   project: SessionGitProjectSchema.optional()
 }).strict();
 
 // ../../shared/protocol/dist/sessions/session-git-diff.js
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 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;
@@ -1387,24 +1406,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 = z14.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
-var SessionGitDiffDataSchema = z14.object({
+var commitSchema = z15.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
+var SessionGitDiffDataSchema = z15.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 = z14.object({
+var SessionGitDiffEntrySchema = z15.object({
   path: SessionFileReadDataSchema.shape.path,
-  status: z14.enum(["added", "modified", "deleted", "untracked"])
+  status: z15.enum(["added", "modified", "deleted", "untracked"])
 }).strict();
-var SessionGitDiffResultDataSchema = z14.object({
+var SessionGitDiffResultDataSchema = z15.object({
   rootRevision: SessionFileReadDataSchema.shape.rootRevision,
-  baseRef: z14.enum(["origin/main", "main"]),
+  baseRef: z15.enum(["origin/main", "main"]),
   baseCommit: commitSchema,
-  files: z14.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
+  files: z15.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
   path: SessionFileReadDataSchema.shape.path.optional(),
-  patch: z14.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
-  binary: z14.boolean().optional()
+  patch: z15.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
+  binary: z15.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) {
@@ -1418,13 +1437,13 @@ var SessionGitDiffResultDataSchema = z14.object({
     context.addIssue({ code: "custom", message: "Expected a text patch or an explicit binary change" });
   }
 });
-var SessionGitDiffFileErrorSchema = z14.object({
-  code: z14.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
-  message: z14.string().min(1).max(512)
+var SessionGitDiffFileErrorSchema = z15.object({
+  code: z15.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
+  message: z15.string().min(1).max(512)
 }).strict();
 var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
   // Error paths are display-only: they must never be used for file requests.
-  path: z14.string().min(1).max(32768).refine((value) => !value.includes("\0")),
+  path: z15.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) {
@@ -1432,12 +1451,12 @@ var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
   }
 });
 var SessionGitDiffPartialResultDataSchema = SessionGitDiffResultDataSchema.safeExtend({
-  files: z14.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
+  files: z15.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
 });
-var SessionGitDiffGzipResultDataSchema = z14.object({
-  encoding: z14.literal("gzip"),
-  byteLength: z14.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
-  data: z14.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
+var SessionGitDiffGzipResultDataSchema = z15.object({
+  encoding: z15.literal("gzip"),
+  byteLength: z15.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
+  data: z15.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;
@@ -1447,13 +1466,13 @@ var SessionGitDiffGzipResultDataSchema = z14.object({
     context.addIssue({ code: "custom", message: "Invalid gzip transfer" });
   }
 });
-var SessionGitDiffV2ResultDataSchema = z14.union([
+var SessionGitDiffV2ResultDataSchema = z15.union([
   SessionGitDiffResultDataSchema,
   SessionGitDiffGzipResultDataSchema
 ]);
 
 // ../../shared/protocol/dist/sessions/session-resource.js
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
 var SESSION_RESOURCE_GZIP_THRESHOLD_BYTES = 20 * 1024;
 var SESSION_RESOURCE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
@@ -1467,18 +1486,18 @@ var SESSION_RESOURCE_MEDIA_TYPES = [
   "text/css",
   "text/javascript"
 ];
-var SessionResourceReadDataSchema = z15.object({
-  path: z15.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
-  rootRevision: z15.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+var SessionResourceReadDataSchema = z16.object({
+  path: z16.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
+  rootRevision: z16.string().regex(/^[A-Za-z0-9_-]{43}$/u)
 }).strict();
-var SessionResourceReadResultDataSchema = z15.object({
+var SessionResourceReadResultDataSchema = z16.object({
   path: SessionResourceReadDataSchema.shape.path,
   rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
-  mediaType: z15.enum(SESSION_RESOURCE_MEDIA_TYPES),
-  originalByteLength: z15.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
-  byteLength: z15.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
-  encoding: z15.enum(["identity", "gzip"]),
-  data: z15.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
+  mediaType: z16.enum(SESSION_RESOURCE_MEDIA_TYPES),
+  originalByteLength: z16.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
+  byteLength: z16.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
+  encoding: z16.enum(["identity", "gzip"]),
+  data: z16.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)
@@ -1491,115 +1510,115 @@ var SessionResourceReadResultDataSchema = z15.object({
 });
 
 // ../../shared/protocol/dist/sessions/session-images.js
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var SESSION_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
 var SESSION_IMAGE_MAX_PIXELS = 16 * 1024 * 1024;
-var SessionImageIdSchema = z16.uuid();
-var SessionImageTransferModeSchema = z16.enum(["direct", "proxy"]);
-var DirectUrlSchema = z16.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
+var SessionImageIdSchema = z17.uuid();
+var SessionImageTransferModeSchema = z17.enum(["direct", "proxy"]);
+var DirectUrlSchema = z17.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 = z16.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
-var SessionImageTransferHeadersSchema = z16.record(z16.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z16.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
-var SessionImageUploadRequestSchema = z16.object({
+var ProxyUrlSchema = z17.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
+var SessionImageTransferHeadersSchema = z17.record(z17.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z17.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
+var SessionImageUploadRequestSchema = z17.object({
   machineId: IdSchema,
   sessionId: IdSchema,
-  sizeBytes: z16.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
+  sizeBytes: z17.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
 }).strict();
-var SessionImageScopeSchema = z16.object({
+var SessionImageScopeSchema = z17.object({
   machineId: IdSchema,
   sessionId: IdSchema
 }).strict();
 var UploadResultFields = {
   imageId: SessionImageIdSchema,
-  uploadExpiresAt: z16.number().int().positive(),
-  method: z16.literal("PUT"),
-  contentType: z16.literal("image/webp"),
+  uploadExpiresAt: z17.number().int().positive(),
+  method: z17.literal("PUT"),
+  contentType: z17.literal("image/webp"),
   headers: SessionImageTransferHeadersSchema.refine((headers) => headers["content-type"] === "image/webp")
 };
-var SessionImageUploadResultSchema = z16.discriminatedUnion("mode", [
-  z16.object({ ...UploadResultFields, mode: z16.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
-  z16.object({ ...UploadResultFields, mode: z16.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
+var SessionImageUploadResultSchema = z17.discriminatedUnion("mode", [
+  z17.object({ ...UploadResultFields, mode: z17.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
+  z17.object({ ...UploadResultFields, mode: z17.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
 ]);
-var SessionImageCommitResultSchema = z16.object({
+var SessionImageCommitResultSchema = z17.object({
   imageId: SessionImageIdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  sizeBytes: z16.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
-  width: z16.number().int().positive(),
-  height: z16.number().int().positive(),
-  sha256: z16.string().regex(/^[a-f0-9]{64}$/u),
-  expiresAt: z16.number().int().positive()
+  sizeBytes: z17.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
+  width: z17.number().int().positive(),
+  height: z17.number().int().positive(),
+  sha256: z17.string().regex(/^[a-f0-9]{64}$/u),
+  expiresAt: z17.number().int().positive()
 }).strict();
 var DownloadResultFields = {
   image: SessionImageCommitResultSchema,
-  downloadExpiresAt: z16.number().int().positive(),
-  method: z16.literal("GET"),
+  downloadExpiresAt: z17.number().int().positive(),
+  method: z17.literal("GET"),
   headers: SessionImageTransferHeadersSchema
 };
-var SessionImageDownloadResultSchema = z16.discriminatedUnion("mode", [
-  z16.object({ ...DownloadResultFields, mode: z16.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
-  z16.object({ ...DownloadResultFields, mode: z16.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
+var SessionImageDownloadResultSchema = z17.discriminatedUnion("mode", [
+  z17.object({ ...DownloadResultFields, mode: z17.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
+  z17.object({ ...DownloadResultFields, mode: z17.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
 ]);
-var TimelineImageBlobRequestSchema = z16.object({
-  sha256: z16.string().regex(/^[a-f0-9]{64}$/u)
+var TimelineImageBlobRequestSchema = z17.object({
+  sha256: z17.string().regex(/^[a-f0-9]{64}$/u)
 }).strict();
-var TimelineImageBlobResultSchema = z16.object({
+var TimelineImageBlobResultSchema = z17.object({
   sha256: TimelineImageBlobRequestSchema.shape.sha256,
   image: SessionImageCommitResultSchema
 }).strict();
 
 // ../../shared/protocol/dist/sessions/session-rename.js
-import { z as z17 } from "zod";
+import { z as z18 } 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 = z17.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
-var SessionRenameDataSchema = z17.object({ name: SessionNameSchema }).strict();
-var SessionRenameResultDataSchema = z17.object({ name: SessionNameSchema }).strict();
+var SessionNameSchema = z18.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
+var SessionRenameDataSchema = z18.object({ name: SessionNameSchema }).strict();
+var SessionRenameResultDataSchema = z18.object({ name: SessionNameSchema }).strict();
 
 // ../../shared/protocol/dist/sessions/sessions.js
-import { z as z18 } from "zod";
-var GroupChatParticipantSchema = z18.object({
+import { z as z19 } from "zod";
+var GroupChatParticipantSchema = z19.object({
   sessionId: IdSchema,
-  title: z18.string().trim().min(1).max(260)
+  title: z19.string().trim().min(1).max(260)
 }).strict();
-var GroupChatInfoSchema = z18.object({
-  participants: z18.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
-  state: z18.enum(["ready", "running", "paused", "blocked"])
+var GroupChatInfoSchema = z19.object({
+  participants: z19.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
+  state: z19.enum(["ready", "running", "paused", "blocked"])
 }).strict();
-var SessionSummarySchema = z18.object({
+var SessionSummarySchema = z19.object({
   userId: IdSchema,
   sessionId: IdSchema,
   machineId: IdSchema,
-  summary: z18.string().max(4096).optional(),
-  renameSupported: z18.boolean().optional(),
-  workingDirectory: z18.string().max(32768).optional(),
-  gitRoot: z18.string().max(32768).optional(),
-  repository: z18.string().max(1024).optional(),
-  gitRemoteUrl: z18.string().max(32768).optional(),
-  branch: z18.string().max(1024).optional(),
-  isRemote: z18.boolean(),
+  summary: z19.string().max(4096).optional(),
+  renameSupported: z19.boolean().optional(),
+  workingDirectory: z19.string().max(32768).optional(),
+  gitRoot: z19.string().max(32768).optional(),
+  repository: z19.string().max(1024).optional(),
+  gitRemoteUrl: z19.string().max(32768).optional(),
+  branch: z19.string().max(1024).optional(),
+  isRemote: z19.boolean(),
   createdAt: IsoDateSchema,
   modifiedAt: IsoDateSchema,
   groupChat: GroupChatInfoSchema.optional()
 });
-var SessionsSnapshotSchema = z18.object({
+var SessionsSnapshotSchema = z19.object({
   userId: IdSchema,
   machineId: IdSchema,
-  machineName: z18.string().trim().min(1).max(120),
-  platform: z18.string().trim().min(1).max(64),
+  machineName: z19.string().trim().min(1).max(120),
+  platform: z19.string().trim().min(1).max(64),
   agentRunId: IdSchema,
-  sequence: z18.number().int().positive(),
+  sequence: z19.number().int().positive(),
   generatedAt: IsoDateSchema,
-  complete: z18.boolean(),
-  totalCount: z18.number().int().nonnegative(),
-  nextCursor: z18.string().min(1).max(1024).optional(),
-  sessions: z18.array(SessionSummarySchema)
+  complete: z19.boolean(),
+  totalCount: z19.number().int().nonnegative(),
+  nextCursor: z19.string().min(1).max(1024).optional(),
+  sessions: z19.array(SessionSummarySchema)
 }).superRefine((snapshot, context) => {
   if (snapshot.totalCount < snapshot.sessions.length) {
     context.addIssue({
@@ -1641,47 +1660,47 @@ var SessionsSnapshotSchema = z18.object({
     sessionIds.add(session.sessionId);
   }
 });
-var SessionListRequestSchema = z18.object({
+var SessionListRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
-  cursor: z18.string().min(1).max(1024).optional()
+  cursor: z19.string().min(1).max(1024).optional()
 });
-var SessionListResultSchema = z18.discriminatedUnion("ok", [
-  z18.object({
-    ok: z18.literal(true),
+var SessionListResultSchema = z19.discriminatedUnion("ok", [
+  z19.object({
+    ok: z19.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     snapshot: SessionsSnapshotSchema
   }),
-  z18.object({
-    ok: z18.literal(false),
+  z19.object({
+    ok: z19.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     error: ProtocolFailureSchema
   })
 ]);
-var SessionAgentModeSchema = z18.enum([
+var SessionAgentModeSchema = z19.enum([
   "interactive",
   "plan",
   "autopilot"
 ]);
-var AgentConfigurationOptionSchema = z18.object({
+var AgentConfigurationOptionSchema = z19.object({
   id: IdSchema,
-  name: z18.string().trim().min(1).max(260),
-  value: z18.string().min(1).max(256),
-  options: z18.array(z18.object({
-    value: z18.string().min(1).max(256),
-    name: z18.string().trim().min(1).max(260)
+  name: z19.string().trim().min(1).max(260),
+  value: z19.string().min(1).max(256),
+  options: z19.array(z19.object({
+    value: z19.string().min(1).max(256),
+    name: z19.string().trim().min(1).max(260)
   }).strict()).min(1).max(100)
 }).strict();
-var AgentConfigurationChangeSchema = z18.object({
+var AgentConfigurationChangeSchema = z19.object({
   id: IdSchema,
-  value: z18.string().min(1).max(256)
+  value: z19.string().min(1).max(256)
 }).strict();
-var WorkspaceOptionSchema = z18.object({
+var WorkspaceOptionSchema = z19.object({
   id: IdSchema,
-  name: z18.string().trim().min(1).max(260),
-  path: z18.string().trim().min(1).max(32768)
+  name: z19.string().trim().min(1).max(260),
+  path: z19.string().trim().min(1).max(32768)
 });
 var REASONING_EFFORTS = [
   "low",
@@ -1690,113 +1709,113 @@ var REASONING_EFFORTS = [
   "xhigh",
   "max"
 ];
-var ReasoningEffortSchema = z18.enum(REASONING_EFFORTS);
-var CopilotModelOptionSchema = z18.object({
+var ReasoningEffortSchema = z19.enum(REASONING_EFFORTS);
+var CopilotModelOptionSchema = z19.object({
   id: IdSchema,
-  name: z18.string().trim().min(1).max(260),
-  isDefault: z18.boolean(),
-  supportedReasoningEfforts: z18.array(ReasoningEffortSchema).optional(),
+  name: z19.string().trim().min(1).max(260),
+  isDefault: z19.boolean(),
+  supportedReasoningEfforts: z19.array(ReasoningEffortSchema).optional(),
   defaultReasoningEffort: ReasoningEffortSchema.optional(),
-  creation: z18.object({
+  creation: z19.object({
     agentId: IdSchema,
-    agentName: z18.string().trim().min(1).max(260),
-    modelName: z18.string().trim().min(1).max(260),
-    agentModes: z18.array(SessionAgentModeSchema).min(1),
-    reasoningEffortConfigurationSupported: z18.boolean(),
-    isDefault: z18.boolean()
+    agentName: z19.string().trim().min(1).max(260),
+    modelName: z19.string().trim().min(1).max(260),
+    agentModes: z19.array(SessionAgentModeSchema).min(1),
+    reasoningEffortConfigurationSupported: z19.boolean(),
+    isDefault: z19.boolean()
   }).strict().optional()
 });
-var SessionReasoningEffortSchema = z18.enum([
+var SessionReasoningEffortSchema = z19.enum([
   "default",
   ...REASONING_EFFORTS
 ]);
-var CurrentReasoningEffortSchema = z18.string().trim().min(1).max(64);
-var SessionToolInfoSchema = z18.object({
-  name: z18.string().trim().min(1).max(260),
-  description: z18.string().trim().min(1).max(4096).optional(),
-  deferred: z18.boolean().optional()
+var CurrentReasoningEffortSchema = z19.string().trim().min(1).max(64);
+var SessionToolInfoSchema = z19.object({
+  name: z19.string().trim().min(1).max(260),
+  description: z19.string().trim().min(1).max(4096).optional(),
+  deferred: z19.boolean().optional()
 });
-var SessionSlashCommandInfoSchema = z18.object({
-  name: z18.string().trim().min(1).max(260),
-  description: z18.string().trim().min(1).max(4096).optional(),
-  kind: z18.enum(["builtin", "skill", "client"])
+var SessionSlashCommandInfoSchema = z19.object({
+  name: z19.string().trim().min(1).max(260),
+  description: z19.string().trim().min(1).max(4096).optional(),
+  kind: z19.enum(["builtin", "skill", "client"])
 });
-var SessionSkillInfoSchema = z18.object({
-  name: z18.string().trim().min(1).max(260),
-  description: z18.string().trim().min(1).max(4096).optional(),
-  source: z18.string().trim().min(1).max(260),
-  enabled: z18.boolean(),
-  userInvocable: z18.boolean(),
-  commandName: z18.string().trim().min(1).max(260).optional()
+var SessionSkillInfoSchema = z19.object({
+  name: z19.string().trim().min(1).max(260),
+  description: z19.string().trim().min(1).max(4096).optional(),
+  source: z19.string().trim().min(1).max(260),
+  enabled: z19.boolean(),
+  userInvocable: z19.boolean(),
+  commandName: z19.string().trim().min(1).max(260).optional()
 });
-var SessionEnvironmentInfoSchema = z18.object({
-  tools: z18.array(SessionToolInfoSchema).max(512),
-  slashCommands: z18.array(SessionSlashCommandInfoSchema).max(512),
-  skills: z18.array(SessionSkillInfoSchema).max(512)
+var SessionEnvironmentInfoSchema = z19.object({
+  tools: z19.array(SessionToolInfoSchema).max(512),
+  slashCommands: z19.array(SessionSlashCommandInfoSchema).max(512),
+  skills: z19.array(SessionSkillInfoSchema).max(512)
 });
-var SessionOptionsRequestSchema = z18.object({
+var SessionOptionsRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema.optional(),
   workspaceId: IdSchema.optional(),
-  capabilities: z18.array(IdSchema).max(64).optional()
+  capabilities: z19.array(IdSchema).max(64).optional()
 });
-var SessionOptionsResultSchema = z18.discriminatedUnion("ok", [
-  z18.object({
-    ok: z18.literal(true),
+var SessionOptionsResultSchema = z19.discriminatedUnion("ok", [
+  z19.object({
+    ok: z19.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema.optional(),
-    workspaces: z18.array(WorkspaceOptionSchema),
-    models: z18.array(CopilotModelOptionSchema).min(1),
-    modelRefreshError: z18.string().min(1).max(4096).optional(),
-    agentModes: z18.array(SessionAgentModeSchema).min(1),
-    reasoningEffortConfigurationSupported: z18.literal(true).optional(),
-    fileAttachmentsSupported: z18.boolean().optional(),
-    worktreeCreationSupported: z18.literal(true).optional(),
-    worktreeBranches: z18.array(z18.string().min(1).max(1024)).optional(),
-    worktreeCurrentBranch: z18.string().min(1).max(1024).optional(),
+    workspaces: z19.array(WorkspaceOptionSchema),
+    models: z19.array(CopilotModelOptionSchema).min(1),
+    modelRefreshError: z19.string().min(1).max(4096).optional(),
+    agentModes: z19.array(SessionAgentModeSchema).min(1),
+    reasoningEffortConfigurationSupported: z19.literal(true).optional(),
+    fileAttachmentsSupported: z19.boolean().optional(),
+    worktreeCreationSupported: z19.literal(true).optional(),
+    worktreeBranches: z19.array(z19.string().min(1).max(1024)).optional(),
+    worktreeCurrentBranch: z19.string().min(1).max(1024).optional(),
     currentModelId: IdSchema.optional(),
     currentAgentMode: SessionAgentModeSchema.optional(),
     currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
     environment: SessionEnvironmentInfoSchema.optional(),
-    environmentPending: z18.literal(true).optional(),
-    agentName: z18.string().trim().min(1).max(260).optional(),
-    configOptions: z18.array(AgentConfigurationOptionSchema).max(32).optional()
+    environmentPending: z19.literal(true).optional(),
+    agentName: z19.string().trim().min(1).max(260).optional(),
+    configOptions: z19.array(AgentConfigurationOptionSchema).max(32).optional()
   }),
-  z18.object({
-    ok: z18.literal(false),
+  z19.object({
+    ok: z19.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema.optional(),
     error: ProtocolFailureSchema,
-    failureStage: z18.enum(["models", "configuration", "workspaces"]).optional(),
-    models: z18.array(CopilotModelOptionSchema).min(1).optional(),
-    agentModes: z18.array(SessionAgentModeSchema).min(1).optional(),
-    reasoningEffortConfigurationSupported: z18.literal(true).optional(),
-    fileAttachmentsSupported: z18.boolean().optional(),
+    failureStage: z19.enum(["models", "configuration", "workspaces"]).optional(),
+    models: z19.array(CopilotModelOptionSchema).min(1).optional(),
+    agentModes: z19.array(SessionAgentModeSchema).min(1).optional(),
+    reasoningEffortConfigurationSupported: z19.literal(true).optional(),
+    fileAttachmentsSupported: z19.boolean().optional(),
     currentModelId: IdSchema.optional(),
     currentAgentMode: SessionAgentModeSchema.optional(),
     currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
-    agentName: z18.string().trim().min(1).max(260).optional(),
-    configOptions: z18.array(AgentConfigurationOptionSchema).max(32).optional()
+    agentName: z19.string().trim().min(1).max(260).optional(),
+    configOptions: z19.array(AgentConfigurationOptionSchema).max(32).optional()
   })
 ]);
-var SessionCreateRequestSchema = z18.object({
+var SessionCreateRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
   workspaceId: IdSchema,
   modelId: IdSchema,
   agentMode: SessionAgentModeSchema,
   reasoningEffort: SessionReasoningEffortSchema.optional(),
-  worktree: z18.object({
-    branchName: z18.string().trim().min(1).max(120).optional(),
-    baseBranch: z18.string().trim().min(1).max(1024).optional()
+  worktree: z19.object({
+    branchName: z19.string().trim().min(1).max(120).optional(),
+    baseBranch: z19.string().trim().min(1).max(1024).optional()
   }).strict().optional()
 });
-var SessionCreateResultSchema = z18.discriminatedUnion("ok", [
-  z18.object({
-    ok: z18.literal(true),
+var SessionCreateResultSchema = z19.discriminatedUnion("ok", [
+  z19.object({
+    ok: z19.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     session: SessionSummarySchema,
@@ -1804,34 +1823,34 @@ var SessionCreateResultSchema = z18.discriminatedUnion("ok", [
     agentMode: SessionAgentModeSchema,
     reasoningEffort: SessionReasoningEffortSchema.optional()
   }),
-  z18.object({
-    ok: z18.literal(false),
+  z19.object({
+    ok: z19.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     error: ProtocolFailureSchema
   })
 ]);
-var SessionDeleteRequestSchema = z18.object({
+var SessionDeleteRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema
 }).strict();
-var SessionDeleteResultSchema = z18.discriminatedUnion("ok", [
-  z18.object({
-    ok: z18.literal(true),
+var SessionDeleteResultSchema = z19.discriminatedUnion("ok", [
+  z19.object({
+    ok: z19.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema
   }).strict(),
-  z18.object({
-    ok: z18.literal(false),
+  z19.object({
+    ok: z19.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     error: ProtocolFailureSchema
   }).strict()
 ]);
-var SessionConfigureRequestSchema = z18.object({
+var SessionConfigureRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
@@ -1840,59 +1859,59 @@ var SessionConfigureRequestSchema = z18.object({
   reasoningEffort: SessionReasoningEffortSchema.optional(),
   configOption: AgentConfigurationChangeSchema.optional()
 }).refine((request) => request.modelId !== void 0 || request.agentMode !== void 0 || request.reasoningEffort !== void 0 || request.configOption !== void 0, { message: "A modelId, agentMode, reasoningEffort, or configOption change is required" });
-var SessionConfigureResultSchema = z18.discriminatedUnion("ok", [
-  z18.object({
-    ok: z18.literal(true),
+var SessionConfigureResultSchema = z19.discriminatedUnion("ok", [
+  z19.object({
+    ok: z19.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     modelId: IdSchema.optional(),
     agentMode: SessionAgentModeSchema,
     reasoningEffort: CurrentReasoningEffortSchema.optional(),
-    configOptions: z18.array(AgentConfigurationOptionSchema).max(32).optional()
+    configOptions: z19.array(AgentConfigurationOptionSchema).max(32).optional()
   }),
-  z18.object({
-    ok: z18.literal(false),
+  z19.object({
+    ok: z19.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     error: ProtocolFailureSchema
   })
 ]);
-var SessionRemoteActionSchema = z18.enum([
+var SessionRemoteActionSchema = z19.enum([
   "status",
   "enable",
   "disable"
 ]);
-var SessionRemoteStateSchema = z18.enum([
+var SessionRemoteStateSchema = z19.enum([
   "off",
   "connecting",
   "active",
   "error"
 ]);
-var SessionRemoteRequestSchema = z18.object({
+var SessionRemoteRequestSchema = z19.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
   action: SessionRemoteActionSchema
 });
-var SessionRemoteStatusSchema = z18.object({
+var SessionRemoteStatusSchema = z19.object({
   state: SessionRemoteStateSchema,
   attachedSessionId: IdSchema.optional(),
-  url: z18.url().max(32768).optional(),
-  steerable: z18.boolean(),
+  url: z19.url().max(32768).optional(),
+  steerable: z19.boolean(),
   error: ProtocolFailureSchema.optional()
 });
-var SessionRemoteResultSchema = z18.discriminatedUnion("ok", [
-  z18.object({
-    ok: z18.literal(true),
+var SessionRemoteResultSchema = z19.discriminatedUnion("ok", [
+  z19.object({
+    ok: z19.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     status: SessionRemoteStatusSchema
   }),
-  z18.object({
-    ok: z18.literal(false),
+  z19.object({
+    ok: z19.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
@@ -1901,42 +1920,42 @@ var SessionRemoteResultSchema = z18.discriminatedUnion("ok", [
 ]);
 
 // ../../shared/protocol/dist/sessions/group-chat.js
-import { z as z19 } from "zod";
+import { z as z20 } 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 = z19.object({
+var GroupChatCreateDataSchema = z20.object({
   peerSessionId: IdSchema
 }).strict();
-var GroupChatCreateResultDataSchema = z19.object({
+var GroupChatCreateResultDataSchema = z20.object({
   session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
 }).strict();
 
 // ../../shared/protocol/dist/sessions/prompts.js
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // ../../shared/protocol/dist/conversation/attachments.js
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var MAX_INLINE_IMAGE_BYTES = 3 * 1024 * 1024;
 var MAX_INLINE_HTML_BYTES = 512 * 1024;
 var MAX_PROMPT_FILE_BYTES = 1024 * 1024;
-var InlineImageMimeTypeSchema = z20.enum([
+var InlineImageMimeTypeSchema = z21.enum([
   "image/gif",
   "image/jpeg",
   "image/png",
   "image/webp"
 ]);
-var Base64DataSchema = z20.string().min(4).max(Math.ceil(MAX_INLINE_IMAGE_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, "Expected canonical base64 data");
-var Sha256Schema = z20.string().regex(/^[a-f0-9]{64}$/);
+var Base64DataSchema = z21.string().min(4).max(Math.ceil(MAX_INLINE_IMAGE_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, "Expected canonical base64 data");
+var Sha256Schema = z21.string().regex(/^[a-f0-9]{64}$/);
 function decodedBase64ByteLength(value) {
   const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
   return value.length / 4 * 3 - padding;
 }
-var PromptImageAttachmentSchema = z20.object({
-  name: z20.string().trim().min(1).max(255),
-  mimeType: z20.enum(["image/jpeg", "image/png", "image/webp"]),
+var PromptImageAttachmentSchema = z21.object({
+  name: z21.string().trim().min(1).max(255),
+  mimeType: z21.enum(["image/jpeg", "image/png", "image/webp"]),
   data: Base64DataSchema,
-  byteLength: z20.number().int().positive().max(MAX_INLINE_IMAGE_BYTES),
+  byteLength: z21.number().int().positive().max(MAX_INLINE_IMAGE_BYTES),
   sha256: Sha256Schema
 }).strict().superRefine((attachment, context) => {
   if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
@@ -1947,11 +1966,11 @@ var PromptImageAttachmentSchema = z20.object({
     });
   }
 });
-var PromptFileAttachmentSchema = z20.object({
-  name: z20.string().trim().min(1).max(255).regex(/^[^\\/\x00-\x1f\x7f]+$/).refine((name) => name !== "." && name !== "..", "Expected a filename"),
-  mimeType: z20.string().max(256).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
+var PromptFileAttachmentSchema = z21.object({
+  name: z21.string().trim().min(1).max(255).regex(/^[^\\/\x00-\x1f\x7f]+$/).refine((name) => name !== "." && name !== "..", "Expected a filename"),
+  mimeType: z21.string().max(256).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
   data: Base64DataSchema.max(Math.ceil(MAX_PROMPT_FILE_BYTES / 3) * 4),
-  byteLength: z20.number().int().positive().max(MAX_PROMPT_FILE_BYTES),
+  byteLength: z21.number().int().positive().max(MAX_PROMPT_FILE_BYTES),
   sha256: Sha256Schema
 }).strict().superRefine((attachment, context) => {
   if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
@@ -1962,8 +1981,8 @@ var PromptFileAttachmentSchema = z20.object({
     });
   }
 });
-var ConversationAttachmentSchema = z20.object({
-  kind: z20.enum([
+var ConversationAttachmentSchema = z21.object({
+  kind: z21.enum([
     "file",
     "image",
     "html",
@@ -1971,13 +1990,13 @@ var ConversationAttachmentSchema = z20.object({
     "github-reference",
     "unknown"
   ]),
-  name: z20.string().trim().min(1).max(1024),
-  mimeType: z20.string().trim().min(1).max(256).optional(),
-  uri: z20.string().trim().min(1).max(32768).optional(),
+  name: z21.string().trim().min(1).max(1024),
+  mimeType: z21.string().trim().min(1).max(256).optional(),
+  uri: z21.string().trim().min(1).max(32768).optional(),
   data: Base64DataSchema.optional(),
-  byteLength: z20.number().int().positive().max(MAX_INLINE_IMAGE_BYTES).optional(),
+  byteLength: z21.number().int().positive().max(MAX_INLINE_IMAGE_BYTES).optional(),
   sha256: Sha256Schema.optional(),
-  imageRef: z20.literal("sha256").optional()
+  imageRef: z21.literal("sha256").optional()
 }).strict().superRefine((attachment, context) => {
   if (attachment.imageRef !== void 0) {
     if (attachment.kind !== "image" || attachment.data !== void 0 || attachment.sha256 === void 0 || attachment.byteLength === void 0 || !InlineImageMimeTypeSchema.safeParse(attachment.mimeType).success) {
@@ -2035,20 +2054,20 @@ var ConversationAttachmentSchema = z20.object({
 });
 
 // ../../shared/protocol/dist/conversation/timeline.js
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // ../../shared/protocol/dist/conversation/conversation.js
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var CONVERSATION_ACTIVITY_STEP_LIMIT = 1e3;
 var CONVERSATION_SOURCE_ID_LIMIT = 1e3;
 var ConversationItemBaseShape = {
   id: IdSchema,
-  revision: z21.number().int().positive(),
+  revision: z22.number().int().positive(),
   turnId: IdSchema,
   timestamp: IsoDateSchema,
-  sourceEventIds: z21.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT),
-  sourceMessageIds: z21.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional(),
-  sourceInteractionIds: z21.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional()
+  sourceEventIds: z22.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT),
+  sourceMessageIds: z22.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional(),
+  sourceInteractionIds: z22.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional()
 };
 var MAX_INLINE_IMAGE_MESSAGE_BYTES = 3 * 1024 * 1024;
 var MAX_INLINE_IMAGES_PER_MESSAGE = 4;
@@ -2056,67 +2075,67 @@ var ActivityStepTimeShape = {
   // First observed event time; completion updates must not move an existing call.
   timestamp: IsoDateSchema.optional()
 };
-var ConversationToolStepSchema = z21.object({
+var ConversationToolStepSchema = z22.object({
   id: IdSchema,
-  kind: z21.literal("tool"),
-  name: z21.string().trim().min(1).max(256),
-  status: z21.enum(["running", "completed", "failed"]),
+  kind: z22.literal("tool"),
+  name: z22.string().trim().min(1).max(256),
+  status: z22.enum(["running", "completed", "failed"]),
   ...ActivityStepTimeShape
 }).strict();
-var ConversationSkillStepSchema = z21.object({
+var ConversationSkillStepSchema = z22.object({
   id: IdSchema,
-  kind: z21.literal("skill"),
-  name: z21.string().trim().min(1).max(256),
-  status: z21.literal("completed"),
-  description: z21.string().trim().min(1).max(2048).optional(),
-  source: z21.string().trim().min(1).max(256).optional(),
+  kind: z22.literal("skill"),
+  name: z22.string().trim().min(1).max(256),
+  status: z22.literal("completed"),
+  description: z22.string().trim().min(1).max(2048).optional(),
+  source: z22.string().trim().min(1).max(256).optional(),
   ...ActivityStepTimeShape
 }).strict();
-var ConversationSubagentStepSchema = z21.object({
+var ConversationSubagentStepSchema = z22.object({
   id: IdSchema,
-  kind: z21.literal("subagent"),
-  name: z21.string().trim().min(1).max(256),
-  status: z21.enum(["running", "completed", "failed"]),
-  description: z21.string().trim().min(1).max(2048).optional(),
-  model: z21.string().trim().min(1).max(256).optional(),
-  durationMs: z21.number().int().nonnegative().optional(),
-  resultSummary: z21.string().max(4096).optional(),
-  error: z21.string().max(4096).optional(),
+  kind: z22.literal("subagent"),
+  name: z22.string().trim().min(1).max(256),
+  status: z22.enum(["running", "completed", "failed"]),
+  description: z22.string().trim().min(1).max(2048).optional(),
+  model: z22.string().trim().min(1).max(256).optional(),
+  durationMs: z22.number().int().nonnegative().optional(),
+  resultSummary: z22.string().max(4096).optional(),
+  error: z22.string().max(4096).optional(),
   ...ActivityStepTimeShape
 }).strict();
-var ConversationPermissionStepSchema = z21.object({
+var ConversationPermissionStepSchema = z22.object({
   id: IdSchema,
-  kind: z21.literal("permission"),
-  name: z21.string().trim().min(1).max(256),
-  status: z21.enum(["running", "completed", "failed"]),
-  description: z21.string().trim().min(1).max(2048).optional(),
-  resultSummary: z21.string().max(4096).optional(),
-  error: z21.string().max(4096).optional(),
+  kind: z22.literal("permission"),
+  name: z22.string().trim().min(1).max(256),
+  status: z22.enum(["running", "completed", "failed"]),
+  description: z22.string().trim().min(1).max(2048).optional(),
+  resultSummary: z22.string().max(4096).optional(),
+  error: z22.string().max(4096).optional(),
   ...ActivityStepTimeShape
 }).strict();
-var ConversationActivityStepSchema = z21.discriminatedUnion("kind", [
+var ConversationActivityStepSchema = z22.discriminatedUnion("kind", [
   ConversationToolStepSchema,
   ConversationSkillStepSchema,
   ConversationSubagentStepSchema,
   ConversationPermissionStepSchema
 ]);
-var ConversationHumanMessageSchema = z21.object({
+var ConversationHumanMessageSchema = z22.object({
   ...ConversationItemBaseShape,
-  kind: z21.literal("human-message"),
-  actor: z21.literal("human"),
-  content: z21.string().max(1e5),
-  attachments: z21.array(ConversationAttachmentSchema).max(100),
+  kind: z22.literal("human-message"),
+  actor: z22.literal("human"),
+  content: z22.string().max(1e5),
+  attachments: z22.array(ConversationAttachmentSchema).max(100),
   operationId: IdSchema.optional()
 }).strict();
-var ConversationAssistantMessageSchema = z21.object({
+var ConversationAssistantMessageSchema = z22.object({
   ...ConversationItemBaseShape,
-  kind: z21.literal("assistant-message"),
-  actor: z21.enum(["assistant", "subagent"]),
-  content: z21.string().max(5e5),
-  attachments: z21.array(ConversationAttachmentSchema).max(100).optional(),
-  model: z21.string().trim().min(1).max(256).optional(),
+  kind: z22.literal("assistant-message"),
+  actor: z22.enum(["assistant", "subagent"]),
+  content: z22.string().max(5e5),
+  attachments: z22.array(ConversationAttachmentSchema).max(100).optional(),
+  model: z22.string().trim().min(1).max(256).optional(),
   agentId: IdSchema.optional(),
-  final: z21.boolean()
+  final: z22.boolean()
 }).strict().superRefine((message, context) => {
   const inlineImages = message.attachments?.filter((attachment) => attachment.kind === "image" && attachment.data !== void 0) ?? [];
   if (inlineImages.length > MAX_INLINE_IMAGES_PER_MESSAGE) {
@@ -2135,166 +2154,166 @@ var ConversationAssistantMessageSchema = z21.object({
     });
   }
 });
-var ConversationActivityGroupSchema = z21.object({
+var ConversationActivityGroupSchema = z22.object({
   ...ConversationItemBaseShape,
-  kind: z21.literal("activity-group"),
-  actor: z21.enum(["assistant", "subagent"]),
-  status: z21.enum(["running", "completed", "failed"]),
-  steps: z21.array(ConversationActivityStepSchema).max(CONVERSATION_ACTIVITY_STEP_LIMIT)
+  kind: z22.literal("activity-group"),
+  actor: z22.enum(["assistant", "subagent"]),
+  status: z22.enum(["running", "completed", "failed"]),
+  steps: z22.array(ConversationActivityStepSchema).max(CONVERSATION_ACTIVITY_STEP_LIMIT)
 }).strict();
-var ConversationNoticeSchema = z21.object({
+var ConversationNoticeSchema = z22.object({
   ...ConversationItemBaseShape,
-  kind: z21.literal("notice"),
-  actor: z21.enum(["system", "assistant", "subagent"]),
-  severity: z21.enum(["info", "success", "warning", "error"]),
-  title: z21.string().trim().min(1).max(256),
-  content: z21.string().max(4096),
-  presentation: z21.literal("compact").optional()
+  kind: z22.literal("notice"),
+  actor: z22.enum(["system", "assistant", "subagent"]),
+  severity: z22.enum(["info", "success", "warning", "error"]),
+  title: z22.string().trim().min(1).max(256),
+  content: z22.string().max(4096),
+  presentation: z22.literal("compact").optional()
 }).strict();
-var ConversationPlanTodoSchema = z21.object({
+var ConversationPlanTodoSchema = z22.object({
   id: IdSchema,
-  title: z21.string().trim().min(1).max(1024),
-  description: z21.string().max(4096).optional(),
-  status: z21.string().trim().min(1).max(64),
-  dependsOn: z21.array(IdSchema).max(100)
+  title: z22.string().trim().min(1).max(1024),
+  description: z22.string().max(4096).optional(),
+  status: z22.string().trim().min(1).max(64),
+  dependsOn: z22.array(IdSchema).max(100)
 }).strict();
-var ConversationPlanUpdateSchema = z21.object({
+var ConversationPlanUpdateSchema = z22.object({
   ...ConversationItemBaseShape,
-  kind: z21.literal("plan-update"),
-  actor: z21.enum(["assistant", "subagent"]),
-  operation: z21.enum(["created", "updated", "deleted"]),
-  content: z21.string().max(1e5),
-  todos: z21.array(ConversationPlanTodoSchema).max(1e3)
+  kind: z22.literal("plan-update"),
+  actor: z22.enum(["assistant", "subagent"]),
+  operation: z22.enum(["created", "updated", "deleted"]),
+  content: z22.string().max(1e5),
+  todos: z22.array(ConversationPlanTodoSchema).max(1e3)
 }).strict();
-var ConversationItemSchema = z21.discriminatedUnion("kind", [
+var ConversationItemSchema = z22.discriminatedUnion("kind", [
   ConversationHumanMessageSchema,
   ConversationAssistantMessageSchema,
   ConversationActivityGroupSchema,
   ConversationNoticeSchema,
   ConversationPlanUpdateSchema
 ]);
-var ConversationItemUpsertSchema = z21.object({
+var ConversationItemUpsertSchema = z22.object({
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
   item: ConversationItemSchema
 });
-var ConversationActivityStepUpsertSchema = z21.object({
+var ConversationActivityStepUpsertSchema = z22.object({
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
   activityId: IdSchema,
-  revision: z21.number().int().positive(),
+  revision: z22.number().int().positive(),
   turnId: IdSchema,
   timestamp: IsoDateSchema,
-  actor: z21.enum(["assistant", "subagent"]),
-  status: z21.enum(["running", "completed", "failed"]),
+  actor: z22.enum(["assistant", "subagent"]),
+  status: z22.enum(["running", "completed", "failed"]),
   sourceEventId: IdSchema,
   step: ConversationActivityStepSchema
 }).strict();
 
 // ../../shared/protocol/dist/conversation/timeline.js
-var SessionUserPreviewSchema = z22.object({
+var SessionUserPreviewSchema = z23.object({
   id: IdSchema,
-  revision: z22.number().int().positive(),
+  revision: z23.number().int().positive(),
   timestamp: IsoDateSchema,
-  text: z22.string().max(4096)
+  text: z23.string().max(4096)
 });
-var SessionAssistantPreviewSchema = z22.object({
+var SessionAssistantPreviewSchema = z23.object({
   id: IdSchema,
-  revision: z22.number().int().positive(),
+  revision: z23.number().int().positive(),
   timestamp: IsoDateSchema,
-  sourceEventIds: z22.array(IdSchema).min(1).max(1e3),
-  text: z22.string().max(4096),
-  final: z22.boolean(),
-  attachments: z22.array(ConversationAttachmentSchema.refine((attachment) => attachment.kind === "image" && attachment.imageRef === "sha256", "Assistant previews contain image references only")).max(4),
-  kind: z22.enum(["assistant-message", "task-completion"]).optional()
+  sourceEventIds: z23.array(IdSchema).min(1).max(1e3),
+  text: z23.string().max(4096),
+  final: z23.boolean(),
+  attachments: z23.array(ConversationAttachmentSchema.refine((attachment) => attachment.kind === "image" && attachment.imageRef === "sha256", "Assistant previews contain image references only")).max(4),
+  kind: z23.enum(["assistant-message", "task-completion"]).optional()
 });
 var SESSION_TIMELINE_PAGE_SIZE = 100;
-var SessionTimelinePageRequestSchema = z22.object({
+var SessionTimelinePageRequestSchema = z23.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  cursor: z22.string().max(32768).optional(),
-  metadataOnly: z22.boolean().optional(),
-  acceptContentEncodings: z22.array(z22.string().min(1).max(32)).max(8).optional(),
-  imageReferences: z22.boolean().optional(),
-  pageSize: z22.number().int().min(1).max(SESSION_TIMELINE_PAGE_SIZE).default(SESSION_TIMELINE_PAGE_SIZE),
-  assistantPreview: z22.boolean().optional()
+  cursor: z23.string().max(32768).optional(),
+  metadataOnly: z23.boolean().optional(),
+  acceptContentEncodings: z23.array(z23.string().min(1).max(32)).max(8).optional(),
+  imageReferences: z23.boolean().optional(),
+  pageSize: z23.number().int().min(1).max(SESSION_TIMELINE_PAGE_SIZE).default(SESSION_TIMELINE_PAGE_SIZE),
+  assistantPreview: z23.boolean().optional()
 });
-var SessionWatchRequestSchema = z22.object({
+var SessionWatchRequestSchema = z23.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  watching: z22.boolean()
+  watching: z23.boolean()
 }).strict();
-var SessionWatchResultSchema = z22.discriminatedUnion("ok", [
-  z22.object({
-    ok: z22.literal(true),
+var SessionWatchResultSchema = z23.discriminatedUnion("ok", [
+  z23.object({
+    ok: z23.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
-    watching: z22.boolean()
+    watching: z23.boolean()
   }).strict(),
-  z22.object({
-    ok: z22.literal(false),
+  z23.object({
+    ok: z23.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
-    watching: z22.boolean(),
+    watching: z23.boolean(),
     error: ProtocolFailureSchema
   }).strict()
 ]);
-var SessionTimelinePageSchema = z22.object({
-  items: z22.array(ConversationItemSchema).max(SESSION_TIMELINE_PAGE_SIZE),
-  cursor: z22.string().max(32768),
-  hasMore: z22.boolean(),
-  cursorStatus: z22.enum(["ok", "expired"]),
+var SessionTimelinePageSchema = z23.object({
+  items: z23.array(ConversationItemSchema).max(SESSION_TIMELINE_PAGE_SIZE),
+  cursor: z23.string().max(32768),
+  hasMore: z23.boolean(),
+  cursorStatus: z23.enum(["ok", "expired"]),
   assistantPreview: SessionAssistantPreviewSchema.optional(),
   userPreview: SessionUserPreviewSchema.optional(),
-  previewsComplete: z22.boolean().optional()
+  previewsComplete: z23.boolean().optional()
 });
-var SessionTimelinePageResultSchema = z22.discriminatedUnion("ok", [
-  z22.object({
-    ok: z22.literal(true),
+var SessionTimelinePageResultSchema = z23.discriminatedUnion("ok", [
+  z23.object({
+    ok: z23.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     page: SessionTimelinePageSchema
   }),
-  z22.object({
-    ok: z22.literal(false),
+  z23.object({
+    ok: z23.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     error: ProtocolFailureSchema
   })
 ]);
-var SessionTimelineInvalidatedSchema = z22.object({
+var SessionTimelineInvalidatedSchema = z23.object({
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  reason: z22.enum(["clear", "rewind"]),
+  reason: z23.enum(["clear", "rewind"]),
   sourceEventId: IdSchema,
   timestamp: IsoDateSchema
 }).strict();
 
 // ../../shared/protocol/dist/sessions/prompts.js
-var SessionAvatarPersonaSchema = z23.object({
-  role: z23.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
-  displayName: z23.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
+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()
 }).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 = z23.object({
+var SessionPromptRequestSchema = z24.object({
   requestId: IdSchema,
   operationId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  prompt: z23.string().trim().max(1e5),
-  attachments: z23.array(PromptImageAttachmentSchema).max(4).optional(),
-  fileAttachments: z23.array(PromptFileAttachmentSchema).max(4).optional(),
+  prompt: z24.string().trim().max(1e5),
+  attachments: z24.array(PromptImageAttachmentSchema).max(4).optional(),
+  fileAttachments: z24.array(PromptFileAttachmentSchema).max(4).optional(),
   avatarPersona: SessionAvatarPersonaSchema.optional(),
-  mode: z23.enum(["enqueue", "immediate"]).default("enqueue")
+  mode: z24.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({
@@ -2320,22 +2339,22 @@ var SessionPromptRequestSchema = z23.object({
     });
   }
 });
-var SessionPromptResultSchema = z23.discriminatedUnion("ok", [
-  z23.object({
-    ok: z23.literal(true),
+var SessionPromptResultSchema = z24.discriminatedUnion("ok", [
+  z24.object({
+    ok: z24.literal(true),
     requestId: IdSchema,
     operationId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
     messageId: IdSchema,
-    mode: z23.enum(["enqueue", "immediate"]),
-    deliveryState: z23.enum(["queued", "processing"]),
+    mode: z24.enum(["enqueue", "immediate"]),
+    deliveryState: z24.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()
   }),
-  z23.object({
-    ok: z23.literal(false),
+  z24.object({
+    ok: z24.literal(false),
     requestId: IdSchema,
     operationId: IdSchema,
     machineId: IdSchema,
@@ -2343,29 +2362,29 @@ var SessionPromptResultSchema = z23.discriminatedUnion("ok", [
     error: ProtocolFailureSchema
   })
 ]);
-var SessionActivityUpdateSchema = z23.object({
+var SessionActivityUpdateSchema = z24.object({
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  state: z23.enum(["working", "idle"]),
+  state: z24.enum(["working", "idle"]),
   occurredAt: IsoDateSchema,
   assistantPreview: SessionAssistantPreviewSchema.optional(),
   userPreview: SessionUserPreviewSchema.optional()
 });
-var SessionAbortRequestSchema = z23.object({
+var SessionAbortRequestSchema = z24.object({
   requestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema
 });
-var SessionAbortResultSchema = z23.discriminatedUnion("ok", [
-  z23.object({
-    ok: z23.literal(true),
+var SessionAbortResultSchema = z24.discriminatedUnion("ok", [
+  z24.object({
+    ok: z24.literal(true),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema
   }),
-  z23.object({
-    ok: z23.literal(false),
+  z24.object({
+    ok: z24.literal(false),
     requestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema,
@@ -2374,12 +2393,12 @@ var SessionAbortResultSchema = z23.discriminatedUnion("ok", [
 ]);
 
 // ../../shared/protocol/dist/sessions/interactions.js
-import { z as z24 } from "zod";
-var InteractionFormFieldSchema = z24.object({
+import { z as z25 } from "zod";
+var InteractionFormFieldSchema = z25.object({
   id: IdSchema,
-  label: z24.string().trim().min(1).max(1024),
-  description: z24.string().max(2048).optional(),
-  inputType: z24.enum([
+  label: z25.string().trim().min(1).max(1024),
+  description: z25.string().max(2048).optional(),
+  inputType: z25.enum([
     "text",
     "number",
     "integer",
@@ -2387,77 +2406,77 @@ var InteractionFormFieldSchema = z24.object({
     "select",
     "multi-select"
   ]),
-  required: z24.boolean(),
-  options: z24.array(z24.string().max(1024)).max(100),
-  defaultValue: z24.union([
-    z24.string().max(4096),
-    z24.number().finite(),
-    z24.boolean(),
-    z24.array(z24.string().max(1024)).max(100)
+  required: z25.boolean(),
+  options: z25.array(z25.string().max(1024)).max(100),
+  defaultValue: z25.union([
+    z25.string().max(4096),
+    z25.number().finite(),
+    z25.boolean(),
+    z25.array(z25.string().max(1024)).max(100)
   ]).optional(),
-  minimum: z24.number().finite().optional(),
-  maximum: z24.number().finite().optional(),
-  minLength: z24.number().int().nonnegative().max(1e6).optional(),
-  maxLength: z24.number().int().nonnegative().max(1e6).optional(),
-  minItems: z24.number().int().nonnegative().max(100).optional(),
-  maxItems: z24.number().int().nonnegative().max(100).optional(),
-  format: z24.enum(["email", "uri", "date", "date-time"]).optional()
+  minimum: z25.number().finite().optional(),
+  maximum: z25.number().finite().optional(),
+  minLength: z25.number().int().nonnegative().max(1e6).optional(),
+  maxLength: z25.number().int().nonnegative().max(1e6).optional(),
+  minItems: z25.number().int().nonnegative().max(100).optional(),
+  maxItems: z25.number().int().nonnegative().max(100).optional(),
+  format: z25.enum(["email", "uri", "date", "date-time"]).optional()
 }).strict();
-var InteractionPermissionRequestSchema = z24.object({
-  kind: z24.literal("permission"),
+var InteractionPermissionRequestSchema = z25.object({
+  kind: z25.literal("permission"),
   permissionKind: IdSchema,
-  title: z24.string().trim().min(1).max(256),
-  description: z24.string().max(4096),
-  canApproveSession: z24.boolean(),
-  canApproveAlways: z24.boolean().optional(),
-  approvalScope: z24.string().trim().min(1).max(4096).optional()
+  title: z25.string().trim().min(1).max(256),
+  description: z25.string().max(4096),
+  canApproveSession: z25.boolean(),
+  canApproveAlways: z25.boolean().optional(),
+  approvalScope: z25.string().trim().min(1).max(4096).optional()
 }).strict();
-var InteractionUserInputRequestSchema = z24.object({
-  kind: z24.literal("user_input"),
-  question: z24.string().trim().min(1).max(4096),
-  choices: z24.array(z24.string().max(1024)).max(100),
-  allowFreeform: z24.boolean()
+var InteractionUserInputRequestSchema = z25.object({
+  kind: z25.literal("user_input"),
+  question: z25.string().trim().min(1).max(4096),
+  choices: z25.array(z25.string().max(1024)).max(100),
+  allowFreeform: z25.boolean()
 }).strict();
-var InteractionElicitationRequestSchema = z24.object({
-  kind: z24.literal("elicitation"),
-  message: z24.string().trim().min(1).max(4096),
-  mode: z24.enum(["form", "url"]),
-  source: z24.string().trim().min(1).max(256).optional(),
-  url: z24.url().max(32768).optional(),
-  fields: z24.array(InteractionFormFieldSchema).max(100)
+var InteractionElicitationRequestSchema = z25.object({
+  kind: z25.literal("elicitation"),
+  message: z25.string().trim().min(1).max(4096),
+  mode: z25.enum(["form", "url"]),
+  source: z25.string().trim().min(1).max(256).optional(),
+  url: z25.url().max(32768).optional(),
+  fields: z25.array(InteractionFormFieldSchema).max(100)
 }).strict();
-var InteractionMcpOauthRequestSchema = z24.object({
-  kind: z24.literal("mcp_oauth"),
-  serverName: z24.string().trim().min(1).max(256),
-  serverUrl: z24.url().max(32768),
-  reason: z24.enum(["initial", "refresh", "reauth", "upscope"]),
-  responseMode: z24.literal("cancel-only")
+var InteractionMcpOauthRequestSchema = z25.object({
+  kind: z25.literal("mcp_oauth"),
+  serverName: z25.string().trim().min(1).max(256),
+  serverUrl: z25.url().max(32768),
+  reason: z25.enum(["initial", "refresh", "reauth", "upscope"]),
+  responseMode: z25.literal("cancel-only")
 }).strict();
-var InteractionMcpHeadersRequestSchema = z24.object({
-  kind: z24.literal("mcp_headers"),
-  serverName: z24.string().trim().min(1).max(256),
-  serverUrl: z24.url().max(32768),
-  reason: z24.string().trim().min(1).max(256),
-  responseMode: z24.literal("none-only")
+var InteractionMcpHeadersRequestSchema = z25.object({
+  kind: z25.literal("mcp_headers"),
+  serverName: z25.string().trim().min(1).max(256),
+  serverUrl: z25.url().max(32768),
+  reason: z25.string().trim().min(1).max(256),
+  responseMode: z25.literal("none-only")
 }).strict();
-var InteractionAutoModeSwitchRequestSchema = z24.object({
-  kind: z24.literal("auto_mode_switch"),
+var InteractionAutoModeSwitchRequestSchema = z25.object({
+  kind: z25.literal("auto_mode_switch"),
   errorCode: IdSchema.optional(),
-  retryAfterSeconds: z24.number().int().nonnegative().optional()
+  retryAfterSeconds: z25.number().int().nonnegative().optional()
 }).strict();
-var InteractionSessionLimitsRequestSchema = z24.object({
-  kind: z24.literal("session_limits"),
-  maxAiCredits: z24.number().finite().nonnegative(),
-  usedAiCredits: z24.number().finite().nonnegative()
+var InteractionSessionLimitsRequestSchema = z25.object({
+  kind: z25.literal("session_limits"),
+  maxAiCredits: z25.number().finite().nonnegative(),
+  usedAiCredits: z25.number().finite().nonnegative()
 }).strict();
-var InteractionExitPlanRequestSchema = z24.object({
-  kind: z24.literal("exit_plan"),
-  summary: z24.string().max(4096),
-  planContent: z24.string().max(1e5).optional(),
-  actions: z24.array(IdSchema).min(1).max(20),
+var InteractionExitPlanRequestSchema = z25.object({
+  kind: z25.literal("exit_plan"),
+  summary: z25.string().max(4096),
+  planContent: z25.string().max(1e5).optional(),
+  actions: z25.array(IdSchema).min(1).max(20),
   recommendedAction: IdSchema
 }).strict();
-var InteractionRequestSchema = z24.discriminatedUnion("kind", [
+var InteractionRequestSchema = z25.discriminatedUnion("kind", [
   InteractionPermissionRequestSchema,
   InteractionUserInputRequestSchema,
   InteractionElicitationRequestSchema,
@@ -2467,81 +2486,81 @@ var InteractionRequestSchema = z24.discriminatedUnion("kind", [
   InteractionSessionLimitsRequestSchema,
   InteractionExitPlanRequestSchema
 ]);
-var InteractionPermissionResponseSchema = z24.object({
-  kind: z24.literal("permission"),
-  decision: z24.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
-  feedback: z24.string().trim().min(1).max(2048).optional()
+var InteractionPermissionResponseSchema = z25.object({
+  kind: z25.literal("permission"),
+  decision: z25.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
+  feedback: z25.string().trim().min(1).max(2048).optional()
 }).strict();
-var InteractionUserInputResponseSchema = z24.object({
-  kind: z24.literal("user_input"),
-  answer: z24.string().max(1e5),
-  wasFreeform: z24.boolean()
+var InteractionUserInputResponseSchema = z25.object({
+  kind: z25.literal("user_input"),
+  answer: z25.string().max(1e5),
+  wasFreeform: z25.boolean()
 }).strict();
-var InteractionFieldValueSchema = z24.union([
-  z24.string().max(4096),
-  z24.number(),
-  z24.boolean(),
-  z24.array(z24.string().max(1024)).max(100)
+var InteractionFieldValueSchema = z25.union([
+  z25.string().max(4096),
+  z25.number(),
+  z25.boolean(),
+  z25.array(z25.string().max(1024)).max(100)
 ]);
-var InteractionElicitationResponseSchema = z24.object({
-  kind: z24.literal("elicitation"),
-  action: z24.enum(["accept", "decline", "cancel"]),
-  values: z24.record(z24.string().max(256), InteractionFieldValueSchema)
+var InteractionElicitationResponseSchema = z25.object({
+  kind: z25.literal("elicitation"),
+  action: z25.enum(["accept", "decline", "cancel"]),
+  values: z25.record(z25.string().max(256), InteractionFieldValueSchema)
 }).strict();
-var InteractionMcpOauthResponseSchema = z24.object({
-  kind: z24.literal("mcp_oauth"),
-  action: z24.literal("cancel")
+var InteractionMcpOauthResponseSchema = z25.object({
+  kind: z25.literal("mcp_oauth"),
+  action: z25.literal("cancel")
 }).strict();
-var InteractionMcpHeadersResponseSchema = z24.object({
-  kind: z24.literal("mcp_headers"),
-  action: z24.literal("none")
+var InteractionMcpHeadersResponseSchema = z25.object({
+  kind: z25.literal("mcp_headers"),
+  action: z25.literal("none")
 }).strict();
-var InteractionAutoModeSwitchResponseSchema = z24.object({
-  kind: z24.literal("auto_mode_switch"),
-  action: z24.enum(["yes", "yes_always", "no"])
+var InteractionAutoModeSwitchResponseSchema = z25.object({
+  kind: z25.literal("auto_mode_switch"),
+  action: z25.enum(["yes", "yes_always", "no"])
 }).strict();
-var InteractionSessionLimitsResponseSchema = z24.object({
-  kind: z24.literal("session_limits"),
-  action: z24.enum(["add", "set", "unset", "cancel"]),
-  additionalAiCredits: z24.number().positive().optional(),
-  maxAiCredits: z24.number().positive().optional()
+var InteractionSessionLimitsResponseSchema = z25.object({
+  kind: z25.literal("session_limits"),
+  action: z25.enum(["add", "set", "unset", "cancel"]),
+  additionalAiCredits: z25.number().positive().optional(),
+  maxAiCredits: z25.number().positive().optional()
 }).strict().superRefine((response, context) => {
   if (response.action === "add" && response.additionalAiCredits === void 0) {
     context.addIssue({
-      code: z24.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       path: ["additionalAiCredits"],
       message: "additionalAiCredits is required for add"
     });
   }
   if (response.action === "set" && response.maxAiCredits === void 0) {
     context.addIssue({
-      code: z24.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       path: ["maxAiCredits"],
       message: "maxAiCredits is required for set"
     });
   }
   if (response.action !== "add" && response.additionalAiCredits !== void 0) {
     context.addIssue({
-      code: z24.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       path: ["additionalAiCredits"],
       message: "additionalAiCredits is only valid for add"
     });
   }
   if (response.action !== "set" && response.maxAiCredits !== void 0) {
     context.addIssue({
-      code: z24.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       path: ["maxAiCredits"],
       message: "maxAiCredits is only valid for set"
     });
   }
 });
-var InteractionExitPlanResponseSchema = z24.object({
-  kind: z24.literal("exit_plan"),
-  approved: z24.boolean(),
+var InteractionExitPlanResponseSchema = z25.object({
+  kind: z25.literal("exit_plan"),
+  approved: z25.boolean(),
   selectedAction: IdSchema.optional(),
-  feedback: z24.string().trim().min(1).max(4096).optional()
+  feedback: z25.string().trim().min(1).max(4096).optional()
 }).strict();
-var InteractionResponseSchema = z24.discriminatedUnion("kind", [
+var InteractionResponseSchema = z25.discriminatedUnion("kind", [
   InteractionPermissionResponseSchema,
   InteractionUserInputResponseSchema,
   InteractionElicitationResponseSchema,
@@ -2551,30 +2570,30 @@ var InteractionResponseSchema = z24.discriminatedUnion("kind", [
   InteractionSessionLimitsResponseSchema,
   InteractionExitPlanResponseSchema
 ]);
-var InteractionRequestPayloadSchema = z24.object({
+var InteractionRequestPayloadSchema = z25.object({
   interactionRequestId: IdSchema,
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
   request: InteractionRequestSchema
 }).strict();
-var InteractionRespondRequestSchema = z24.object({
+var InteractionRespondRequestSchema = z25.object({
   requestId: IdSchema,
   interactionRequestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
   response: InteractionResponseSchema
 }).strict();
-var InteractionRespondResultSchema = z24.discriminatedUnion("ok", [
-  z24.object({
-    ok: z24.literal(true),
+var InteractionRespondResultSchema = z25.discriminatedUnion("ok", [
+  z25.object({
+    ok: z25.literal(true),
     requestId: IdSchema,
     interactionRequestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema
   }).strict(),
-  z24.object({
-    ok: z24.literal(false),
+  z25.object({
+    ok: z25.literal(false),
     requestId: IdSchema,
     interactionRequestId: IdSchema,
     machineId: IdSchema,
@@ -2582,31 +2601,31 @@ var InteractionRespondResultSchema = z24.discriminatedUnion("ok", [
     error: ProtocolFailureSchema
   }).strict()
 ]);
-var PermissionRequestPayloadSchema = z24.object({
+var PermissionRequestPayloadSchema = z25.object({
   permissionRequestId: IdSchema,
   userId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  request: z24.record(z24.string(), z24.unknown())
+  request: z25.record(z25.string(), z25.unknown())
 });
-var PermissionRespondRequestSchema = z24.object({
+var PermissionRespondRequestSchema = z25.object({
   requestId: IdSchema,
   permissionRequestId: IdSchema,
   machineId: IdSchema,
   sessionId: IdSchema,
-  decision: z24.enum(["approve-once", "reject"]),
-  feedback: z24.string().trim().min(1).max(2048).optional()
+  decision: z25.enum(["approve-once", "reject"]),
+  feedback: z25.string().trim().min(1).max(2048).optional()
 });
-var PermissionRespondResultSchema = z24.discriminatedUnion("ok", [
-  z24.object({
-    ok: z24.literal(true),
+var PermissionRespondResultSchema = z25.discriminatedUnion("ok", [
+  z25.object({
+    ok: z25.literal(true),
     requestId: IdSchema,
     permissionRequestId: IdSchema,
     machineId: IdSchema,
     sessionId: IdSchema
   }),
-  z24.object({
-    ok: z24.literal(false),
+  z25.object({
+    ok: z25.literal(false),
     requestId: IdSchema,
     permissionRequestId: IdSchema,
     machineId: IdSchema,
@@ -2616,42 +2635,42 @@ var PermissionRespondResultSchema = z24.discriminatedUnion("ok", [
 ]);
 
 // ../../shared/protocol/dist/conversation/timeline-sync.js
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 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()
+  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 = 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"),
+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",
@@ -2660,36 +2679,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;
@@ -2700,10 +2719,10 @@ var TimelineImageChunkSchema = z25.object({
 });
 
 // ../../shared/protocol/dist/workbench.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // ../../shared/protocol/dist/schedules.js
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var SCHEDULE_OPERATIONS = [
   "schedule.snapshot",
   "schedule.create",
@@ -2711,90 +2730,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()
+  error: z27.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(),
+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,
@@ -2811,10 +2830,10 @@ var ScheduleAndroidSchemas = {
 };
 
 // ../../shared/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_OPERATIONS = [
   "operation.get",
   "question.ask",
@@ -2833,104 +2852,104 @@ var WORKBENCH_OPERATIONS = [
   ...SCHEDULE_OPERATIONS
 ];
 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)
+  prompt: z28.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()
+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 = z27.object({
-  commands: z27.array(WorkbenchCommandSchema).max(512)
+var WorkbenchCommandListResultSchema = z28.object({
+  commands: z28.array(WorkbenchCommandSchema).max(512)
 }).strict();
-var WorkbenchCommandInvokeRequestSchema = z27.object({
+var WorkbenchCommandInvokeRequestSchema = z28.object({
   ...Submission2,
-  name: z27.string().trim().min(1).max(260),
-  input: z27.string().max(16e3)
+  name: z28.string().trim().min(1).max(260),
+  input: z28.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)
+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 = 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)
+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,
@@ -2938,48 +2957,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 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 = z27.object({
-  changed: z27.boolean(),
+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();
@@ -3015,6 +3034,8 @@ var WorkbenchAndroidSchemas = {
 
 // ../../shared/protocol/dist/codegen/android-schemas.js
 var AndroidProtocolSchemas = {
+  BrowserOpenUrlParams: BrowserOpenUrlParamsSchema,
+  BrowserOpenUrlResult: BrowserOpenUrlResultSchema,
   TimelineImageBlobRequest: TimelineImageBlobRequestSchema,
   TimelineImageBlobResult: TimelineImageBlobResultSchema,
   SessionImageUploadRequest: SessionImageUploadRequestSchema,
@@ -3134,49 +3155,49 @@ import {
   SessionImageRelayUrlSchema,
   SessionImagesConfigSchema
 } from "@agentknight/sdk";
-var BooleanStringSchema = z28.enum(["true", "false"]).default("false").transform((value) => value === "true");
-var EnabledBooleanStringSchema = z28.enum(["true", "false"]).default("true").transform((value) => value === "true");
-var OptionalPathSchema = z28.preprocess(
+var BooleanStringSchema = z29.enum(["true", "false"]).default("false").transform((value) => value === "true");
+var EnabledBooleanStringSchema = z29.enum(["true", "false"]).default("true").transform((value) => value === "true");
+var OptionalPathSchema = z29.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z28.string().trim().min(1).optional()
+  z29.string().trim().min(1).optional()
 );
-var AcpArgumentsSchema = z28.string().default("[]").transform((value, context) => {
+var AcpArgumentsSchema = z29.string().default("[]").transform((value, context) => {
   let decoded;
   try {
     decoded = JSON.parse(value);
   } catch (error) {
     if (!(error instanceof SyntaxError)) throw error;
     context.addIssue({ code: "custom", message: "AGENTKNIGHT_ACP_ARGS must be a JSON array of strings" });
-    return z28.NEVER;
+    return z29.NEVER;
   }
-  const parsed = z28.array(z28.string()).max(128).safeParse(decoded);
+  const parsed = z29.array(z29.string()).max(128).safeParse(decoded);
   if (!parsed.success) {
     context.addIssue({ code: "custom", message: "AGENTKNIGHT_ACP_ARGS must be a JSON array of strings" });
-    return z28.NEVER;
+    return z29.NEVER;
   }
   return parsed.data;
 });
-var EnvironmentSchema = z28.object({
-  RELAY_URL: z28.url(),
-  RELAY_TOKEN: z28.string().min(24).optional(),
-  RELAY_AUTH: z28.enum(["token", "microsoft"]).optional(),
-  USER_ID: z28.string().trim().min(1).max(256).default("admin"),
-  AGENTKNIGHT_MACHINE_NAME: z28.string().trim().min(1).max(120).optional(),
-  AGENTKNIGHT_HOME: z28.string().trim().min(1).optional(),
-  AGENTKNIGHT_WORKSPACE_ROOT: z28.string().trim().min(1).optional(),
-  AGENTKNIGHT_CODING_AGENT: z28.enum(["managed", ...CODING_AGENT_IDS2]).default("managed"),
+var EnvironmentSchema = z29.object({
+  RELAY_URL: z29.url(),
+  RELAY_TOKEN: z29.string().min(24).optional(),
+  RELAY_AUTH: z29.enum(["token", "microsoft"]).optional(),
+  USER_ID: z29.string().trim().min(1).max(256).default("admin"),
+  AGENTKNIGHT_MACHINE_NAME: z29.string().trim().min(1).max(120).optional(),
+  AGENTKNIGHT_HOME: z29.string().trim().min(1).optional(),
+  AGENTKNIGHT_WORKSPACE_ROOT: z29.string().trim().min(1).optional(),
+  AGENTKNIGHT_CODING_AGENT: z29.enum(["managed", ...CODING_AGENT_IDS2]).default("managed"),
   AGENTKNIGHT_GROUP_CHAT_ENABLED: EnabledBooleanStringSchema,
   AGENTKNIGHT_PEER_CHAT_ENABLED: EnabledBooleanStringSchema,
   PI_CODING_AGENT_DIR: OptionalPathSchema,
   AGENTKNIGHT_CODEX_COMMAND: OptionalPathSchema,
   AGENTKNIGHT_ACP_COMMAND: OptionalPathSchema,
   AGENTKNIGHT_ACP_ARGS: AcpArgumentsSchema,
-  SESSION_REFRESH_INTERVAL_MS: z28.coerce.number().int().min(5e3).max(36e5).default(3e4),
-  HEARTBEAT_INTERVAL_MS: z28.coerce.number().int().min(5e3).max(12e4).default(15e3),
-  LOG_LEVEL: z28.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]).default("info"),
+  SESSION_REFRESH_INTERVAL_MS: z29.coerce.number().int().min(5e3).max(36e5).default(3e4),
+  HEARTBEAT_INTERVAL_MS: z29.coerce.number().int().min(5e3).max(12e4).default(15e3),
+  LOG_LEVEL: z29.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]).default("info"),
   SHOW_PAIRING_QR: BooleanStringSchema,
   PAIRING_PAGE_ENABLED: EnabledBooleanStringSchema,
-  PAIRING_PAGE_PORT: z28.coerce.number().int().min(1024).max(65535).default(defaultPairingPagePort),
+  PAIRING_PAGE_PORT: z29.coerce.number().int().min(1024).max(65535).default(defaultPairingPagePort),
   PC_AGENT_EXIT_AFTER_SNAPSHOT: BooleanStringSchema,
   SNAPSHOT_SUPPRESSION_ENABLED: EnabledBooleanStringSchema,
   TIMELINE_COMPRESSION_ENABLED: BooleanStringSchema,
@@ -3184,7 +3205,7 @@ var EnvironmentSchema = z28.object({
   SESSION_IMAGES_ALLOW_UNENCRYPTED_STORAGE: EnabledBooleanStringSchema,
   SESSION_IMAGES_STORAGE_ACCOUNT: SessionImagesConfigSchema.shape.storageAccount.default("agentknightimagesbsp09"),
   SESSION_IMAGES_STORAGE_CONTAINER: SessionImagesConfigSchema.shape.storageContainer.optional(),
-  SECURE_MESSAGE_PACKET_BUDGET: z28.coerce.number().int().min(2048).max(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH).default(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH)
+  SECURE_MESSAGE_PACKET_BUDGET: z29.coerce.number().int().min(2048).max(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH).default(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH)
 }).superRefine((value, context) => {
   if (value.SESSION_IMAGES_ALLOW_UNENCRYPTED_STORAGE) {
     if (!SessionImageRelayUrlSchema.safeParse(value.RELAY_URL).success) {
@@ -3252,8 +3273,8 @@ function loadConfig(environment = process.env, options = {}) {
   }
   return {
     ...settings2,
-    relayToken: z28.string().min(32).max(4096).parse(options.relayCredential.token),
-    userId: z28.string().min(1).max(256).parse(options.relayCredential.user.userId)
+    relayToken: z29.string().min(32).max(4096).parse(options.relayCredential.token),
+    userId: z29.string().min(1).max(256).parse(options.relayCredential.user.userId)
   };
 }
 function loadStartupConfig(environment = process.env, options = {}) {
@@ -4435,7 +4456,7 @@ import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual
 import { createHash as createHash2 } from "node:crypto";
 import { platform } from "node:os";
 import { brotliCompressSync, brotliDecompressSync } from "node:zlib";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var STORE_MESSAGES = {
   unavailable: "Unlock your operating system credential store and restart AgentKnight. No file-based credential fallback is available.",
   invalid: "The saved Relay credential is invalid. Recover it in your operating system credential manager before signing in.",
@@ -4468,30 +4489,30 @@ function normalizeRelayOrigin(value) {
     throw new RelayCredentialStoreError("address");
   }
 }
-var ConfirmationSchema = z29.discriminatedUnion("status", [
-  z29.object({
-    status: z29.literal("pending"),
-    confirmBy: z29.number().int().positive(),
+var ConfirmationSchema = z30.discriminatedUnion("status", [
+  z30.object({
+    status: z30.literal("pending"),
+    confirmBy: z30.number().int().positive(),
     enrollmentId: PcEnrollmentIdSchema,
     verifier: PcEnrollmentVerifierRequestSchema.shape.verifier
   }).strict(),
-  z29.object({
-    status: z29.literal("confirmed"),
-    confirmBy: z29.number().int().positive()
+  z30.object({
+    status: z30.literal("confirmed"),
+    confirmBy: z30.number().int().positive()
   }).strict()
 ]);
-var RelayCredentialSchema = z29.object({
-  version: z29.literal(1),
-  relayUrl: z29.string().max(2048),
+var RelayCredentialSchema = z30.object({
+  version: z30.literal(1),
+  relayUrl: z30.string().max(2048),
   machineId: PcEnrollmentStartRequestSchema.shape.machineId,
-  token: z29.string().min(32).max(4096),
-  tokenId: z29.string().min(1).max(256),
-  grantId: z29.uuid(),
+  token: z30.string().min(32).max(4096),
+  tokenId: z30.string().min(1).max(256),
+  grantId: z30.uuid(),
   user: AuthUserSchema,
   confirmation: ConfirmationSchema
 }).strict();
-var SlotsSchema = z29.object({
-  version: z29.literal(1),
+var SlotsSchema = z30.object({
+  version: z30.literal(1),
   pending: RelayCredentialSchema.optional(),
   confirmed: RelayCredentialSchema.optional()
 }).strict();
@@ -5377,7 +5398,7 @@ import { mkdtemp, rm as rm2 } from "node:fs/promises";
 import { createConnection, createServer as createServer2 } from "node:net";
 import { tmpdir } from "node:os";
 import { join as join4, resolve as resolve3 } from "node:path";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 import { DataDirectoryLease } from "@agentknight/sdk/runtime";
 import {
   PEER_CHAT_TIMEOUT_MS,
@@ -5389,16 +5410,16 @@ import {
 import { randomUUID } from "node:crypto";
 import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join3 } from "node:path";
-import { z as z30 } from "zod";
-var UpgradeStateSchema = z30.object({
-  id: z30.uuid(),
-  phase: z30.enum(["preparing", "ready", "waiting-idle", "switching", "verifying", "succeeded", "rolled-back", "failed"]),
-  fromVersion: z30.string(),
-  toVersion: z30.string(),
-  updatedAt: z30.iso.datetime(),
-  error: z30.string().optional()
+import { z as z31 } from "zod";
+var UpgradeStateSchema = z31.object({
+  id: z31.uuid(),
+  phase: z31.enum(["preparing", "ready", "waiting-idle", "switching", "verifying", "succeeded", "rolled-back", "failed"]),
+  fromVersion: z31.string(),
+  toVersion: z31.string(),
+  updatedAt: z31.iso.datetime(),
+  error: z31.string().optional()
 });
-var UpgradeSuccessSchema = z30.object({ version: z30.string(), upgradedAt: z30.iso.datetime() });
+var UpgradeSuccessSchema = z31.object({ version: z31.string(), upgradedAt: z31.iso.datetime() });
 async function readOptionalJson(path) {
   try {
     return JSON.parse(await readFile2(path, "utf8"));
@@ -5428,39 +5449,39 @@ async function readLastUpgrade(directory) {
 }
 
 // src/runtime.ts
-var RuntimeDescriptorSchema = z31.object({
-  pid: z31.number().int().positive(),
-  instanceId: z31.uuid(),
-  endpoint: z31.string().min(1),
-  token: z31.string().min(32),
-  upgradeId: z31.uuid().optional()
+var RuntimeDescriptorSchema = z32.object({
+  pid: z32.number().int().positive(),
+  instanceId: z32.uuid(),
+  endpoint: z32.string().min(1),
+  token: z32.string().min(32),
+  upgradeId: z32.uuid().optional()
 });
-var RuntimeStatusSchema = z31.object({
-  version: z31.string().min(1),
-  pid: z31.number().int().positive(),
-  instanceId: z31.uuid(),
-  ready: z31.boolean(),
-  busy: z31.boolean(),
-  relayUrl: z31.string().url(),
-  identityHash: z31.string().min(1),
-  configPath: z31.string().optional(),
-  configHash: z31.string().optional(),
-  executable: z31.string().min(1),
-  cliPath: z31.string().min(1),
-  cwd: z31.string().min(1),
-  args: z31.array(z31.string()),
-  canRestart: z31.boolean().default(false),
-  restartEnvironment: z31.record(z31.string(), z31.string()).default({}),
-  upgradeId: z31.uuid().optional(),
-  stopping: z31.boolean().optional()
+var RuntimeStatusSchema = z32.object({
+  version: z32.string().min(1),
+  pid: z32.number().int().positive(),
+  instanceId: z32.uuid(),
+  ready: z32.boolean(),
+  busy: z32.boolean(),
+  relayUrl: z32.string().url(),
+  identityHash: z32.string().min(1),
+  configPath: z32.string().optional(),
+  configHash: z32.string().optional(),
+  executable: z32.string().min(1),
+  cliPath: z32.string().min(1),
+  cwd: z32.string().min(1),
+  args: z32.array(z32.string()),
+  canRestart: z32.boolean().default(false),
+  restartEnvironment: z32.record(z32.string(), z32.string()).default({}),
+  upgradeId: z32.uuid().optional(),
+  stopping: z32.boolean().optional()
 });
-var RequestSchema = z31.discriminatedUnion("command", [
-  z31.object({ token: z31.string(), command: z31.enum(["status", "prepare", "cancel", "stop"]) }),
-  z31.object({ token: z31.string(), command: z31.literal("peer-chat"), payload: PeerChatRequestSchema2 })
+var RequestSchema = z32.discriminatedUnion("command", [
+  z32.object({ token: z32.string(), command: z32.enum(["status", "prepare", "cancel", "stop"]) }),
+  z32.object({ token: z32.string(), command: z32.literal("peer-chat"), payload: PeerChatRequestSchema2 })
 ]);
-var ResponseSchema = z31.discriminatedUnion("ok", [
-  z31.object({ ok: z31.literal(true), status: RuntimeStatusSchema.optional(), reply: PeerChatResultSchema.optional() }),
-  z31.object({ ok: z31.literal(false), error: z31.string() })
+var ResponseSchema = z32.discriminatedUnion("ok", [
+  z32.object({ ok: z32.literal(true), status: RuntimeStatusSchema.optional(), reply: PeerChatResultSchema.optional() }),
+  z32.object({ ok: z32.literal(false), error: z32.string() })
 ]);
 var MAX_MESSAGE_BYTES = 32 * 1024;
 var MAX_PEER_REQUEST_BYTES = 128 * 1024;
@@ -5723,7 +5744,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import { copyFile as copyFile2, mkdir as mkdir5, open as open2, realpath as realpath2, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname5, join as join9, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // src/upgrade-packages.ts
 import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
@@ -5737,7 +5758,7 @@ import { createHash as createHash5 } from "node:crypto";
 import { open } from "node:fs/promises";
 import { join as join5 } from "node:path";
 import { promisify } from "node:util";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/restart-environment.ts
 import { resolve as resolve4 } from "node:path";
@@ -5775,10 +5796,10 @@ function restartEnvironment(effective, persisted, dataDirectory) {
 
 // src/upgrade-supervisor.ts
 var execute = promisify(execFile);
-var SupervisorSchema = z32.discriminatedUnion("kind", [
-  z32.object({ kind: z32.literal("process") }),
-  z32.object({ kind: z32.literal("windows-task"), name: z32.string(), path: z32.string(), definitionHash: z32.string() }),
-  z32.object({ kind: z32.literal("launchd"), domain: z32.string(), label: z32.string(), plist: z32.string() })
+var SupervisorSchema = z33.discriminatedUnion("kind", [
+  z33.object({ kind: z33.literal("process") }),
+  z33.object({ kind: z33.literal("windows-task"), name: z33.string(), path: z33.string(), definitionHash: z33.string() }),
+  z33.object({ kind: z33.literal("launchd"), domain: z33.string(), label: z33.string(), plist: z33.string() })
 ]);
 function globalPackageDirectory(prefix) {
   return process.platform === "win32" ? join5(prefix, "node_modules", "@agentknight", "client") : join5(prefix, "lib", "node_modules", "@agentknight", "client");
@@ -5806,7 +5827,7 @@ async function assertInstallationIdle(prefix, allowedPid) {
       } | ForEach-Object { [int]$_.ProcessId });
       ConvertTo-Json -InputObject $ids -Compress
     `);
-    pids = z32.array(z32.number().int().positive()).parse(JSON.parse(result));
+    pids = z33.array(z33.number().int().positive()).parse(JSON.parse(result));
   } else {
     const result = await execute("ps", ["-eo", "pid=,args="], { timeout: 1e4 });
     pids = result.stdout.split("\n").flatMap((line) => {
@@ -5842,7 +5863,7 @@ async function detectSupervisor(runtime) {
       if($matches.Count -gt 1) { throw 'Multiple scheduled tasks match this Agent. Refusing to choose.' };
       if($matches.Count -eq 1) { $matches[0] | ConvertTo-Json -Compress } else { 'null' }
     `);
-    const task = z32.object({ name: z32.string(), path: z32.string(), xml: z32.string() }).nullable().parse(JSON.parse(result));
+    const task = z33.object({ name: z33.string(), path: z33.string(), xml: z33.string() }).nullable().parse(JSON.parse(result));
     return task === null ? { kind: "process" } : {
       kind: "windows-task",
       name: task.name,
@@ -6362,13 +6383,13 @@ async function prepareUpgradePackages(options) {
 import { mkdir as mkdir4, readFile as readFile4, rm as rm5, stat } from "node:fs/promises";
 import { createHash as createHash7 } from "node:crypto";
 import { join as join8, resolve as resolve7 } from "node:path";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 
 // src/upgrade-startup.ts
 import { rename as rename2, rm as rm4 } from "node:fs/promises";
 import { basename, dirname as dirname4, join as join7, resolve as resolve6 } from "node:path";
-import { z as z33 } from "zod";
-var PermitSchema = z33.object({ id: z33.uuid(), version: z33.string(), cliPath: z33.string() });
+import { z as z34 } from "zod";
+var PermitSchema = z34.object({ id: z34.uuid(), version: z34.string(), cliPath: z34.string() });
 function globalUpgradeLockPath(cliPath) {
   const packageDirectory = dirname4(dirname4(cliPath));
   const scope = dirname4(packageDirectory);
@@ -6382,14 +6403,14 @@ async function claimUpgradeStartup(directory, version, cliPath) {
   const globalPath = globalUpgradeLockPath(cliPath);
   const globalLock = globalPath === void 0 ? void 0 : await readOptionalJson(globalPath);
   if (globalLock !== void 0) {
-    const globalOwner = z33.object({ id: z33.uuid(), dataDirectory: z33.string() }).parse(globalLock);
+    const globalOwner = z34.object({ id: z34.uuid(), dataDirectory: z34.string() }).parse(globalLock);
     if (lock === void 0 || resolve6(globalOwner.dataDirectory) !== resolve6(directory)) {
       throw new Error("This global installation is being upgraded for another data directory. Wait for that upgrade to finish.");
     }
   }
   if (lock === void 0) return void 0;
-  const owner = z33.object({ id: z33.uuid() }).parse(lock);
-  if (globalLock !== void 0 && z33.object({ id: z33.uuid() }).parse(globalLock).id !== owner.id) {
+  const owner = z34.object({ id: z34.uuid() }).parse(lock);
+  if (globalLock !== void 0 && z34.object({ id: z34.uuid() }).parse(globalLock).id !== owner.id) {
     throw new Error("Local and global upgrade ownership disagree; inspect the interrupted upgrade before starting.");
   }
   const path = join7(directory, "run", "upgrade-start.json");
@@ -6406,24 +6427,24 @@ async function claimUpgradeStartup(directory, version, cliPath) {
 }
 
 // src/upgrade-job.ts
-var PreparedPackagesSchema = z34.object({
-  targetArchive: z34.string(),
-  rollbackArchive: z34.string(),
-  cacheDirectory: z34.string(),
-  registry: z34.string().url()
+var PreparedPackagesSchema = z35.object({
+  targetArchive: z35.string(),
+  rollbackArchive: z35.string(),
+  cacheDirectory: z35.string(),
+  registry: z35.string().url()
 });
-var UpgradePlanSchema = z34.object({
-  id: z34.uuid(),
-  dataDirectory: z34.string(),
-  directory: z34.string(),
-  prefix: z34.string(),
-  currentVersion: z34.string(),
-  targetVersion: z34.string(),
+var UpgradePlanSchema = z35.object({
+  id: z35.uuid(),
+  dataDirectory: z35.string(),
+  directory: z35.string(),
+  prefix: z35.string(),
+  currentVersion: z35.string(),
+  targetVersion: z35.string(),
   packages: PreparedPackagesSchema,
   runtime: RuntimeStatusSchema.optional(),
   supervisor: SupervisorSchema,
-  taskName: z34.string(),
-  configHash: z34.string().optional()
+  taskName: z35.string(),
+  configHash: z35.string().optional()
 });
 async function fileHash(path) {
   return createHash7("sha256").update(await readFile4(path)).digest("hex");
@@ -6506,7 +6527,7 @@ async function upgrade(options) {
   const lockPath = join9(root, "upgrade.lock");
   const existing = await readOptionalJson(lockPath);
   if (existing !== void 0) {
-    const owner = z35.object({ pid: z35.number().int().positive() }).parse(existing);
+    const owner = z36.object({ pid: z36.number().int().positive() }).parse(existing);
     if (processExists(owner.pid)) throw new Error("Another upgrade is already running. Use agentknight status.");
     throw new Error(`An interrupted upgrade needs review. Read ${join9(root, "status.json")} before removing ${lockPath}.`);
   }
@@ -6804,17 +6825,17 @@ import { initialize, supportsAgentSelection } from "@agentknight/sdk";
 
 // src/chat-settings.ts
 import { join as join11 } from "node:path";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var settings = {
   groupChatEnabled: {
     file: "group-chat-settings.json",
     label: "Group chat",
-    schema: z36.object({ groupChatEnabled: z36.boolean() }).strict().transform((value) => value.groupChatEnabled)
+    schema: z37.object({ groupChatEnabled: z37.boolean() }).strict().transform((value) => value.groupChatEnabled)
   },
   peerChatEnabled: {
     file: "peer-chat-settings.json",
     label: "Peer chat",
-    schema: z36.object({ peerChatEnabled: z36.boolean() }).strict().transform((value) => value.peerChatEnabled)
+    schema: z37.object({ peerChatEnabled: z37.boolean() }).strict().transform((value) => value.peerChatEnabled)
   }
 };
 var ChatSettings = class _ChatSettings {
@@ -6862,14 +6883,14 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 import { link, lstat as lstat2, mkdir as mkdir6, readFile as readFile5, readlink, rename as rename3, rm as rm7, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3, hostname } from "node:os";
 import { dirname as dirname6, join as join12, resolve as resolve9 } from "node:path";
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 import { DeviceIdentitySchema, LEGACY_CLIENT_STATE_DIRECTORY } from "@agentknight/sdk";
 import { DeviceIdentitySchema as DeviceIdentitySchema2 } from "@agentknight/sdk";
-var LegacyDeviceIdentitySchema = z37.object({
-  schemaVersion: z37.literal(1),
-  machineId: z37.uuid(),
-  machineName: z37.string().trim().min(1).max(120),
-  createdAt: z37.iso.datetime({ offset: true })
+var LegacyDeviceIdentitySchema = z38.object({
+  schemaVersion: z38.literal(1),
+  machineId: z38.uuid(),
+  machineName: z38.string().trim().min(1).max(120),
+  createdAt: z38.iso.datetime({ offset: true })
 });
 function resolveMachineName(environment = process.env, fallback = hostname()) {
   const computerName = environment.COMPUTERNAME?.trim();
@@ -6890,7 +6911,7 @@ async function readStableDeviceId(path) {
   const info = await optionalStat(path);
   if (info === void 0) return void 0;
   if (!info.isFile()) throw new Error(`Device ID must be a regular file, not a link: ${path}`);
-  const parsed = z37.uuid().safeParse((await readFile5(path, "utf8")).trim());
+  const parsed = z38.uuid().safeParse((await readFile5(path, "utf8")).trim());
   if (!parsed.success) throw new Error(`Invalid device ID in ${path}`, { cause: parsed.error });
   return parsed.data;
 }
@@ -6953,7 +6974,7 @@ async function loadOrCreateDeviceIdentity(dataDirectory, currentMachineName = re
   await requireDirectory(dataDirectory);
   let existing;
   try {
-    existing = z37.union([DeviceIdentitySchema, LegacyDeviceIdentitySchema]).parse(
+    existing = z38.union([DeviceIdentitySchema, LegacyDeviceIdentitySchema]).parse(
       JSON.parse(await readFile5(path, "utf8"))
     );
   } catch (error) {