@aspectlylabs/mikka 0.0.63 → 0.0.65

package/login.js

@@ -264,14 +264,14 @@ var require_semver = __commonJS({
         if (!m[4]) {
           this.prerelease = [];
         } else {
-          this.prerelease = m[4].split(".").map((id3) => {
-            if (/^[0-9]+$/.test(id3)) {
-              const num = +id3;
+          this.prerelease = m[4].split(".").map((id4) => {
+            if (/^[0-9]+$/.test(id4)) {
+              const num = +id4;
               if (num >= 0 && num < MAX_SAFE_INTEGER) {
                 return num;
               }
             }
-            return id3;
+            return id4;
           });
         }
         this.build = m[5] ? m[5].split(".") : [];
@@ -1140,23 +1140,23 @@ var require_range = __commonJS({
       debug("stars", comp);
       return comp;
     };
-    var isX = (id3) => !id3 || id3.toLowerCase() === "x" || id3 === "*";
+    var isX = (id4) => !id4 || id4.toLowerCase() === "x" || id4 === "*";
     var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
     var replaceTildes = (comp, options) => {
       return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
     };
     var replaceTilde = (comp, options) => {
       const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-      const z27 = options.includePrerelease ? "-0" : "";
+      const z28 = options.includePrerelease ? "-0" : "";
       return comp.replace(r, (_, M, m, p, pr) => {
         debug("tilde", comp, _, M, m, p, pr);
         let ret;
         if (isX(M)) {
           ret = "";
         } else if (isX(m)) {
-          ret = `>=${M}.0.0${z27} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z28} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
-          ret = `>=${M}.${m}.0${z27} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M}.${m}.0${z28} <${M}.${+m + 1}.0-0`;
         } else if (pr) {
           debug("replaceTilde pr", pr);
           ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
@@ -1173,19 +1173,19 @@ var require_range = __commonJS({
     var replaceCaret = (comp, options) => {
       debug("caret", comp, options);
       const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-      const z27 = options.includePrerelease ? "-0" : "";
+      const z28 = options.includePrerelease ? "-0" : "";
       return comp.replace(r, (_, M, m, p, pr) => {
         debug("caret", comp, _, M, m, p, pr);
         let ret;
         if (isX(M)) {
           ret = "";
         } else if (isX(m)) {
-          ret = `>=${M}.0.0${z27} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z28} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
           if (M === "0") {
-            ret = `>=${M}.${m}.0${z27} <${M}.${+m + 1}.0-0`;
+            ret = `>=${M}.${m}.0${z28} <${M}.${+m + 1}.0-0`;
           } else {
-            ret = `>=${M}.${m}.0${z27} <${+M + 1}.0.0-0`;
+            ret = `>=${M}.${m}.0${z28} <${+M + 1}.0.0-0`;
           }
         } else if (pr) {
           debug("replaceCaret pr", pr);
@@ -2723,35 +2723,77 @@ var daemonRpc = {
 };
 
 // ../protocol/src/device.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
+
+// ../protocol/src/policy-snapshot.ts
+import { z as z11 } from "zod";
+var POLICY_SNAPSHOT_TTL_MS = 5 * 6e4;
+var id = z11.string().min(1).max(128);
+var digest = z11.string().regex(/^[a-f0-9]{64}$/);
+var policyScopeSchema = z11.strictObject({
+  workspaceIds: z11.array(id).max(2),
+  hierarchy: z11.strictObject({ workspaceId: z11.uuid(), teamId: z11.uuid(), projectId: z11.uuid().nullable() }).nullable()
+});
+var policySnapshotPayloadSchema = z11.strictObject({
+  version: z11.literal(1),
+  issuer: z11.url().max(1e3),
+  ownerId: id,
+  deviceId: id,
+  runId: id,
+  revision: digest,
+  policyHash: digest,
+  scope: policyScopeSchema,
+  policy: runPolicySchema,
+  issuedAt: z11.number().int().nonnegative(),
+  expiresAt: z11.number().int().nonnegative()
+});
+var signedPolicySnapshotSchema = z11.strictObject({
+  algorithm: z11.literal("Ed25519"),
+  keyId: digest,
+  payload: policySnapshotPayloadSchema,
+  signature: z11.string().regex(/^[A-Za-z0-9_-]{86}$/)
+});
+var policyDistributionContextSchema = z11.strictObject({
+  version: z11.literal(1),
+  algorithm: z11.literal("Ed25519"),
+  keyId: digest,
+  publicKey: z11.string().regex(/^[A-Za-z0-9_-]{59}$/),
+  issuer: z11.url().max(1e3),
+  ownerId: id,
+  deviceId: id,
+  runId: id,
+  revision: digest,
+  scope: policyScopeSchema,
+  required: z11.boolean()
+});
 
 // ../protocol/src/skill.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // ../protocol/src/skill-artifact.ts
-import { z as z11 } from "zod";
-var skillArtifactRefSchema = z11.object({
-  schemaVersion: z11.literal(1),
-  registryId: z11.enum(["mikka-builtin", "mikka-team"]),
-  skillId: z11.uuid(),
-  versionId: z11.uuid(),
-  format: z11.literal("single-skill-md-v1"),
-  sha256: z11.string().regex(/^[a-f0-9]{64}$/)
+import { z as z12 } from "zod";
+var skillArtifactRefSchema = z12.object({
+  schemaVersion: z12.literal(1),
+  registryId: z12.enum(["mikka-builtin", "mikka-team"]),
+  skillId: z12.uuid(),
+  versionId: z12.uuid(),
+  format: z12.literal("single-skill-md-v1"),
+  sha256: z12.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var skillAssignmentReceiptSchema = z11.object({
-  id: z11.uuid(),
-  runId: z11.uuid(),
-  issueId: z11.uuid(),
-  agentId: z11.uuid(),
-  repoId: z11.uuid(),
-  deviceId: z11.uuid(),
-  leaseExpiresAt: z11.iso.datetime(),
-  assignedAt: z11.iso.datetime(),
+var skillAssignmentReceiptSchema = z12.object({
+  id: z12.uuid(),
+  runId: z12.uuid(),
+  issueId: z12.uuid(),
+  agentId: z12.uuid(),
+  repoId: z12.uuid(),
+  deviceId: z12.uuid(),
+  leaseExpiresAt: z12.iso.datetime(),
+  assignedAt: z12.iso.datetime(),
   artifact: skillArtifactRefSchema
 }).strict();
-var skillReceiptRevalidationSchema = z11.object({
+var skillReceiptRevalidationSchema = z12.object({
   skillReceipt: skillAssignmentReceiptSchema,
-  leaseExpiresAt: z11.iso.datetime()
+  leaseExpiresAt: z12.iso.datetime()
 }).strict();
 
 // ../protocol/src/skill.ts
@@ -2762,43 +2804,43 @@ var MAX_SKILL_INSTRUCTIONS_LENGTH = 2e4;
 var MAX_SKILL_FILES = 20;
 var MAX_SKILL_FILE_PATH_LENGTH = 200;
 var MAX_SKILL_FILE_CONTENT_LENGTH = 1e5;
-var skillFilePathSchema = z12.string().min(1).max(MAX_SKILL_FILE_PATH_LENGTH).refine(
+var skillFilePathSchema = z13.string().min(1).max(MAX_SKILL_FILE_PATH_LENGTH).refine(
   (path) => !path.startsWith("/") && !path.includes("\\") && !path.split("/").some((segment) => segment === ".." || segment === ""),
   { message: "A skill file path must be relative and stay inside the skill." }
 );
-var skillFileSchema = z12.object({
+var skillFileSchema = z13.object({
   path: skillFilePathSchema,
-  content: z12.string().max(MAX_SKILL_FILE_CONTENT_LENGTH)
-});
-var skillFilesSchema = z12.array(skillFileSchema).max(MAX_SKILL_FILES);
-var skillNameSchema = z12.string().trim().min(1).max(MAX_SKILL_NAME_LENGTH);
-var skillDescriptionSchema = z12.string().trim().max(MAX_SKILL_DESCRIPTION_LENGTH);
-var skillInstructionsSchema = z12.string().trim().min(1).max(MAX_SKILL_INSTRUCTIONS_LENGTH);
-var runSkillSchema = z12.object({
-  id: z12.uuid(),
+  content: z13.string().max(MAX_SKILL_FILE_CONTENT_LENGTH)
+});
+var skillFilesSchema = z13.array(skillFileSchema).max(MAX_SKILL_FILES);
+var skillNameSchema = z13.string().trim().min(1).max(MAX_SKILL_NAME_LENGTH);
+var skillDescriptionSchema = z13.string().trim().max(MAX_SKILL_DESCRIPTION_LENGTH);
+var skillInstructionsSchema = z13.string().trim().min(1).max(MAX_SKILL_INSTRUCTIONS_LENGTH);
+var runSkillSchema = z13.object({
+  id: z13.uuid(),
   name: skillNameSchema,
-  description: z12.string().nullable(),
+  description: z13.string().nullable(),
   instructions: skillInstructionsSchema,
   files: skillFilesSchema
 });
-var runSkillRefSchema = z12.object({
-  id: z12.uuid(),
+var runSkillRefSchema = z13.object({
+  id: z13.uuid(),
   name: skillNameSchema
 });
 
 // ../protocol/src/device.ts
-var id = z13.string().min(1).max(64);
-var isoTime = z13.iso.datetime({ offset: true });
-var deviceComputerCapability = z13.object({ installed: z13.boolean(), version: z13.string().max(100).nullable() }).strict();
-var deviceRegistration = z13.object({
-  deviceType: z13.enum(["laptop", "server"]).optional(),
-  name: z13.string().trim().min(1).max(200),
-  hostname: z13.string().max(255).nullable().optional(),
-  platform: z13.string().max(50),
-  arch: z13.string().max(50),
-  daemonVersion: z13.string().max(50),
-  protocolVersion: z13.number().int(),
-  harnesses: z13.array(harnessInfoSchema).max(20),
+var id2 = z14.string().min(1).max(64);
+var isoTime = z14.iso.datetime({ offset: true });
+var deviceComputerCapability = z14.object({ installed: z14.boolean(), version: z14.string().max(100).nullable() }).strict();
+var deviceRegistration = z14.object({
+  deviceType: z14.enum(["laptop", "server"]).optional(),
+  name: z14.string().trim().min(1).max(200),
+  hostname: z14.string().max(255).nullable().optional(),
+  platform: z14.string().max(50),
+  arch: z14.string().max(50),
+  daemonVersion: z14.string().max(50),
+  protocolVersion: z14.number().int(),
+  harnesses: z14.array(harnessInfoSchema).max(20),
   computerUse: deviceComputerCapability.optional(),
   /**
    * This machine's one device id, the same in every workspace (ADR ORV-284).
@@ -2806,104 +2848,104 @@ var deviceRegistration = z13.object({
    * An id the server does not know yet becomes the new device's id; another
    * person's id registers a new device.
    */
-  deviceId: id.optional(),
+  deviceId: id2.optional(),
   /** Needed only when the user belongs to more than one workspace. */
-  workspaceId: z13.uuid().optional()
+  workspaceId: z14.uuid().optional()
 });
-var deviceRegistered = z13.object({
-  deviceId: id,
-  workspaceId: z13.uuid()
+var deviceRegistered = z14.object({
+  deviceId: id2,
+  workspaceId: z14.uuid()
 });
-var heartbeatRunSchema = z13.object({
-  runId: id,
+var heartbeatRunSchema = z14.object({
+  runId: id2,
   /** Last tool call, turn boundary or file change (not raw output). */
   lastProgressAt: isoTime
 });
-var deviceManagementCommand = z13.object({ id: z13.uuid(), kind: z13.enum(["redetect", "restart", "update", "uninstall"]) });
-var deviceHeartbeatSchema = z13.object({
-  completedDeviceCommands: z13.array(z13.uuid()).max(100).optional(),
-  failedDeviceCommands: z13.array(z13.object({ id: z13.uuid(), error: z13.string().max(500) })).max(100).optional(),
-  harnesses: z13.array(harnessInfoSchema).max(20),
+var deviceManagementCommand = z14.object({ id: z14.uuid(), kind: z14.enum(["redetect", "restart", "update", "uninstall"]) });
+var deviceHeartbeatSchema = z14.object({
+  completedDeviceCommands: z14.array(z14.uuid()).max(100).optional(),
+  failedDeviceCommands: z14.array(z14.object({ id: z14.uuid(), error: z14.string().max(500) })).max(100).optional(),
+  harnesses: z14.array(harnessInfoSchema).max(20),
   computerUse: deviceComputerCapability.optional(),
-  deviceType: z13.enum(["laptop", "server"]).optional(),
-  runs: z13.array(heartbeatRunSchema).max(500),
-  worktreeDiskBytes: z13.number().int().nonnegative(),
+  deviceType: z14.enum(["laptop", "server"]).optional(),
+  runs: z14.array(heartbeatRunSchema).max(500),
+  worktreeDiskBytes: z14.number().int().nonnegative(),
   /**
    * Subscription windows read on this device. Absent when the daemon is not
    * polling. Numbers only, never a vendor credential (ADR 0027).
    */
-  quotas: z13.array(quotaSnapshotSchema).max(6).optional()
+  quotas: z14.array(quotaSnapshotSchema).max(6).optional()
 });
-var heartbeatResultSchema = z13.object({
-  deviceCommands: z13.array(deviceManagementCommand).max(1).optional(),
+var heartbeatResultSchema = z14.object({
+  deviceCommands: z14.array(deviceManagementCommand).max(1).optional(),
   /** Renewed lease expiry per run id; a run missing here is not renewed. */
-  leases: z13.record(z13.string(), isoTime),
+  leases: z14.record(z14.string(), isoTime),
   /**
    * Runs the device reported that it no longer holds: they ended on the
    * server, or went to another attempt after the lease ran out. The daemon
    * stops them now instead of when their lease runs out.
    */
-  revoked: z13.array(id).max(500).optional(),
+  revoked: z14.array(id2).max(500).optional(),
   /** Short-lived cloud device token, returned only over its authenticated link. */
-  cloudCredential: z13.string().regex(/^orv_[A-Za-z0-9_-]{43}$/).optional()
+  cloudCredential: z14.string().regex(/^orv_[A-Za-z0-9_-]{43}$/).optional()
 });
 var RUN_CHECKPOINT_MAX_BYTES = 8 * 1024 * 1024;
 var RUN_CHECKPOINT_RECOVERY_MAX_AGE_MS = 30 * 6e4;
-var runCheckpointSchema = z13.object({
+var runCheckpointSchema = z14.object({
   /** The commit the run's worktree started from. */
-  baseCommit: z13.string().regex(/^[0-9a-f]{40,64}$/),
+  baseCommit: z14.string().regex(/^[0-9a-f]{40,64}$/),
   /**
    * `git diff --binary` from `baseCommit` to the whole worktree (tracked
    * and untracked files, ignored ones left out, the agent's own commits
    * included), gzipped, base64.
    */
-  patch: z13.string().max(Math.ceil(RUN_CHECKPOINT_MAX_BYTES * 4 / 3) + 4),
+  patch: z14.string().max(Math.ceil(RUN_CHECKPOINT_MAX_BYTES * 4 / 3) + 4),
   /** Files the patch touches. */
-  files: z13.number().int().nonnegative(),
+  files: z14.number().int().nonnegative(),
   takenAt: isoTime,
   /** The latest tree could not be checkpointed; it supersedes older patches. */
-  unavailableReason: z13.literal("too_large").optional()
+  unavailableReason: z14.literal("too_large").optional()
 });
-var setupRecipeSchema = z13.object({
+var setupRecipeSchema = z14.object({
   /** Paths relative to the main checkout copied into each new worktree. */
-  copyFiles: z13.array(z13.string().max(1e3)).max(200),
+  copyFiles: z14.array(z14.string().max(1e3)).max(200),
   /** Shell command run in the worktree, e.g. `bun install`. */
-  command: z13.string().max(2e3).optional(),
+  command: z14.string().max(2e3).optional(),
   /** Approved once per repo by the user; unapproved recipes never run. */
-  approved: z13.boolean()
+  approved: z14.boolean()
 });
-var deviceRepoSchema = z13.object({
-  repoId: id,
-  name: z13.string().max(500),
+var deviceRepoSchema = z14.object({
+  repoId: id2,
+  name: z14.string().max(500),
   /** Logical repository key; only trusted cloud runtimes use an absolute path. */
-  path: z13.string().min(1).max(4e3),
-  remoteUrl: z13.string().max(2e3).nullable().optional(),
+  path: z14.string().min(1).max(4e3),
+  remoteUrl: z14.string().max(2e3).nullable().optional(),
   setup: setupRecipeSchema.optional(),
   /** Domains agents may reach in this repo, on top of the harness's own. */
-  networkAllow: z13.array(z13.string().min(1).max(253)).max(200).optional(),
+  networkAllow: z14.array(z14.string().min(1).max(253)).max(200).optional(),
   /** Push run branches after a verified hand-in ("always for this repo"). */
-  push: z13.object({
-    approved: z13.boolean(),
-    remote: z13.string().min(1).max(200).optional()
+  push: z14.object({
+    approved: z14.boolean(),
+    remote: z14.string().min(1).max(200).optional()
   }).optional()
 });
-var deviceReposResponse = z13.object({
-  repos: z13.array(deviceRepoSchema)
+var deviceReposResponse = z14.object({
+  repos: z14.array(deviceRepoSchema)
 });
-var pendingRunsResponse = z13.object({ runIds: z13.array(id) });
+var pendingRunsResponse = z14.object({ runIds: z14.array(id2) });
 var RUN_KINDS = ["implement", "acceptance", "fix", "plan"];
-var runAssignmentSchema = z13.object({
-  runId: id,
-  issueId: id,
-  deviceId: id,
-  repoId: id,
+var runAssignmentSchema = z14.object({
+  runId: id2,
+  issueId: id2,
+  deviceId: id2,
+  repoId: id2,
   /** Clone URL for local runs; hosted computer assignments keep their isolated workspace. */
-  remoteUrl: z13.string().min(1).max(4e3).optional(),
+  remoteUrl: z14.string().min(1).max(4e3).optional(),
   /** Absent means origin/HEAD after fetch. */
-  baseBranch: z13.string().min(1).max(500).optional(),
-  expectedRepoRemote: z13.string().max(2e3).optional(),
+  baseBranch: z14.string().min(1).max(500).optional(),
+  expectedRepoRemote: z14.string().max(2e3).optional(),
   harness: harnessSchema,
-  prompt: z13.string().max(1e5),
+  prompt: z14.string().max(1e5),
   /**
    * The model the harness's CLI is asked to run, from the per-harness
    * preference of the person this run works for (ADR 0060). Absent: the
@@ -2912,42 +2954,42 @@ var runAssignmentSchema = z13.object({
    */
   model: modelNameSchema.optional(),
   /** Owner-bound selection only; no subscription credential enters the assignment. */
-  subscriptionBinding: z13.object({
-    bindingId: z13.uuid(),
-    ownerId: z13.string().min(1).max(128),
-    workspaceId: z13.uuid(),
-    consumerId: z13.uuid(),
-    route: z13.enum(["codex_cli", "claude_code_cli"])
+  subscriptionBinding: z14.object({
+    bindingId: z14.uuid(),
+    ownerId: z14.string().min(1).max(128),
+    workspaceId: z14.uuid(),
+    consumerId: z14.uuid(),
+    route: z14.enum(["codex_cli", "claude_code_cli"])
   }).strict().optional(),
   /** Local host authority comes only from the server's owner-bound Bot run. */
-  localComputer: z13.object({
-    botId: z13.uuid(),
-    ownerId: z13.string().min(1).max(128),
-    workspaceId: z13.uuid(),
-    policyVersion: z13.number().int().nonnegative().max(2147483647),
-    permission: z13.enum(["allow", "ask"])
+  localComputer: z14.object({
+    botId: z14.uuid(),
+    ownerId: z14.string().min(1).max(128),
+    workspaceId: z14.uuid(),
+    policyVersion: z14.number().int().nonnegative().max(2147483647),
+    permission: z14.enum(["allow", "ask"])
   }).strict().optional(),
   /** Trusted server assignment; the model cannot choose a Bot or display. */
-  computer: z13.object({
-    botId: z13.uuid(),
-    ownerId: z13.string().min(1).max(128),
-    display: z13.string().regex(/^:[1-9][0-9]{0,2}$/),
-    policyVersion: z13.number().int().nonnegative().max(2147483647)
+  computer: z14.object({
+    botId: z14.uuid(),
+    ownerId: z14.string().min(1).max(128),
+    display: z14.string().regex(/^:[1-9][0-9]{0,2}$/),
+    policyVersion: z14.number().int().nonnegative().max(2147483647)
   }).strict().optional(),
   /**
    * 4e3: the task's explicit user variables (workspace + matching repository secrets/env, NAME -> value).
    * Cloud workers only. Passed into the task container through its own channel, never into the worker's
    * env, and never written to the run journal.
    */
-  taskEnv: z13.record(z13.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), z13.string().max(65536)).optional(),
+  taskEnv: z14.record(z14.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), z14.string().max(65536)).optional(),
   /**
    * Names in `taskEnv` that are secrets (kind 'secret'; env vars are not listed). The daemon masks
    * their values (raw + standard base64) in run output before anything is uploaded; the server
    * masks again. Older daemons strip this field and rely on server-side masking only.
    */
-  taskSecretNames: z13.array(z13.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/)).max(500).optional(),
+  taskSecretNames: z14.array(z14.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/)).max(500).optional(),
   /** Mock harness only: fixture name under `packages/daemon/fixtures`. */
-  fixture: z13.string().max(200).optional(),
+  fixture: z14.string().max(200).optional(),
   /**
    * The issue's branch (`mikka/<team>-<number>`, ADR 0024): every run of
    * the issue pushes its verified commit here, so one pull request follows
@@ -2955,9 +2997,9 @@ var runAssignmentSchema = z13.object({
    * this branch from the remote when it exists. Without it the daemon
    * pushes the run's own branch.
    */
-  pushBranch: z13.string().min(1).max(250).optional(),
+  pushBranch: z14.string().min(1).max(250).optional(),
   /** Run by the daemon in the worktree after the agent submits. */
-  verifyCommand: z13.string().max(2e3).optional(),
+  verifyCommand: z14.string().max(2e3).optional(),
   /** Run lease; renewed through the device heartbeat. */
   leaseExpiresAt: isoTime.optional(),
   /**
@@ -2966,27 +3008,27 @@ var runAssignmentSchema = z13.object({
    * it stops working when the run ends. Absent: the server could not issue
    * one, and the run goes ahead without it.
    */
-  mcp: z13.object({ url: z13.url(), token: z13.string().min(1).max(200), mailbox: z13.literal(true).optional() }).optional(),
+  mcp: z14.object({ url: z14.url(), token: z14.string().min(1).max(200), mailbox: z14.literal(true).optional() }).optional(),
   /** Agent-owned GitHub delivery; the same run token exchanges short-lived credentials. */
-  github: z13.object({
-    endpoint: z13.url(),
-    repository: z13.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
-    branch: z13.string().regex(/^mikka\/[a-z0-9-]+-[1-9][0-9]*$/)
+  github: z14.object({
+    endpoint: z14.url(),
+    repository: z14.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
+    branch: z14.string().regex(/^mikka\/[a-z0-9-]+-[1-9][0-9]*$/)
   }).strict().optional(),
   /** Question continuation must not silently open a different session. */
   /**
    * What the orchestrator dispatched this run for (ADR 0023). `plan` writes a
    * spec and proposes a split instead of changing code (ADR ORV-205).
    */
-  kind: z13.enum(RUN_KINDS).optional(),
+  kind: z14.enum(RUN_KINDS).optional(),
   /**
    * The earlier run this one continues (continue, fix, answer, a person's
    * message): the daemon works on in that run's worktree, on this run's
    * branch, so nothing the earlier run left uncommitted is lost.
    */
-  continuesRunId: id.optional(),
+  continuesRunId: id2.optional(),
   /** A same-device retry with no usable snapshot must reuse its real worktree. */
-  requireWorktreeContinuation: z13.literal(true).optional(),
+  requireWorktreeContinuation: z14.literal(true).optional(),
   /**
    * The latest checkpoint of the attempt this run takes over after its
    * machine went offline. Used only for a new worktree (another machine, or
@@ -2999,37 +3041,40 @@ var runAssignmentSchema = z13.object({
    * The harness session to continue. A daemon that cannot resume starts a
    * new session with `prompt`, which always carries the full brief.
    */
-  resumeSessionId: z13.string().max(500).optional(),
-  requireSessionResume: z13.boolean().optional(),
-  preserveQuestionWorktree: z13.boolean().optional(),
-  questionId: z13.uuid().optional(),
+  resumeSessionId: z14.string().max(500).optional(),
+  requireSessionResume: z14.boolean().optional(),
+  preserveQuestionWorktree: z14.boolean().optional(),
+  questionId: z14.uuid().optional(),
   /**
    * What this run adds on top of the brief (a person's message, an answer,
    * a fix request). A resumed session gets only this as its next message;
    * a new session gets `prompt`, which already includes it.
    */
-  followUp: z13.string().max(1e5).optional(),
+  followUp: z14.string().max(1e5).optional(),
   /**
    * The workspace's agent permissions and network allow-list (ADR 0028).
    * Absent from an older server: the daemon applies the ADR 0009 defaults.
    */
   policy: runPolicySchema.optional(),
   /** Trusted server revision for the exact run policy; older servers omit it. */
-  policyRevision: z13.string().regex(/^[a-f0-9]{64}$/).optional(),
+  policyRevision: z14.string().regex(/^[a-f0-9]{64}$/).optional(),
+  /** Only a trusted server context can make a snapshot required. */
+  policySnapshotRequired: z14.boolean().optional(),
+  policySnapshot: signedPolicySnapshotSchema.optional(),
   /**
    * The skills mounted on this run's agent and still enabled, resolved at
    * claim time the way `policy` is. The daemon inlines them into the agent's
    * brief and writes them under the run's directory. Absent from an older
    * server: the run simply has none.
    */
-  skills: z13.array(runSkillSchema).max(MAX_SKILLS_PER_RUN).optional(),
+  skills: z14.array(runSkillSchema).max(MAX_SKILLS_PER_RUN).optional(),
   /** Server-minted assignment provenance; does not grant any policy permission. */
   skillReceipt: skillAssignmentReceiptSchema.optional(),
   /** Frozen by the server benchmark ledger; never extracted from model output. */
   benchmark: runBenchmarkContext.optional()
 });
-var runPatchSchema = z13.object({
-  state: z13.enum([
+var runPatchSchema = z14.object({
+  state: z14.enum([
     "queued",
     "preparing",
     "running",
@@ -3040,69 +3085,69 @@ var runPatchSchema = z13.object({
     "failed",
     "cancelled"
   ]),
-  sessionId: z13.string().max(500).nullable().optional(),
-  worktree: z13.string().max(4e3).nullable().optional(),
-  error: z13.string().max(1e4).nullable().optional(),
+  sessionId: z14.string().max(500).nullable().optional(),
+  worktree: z14.string().max(4e3).nullable().optional(),
+  error: z14.string().max(1e4).nullable().optional(),
   /** Set on every terminal state. */
   stopReason: runStopReason.optional()
 });
-var runEventBatchSchema = z13.object({
-  fromSeq: z13.number().int().min(1),
-  chunks: z13.array(z13.looseObject({ type: z13.string() })).min(1).max(1e3)
+var runEventBatchSchema = z14.object({
+  fromSeq: z14.number().int().min(1),
+  chunks: z14.array(z14.looseObject({ type: z14.string() })).min(1).max(1e3)
 });
-var runEventsAccepted = z13.object({
+var runEventsAccepted = z14.object({
   /** Producer seq of the last chunk the server holds for this run. */
-  offset: z13.string()
-});
-var runCommandSchema = z13.discriminatedUnion("kind", [
-  z13.object({
-    kind: z13.literal("input"),
-    runId: id,
-    messageId: z13.uuid(),
-    text: z13.string().min(1).max(1e5)
+  offset: z14.string()
+});
+var runCommandSchema = z14.discriminatedUnion("kind", [
+  z14.object({
+    kind: z14.literal("input"),
+    runId: id2,
+    messageId: z14.uuid(),
+    text: z14.string().min(1).max(1e5)
   }),
-  z13.object({ kind: z13.literal("stop"), runId: id })
+  z14.object({ kind: z14.literal("stop"), runId: id2 })
 ]);
-var runCommandsResponse = z13.object({
-  commands: z13.array(runCommandSchema).max(500)
+var runCommandsResponse = z14.object({
+  commands: z14.array(runCommandSchema).max(500)
 });
-var runCommandsAck = z13.object({
-  delivered: z13.array(z13.uuid()).max(500)
+var runCommandsAck = z14.object({
+  delivered: z14.array(z14.uuid()).max(500)
 });
 var FS_MAX_ENTRIES = 500;
-var fsBrowseRequest = z13.object({
+var fsBrowseRequest = z14.object({
   /** Absolute path on the device; omitted: the device's home folder. */
-  path: z13.string().trim().min(1).max(4e3).optional(),
-  showHidden: z13.boolean().optional()
+  path: z14.string().trim().min(1).max(4e3).optional(),
+  showHidden: z14.boolean().optional()
 });
-var fsPendingRequest = fsBrowseRequest.extend({ id: z13.uuid() });
-var fsRequestsResponse = z13.object({
-  requests: z13.array(fsPendingRequest).max(50)
+var fsPendingRequest = fsBrowseRequest.extend({ id: z14.uuid() });
+var fsRequestsResponse = z14.object({
+  requests: z14.array(fsPendingRequest).max(50)
 });
-var fsEntry = z13.object({
-  name: z13.string().max(1e3),
-  path: z13.string().max(4e3),
+var fsEntry = z14.object({
+  name: z14.string().max(1e3),
+  path: z14.string().max(4e3),
   /** The folder is the top level of a git repo (it has a `.git`). */
-  isRepo: z13.boolean()
+  isRepo: z14.boolean()
 });
-var fsListing = z13.object({
-  ok: z13.literal(true),
-  path: z13.string().max(4e3),
+var fsListing = z14.object({
+  ok: z14.literal(true),
+  path: z14.string().max(4e3),
   /** Null at the filesystem root. */
-  parent: z13.string().max(4e3).nullable(),
-  home: z13.string().max(4e3),
+  parent: z14.string().max(4e3).nullable(),
+  home: z14.string().max(4e3),
   /** `darwin`, `linux`, `win32`: for path separators and wording. */
-  platform: z13.string().max(50),
-  entries: z13.array(fsEntry).max(FS_MAX_ENTRIES),
+  platform: z14.string().max(50),
+  entries: z14.array(fsEntry).max(FS_MAX_ENTRIES),
   /** More folders existed than `FS_MAX_ENTRIES`. */
-  truncated: z13.boolean(),
+  truncated: z14.boolean(),
   /**
    * The git repo `path` is in, if any: its top level and `origin` (or the
    * first remote). This is what `device.addRepo` should be given.
    */
-  repo: z13.object({
-    path: z13.string().max(4e3),
-    remoteUrl: z13.string().max(2e3).nullable()
+  repo: z14.object({
+    path: z14.string().max(4e3),
+    remoteUrl: z14.string().max(2e3).nullable()
   }).nullable()
 });
 var FS_ERROR_CODES = [
@@ -3111,46 +3156,46 @@ var FS_ERROR_CODES = [
   "denied",
   "failed"
 ];
-var fsFailure = z13.object({
-  ok: z13.literal(false),
-  code: z13.enum(FS_ERROR_CODES),
-  message: z13.string().max(1e3)
+var fsFailure = z14.object({
+  ok: z14.literal(false),
+  code: z14.enum(FS_ERROR_CODES),
+  message: z14.string().max(1e3)
 });
-var fsResult = z13.discriminatedUnion("ok", [fsListing, fsFailure]);
+var fsResult = z14.discriminatedUnion("ok", [fsListing, fsFailure]);
 
 // ../protocol/src/orchestrator.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var minutes = (n) => n * 6e4;
-var orchestratorSettingsSchema = z14.object({
+var orchestratorSettingsSchema = z15.object({
   /** "Continue" prompts after a turn ended without a submit. */
-  maxContinuations: z14.number().int().min(0).max(20).default(3),
+  maxContinuations: z15.number().int().min(0).max(20).default(3),
   /** Resumes after the CLI crashed, before one fresh session. */
-  maxCrashRetries: z14.number().int().min(0).max(20).default(3),
+  maxCrashRetries: z15.number().int().min(0).max(20).default(3),
   /** Fix rounds after the daemon's verify failed. */
-  maxFixAttempts: z14.number().int().min(0).max(20).default(3),
+  maxFixAttempts: z15.number().int().min(0).max(20).default(3),
   /** "You seem stuck" prompts after a run stalled. */
-  maxStallRecoveries: z14.number().int().min(0).max(20).default(2),
+  maxStallRecoveries: z15.number().int().min(0).max(20).default(2),
   /** No progress for this long while the lease is fresh = stalled. */
-  stalledAfterMs: z14.number().int().min(minutes(1)).default(minutes(10)),
+  stalledAfterMs: z15.number().int().min(minutes(1)).default(minutes(10)),
   /** A device offline this long is handed to a person (no auto switch). */
-  deviceOfflineEscalateMs: z14.number().int().min(0).default(minutes(30)),
+  deviceOfflineEscalateMs: z15.number().int().min(0).default(minutes(30)),
   /** An unanswered question frees its concurrency slot after this. */
-  questionSlotReleaseMs: z14.number().int().min(0).default(minutes(24 * 60)),
+  questionSlotReleaseMs: z15.number().int().min(0).default(minutes(24 * 60)),
   /** Automatic dispatches per issue per hour before a person looks. */
-  maxDispatchesPerHour: z14.number().int().min(1).max(100).default(6),
+  maxDispatchesPerHour: z15.number().int().min(1).max(100).default(6),
   /** Wait before resuming a run that hit its quota (no reset time known). */
-  quotaBackoffMs: z14.number().int().min(0).default(minutes(15)),
+  quotaBackoffMs: z15.number().int().min(0).default(minutes(15)),
   /**
    * How often an issue waiting on its pull request or CI asks GitHub again
    * when no webhook arrived (ADR 0024).
    */
-  ciRecheckMs: z14.number().int().min(3e4).default(minutes(2)),
+  ciRecheckMs: z15.number().int().min(3e4).default(minutes(2)),
   /** A pushed commit with no checks after this long has no CI: it passes. */
-  ciNoChecksMs: z14.number().int().min(0).default(minutes(5)),
+  ciNoChecksMs: z15.number().int().min(0).default(minutes(5)),
   /** CI still running after this long goes to a person. */
-  ciTimeoutMs: z14.number().int().min(minutes(5)).default(minutes(120)),
+  ciTimeoutMs: z15.number().int().min(minutes(5)).default(minutes(120)),
   /** Remote URL of the repo this project's issues run in. */
-  repoUrl: z14.string().max(2e3).optional()
+  repoUrl: z15.string().max(2e3).optional()
 });
 var CRASH_BACKOFF_MS = [1e4, 6e4, minutes(5)];
 var UPSTREAM_RECHECK_MS = minutes(5);
@@ -3194,30 +3239,30 @@ var WAIT_DETAIL_CODES = [
   ...PERSON_WAIT_DETAIL_CODES,
   ...EXTERNAL_WAIT_DETAIL_CODES
 ];
-var waitDetailSchema = z14.object({
-  code: z14.enum(WAIT_DETAIL_CODES),
-  params: z14.record(
-    z14.string(),
-    z14.union([
-      z14.string(),
-      z14.number(),
-      z14.array(z14.string()),
+var waitDetailSchema = z15.object({
+  code: z15.enum(WAIT_DETAIL_CODES),
+  params: z15.record(
+    z15.string(),
+    z15.union([
+      z15.string(),
+      z15.number(),
+      z15.array(z15.string()),
       // `repo_ambiguous`: the repos a person can pick from.
-      z14.array(z14.record(z14.string(), z14.string()))
+      z15.array(z15.record(z15.string(), z15.string()))
     ])
   ).optional()
 });
-var prChecksSchema = z14.object({
-  state: z14.enum(["pending", "success", "failure", "none"]),
+var prChecksSchema = z15.object({
+  state: z15.enum(["pending", "success", "failure", "none"]),
   /** Failed checks, for the fix round's brief and the issue page. */
-  failing: z14.array(
-    z14.object({
-      name: z14.string().max(500),
-      summary: z14.string().max(4e3).optional(),
-      url: z14.string().max(2e3).optional()
+  failing: z15.array(
+    z15.object({
+      name: z15.string().max(500),
+      summary: z15.string().max(4e3).optional(),
+      url: z15.string().max(2e3).optional()
     })
   ).max(50),
-  total: z14.number().int().min(0)
+  total: z15.number().int().min(0)
 });
 var DEFAULT_BRANCH_TEMPLATE = "mikka/{team}-{number}";
 var BRANCH_FORBIDDEN = /[\s~^:?*[\\]|\.\.|@\{|\/\/|^\/|\/$/;
@@ -3226,29 +3271,29 @@ var hasControlCharacter = (value) => [...value].some((char) => {
   const code = char.charCodeAt(0);
   return code < 32 || code === 127;
 });
-var branchTemplateSchema = z14.string().trim().min(1).max(200).refine((value) => value.includes("{number}"), {
+var branchTemplateSchema = z15.string().trim().min(1).max(200).refine((value) => value.includes("{number}"), {
   message: "The template must contain {number}."
 }).refine(
   (value) => !BRANCH_FORBIDDEN.test(value) && !hasControlCharacter(value),
   { message: BRANCH_FORBIDDEN_HINT }
 );
-var prBodyTemplateSchema = z14.string().max(2e4).nullable().optional();
+var prBodyTemplateSchema = z15.string().max(2e4).nullable().optional();
 var REVIEW_CHECK_HARNESSES = [
   "claude_code",
   "codex",
   "cursor"
 ];
-var reviewRuleSchema = z14.object({
+var reviewRuleSchema = z15.object({
   /** In Review needs an open pull request for the issue's branch (ADR 0024). */
-  requirePullRequest: z14.boolean().default(true),
+  requirePullRequest: z15.boolean().default(true),
   /** ... and green CI on it. Ignored when no pull request is required. */
-  requireCi: z14.boolean().default(true),
+  requireCi: z15.boolean().default(true),
   /**
    * The harness that must run the read-only check (ADR 0046). Null: any
    * second agent on the device. A configured harness the device does not run
    * means no check runs, exactly as if the device had no second agent.
    */
-  checkHarness: z14.enum(REVIEW_CHECK_HARNESSES).nullable().default(null),
+  checkHarness: z15.enum(REVIEW_CHECK_HARNESSES).nullable().default(null),
   branchTemplate: branchTemplateSchema.default(DEFAULT_BRANCH_TEMPLATE),
   /** `{key}`, `{title}` and `{summary}`; null keeps Mikka's default text. */
   prBodyTemplate: prBodyTemplateSchema.default(null)
@@ -3273,9 +3318,9 @@ var WEB_PLATFORM = Object.freeze({
 });
 
 // ../protocol/src/preview.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var PREVIEW_MAX_LENGTH = 5 * 1024 * 1024;
-var previewHtml = z15.string().max(PREVIEW_MAX_LENGTH);
+var previewHtml = z16.string().max(PREVIEW_MAX_LENGTH);
 var DIRECTIVES = [
   "default-src 'none'",
   "script-src 'unsafe-inline'",
@@ -3292,13 +3337,13 @@ var PREVIEW_CSP_HEADER = ["sandbox allow-scripts", ...DIRECTIVES].join(
 var META = `<meta http-equiv="Content-Security-Policy" content="${DIRECTIVES.join("; ")}">`;
 
 // ../protocol/src/profile.ts
-import { z as z16 } from "zod";
-var usernameSchema = z16.string().trim().min(3, "At least 3 characters.").max(32, "At most 32 characters.").regex(
+import { z as z17 } from "zod";
+var usernameSchema = z17.string().trim().min(3, "At least 3 characters.").max(32, "At most 32 characters.").regex(
   /^[a-z0-9][a-z0-9_-]*$/,
   "Start with a letter or digit; lowercase letters, digits, - and _ only."
 );
-var displayNameSchema = z16.string().trim().min(1, "A name is required.").max(80, "At most 80 characters.");
-var avatarUrlSchema = z16.url().max(2048).refine((value) => /^https?:\/\//.test(value), "Use an http(s) URL.");
+var displayNameSchema = z17.string().trim().min(1, "A name is required.").max(80, "At most 80 characters.");
+var avatarUrlSchema = z17.url().max(2048).refine((value) => /^https?:\/\//.test(value), "Use an http(s) URL.");
 var AVATAR_MAX_BYTES = 5 * 1024 * 1024;
 var AVATAR_CONTENT_TYPES = [
   "image/png",
@@ -3306,16 +3351,16 @@ var AVATAR_CONTENT_TYPES = [
   "image/webp",
   "image/gif"
 ];
-var avatarPresignRequest = z16.object({
-  contentType: z16.enum(AVATAR_CONTENT_TYPES),
+var avatarPresignRequest = z17.object({
+  contentType: z17.enum(AVATAR_CONTENT_TYPES),
   /** Bytes, checked against AVATAR_MAX_BYTES. */
-  size: z16.number().int().positive()
+  size: z17.number().int().positive()
 });
-var avatarPresignResponse = z16.object({
-  uploadUrl: z16.url(),
+var avatarPresignResponse = z17.object({
+  uploadUrl: z17.url(),
   /** What to store in `user.image` once the PUT has succeeded. */
   publicUrl: avatarUrlSchema,
-  expiresIn: z16.number().int().positive()
+  expiresIn: z17.number().int().positive()
 });
 
 // ../protocol/src/relay.ts
@@ -3324,31 +3369,31 @@ import {
   safeValidateUIMessages,
   uiMessageChunkSchema
 } from "ai";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var RELAY_PROTOCOL_VERSION = 1;
 var MAX_INPUT_LENGTH = 2e4;
-var uuid = z17.uuid();
-var runEvent = z17.discriminatedUnion("kind", [
+var uuid = z18.uuid();
+var runEvent = z18.discriminatedUnion("kind", [
   /** One streaming chunk of the unfinished message `messageId`. */
-  z17.object({
-    kind: z17.literal("chunk"),
+  z18.object({
+    kind: z18.literal("chunk"),
     messageId: uuid,
-    chunk: z17.looseObject({ type: z17.string() })
+    chunk: z18.looseObject({ type: z18.string() })
   }),
   /** A finished message; persisted as a `message` row, then fanned out. */
-  z17.object({
-    kind: z17.literal("message.final"),
+  z18.object({
+    kind: z18.literal("message.final"),
     /** Order of the message within the run. */
-    seq: z17.number().int().min(0),
-    message: z17.looseObject({
+    seq: z18.number().int().min(0),
+    message: z18.looseObject({
       id: uuid,
-      role: z17.enum(["system", "user", "assistant"]),
-      parts: z17.array(z17.looseObject({ type: z17.string() }))
+      role: z18.enum(["system", "user", "assistant"]),
+      parts: z18.array(z18.looseObject({ type: z18.string() }))
     })
   }),
-  z17.object({
-    kind: z17.literal("run.status"),
-    status: z17.enum([
+  z18.object({
+    kind: z18.literal("run.status"),
+    status: z18.enum([
       "queued",
       "preparing",
       "running",
@@ -3361,48 +3406,48 @@ var runEvent = z17.discriminatedUnion("kind", [
   })
 ]);
 var chunkSchema = asSchema(uiMessageChunkSchema);
-var v = z17.literal(RELAY_PROTOCOL_VERSION);
-var presenceView = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("issue"), id: uuid }),
-  z17.object({ type: z17.literal("project"), id: uuid })
+var v = z18.literal(RELAY_PROTOCOL_VERSION);
+var presenceView = z18.discriminatedUnion("type", [
+  z18.object({ type: z18.literal("issue"), id: uuid }),
+  z18.object({ type: z18.literal("project"), id: uuid })
 ]);
-var relayClientMessage = z17.discriminatedUnion("type", [
-  z17.object({
+var relayClientMessage = z18.discriminatedUnion("type", [
+  z18.object({
     v,
-    type: z17.literal("subscribe"),
+    type: z18.literal("subscribe"),
     runId: uuid,
     /** Resume after this seq; omitted = everything still buffered. */
-    after: z17.number().int().min(0).optional()
+    after: z18.number().int().min(0).optional()
   }),
-  z17.object({ v, type: z17.literal("unsubscribe"), runId: uuid }),
-  z17.object({ v, type: z17.literal("publish"), runId: uuid, event: runEvent }),
+  z18.object({ v, type: z18.literal("unsubscribe"), runId: uuid }),
+  z18.object({ v, type: z18.literal("publish"), runId: uuid, event: runEvent }),
   /**
    * A person's message to the running agent (ADR 0018). Saved as a `user`
    * message row with this id (a re-send with the same id is applied once),
    * then handed to the run's daemon, which marks it delivered.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("send"),
+    type: z18.literal("send"),
     runId: uuid,
     messageId: uuid,
-    text: z17.string().trim().min(1).max(MAX_INPUT_LENGTH)
+    text: z18.string().trim().min(1).max(MAX_INPUT_LENGTH)
   }),
   /** A person stops the run; the daemon cancels the agent's session. */
-  z17.object({ v, type: z17.literal("stop"), runId: uuid }),
+  z18.object({ v, type: z18.literal("stop"), runId: uuid }),
   /**
    * Says where this connection is looking, in one workspace (ADR 0049). Sent
    * once when a page opens and again every `PRESENCE_HEARTBEAT_MS`; `view`
    * null keeps the member online without naming a page. Never persisted.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("presence"),
+    type: z18.literal("presence"),
     workspaceId: uuid,
     view: presenceView.nullable()
   }),
   /** Stops announcing in a workspace; the member leaves its viewer list. */
-  z17.object({ v, type: z17.literal("presence.leave"), workspaceId: uuid })
+  z18.object({ v, type: z18.literal("presence.leave"), workspaceId: uuid })
 ]);
 var RELAY_ERROR_CODES = [
   "bad_message",
@@ -3416,217 +3461,217 @@ var RELAY_ERROR_CODES = [
   /** `presence` for a workspace the caller is not a member of (ADR 0049). */
   "not_a_member"
 ];
-var relayErrorCode = z17.enum(RELAY_ERROR_CODES);
-var relayServerMessage = z17.discriminatedUnion("type", [
-  z17.object({
+var relayErrorCode = z18.enum(RELAY_ERROR_CODES);
+var relayServerMessage = z18.discriminatedUnion("type", [
+  z18.object({
     v,
-    type: z17.literal("subscribed"),
+    type: z18.literal("subscribed"),
     runId: uuid,
-    latestSeq: z17.number().int().min(0)
+    latestSeq: z18.number().int().min(0)
   }),
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("event"),
+    type: z18.literal("event"),
     runId: uuid,
-    seq: z17.number().int().min(1),
+    seq: z18.number().int().min(1),
     event: runEvent
   }),
   /**
    * `send` / `stop` was saved and is on its way to the run's device.
    * `messageId` is set for `send`.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("accepted"),
+    type: z18.literal("accepted"),
     runId: uuid,
-    request: z17.enum(["send", "stop"]),
+    request: z18.enum(["send", "stop"]),
     messageId: uuid.optional()
   }),
   /** Publisher acknowledgment with the seq the hub assigned. */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("ack"),
+    type: z18.literal("ack"),
     runId: uuid,
-    seq: z17.number().int().min(1)
+    seq: z18.number().int().min(1)
   }),
   /**
    * Everyone the server sees online in this workspace, and where each is
    * looking (ADR 0049). A snapshot after every change, so a client never has
    * to merge deltas; `lastSeenAt` is the server's clock.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("presence"),
+    type: z18.literal("presence"),
     workspaceId: uuid,
-    members: z17.array(
-      z17.object({
+    members: z18.array(
+      z18.object({
         userId: uuid,
         view: presenceView.nullable(),
-        lastSeenAt: z17.number().int()
+        lastSeenAt: z18.number().int()
       })
     )
   }),
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("error"),
+    type: z18.literal("error"),
     code: relayErrorCode,
-    message: z17.string(),
+    message: z18.string(),
     runId: uuid.optional(),
-    minVersion: z17.string().optional()
+    minVersion: z18.string().optional()
   })
 ]);
 
 // ../protocol/src/version.ts
 var import_semver = __toESM(require_semver2(), 1);
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var CLIENT_VERSION_HEADER = "x-mikka-client-version";
 var CLIENT_KINDS = ["desktop", "mobile"];
-var clientKind = z18.enum(CLIENT_KINDS);
-var updateRequiredError = z18.object({
-  error: z18.literal("update_required"),
-  minVersion: z18.string(),
-  message: z18.string()
+var clientKind = z19.enum(CLIENT_KINDS);
+var updateRequiredError = z19.object({
+  error: z19.literal("update_required"),
+  minVersion: z19.string(),
+  message: z19.string()
 });
 
 // ../protocol/src/coordinator.ts
-import { z as z19 } from "zod";
-var coordinatorRuntimeSchema = z19.discriminatedUnion("harness", [
-  z19.object({ harness: z19.literal("ai_sdk") }).strict(),
-  z19.object({ harness: z19.enum(["claude_code", "codex"]), deviceId: z19.uuid(), model: z19.string().trim().min(1).max(120).optional() }).strict()
+import { z as z20 } from "zod";
+var coordinatorRuntimeSchema = z20.discriminatedUnion("harness", [
+  z20.object({ harness: z20.literal("ai_sdk") }).strict(),
+  z20.object({ harness: z20.enum(["claude_code", "codex"]), deviceId: z20.uuid(), model: z20.string().trim().min(1).max(120).optional() }).strict()
 ]);
-var coordinatorToolSpecSchema = z19.object({
-  name: z19.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/),
-  description: z19.string().max(2e4),
-  inputSchema: z19.record(z19.string(), z19.unknown())
-});
-var nativeCoordinatorJobSchema = z19.object({
-  id: z19.uuid(),
-  harness: z19.enum(["claude_code", "codex"]),
-  model: z19.string().optional(),
-  instructions: z19.string().min(1).max(2e5),
-  context: z19.string().min(1).max(5e5),
-  tools: z19.array(coordinatorToolSpecSchema).max(100),
-  expiresAt: z19.iso.datetime()
-});
-var nativeCoordinatorClaimSchema = z19.object({ job: nativeCoordinatorJobSchema.nullable() });
-var nativeCoordinatorCommandSchema = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("tool"), callId: z19.string().min(1).max(200), name: z19.string().min(1).max(64), input: z19.record(z19.string(), z19.unknown()) }).strict(),
-  z19.object({ type: z19.literal("complete"), text: z19.string().min(1).max(2e5).refine((value) => value.trim().length > 0) }).strict(),
-  z19.object({ type: z19.literal("failed") }).strict()
+var coordinatorToolSpecSchema = z20.object({
+  name: z20.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/),
+  description: z20.string().max(2e4),
+  inputSchema: z20.record(z20.string(), z20.unknown())
+});
+var nativeCoordinatorJobSchema = z20.object({
+  id: z20.uuid(),
+  harness: z20.enum(["claude_code", "codex"]),
+  model: z20.string().optional(),
+  instructions: z20.string().min(1).max(2e5),
+  context: z20.string().min(1).max(5e5),
+  tools: z20.array(coordinatorToolSpecSchema).max(100),
+  expiresAt: z20.iso.datetime()
+});
+var nativeCoordinatorClaimSchema = z20.object({ job: nativeCoordinatorJobSchema.nullable() });
+var nativeCoordinatorCommandSchema = z20.discriminatedUnion("type", [
+  z20.object({ type: z20.literal("tool"), callId: z20.string().min(1).max(200), name: z20.string().min(1).max(64), input: z20.record(z20.string(), z20.unknown()) }).strict(),
+  z20.object({ type: z20.literal("complete"), text: z20.string().min(1).max(2e5).refine((value) => value.trim().length > 0) }).strict(),
+  z20.object({ type: z20.literal("failed") }).strict()
 ]);
-var nativeCoordinatorToolResultSchema = z19.discriminatedUnion("status", [
-  z19.object({ status: z19.literal("pending") }),
-  z19.object({ status: z19.literal("done"), output: z19.unknown() })
+var nativeCoordinatorToolResultSchema = z20.discriminatedUnion("status", [
+  z20.object({ status: z20.literal("pending") }),
+  z20.object({ status: z20.literal("done"), output: z20.unknown() })
 ]);
 
 // ../protocol/src/computer.ts
-import { z as z20 } from "zod";
-var machineStateSchema = z20.enum(["sleeping", "waking", "running", "error"]);
-var controlStateSchema = z20.enum(["agent", "user", "idle"]);
-var computerToolSchema = z20.enum(["click", "type", "key", "scroll", "screenshot"]);
-var screenRectSchema = z20.object({ x: z20.number(), y: z20.number(), w: z20.number().nonnegative(), h: z20.number().nonnegative() });
-var computerActionSchema = z20.object({ tool: computerToolSchema, x: z20.number().optional(), y: z20.number().optional(), text: z20.string().optional(), rect: screenRectSchema.optional() });
-var lastActionSchema = computerActionSchema.omit({ text: true }).extend({ at: z20.iso.datetime() });
-var approvalViewSchema = z20.object({
-  id: z20.string(),
-  digest: z20.string(),
-  runId: z20.string(),
-  botId: z20.string(),
+import { z as z21 } from "zod";
+var machineStateSchema = z21.enum(["sleeping", "waking", "running", "error"]);
+var controlStateSchema = z21.enum(["agent", "user", "idle"]);
+var computerToolSchema = z21.enum(["click", "type", "key", "scroll", "screenshot"]);
+var screenRectSchema = z21.object({ x: z21.number(), y: z21.number(), w: z21.number().nonnegative(), h: z21.number().nonnegative() });
+var computerActionSchema = z21.object({ tool: computerToolSchema, x: z21.number().optional(), y: z21.number().optional(), text: z21.string().optional(), rect: screenRectSchema.optional() });
+var lastActionSchema = computerActionSchema.omit({ text: true }).extend({ at: z21.iso.datetime() });
+var approvalViewSchema = z21.object({
+  id: z21.string(),
+  digest: z21.string(),
+  runId: z21.string(),
+  botId: z21.string(),
   action: computerActionSchema,
-  summary: z20.string(),
-  expiresAt: z20.iso.datetime()
+  summary: z21.string(),
+  expiresAt: z21.iso.datetime()
 });
-var computerStateSchema = z20.object({
+var computerStateSchema = z21.object({
   machine: machineStateSchema,
   control: controlStateSchema,
-  controlledBy: z20.object({ userId: z20.string() }).optional(),
+  controlledBy: z21.object({ userId: z21.string() }).optional(),
   lastAction: lastActionSchema.optional(),
   pendingApproval: approvalViewSchema.optional()
 });
-var viewerModeSchema = z20.enum(["view", "control"]);
-var viewerRequestSchema = z20.object({ mode: viewerModeSchema }).strict();
-var viewerGrantSchema = z20.object({ url: z20.url({ protocol: /^wss$/ }), expiresAt: z20.iso.datetime() });
-var createBotSchema = z20.object({ name: z20.string().trim().min(1).max(120) }).strict();
-var botViewSchema = z20.object({ id: z20.uuid(), name: z20.string().min(1).max(120) });
-var approvalDecisionSchema = z20.object({ digest: z20.string(), decision: z20.enum(["approve", "deny"]), scope: z20.enum(["once", "run"]) }).strict();
-var computerTaskStateSchema = z20.enum(["working", "approval", "done", "failed"]);
-var computerTaskSchema = z20.object({ botId: z20.string(), runId: z20.string(), task: z20.string(), state: computerTaskStateSchema, approvalId: z20.string().optional() });
-var computerEventSchema = z20.discriminatedUnion("type", [
-  z20.object({ type: z20.literal("computer.machine"), state: machineStateSchema }),
-  z20.object({ type: z20.literal("computer.control"), botId: z20.string(), control: controlStateSchema, controlledBy: z20.object({ userId: z20.string() }).optional() }),
-  z20.object({ type: z20.literal("computer.action"), botId: z20.string(), lastAction: lastActionSchema }),
-  z20.object({ type: z20.literal("computer.approval"), botId: z20.string(), approval: approvalViewSchema.nullable() })
+var viewerModeSchema = z21.enum(["view", "control"]);
+var viewerRequestSchema = z21.object({ mode: viewerModeSchema }).strict();
+var viewerGrantSchema = z21.object({ url: z21.url({ protocol: /^wss$/ }), expiresAt: z21.iso.datetime() });
+var createBotSchema = z21.object({ name: z21.string().trim().min(1).max(120) }).strict();
+var botViewSchema = z21.object({ id: z21.uuid(), name: z21.string().min(1).max(120) });
+var approvalDecisionSchema = z21.object({ digest: z21.string(), decision: z21.enum(["approve", "deny"]), scope: z21.enum(["once", "run"]) }).strict();
+var computerTaskStateSchema = z21.enum(["working", "approval", "done", "failed"]);
+var computerTaskSchema = z21.object({ botId: z21.string(), runId: z21.string(), task: z21.string(), state: computerTaskStateSchema, approvalId: z21.string().optional() });
+var computerEventSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("computer.machine"), state: machineStateSchema }),
+  z21.object({ type: z21.literal("computer.control"), botId: z21.string(), control: controlStateSchema, controlledBy: z21.object({ userId: z21.string() }).optional() }),
+  z21.object({ type: z21.literal("computer.action"), botId: z21.string(), lastAction: lastActionSchema }),
+  z21.object({ type: z21.literal("computer.approval"), botId: z21.string(), approval: approvalViewSchema.nullable() })
 ]);
-var reviewDigestSchema = z20.string().regex(/^[a-f0-9]{64}$/);
-var localComputerCall = z20.discriminatedUnion("name", [
-  z20.object({ name: z20.literal("get_desktop_state"), arguments: z20.object({}).strict() }).strict(),
-  z20.object({ name: z20.literal("click"), arguments: z20.object({ x: z20.number().int().min(0).max(1e5), y: z20.number().int().min(0).max(1e5) }).strict() }).strict(),
-  z20.object({ name: z20.literal("type_text"), arguments: z20.object({ text: z20.string().min(1).max(8e3) }).strict() }).strict(),
-  z20.object({ name: z20.literal("press_key"), arguments: z20.object({
-    key: z20.string().regex(/^(?:[\x20-\x7e]|enter|return|tab|escape|space|backspace|delete|insert|home|end|pageup|pagedown|up|down|left|right|f(?:[1-9]|1[0-2]))$/),
-    modifiers: z20.array(z20.enum(["ctrl", "shift", "alt", "super"])).max(4).refine((items) => new Set(items).size === items.length).optional()
+var reviewDigestSchema = z21.string().regex(/^[a-f0-9]{64}$/);
+var localComputerCall = z21.discriminatedUnion("name", [
+  z21.object({ name: z21.literal("get_desktop_state"), arguments: z21.object({}).strict() }).strict(),
+  z21.object({ name: z21.literal("click"), arguments: z21.object({ x: z21.number().int().min(0).max(1e5), y: z21.number().int().min(0).max(1e5) }).strict() }).strict(),
+  z21.object({ name: z21.literal("type_text"), arguments: z21.object({ text: z21.string().min(1).max(8e3) }).strict() }).strict(),
+  z21.object({ name: z21.literal("press_key"), arguments: z21.object({
+    key: z21.string().regex(/^(?:[\x20-\x7e]|enter|return|tab|escape|space|backspace|delete|insert|home|end|pageup|pagedown|up|down|left|right|f(?:[1-9]|1[0-2]))$/),
+    modifiers: z21.array(z21.enum(["ctrl", "shift", "alt", "super"])).max(4).refine((items) => new Set(items).size === items.length).optional()
   }).strict() }).strict(),
-  z20.object({ name: z20.literal("scroll"), arguments: z20.object({ direction: z20.enum(["up", "down", "left", "right"]), amount: z20.number().int().min(1).max(50), x: z20.number().int().min(0).max(1e5), y: z20.number().int().min(0).max(1e5) }).strict() }).strict()
+  z21.object({ name: z21.literal("scroll"), arguments: z21.object({ direction: z21.enum(["up", "down", "left", "right"]), amount: z21.number().int().min(1).max(50), x: z21.number().int().min(0).max(1e5), y: z21.number().int().min(0).max(1e5) }).strict() }).strict()
 ]);
-var localComputerRequest = z20.object({
-  id: z20.uuid(),
-  runId: z20.uuid(),
+var localComputerRequest = z21.object({
+  id: z21.uuid(),
+  runId: z21.uuid(),
   target: reviewDigestSchema,
-  display: z20.string().regex(/^:[1-9][0-9]{0,2}$/).optional(),
+  display: z21.string().regex(/^:[1-9][0-9]{0,2}$/).optional(),
   call: localComputerCall,
-  expiresAt: z20.number().int().positive(),
+  expiresAt: z21.number().int().positive(),
   digest: reviewDigestSchema
 }).strict();
-var localComputerDecision = z20.object({ id: z20.uuid(), digest: reviewDigestSchema, approve: z20.boolean() }).strict();
-var computerSyncBody = z20.object({ requests: z20.array(localComputerRequest).max(20) }).strict();
-var computerSyncResponse = z20.object({ decisions: z20.array(localComputerDecision).max(20) }).strict();
+var localComputerDecision = z21.object({ id: z21.uuid(), digest: reviewDigestSchema, approve: z21.boolean() }).strict();
+var computerSyncBody = z21.object({ requests: z21.array(localComputerRequest).max(20) }).strict();
+var computerSyncResponse = z21.object({ decisions: z21.array(localComputerDecision).max(20) }).strict();
 
 // ../protocol/src/subscription.ts
-import { z as z21 } from "zod";
-var id2 = z21.string().min(1).max(128);
-var subscriptionRouteSchema = z21.enum([
+import { z as z22 } from "zod";
+var id3 = z22.string().min(1).max(128);
+var subscriptionRouteSchema = z22.enum([
   "codex_cli",
   "claude_code_cli",
   "codex_cpa",
   "claude_cpa",
   "openai_siwc"
 ]);
-var subscriptionConnectionSchema = z21.object({
-  id: id2,
-  ownerId: id2,
-  workspaceId: id2,
-  provider: z21.enum(["openai", "anthropic"]),
-  state: z21.enum([
+var subscriptionConnectionSchema = z22.object({
+  id: id3,
+  ownerId: id3,
+  workspaceId: id3,
+  provider: z22.enum(["openai", "anthropic"]),
+  state: z22.enum([
     "pending",
     "connected",
     "reconnect_required",
     "disconnected"
   ]),
   // Increment on reconnect/disconnect. Old bindings cannot become valid again.
-  revision: z21.number().int().positive(),
+  revision: z22.number().int().positive(),
   quota: quotaSnapshotSchema
 }).strict();
-var subscriptionBindingSchema = z21.object({
-  id: id2,
-  ownerId: id2,
-  workspaceId: id2,
+var subscriptionBindingSchema = z22.object({
+  id: id3,
+  ownerId: id3,
+  workspaceId: id3,
   // An agent or assistant session selected explicitly by the owner.
-  consumerId: id2,
-  connectionId: id2,
-  connectionRevision: z21.number().int().positive(),
+  consumerId: id3,
+  connectionId: id3,
+  connectionRevision: z22.number().int().positive(),
   route: subscriptionRouteSchema
 }).strict();
-var nativeBrokerContextSchema = z21.object({
-  route: z21.enum(["codex_cli", "claude_code_cli"]),
-  modelId: z21.string().min(1).max(128),
-  revision: z21.number().int().positive(),
-  accountId: z21.string().min(1).max(512),
-  plan: z21.string().max(40).optional(),
-  expiresAt: z21.iso.datetime()
+var nativeBrokerContextSchema = z22.object({
+  route: z22.enum(["codex_cli", "claude_code_cli"]),
+  modelId: z22.string().min(1).max(128),
+  revision: z22.number().int().positive(),
+  accountId: z22.string().min(1).max(512),
+  plan: z22.string().max(40).optional(),
+  expiresAt: z22.iso.datetime()
 }).strict();
 
 // src/login.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/errors.ts
 var DaemonError = class extends Error {
@@ -3649,7 +3694,7 @@ var ServerUnreachableError = class extends DaemonError {
 // package.json
 var package_default = {
   name: "@mikka/daemon",
-  version: "0.0.63",
+  version: "0.0.65",
   description: "Local Mikka daemon: runs agents through the user's own CLIs",
   type: "module",
   private: true,
@@ -3708,17 +3753,17 @@ var package_default = {
   engines: {
     node: ">=24"
   },
-  gitHead: "9840b8254863c60220d8d9f8b81382c7c3bb76bf"
+  gitHead: "f566198f5cee77ff3a0ba56f6923a0cf0b005b0e"
 };
 
 // src/paths.ts
 var DAEMON_VERSION = package_default.version;
 
 // src/server-link-http.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../protocol/src/capture.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var CAPTURE_CONTENT_TYPES = [
   "image/png",
   "image/jpeg",
@@ -3734,69 +3779,69 @@ var CAPTURE_MAX_BYTES = {
 };
 var RECORDING_MAX_SECONDS = 300;
 var CAPTURE_TITLE_MAX = 200;
-var sha256 = z22.string().regex(/^[a-f0-9]{64}$/);
-var title = z22.string().trim().min(1).max(CAPTURE_TITLE_MAX);
-var captureUploadRequest = z22.object({
+var sha256 = z23.string().regex(/^[a-f0-9]{64}$/);
+var title = z23.string().trim().min(1).max(CAPTURE_TITLE_MAX);
+var captureUploadRequest = z23.object({
   /** Stable client id, persisted before the first network attempt. */
-  captureId: z22.uuid().optional(),
+  captureId: z23.uuid().optional(),
   title,
-  contentType: z22.enum(CAPTURE_CONTENT_TYPES),
-  size: z22.number().int().min(1).max(CAPTURE_MAX_BYTES.video),
+  contentType: z23.enum(CAPTURE_CONTENT_TYPES),
+  size: z23.number().int().min(1).max(CAPTURE_MAX_BYTES.video),
   sha256
 }).strict();
-var captureUploadTarget = z22.discriminatedUnion("target", [
-  z22.object({ target: z22.literal("storage"), url: z22.url({ protocol: /^https$/ }), headers: z22.record(z22.string(), z22.string()) }),
-  z22.object({ target: z22.literal("server") })
+var captureUploadTarget = z23.discriminatedUnion("target", [
+  z23.object({ target: z23.literal("storage"), url: z23.url({ protocol: /^https$/ }), headers: z23.record(z23.string(), z23.string()) }),
+  z23.object({ target: z23.literal("server") })
 ]);
-var captureUploadResponse = z22.object({
-  captureId: z22.uuid(),
+var captureUploadResponse = z23.object({
+  captureId: z23.uuid(),
   upload: captureUploadTarget
 });
-var captureView = z22.object({
-  id: z22.uuid(),
-  kind: z22.enum(CAPTURE_KINDS),
-  contentType: z22.enum(CAPTURE_CONTENT_TYPES),
-  title: z22.string(),
-  size: z22.number().int().nonnegative(),
-  durationMs: z22.number().int().nonnegative().nullable(),
-  source: z22.enum(CAPTURE_SOURCES),
-  createdAt: z22.iso.datetime()
-});
-var captureCompleteResponse = z22.object({ capture: captureView });
-var screenCaptureRequest = z22.discriminatedUnion("action", [
-  z22.object({ action: z22.literal("screenshot"), title }).strict(),
-  z22.object({ action: z22.literal("start_recording"), title, maxSeconds: z22.number().int().min(5).max(RECORDING_MAX_SECONDS).optional() }).strict(),
-  z22.object({ action: z22.literal("stop_recording") }).strict()
+var captureView = z23.object({
+  id: z23.uuid(),
+  kind: z23.enum(CAPTURE_KINDS),
+  contentType: z23.enum(CAPTURE_CONTENT_TYPES),
+  title: z23.string(),
+  size: z23.number().int().nonnegative(),
+  durationMs: z23.number().int().nonnegative().nullable(),
+  source: z23.enum(CAPTURE_SOURCES),
+  createdAt: z23.iso.datetime()
+});
+var captureCompleteResponse = z23.object({ capture: captureView });
+var screenCaptureRequest = z23.discriminatedUnion("action", [
+  z23.object({ action: z23.literal("screenshot"), title }).strict(),
+  z23.object({ action: z23.literal("start_recording"), title, maxSeconds: z23.number().int().min(5).max(RECORDING_MAX_SECONDS).optional() }).strict(),
+  z23.object({ action: z23.literal("stop_recording") }).strict()
 ]);
-var screenCaptureResponse = z22.discriminatedUnion("action", [
-  z22.object({ action: z22.literal("screenshot"), capture: captureView }),
-  z22.object({ action: z22.literal("start_recording"), recordingId: z22.uuid(), stopsAt: z22.iso.datetime() }),
-  z22.object({ action: z22.literal("stop_recording"), capture: captureView })
+var screenCaptureResponse = z23.discriminatedUnion("action", [
+  z23.object({ action: z23.literal("screenshot"), capture: captureView }),
+  z23.object({ action: z23.literal("start_recording"), recordingId: z23.uuid(), stopsAt: z23.iso.datetime() }),
+  z23.object({ action: z23.literal("stop_recording"), capture: captureView })
 ]);
 
 // src/run-mailbox.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // ../protocol/src/mailbox.ts
-import { z as z23 } from "zod";
-var mailboxSend = z23.object({ to: z23.uuid(), key: z23.uuid().describe("Stable idempotency key; reuse only to retry this exact envelope."), text: z23.string().trim().min(1).max(4e3), replyTo: z23.uuid().optional() }).strict();
-var mailboxAck = z23.object({ ids: z23.array(z23.uuid()).max(50) }).strict();
+import { z as z24 } from "zod";
+var mailboxSend = z24.object({ to: z24.uuid(), key: z24.uuid().describe("Stable idempotency key; reuse only to retry this exact envelope."), text: z24.string().trim().min(1).max(4e3), replyTo: z24.uuid().optional() }).strict();
+var mailboxAck = z24.object({ ids: z24.array(z24.uuid()).max(50) }).strict();
 var mailboxInputs = {
-  mailbox_recipients: z23.object({}).strict(),
+  mailbox_recipients: z24.object({}).strict(),
   mailbox_send: mailboxSend,
-  mailbox_inbox: z23.object({}).strict(),
+  mailbox_inbox: z24.object({}).strict(),
   mailbox_ack: mailboxAck,
-  mailbox_sent: z23.object({}).strict()
+  mailbox_sent: z24.object({}).strict()
 };
 
 // src/run-mailbox.ts
-var requestSchema = z24.union([
-  z24.object({ operation: z24.literal("list") }).strict(),
-  z24.object({ operation: z24.literal("call"), name: z24.enum(Object.keys(mailboxInputs)), arguments: z24.unknown() }).strict()
+var requestSchema = z25.union([
+  z25.object({ operation: z25.literal("list") }).strict(),
+  z25.object({ operation: z25.literal("call"), name: z25.enum(Object.keys(mailboxInputs)), arguments: z25.unknown() }).strict()
 ]);
 
 // src/server-link-http.ts
-var deviceSessionRejection = z25.object({ error: z25.enum(["Unauthorized", "authRequired"]) }).strict();
+var deviceSessionRejection = z26.object({ error: z26.enum(["Unauthorized", "authRequired"]) }).strict();
 function serverUrl(base, path) {
   return new URL(`${base.replace(/\/+$/, "")}${path}`);
 }
@@ -3805,16 +3850,16 @@ function serverUrl(base, path) {
 var DEVICE_CODE_PATH = `${AUTH_BASE_PATH}/device/code`;
 var DEVICE_TOKEN_PATH = `${AUTH_BASE_PATH}/device/token`;
 var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
-var deviceCodeResponse = z26.object({
-  device_code: z26.string().min(1),
-  user_code: z26.string().min(1),
-  verification_uri: z26.string(),
-  verification_uri_complete: z26.string().optional(),
-  expires_in: z26.number().positive(),
-  interval: z26.number().positive().default(5)
-});
-var tokenResponse = z26.object({ access_token: z26.string().regex(/^orv_[A-Za-z0-9_-]{43}$/) });
-var errorResponse = z26.object({ error: z26.string() });
+var deviceCodeResponse = z27.object({
+  device_code: z27.string().min(1),
+  user_code: z27.string().min(1),
+  verification_uri: z27.string(),
+  verification_uri_complete: z27.string().optional(),
+  expires_in: z27.number().positive(),
+  interval: z27.number().positive().default(5)
+});
+var tokenResponse = z27.object({ access_token: z27.string().regex(/^orv_[A-Za-z0-9_-]{43}$/) });
+var errorResponse = z27.object({ error: z27.string() });
 var LoginError = class extends DaemonError {
   constructor(reason, message) {
     super(4003, message);