@aspectlylabs/mikka 0.0.63 → 0.0.65

package/http-link.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 z26 = options.includePrerelease ? "-0" : "";
+      const z27 = 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${z26} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z27} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
-          ret = `>=${M}.${m}.0${z26} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M}.${m}.0${z27} <${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 z26 = options.includePrerelease ? "-0" : "";
+      const z27 = 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${z26} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z27} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
           if (M === "0") {
-            ret = `>=${M}.${m}.0${z26} <${M}.${+m + 1}.0-0`;
+            ret = `>=${M}.${m}.0${z27} <${M}.${+m + 1}.0-0`;
           } else {
-            ret = `>=${M}.${m}.0${z26} <${+M + 1}.0.0-0`;
+            ret = `>=${M}.${m}.0${z27} <${+M + 1}.0.0-0`;
           }
         } else if (pr) {
           debug("replaceCaret pr", pr);
@@ -2054,7 +2054,7 @@ var nativeCoordinatorToolResultSchema = z.discriminatedUnion("status", [
 ]);
 
 // src/server-link-http.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/agents/tool-approval.ts
 import { randomUUID } from "node:crypto";
@@ -2170,6 +2170,9 @@ var ToolApprovalGate = class {
   }
 };
 
+// ../protocol/src/policy-snapshot.ts
+import { z as z3 } from "zod";
+
 // ../protocol/src/agent-policy.ts
 import { z as z2 } from "zod";
 var PERMISSION_DECISIONS = ["allow", "ask", "deny"];
@@ -2200,6 +2203,11 @@ var PERMISSION_DEFAULTS = {
   network: "ask",
   computer_use: "ask"
 };
+function permissionChoiceAllowed(action, decision) {
+  return CONFIGURABLE_PERMISSIONS[action].includes(
+    decision
+  );
+}
 var NETWORK_DOMAIN_RE = /^(\*\.)?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*(:[0-9]{1,5})?$/;
 var MAX_NETWORK_DOMAINS = 200;
 var MAX_GUIDANCE_LENGTH = 1e4;
@@ -2219,6 +2227,11 @@ var storedPermissionsSchema = z2.strictObject({
   computer_use: z2.enum(CONFIGURABLE_PERMISSIONS.computer_use)
 }).partial();
 var guidanceSchema = z2.string().max(MAX_GUIDANCE_LENGTH);
+var DEFAULT_NETWORK_ALLOW = [
+  "github.com",
+  "*.github.com",
+  "*.githubusercontent.com"
+];
 var runPolicySchema = z2.strictObject({
   permissions: z2.strictObject({
     install_dependency: z2.enum(PERMISSION_DECISIONS),
@@ -2248,6 +2261,111 @@ var modelByHarnessSchema = z2.strictObject({
 }).partial();
 var APPROVAL_MODES = ["ask", "read_only"];
 var approvalModeSchema = z2.enum(APPROVAL_MODES);
+function resolvePermissions(stored, environment = "local") {
+  const out = {};
+  const record = stored && typeof stored === "object" ? stored : {};
+  for (const action of CONFIGURABLE_ACTIONS) {
+    const value = record[action];
+    out[action] = typeof value === "string" && permissionChoiceAllowed(action, value) ? value : environment === "cloud" && action === "network" ? "allow" : PERMISSION_DEFAULTS[action];
+  }
+  return out;
+}
+function resolveNetworkAllow(stored) {
+  if (stored === null || stored === void 0) return [...DEFAULT_NETWORK_ALLOW];
+  const parsed = networkAllowSchema.safeParse(stored);
+  return parsed.success ? parsed.data : [...DEFAULT_NETWORK_ALLOW];
+}
+function resolveAgentSettings(workspace, team, environment = "local") {
+  const permissions = resolvePermissions(workspace?.permissions, environment);
+  const explicit = storedPermissionsSchema.safeParse(workspace?.permissions ?? {});
+  if (environment === "cloud" && workspace?.networkAllow != null && explicit.success && explicit.data.network === void 0) permissions.network = "ask";
+  const teamGuidance = team?.guidance;
+  const workspaceGuidance = workspace?.guidance ?? null;
+  const fromTeam = teamGuidance !== null && teamGuidance !== void 0;
+  const text2 = (fromTeam ? teamGuidance : workspaceGuidance)?.trim() ?? "";
+  return {
+    policy: {
+      permissions,
+      networkAllow: resolveNetworkAllow(workspace?.networkAllow)
+    },
+    guidance: text2 ? text2 : null,
+    guidanceFrom: text2 ? fromTeam ? "team" : "workspace" : null
+  };
+}
+function defaultRunPolicy() {
+  return resolveAgentSettings(null).policy;
+}
+function runPolicyDigestInput(policy) {
+  const resolved = runPolicySchema.parse(policy ?? defaultRunPolicy());
+  return JSON.stringify(resolved, [...Object.keys(resolved), ...Object.keys(resolved.permissions)].sort());
+}
+
+// ../protocol/src/policy-snapshot.ts
+var POLICY_SNAPSHOT_HEADER = "x-mikka-policy-snapshot";
+var POLICY_SNAPSHOT_VERSION = "1";
+var POLICY_SNAPSHOT_TTL_MS = 5 * 6e4;
+var POLICY_SNAPSHOT_REFRESH_MS = 3e4;
+var id = z3.string().min(1).max(128);
+var digest = z3.string().regex(/^[a-f0-9]{64}$/);
+var policyScopeSchema = z3.strictObject({
+  workspaceIds: z3.array(id).max(2),
+  hierarchy: z3.strictObject({ workspaceId: z3.uuid(), teamId: z3.uuid(), projectId: z3.uuid().nullable() }).nullable()
+});
+var policySnapshotPayloadSchema = z3.strictObject({
+  version: z3.literal(1),
+  issuer: z3.url().max(1e3),
+  ownerId: id,
+  deviceId: id,
+  runId: id,
+  revision: digest,
+  policyHash: digest,
+  scope: policyScopeSchema,
+  policy: runPolicySchema,
+  issuedAt: z3.number().int().nonnegative(),
+  expiresAt: z3.number().int().nonnegative()
+});
+var signedPolicySnapshotSchema = z3.strictObject({
+  algorithm: z3.literal("Ed25519"),
+  keyId: digest,
+  payload: policySnapshotPayloadSchema,
+  signature: z3.string().regex(/^[A-Za-z0-9_-]{86}$/)
+});
+var policyDistributionContextSchema = z3.strictObject({
+  version: z3.literal(1),
+  algorithm: z3.literal("Ed25519"),
+  keyId: digest,
+  publicKey: z3.string().regex(/^[A-Za-z0-9_-]{59}$/),
+  issuer: z3.url().max(1e3),
+  ownerId: id,
+  deviceId: id,
+  runId: id,
+  revision: digest,
+  scope: policyScopeSchema,
+  required: z3.boolean()
+});
+function policyIssuer(base) {
+  const url = new URL(base);
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) throw Error("policyIssuerInvalid");
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+function policySnapshotMessage(payload) {
+  return new TextEncoder().encode(JSON.stringify(policySnapshotPayloadSchema.parse(payload)));
+}
+
+// ../protocol/src/node-policy-snapshot.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { createHash, createPublicKey, verify } from "node:crypto";
+var policySnapshotHash = (policy) => createHash("sha256").update(runPolicyDigestInput(policy)).digest("hex");
+function verifyPolicySnapshot(value, trusted, expected, options = {}) {
+  const context = policyDistributionContextSchema.parse(trusted);
+  const snapshot = signedPolicySnapshotSchema.parse(value), p = snapshot.payload, now = options.now ?? Date.now();
+  if (policyIssuer(context.issuer) !== context.issuer || policyIssuer(p.issuer) !== context.issuer || p.ownerId !== context.ownerId || p.deviceId !== context.deviceId || p.runId !== context.runId || p.revision !== context.revision || p.policyHash !== policySnapshotHash(p.policy) || p.runId !== expected.runId || p.deviceId !== expected.deviceId || p.revision !== expected.revision || snapshot.keyId !== context.keyId || JSON.stringify(p.scope) !== JSON.stringify(context.scope) || expected.policy && JSON.stringify(p.policy) !== JSON.stringify(runPolicySchema.parse(expected.policy))) throw Error("policySnapshotBindingInvalid");
+  if (p.issuedAt > now + 3e4 || p.expiresAt <= p.issuedAt || p.expiresAt - p.issuedAt > POLICY_SNAPSHOT_TTL_MS || !options.allowExpired && p.expiresAt <= now) throw Error("policySnapshotExpired");
+  const der = Buffer2.from(context.publicKey, "base64url");
+  if (createHash("sha256").update(der).digest("hex") !== context.keyId || !verify(null, policySnapshotMessage(p), createPublicKey({ key: der, type: "spki", format: "der" }), Buffer2.from(snapshot.signature, "base64url"))) throw Error("policySnapshotSignatureInvalid");
+  return snapshot;
+}
 
 // src/permissions.ts
 import { lstatSync, readlinkSync, realpathSync } from "node:fs";
@@ -2318,34 +2436,34 @@ function toolApprovalDecision(request, policy, worktree) {
 }
 
 // ../protocol/src/skill.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../protocol/src/skill-artifact.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var SKILL_ARTIFACT_HEADER = "x-mikka-skill-artifacts";
 var TEAM_SKILL_HEADER = "x-mikka-team-skills";
-var skillArtifactRefSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  registryId: z3.enum(["mikka-builtin", "mikka-team"]),
-  skillId: z3.uuid(),
-  versionId: z3.uuid(),
-  format: z3.literal("single-skill-md-v1"),
-  sha256: z3.string().regex(/^[a-f0-9]{64}$/)
+var skillArtifactRefSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  registryId: z4.enum(["mikka-builtin", "mikka-team"]),
+  skillId: z4.uuid(),
+  versionId: z4.uuid(),
+  format: z4.literal("single-skill-md-v1"),
+  sha256: z4.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var skillAssignmentReceiptSchema = z3.object({
-  id: z3.uuid(),
-  runId: z3.uuid(),
-  issueId: z3.uuid(),
-  agentId: z3.uuid(),
-  repoId: z3.uuid(),
-  deviceId: z3.uuid(),
-  leaseExpiresAt: z3.iso.datetime(),
-  assignedAt: z3.iso.datetime(),
+var skillAssignmentReceiptSchema = z4.object({
+  id: z4.uuid(),
+  runId: z4.uuid(),
+  issueId: z4.uuid(),
+  agentId: z4.uuid(),
+  repoId: z4.uuid(),
+  deviceId: z4.uuid(),
+  leaseExpiresAt: z4.iso.datetime(),
+  assignedAt: z4.iso.datetime(),
   artifact: skillArtifactRefSchema
 }).strict();
-var skillReceiptRevalidationSchema = z3.object({
+var skillReceiptRevalidationSchema = z4.object({
   skillReceipt: skillAssignmentReceiptSchema,
-  leaseExpiresAt: z3.iso.datetime()
+  leaseExpiresAt: z4.iso.datetime()
 }).strict();
 
 // ../protocol/src/skill.ts
@@ -2356,39 +2474,39 @@ 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 = z4.string().min(1).max(MAX_SKILL_FILE_PATH_LENGTH).refine(
+var skillFilePathSchema = z5.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 = z4.object({
+var skillFileSchema = z5.object({
   path: skillFilePathSchema,
-  content: z4.string().max(MAX_SKILL_FILE_CONTENT_LENGTH)
+  content: z5.string().max(MAX_SKILL_FILE_CONTENT_LENGTH)
 });
-var skillFilesSchema = z4.array(skillFileSchema).max(MAX_SKILL_FILES);
-var skillNameSchema = z4.string().trim().min(1).max(MAX_SKILL_NAME_LENGTH);
-var skillDescriptionSchema = z4.string().trim().max(MAX_SKILL_DESCRIPTION_LENGTH);
-var skillInstructionsSchema = z4.string().trim().min(1).max(MAX_SKILL_INSTRUCTIONS_LENGTH);
-var runSkillSchema = z4.object({
-  id: z4.uuid(),
+var skillFilesSchema = z5.array(skillFileSchema).max(MAX_SKILL_FILES);
+var skillNameSchema = z5.string().trim().min(1).max(MAX_SKILL_NAME_LENGTH);
+var skillDescriptionSchema = z5.string().trim().max(MAX_SKILL_DESCRIPTION_LENGTH);
+var skillInstructionsSchema = z5.string().trim().min(1).max(MAX_SKILL_INSTRUCTIONS_LENGTH);
+var runSkillSchema = z5.object({
+  id: z5.uuid(),
   name: skillNameSchema,
-  description: z4.string().nullable(),
+  description: z5.string().nullable(),
   instructions: skillInstructionsSchema,
   files: skillFilesSchema
 });
-var runSkillRefSchema = z4.object({
-  id: z4.uuid(),
+var runSkillRefSchema = z5.object({
+  id: z5.uuid(),
   name: skillNameSchema
 });
 
 // ../protocol/src/subscription.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // ../protocol/src/quota.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var QUOTA_VENDORS = ["claude_code", "codex", "cursor"];
-var quotaVendorSchema = z5.enum(QUOTA_VENDORS);
+var quotaVendorSchema = z6.enum(QUOTA_VENDORS);
 var QUOTA_SOURCES = ["local_credentials", "official"];
-var quotaSourceSchema = z5.enum(QUOTA_SOURCES);
+var quotaSourceSchema = z6.enum(QUOTA_SOURCES);
 var QUOTA_WINDOW_KINDS = [
   "five_hour",
   "weekly",
@@ -2397,7 +2515,7 @@ var QUOTA_WINDOW_KINDS = [
   "hourly",
   "other"
 ];
-var quotaWindowKindSchema = z5.enum(QUOTA_WINDOW_KINDS);
+var quotaWindowKindSchema = z6.enum(QUOTA_WINDOW_KINDS);
 var QUOTA_METERS = [
   "auto",
   "api",
@@ -2405,139 +2523,139 @@ var QUOTA_METERS = [
   "team_pool",
   "team_on_demand"
 ];
-var quotaMeterSchema = z5.enum(QUOTA_METERS);
-var quotaWindowSchema = z5.object({
+var quotaMeterSchema = z6.enum(QUOTA_METERS);
+var quotaWindowSchema = z6.object({
   kind: quotaWindowKindSchema,
   /** 0..1 share of the window already used. */
-  used: z5.number().min(0).max(1),
-  resetsAt: z5.string().nullable(),
+  used: z6.number().min(0).max(1),
+  resetsAt: z6.string().nullable(),
   /** Model display name for a per-model window, e.g. "Opus". */
-  model: z5.string().min(1).max(40).optional(),
+  model: z6.string().min(1).max(40).optional(),
   meter: quotaMeterSchema.optional()
 });
-var quotaSnapshotSchema = z5.object({
+var quotaSnapshotSchema = z6.object({
   vendor: quotaVendorSchema,
   source: quotaSourceSchema,
-  status: z5.enum(["ok", "unknown"]),
-  plan: z5.string().max(40).nullable(),
-  windows: z5.array(quotaWindowSchema).max(12),
+  status: z6.enum(["ok", "unknown"]),
+  plan: z6.string().max(40).nullable(),
+  windows: z6.array(quotaWindowSchema).max(12),
   /** When this vendor was last read (ISO-8601). */
-  observedAt: z5.string()
+  observedAt: z6.string()
 });
-var quotaSnapshotReportSchema = z5.object({
+var quotaSnapshotReportSchema = z6.object({
   /** When the whole read finished. Null before the first read. */
-  observedAt: z5.string().nullable(),
-  quotas: z5.array(quotaSnapshotSchema).max(6)
+  observedAt: z6.string().nullable(),
+  quotas: z6.array(quotaSnapshotSchema).max(6)
 });
 
 // ../protocol/src/subscription.ts
-var id = z6.string().min(1).max(128);
-var subscriptionRouteSchema = z6.enum([
+var id2 = z7.string().min(1).max(128);
+var subscriptionRouteSchema = z7.enum([
   "codex_cli",
   "claude_code_cli",
   "codex_cpa",
   "claude_cpa",
   "openai_siwc"
 ]);
-var subscriptionConnectionSchema = z6.object({
-  id,
-  ownerId: id,
-  workspaceId: id,
-  provider: z6.enum(["openai", "anthropic"]),
-  state: z6.enum([
+var subscriptionConnectionSchema = z7.object({
+  id: id2,
+  ownerId: id2,
+  workspaceId: id2,
+  provider: z7.enum(["openai", "anthropic"]),
+  state: z7.enum([
     "pending",
     "connected",
     "reconnect_required",
     "disconnected"
   ]),
   // Increment on reconnect/disconnect. Old bindings cannot become valid again.
-  revision: z6.number().int().positive(),
+  revision: z7.number().int().positive(),
   quota: quotaSnapshotSchema
 }).strict();
-var subscriptionBindingSchema = z6.object({
-  id,
-  ownerId: id,
-  workspaceId: id,
+var subscriptionBindingSchema = z7.object({
+  id: id2,
+  ownerId: id2,
+  workspaceId: id2,
   // An agent or assistant session selected explicitly by the owner.
-  consumerId: id,
-  connectionId: id,
-  connectionRevision: z6.number().int().positive(),
+  consumerId: id2,
+  connectionId: id2,
+  connectionRevision: z7.number().int().positive(),
   route: subscriptionRouteSchema
 }).strict();
-var nativeBrokerContextSchema = z6.object({
-  route: z6.enum(["codex_cli", "claude_code_cli"]),
-  modelId: z6.string().min(1).max(128),
-  revision: z6.number().int().positive(),
-  accountId: z6.string().min(1).max(512),
-  plan: z6.string().max(40).optional(),
-  expiresAt: z6.iso.datetime()
+var nativeBrokerContextSchema = z7.object({
+  route: z7.enum(["codex_cli", "claude_code_cli"]),
+  modelId: z7.string().min(1).max(128),
+  revision: z7.number().int().positive(),
+  accountId: z7.string().min(1).max(512),
+  plan: z7.string().max(40).optional(),
+  expiresAt: z7.iso.datetime()
 }).strict();
 
 // ../protocol/src/computer.ts
-import { z as z7 } from "zod";
-var machineStateSchema = z7.enum(["sleeping", "waking", "running", "error"]);
-var controlStateSchema = z7.enum(["agent", "user", "idle"]);
-var computerToolSchema = z7.enum(["click", "type", "key", "scroll", "screenshot"]);
-var screenRectSchema = z7.object({ x: z7.number(), y: z7.number(), w: z7.number().nonnegative(), h: z7.number().nonnegative() });
-var computerActionSchema = z7.object({ tool: computerToolSchema, x: z7.number().optional(), y: z7.number().optional(), text: z7.string().optional(), rect: screenRectSchema.optional() });
-var lastActionSchema = computerActionSchema.omit({ text: true }).extend({ at: z7.iso.datetime() });
-var approvalViewSchema = z7.object({
-  id: z7.string(),
-  digest: z7.string(),
-  runId: z7.string(),
-  botId: z7.string(),
+import { z as z8 } from "zod";
+var machineStateSchema = z8.enum(["sleeping", "waking", "running", "error"]);
+var controlStateSchema = z8.enum(["agent", "user", "idle"]);
+var computerToolSchema = z8.enum(["click", "type", "key", "scroll", "screenshot"]);
+var screenRectSchema = z8.object({ x: z8.number(), y: z8.number(), w: z8.number().nonnegative(), h: z8.number().nonnegative() });
+var computerActionSchema = z8.object({ tool: computerToolSchema, x: z8.number().optional(), y: z8.number().optional(), text: z8.string().optional(), rect: screenRectSchema.optional() });
+var lastActionSchema = computerActionSchema.omit({ text: true }).extend({ at: z8.iso.datetime() });
+var approvalViewSchema = z8.object({
+  id: z8.string(),
+  digest: z8.string(),
+  runId: z8.string(),
+  botId: z8.string(),
   action: computerActionSchema,
-  summary: z7.string(),
-  expiresAt: z7.iso.datetime()
+  summary: z8.string(),
+  expiresAt: z8.iso.datetime()
 });
-var computerStateSchema = z7.object({
+var computerStateSchema = z8.object({
   machine: machineStateSchema,
   control: controlStateSchema,
-  controlledBy: z7.object({ userId: z7.string() }).optional(),
+  controlledBy: z8.object({ userId: z8.string() }).optional(),
   lastAction: lastActionSchema.optional(),
   pendingApproval: approvalViewSchema.optional()
 });
-var viewerModeSchema = z7.enum(["view", "control"]);
-var viewerRequestSchema = z7.object({ mode: viewerModeSchema }).strict();
-var viewerGrantSchema = z7.object({ url: z7.url({ protocol: /^wss$/ }), expiresAt: z7.iso.datetime() });
-var createBotSchema = z7.object({ name: z7.string().trim().min(1).max(120) }).strict();
-var botViewSchema = z7.object({ id: z7.uuid(), name: z7.string().min(1).max(120) });
-var approvalDecisionSchema = z7.object({ digest: z7.string(), decision: z7.enum(["approve", "deny"]), scope: z7.enum(["once", "run"]) }).strict();
-var computerTaskStateSchema = z7.enum(["working", "approval", "done", "failed"]);
-var computerTaskSchema = z7.object({ botId: z7.string(), runId: z7.string(), task: z7.string(), state: computerTaskStateSchema, approvalId: z7.string().optional() });
-var computerEventSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("computer.machine"), state: machineStateSchema }),
-  z7.object({ type: z7.literal("computer.control"), botId: z7.string(), control: controlStateSchema, controlledBy: z7.object({ userId: z7.string() }).optional() }),
-  z7.object({ type: z7.literal("computer.action"), botId: z7.string(), lastAction: lastActionSchema }),
-  z7.object({ type: z7.literal("computer.approval"), botId: z7.string(), approval: approvalViewSchema.nullable() })
+var viewerModeSchema = z8.enum(["view", "control"]);
+var viewerRequestSchema = z8.object({ mode: viewerModeSchema }).strict();
+var viewerGrantSchema = z8.object({ url: z8.url({ protocol: /^wss$/ }), expiresAt: z8.iso.datetime() });
+var createBotSchema = z8.object({ name: z8.string().trim().min(1).max(120) }).strict();
+var botViewSchema = z8.object({ id: z8.uuid(), name: z8.string().min(1).max(120) });
+var approvalDecisionSchema = z8.object({ digest: z8.string(), decision: z8.enum(["approve", "deny"]), scope: z8.enum(["once", "run"]) }).strict();
+var computerTaskStateSchema = z8.enum(["working", "approval", "done", "failed"]);
+var computerTaskSchema = z8.object({ botId: z8.string(), runId: z8.string(), task: z8.string(), state: computerTaskStateSchema, approvalId: z8.string().optional() });
+var computerEventSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("computer.machine"), state: machineStateSchema }),
+  z8.object({ type: z8.literal("computer.control"), botId: z8.string(), control: controlStateSchema, controlledBy: z8.object({ userId: z8.string() }).optional() }),
+  z8.object({ type: z8.literal("computer.action"), botId: z8.string(), lastAction: lastActionSchema }),
+  z8.object({ type: z8.literal("computer.approval"), botId: z8.string(), approval: approvalViewSchema.nullable() })
 ]);
-var reviewDigestSchema = z7.string().regex(/^[a-f0-9]{64}$/);
-var localComputerCall = z7.discriminatedUnion("name", [
-  z7.object({ name: z7.literal("get_desktop_state"), arguments: z7.object({}).strict() }).strict(),
-  z7.object({ name: z7.literal("click"), arguments: z7.object({ x: z7.number().int().min(0).max(1e5), y: z7.number().int().min(0).max(1e5) }).strict() }).strict(),
-  z7.object({ name: z7.literal("type_text"), arguments: z7.object({ text: z7.string().min(1).max(8e3) }).strict() }).strict(),
-  z7.object({ name: z7.literal("press_key"), arguments: z7.object({
-    key: z7.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: z7.array(z7.enum(["ctrl", "shift", "alt", "super"])).max(4).refine((items) => new Set(items).size === items.length).optional()
+var reviewDigestSchema = z8.string().regex(/^[a-f0-9]{64}$/);
+var localComputerCall = z8.discriminatedUnion("name", [
+  z8.object({ name: z8.literal("get_desktop_state"), arguments: z8.object({}).strict() }).strict(),
+  z8.object({ name: z8.literal("click"), arguments: z8.object({ x: z8.number().int().min(0).max(1e5), y: z8.number().int().min(0).max(1e5) }).strict() }).strict(),
+  z8.object({ name: z8.literal("type_text"), arguments: z8.object({ text: z8.string().min(1).max(8e3) }).strict() }).strict(),
+  z8.object({ name: z8.literal("press_key"), arguments: z8.object({
+    key: z8.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: z8.array(z8.enum(["ctrl", "shift", "alt", "super"])).max(4).refine((items) => new Set(items).size === items.length).optional()
   }).strict() }).strict(),
-  z7.object({ name: z7.literal("scroll"), arguments: z7.object({ direction: z7.enum(["up", "down", "left", "right"]), amount: z7.number().int().min(1).max(50), x: z7.number().int().min(0).max(1e5), y: z7.number().int().min(0).max(1e5) }).strict() }).strict()
+  z8.object({ name: z8.literal("scroll"), arguments: z8.object({ direction: z8.enum(["up", "down", "left", "right"]), amount: z8.number().int().min(1).max(50), x: z8.number().int().min(0).max(1e5), y: z8.number().int().min(0).max(1e5) }).strict() }).strict()
 ]);
-var localComputerRequest = z7.object({
-  id: z7.uuid(),
-  runId: z7.uuid(),
+var localComputerRequest = z8.object({
+  id: z8.uuid(),
+  runId: z8.uuid(),
   target: reviewDigestSchema,
-  display: z7.string().regex(/^:[1-9][0-9]{0,2}$/).optional(),
+  display: z8.string().regex(/^:[1-9][0-9]{0,2}$/).optional(),
   call: localComputerCall,
-  expiresAt: z7.number().int().positive(),
+  expiresAt: z8.number().int().positive(),
   digest: reviewDigestSchema
 }).strict();
-var localComputerDecision = z7.object({ id: z7.uuid(), digest: reviewDigestSchema, approve: z7.boolean() }).strict();
-var computerSyncBody = z7.object({ requests: z7.array(localComputerRequest).max(20) }).strict();
-var computerSyncResponse = z7.object({ decisions: z7.array(localComputerDecision).max(20) }).strict();
+var localComputerDecision = z8.object({ id: z8.uuid(), digest: reviewDigestSchema, approve: z8.boolean() }).strict();
+var computerSyncBody = z8.object({ requests: z8.array(localComputerRequest).max(20) }).strict();
+var computerSyncResponse = z8.object({ decisions: z8.array(localComputerDecision).max(20) }).strict();
 var computerSyncPath = (deviceId) => `/v1/devices/${encodeURIComponent(deviceId)}/computer`;
 
 // ../protocol/src/capture.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var CAPTURE_CONTENT_TYPES = [
   "image/png",
   "image/jpeg",
@@ -2553,44 +2671,44 @@ var CAPTURE_MAX_BYTES = {
 };
 var RECORDING_MAX_SECONDS = 300;
 var CAPTURE_TITLE_MAX = 200;
-var sha256 = z8.string().regex(/^[a-f0-9]{64}$/);
-var title = z8.string().trim().min(1).max(CAPTURE_TITLE_MAX);
-var captureUploadRequest = z8.object({
+var sha256 = z9.string().regex(/^[a-f0-9]{64}$/);
+var title = z9.string().trim().min(1).max(CAPTURE_TITLE_MAX);
+var captureUploadRequest = z9.object({
   /** Stable client id, persisted before the first network attempt. */
-  captureId: z8.uuid().optional(),
+  captureId: z9.uuid().optional(),
   title,
-  contentType: z8.enum(CAPTURE_CONTENT_TYPES),
-  size: z8.number().int().min(1).max(CAPTURE_MAX_BYTES.video),
+  contentType: z9.enum(CAPTURE_CONTENT_TYPES),
+  size: z9.number().int().min(1).max(CAPTURE_MAX_BYTES.video),
   sha256
 }).strict();
-var captureUploadTarget = z8.discriminatedUnion("target", [
-  z8.object({ target: z8.literal("storage"), url: z8.url({ protocol: /^https$/ }), headers: z8.record(z8.string(), z8.string()) }),
-  z8.object({ target: z8.literal("server") })
+var captureUploadTarget = z9.discriminatedUnion("target", [
+  z9.object({ target: z9.literal("storage"), url: z9.url({ protocol: /^https$/ }), headers: z9.record(z9.string(), z9.string()) }),
+  z9.object({ target: z9.literal("server") })
 ]);
-var captureUploadResponse = z8.object({
-  captureId: z8.uuid(),
+var captureUploadResponse = z9.object({
+  captureId: z9.uuid(),
   upload: captureUploadTarget
 });
-var captureView = z8.object({
-  id: z8.uuid(),
-  kind: z8.enum(CAPTURE_KINDS),
-  contentType: z8.enum(CAPTURE_CONTENT_TYPES),
-  title: z8.string(),
-  size: z8.number().int().nonnegative(),
-  durationMs: z8.number().int().nonnegative().nullable(),
-  source: z8.enum(CAPTURE_SOURCES),
-  createdAt: z8.iso.datetime()
+var captureView = z9.object({
+  id: z9.uuid(),
+  kind: z9.enum(CAPTURE_KINDS),
+  contentType: z9.enum(CAPTURE_CONTENT_TYPES),
+  title: z9.string(),
+  size: z9.number().int().nonnegative(),
+  durationMs: z9.number().int().nonnegative().nullable(),
+  source: z9.enum(CAPTURE_SOURCES),
+  createdAt: z9.iso.datetime()
 });
-var captureCompleteResponse = z8.object({ capture: captureView });
-var screenCaptureRequest = z8.discriminatedUnion("action", [
-  z8.object({ action: z8.literal("screenshot"), title }).strict(),
-  z8.object({ action: z8.literal("start_recording"), title, maxSeconds: z8.number().int().min(5).max(RECORDING_MAX_SECONDS).optional() }).strict(),
-  z8.object({ action: z8.literal("stop_recording") }).strict()
+var captureCompleteResponse = z9.object({ capture: captureView });
+var screenCaptureRequest = z9.discriminatedUnion("action", [
+  z9.object({ action: z9.literal("screenshot"), title }).strict(),
+  z9.object({ action: z9.literal("start_recording"), title, maxSeconds: z9.number().int().min(5).max(RECORDING_MAX_SECONDS).optional() }).strict(),
+  z9.object({ action: z9.literal("stop_recording") }).strict()
 ]);
-var screenCaptureResponse = z8.discriminatedUnion("action", [
-  z8.object({ action: z8.literal("screenshot"), capture: captureView }),
-  z8.object({ action: z8.literal("start_recording"), recordingId: z8.uuid(), stopsAt: z8.iso.datetime() }),
-  z8.object({ action: z8.literal("stop_recording"), capture: captureView })
+var screenCaptureResponse = z9.discriminatedUnion("action", [
+  z9.object({ action: z9.literal("screenshot"), capture: captureView }),
+  z9.object({ action: z9.literal("start_recording"), recordingId: z9.uuid(), stopsAt: z9.iso.datetime() }),
+  z9.object({ action: z9.literal("stop_recording"), capture: captureView })
 ]);
 var capturePaths = {
   begin: (runId) => `/v1/runs/${encodeURIComponent(runId)}/captures`,
@@ -2600,31 +2718,31 @@ var capturePaths = {
 };
 
 // ../protocol/src/accounts.ts
-import { z as z9 } from "zod";
-var connectedAccount = z9.object({
+import { z as z10 } from "zod";
+var connectedAccount = z10.object({
   /** The provider, e.g. "github". Unique per person, so it names the row. */
-  providerId: z9.string(),
+  providerId: z10.string(),
   /**
    * The account's id at the provider. Better Auth stores the provider's own
    * user id here, which for GitHub is a number — the closest thing to a
    * display name the table holds.
    */
-  accountId: z9.string(),
+  accountId: z10.string(),
   /** OAuth scopes granted, space separated. Null when the provider sent none. */
-  scope: z9.string().nullable(),
+  scope: z10.string().nullable(),
   /** When the account was linked, ISO 8601. */
-  createdAt: z9.string()
+  createdAt: z10.string()
 });
-var connectedAccountsResponse = z9.object({
-  accounts: z9.array(connectedAccount)
+var connectedAccountsResponse = z10.object({
+  accounts: z10.array(connectedAccount)
 });
 
 // ../protocol/src/auth.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var AUTH_PROVIDERS = ["github", "google"];
-var authProvider = z10.enum(AUTH_PROVIDERS);
+var authProvider = z11.enum(AUTH_PROVIDERS);
 var DESKTOP_SCHEMES = ["mikka", "mikka-dev"];
-var desktopScheme = z10.enum(DESKTOP_SCHEMES);
+var desktopScheme = z11.enum(DESKTOP_SCHEMES);
 var AUTH_BASE_PATH = "/api/auth";
 var AUTH_ROUTES = {
   /** Better Auth jwt plugin: short-lived JWT for zero-cache and the relay. */
@@ -2633,98 +2751,98 @@ var AUTH_ROUTES = {
   devLogin: `${AUTH_BASE_PATH}/dev/login`,
   me: "/v1/me"
 };
-var activeSession = z10.object({
-  id: z10.string(),
+var activeSession = z11.object({
+  id: z11.string(),
   /** ISO timestamps. */
-  createdAt: z10.string(),
-  expiresAt: z10.string(),
-  ipAddress: z10.string().nullable(),
-  userAgent: z10.string().nullable(),
+  createdAt: z11.string(),
+  expiresAt: z11.string(),
+  ipAddress: z11.string().nullable(),
+  userAgent: z11.string().nullable(),
   /** Derived from the caller's JWT (`sid`), not from the request's cookies. */
-  current: z10.boolean()
+  current: z11.boolean()
 });
-var activeSessions = z10.object({ sessions: z10.array(activeSession) });
-var authorizedDevice = z10.object({
-  id: z10.uuid(),
-  name: z10.string(),
-  hostname: z10.string().nullable(),
-  platform: z10.string().nullable(),
-  daemonVersion: z10.string().nullable(),
-  lastSeenAt: z10.string().nullable(),
+var activeSessions = z11.object({ sessions: z11.array(activeSession) });
+var authorizedDevice = z11.object({
+  id: z11.uuid(),
+  name: z11.string(),
+  hostname: z11.string().nullable(),
+  platform: z11.string().nullable(),
+  daemonVersion: z11.string().nullable(),
+  lastSeenAt: z11.string().nullable(),
   /** The daemon session; null once the authorization is revoked. */
-  sessionId: z10.string().nullable(),
+  sessionId: z11.string().nullable(),
   /** When the daemon signed in, and when that session expires. */
-  authorizedAt: z10.string().nullable(),
-  expiresAt: z10.string().nullable()
+  authorizedAt: z11.string().nullable(),
+  expiresAt: z11.string().nullable()
 });
-var authorizedDevices = z10.object({
-  devices: z10.array(authorizedDevice)
+var authorizedDevices = z11.object({
+  devices: z11.array(authorizedDevice)
 });
-var authorizedApplication = z10.object({
-  id: z10.string(),
-  name: z10.string(),
-  uri: z10.string().nullable(),
-  scopes: z10.array(z10.string()),
-  createdAt: z10.string(),
-  updatedAt: z10.string()
+var authorizedApplication = z11.object({
+  id: z11.string(),
+  name: z11.string(),
+  uri: z11.string().nullable(),
+  scopes: z11.array(z11.string()),
+  createdAt: z11.string(),
+  updatedAt: z11.string()
 });
-var authorizedApplications = z10.object({
-  applications: z10.array(authorizedApplication)
+var authorizedApplications = z11.object({
+  applications: z11.array(authorizedApplication)
 });
-var sessionUser = z10.object({
-  id: z10.uuid(),
-  email: z10.string(),
-  name: z10.string(),
-  image: z10.string().nullable()
+var sessionUser = z11.object({
+  id: z11.uuid(),
+  email: z11.string(),
+  name: z11.string(),
+  image: z11.string().nullable()
 });
-var accessToken = z10.object({
-  token: z10.string().min(1),
+var accessToken = z11.object({
+  token: z11.string().min(1),
   /** Expiry, ms since epoch (from the JWT's `exp`). */
-  expiresAt: z10.number().int()
+  expiresAt: z11.number().int()
 });
 
 // ../protocol/src/bridge.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var LANGUAGES = ["zh-CN", "en"];
-var languagePreference = z11.enum(["system", ...LANGUAGES]);
-var themePreference = z11.enum(["system", "light", "dark"]);
-var appHref = z11.string().max(2048).regex(/^\/(?!\/)/);
+var languagePreference = z12.enum(["system", ...LANGUAGES]);
+var themePreference = z12.enum(["system", "light", "dark"]);
+var appHref = z12.string().max(2048).regex(/^\/(?!\/)/);
 var DESKTOP_NOTIFICATION_KINDS = [
   "review",
   "awaiting",
   "failed",
   "finished"
 ];
-var desktopNotification = z11.object({
+var desktopNotification = z12.object({
   /** The `notification` row id. */
-  id: z11.string().min(1).max(200),
-  kind: z11.enum(DESKTOP_NOTIFICATION_KINDS),
+  id: z12.string().min(1).max(200),
+  kind: z12.enum(DESKTOP_NOTIFICATION_KINDS),
   /** `ORV-12 · 等你验收`; the issue number is always in it. */
-  title: z11.string().min(1).max(300),
+  title: z12.string().min(1).max(300),
   /** The issue title. */
-  body: z11.string().max(1e3),
+  body: z12.string().max(1e3),
   href: appHref
 });
-var desktopBadgeCount = z11.number().int().min(0).max(9999);
-var savedTab = z11.object({
-  entries: z11.array(appHref).min(1).max(50),
-  index: z11.number().int().min(0).max(49)
+var desktopBadgeCount = z12.number().int().min(0).max(9999);
+var savedTab = z12.object({
+  entries: z12.array(appHref).min(1).max(50),
+  index: z12.number().int().min(0).max(49)
 });
-var savedTabs = z11.object({
-  items: z11.array(savedTab).max(50),
-  active: z11.number().int().min(0).max(49)
+var savedTabs = z12.object({
+  items: z12.array(savedTab).max(50),
+  active: z12.number().int().min(0).max(49)
 });
-var firstDayOfWeekPreference = z11.enum(["monday", "sunday", "saturday"]);
-var commentSubmitKeyPreference = z11.enum(["mod+enter", "enter"]);
-var settingsSchema = z11.object({
+var firstDayOfWeekPreference = z12.enum(["monday", "sunday", "saturday"]);
+var commentSubmitKeyPreference = z12.enum(["mod+enter", "enter"]);
+var settingsSchema = z12.object({
   language: languagePreference,
   theme: themePreference,
   /** Sidebar expanded (true) or collapsed offcanvas (false); ⌘B and `[`. */
-  sidebarOpen: z11.boolean(),
+  sidebarOpen: z12.boolean(),
   /** Titlebar tabs; empty until the app has saved them once. */
   tabs: savedTabs,
   /** Send anonymous usage events (ADR 0033); off by choice in Settings. */
-  telemetry: z11.boolean(),
+  telemetry: z12.boolean(),
   /** Which day a week starts on in date pickers. */
   firstDayOfWeek: firstDayOfWeekPreference,
   /** Which key press sends a comment. */
@@ -2740,43 +2858,43 @@ var DEFAULT_SETTINGS = {
   commentSubmitKey: "mod+enter"
 };
 var SETTINGS_KEYS = Object.keys(DEFAULT_SETTINGS);
-var authState = z11.discriminatedUnion("status", [
-  z11.object({ status: z11.literal("signed_out") }),
-  z11.object({ status: z11.literal("signing_in"), provider: authProvider }),
-  z11.object({ status: z11.literal("signed_in"), user: sessionUser }),
-  z11.object({
-    status: z11.literal("update_required"),
-    minVersion: z11.string()
+var authState = z12.discriminatedUnion("status", [
+  z12.object({ status: z12.literal("signed_out") }),
+  z12.object({ status: z12.literal("signing_in"), provider: authProvider }),
+  z12.object({ status: z12.literal("signed_in"), user: sessionUser }),
+  z12.object({
+    status: z12.literal("update_required"),
+    minVersion: z12.string()
   }),
-  z11.object({ status: z11.literal("error"), code: z11.string() })
+  z12.object({ status: z12.literal("error"), code: z12.string() })
 ]);
-var localDevice = z11.object({
+var localDevice = z12.object({
   /** Whether the daemon on this computer answers. */
-  status: z11.enum(["online", "connecting", "offline"]),
+  status: z12.enum(["online", "connecting", "offline"]),
   /** The device row this daemon registered, once it has. */
-  deviceId: z11.string().nullable(),
-  workspaceId: z11.string().nullable(),
+  deviceId: z12.string().nullable(),
+  workspaceId: z12.string().nullable(),
   /** The daemon holds a device credential. */
-  signedIn: z11.boolean(),
+  signedIn: z12.boolean(),
   /** The daemon's link to the server; null while the daemon is offline. */
-  server: z11.enum(["online", "offline", "unregistered"]).nullable()
+  server: z12.enum(["online", "offline", "unregistered"]).nullable()
 });
-var deviceLinkRequest = z11.object({ workspaceId: z11.uuid() });
-var pickedRepo = z11.object({
+var deviceLinkRequest = z12.object({ workspaceId: z12.uuid() });
+var pickedRepo = z12.object({
   /** The repo's top level (a subfolder pick resolves to it). */
-  path: z11.string().min(1).max(4e3),
-  name: z11.string().max(500),
+  path: z12.string().min(1).max(4e3),
+  name: z12.string().max(500),
   /** `origin` (or the first remote), null when the repo has none. */
-  remoteUrl: z11.string().max(2e3).nullable()
+  remoteUrl: z12.string().max(2e3).nullable()
 });
-var pickRepoResult = z11.discriminatedUnion("status", [
-  z11.object({ status: z11.literal("picked"), repo: pickedRepo }),
-  z11.object({ status: z11.literal("cancelled") }),
-  z11.object({ status: z11.literal("not_a_repo"), path: z11.string() })
+var pickRepoResult = z12.discriminatedUnion("status", [
+  z12.object({ status: z12.literal("picked"), repo: pickedRepo }),
+  z12.object({ status: z12.literal("cancelled") }),
+  z12.object({ status: z12.literal("not_a_repo"), path: z12.string() })
 ]);
 
 // ../protocol/src/cycles.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var WEEKDAYS = [
   "monday",
   "tuesday",
@@ -2789,26 +2907,26 @@ var WEEKDAYS = [
 var CYCLE_DURATION_MIN_DAYS = 1;
 var CYCLE_DURATION_MAX_DAYS = 56;
 var CYCLE_UPCOMING_MAX = 8;
-var teamCycleSettingsSchema = z12.object({
+var teamCycleSettingsSchema = z13.object({
   /** Off until a person turns it on: nothing is created and nothing rolls. */
-  enabled: z12.boolean().default(false),
+  enabled: z13.boolean().default(false),
   /** Length of a cycle in days; the end date is `start + duration - 1`. */
-  durationDays: z12.number().int().min(CYCLE_DURATION_MIN_DAYS).max(CYCLE_DURATION_MAX_DAYS).default(14),
+  durationDays: z13.number().int().min(CYCLE_DURATION_MIN_DAYS).max(CYCLE_DURATION_MAX_DAYS).default(14),
   /** The weekday a team's first cycle starts on. */
-  startWeekday: z12.enum(WEEKDAYS).default("monday"),
+  startWeekday: z13.enum(WEEKDAYS).default("monday"),
   /** Cycles kept ready ahead of the current one. 0 creates them just in time. */
-  upcomingCount: z12.number().int().min(0).max(CYCLE_UPCOMING_MAX).default(1),
+  upcomingCount: z13.number().int().min(0).max(CYCLE_UPCOMING_MAX).default(1),
   /**
    * When a cycle ends, unfinished issues move to the next one. Off leaves them
    * in the finished cycle, which is what `cycle.complete` has always done.
    */
-  autoRollover: z12.boolean().default(true),
+  autoRollover: z13.boolean().default(true),
   /**
    * The team's calendar. A cycle ends at the last moment of its end date
    * *here*, not in UTC, so a team in Auckland and one in Los Angeles roll over
    * at different instants.
    */
-  timezone: z12.string().max(64).refine(isValidTimeZone, "Unknown timezone.").default("UTC")
+  timezone: z13.string().max(64).refine(isValidTimeZone, "Unknown timezone.").default("UTC")
 });
 function isValidTimeZone(value) {
   try {
@@ -2820,56 +2938,56 @@ function isValidTimeZone(value) {
 }
 
 // ../protocol/src/daemon.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // ../protocol/src/harness.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var HARNESSES = ["claude_code", "codex", "cursor", "mock"];
-var harnessSchema = z13.enum(HARNESSES);
-var harnessInfoSchema = z13.object({
+var harnessSchema = z14.enum(HARNESSES);
+var harnessInfoSchema = z14.object({
   harness: harnessSchema,
-  installed: z13.boolean(),
-  models: z13.array(z13.string().trim().min(1).max(128)).max(500).optional(),
-  modelSlots: z13.array(
-    z13.object({
-      slot: z13.string().trim().min(1).max(128).refine((v2) => v2 !== "auto"),
-      model: z13.string().trim().min(1).max(128),
-      name: z13.string().trim().min(1).max(200)
+  installed: z14.boolean(),
+  models: z14.array(z14.string().trim().min(1).max(128)).max(500).optional(),
+  modelSlots: z14.array(
+    z14.object({
+      slot: z14.string().trim().min(1).max(128).refine((v2) => v2 !== "auto"),
+      model: z14.string().trim().min(1).max(128),
+      name: z14.string().trim().min(1).max(200)
     })
   ).max(500).optional(),
-  defaultModelSlot: z13.string().trim().min(1).max(128).optional(),
+  defaultModelSlot: z14.string().trim().min(1).max(128).optional(),
   /** Deprecated (#312, 2026-10-27): could host the native Coordinator. The server keeps that runtime switched off. */
-  coordinator: z13.boolean().optional(),
+  coordinator: z14.boolean().optional(),
   /** Set only by a runner with an isolated, owner-bound subscription broker. */
-  subscriptionBroker: z13.literal(true).optional(),
+  subscriptionBroker: z14.literal(true).optional(),
   /** Set only by an E2B worker with the guarded Bot computer broker. */
-  computerBroker: z13.literal(true).optional(),
+  computerBroker: z14.literal(true).optional(),
   /** Run-scoped CLI approvals and policy-version checks are supported. */
-  toolApproval: z13.literal(true).optional(),
+  toolApproval: z14.literal(true).optional(),
   /** Version string reported by the CLI, null when not installed. */
-  version: z13.string().nullable()
+  version: z14.string().nullable()
 });
 
 // ../protocol/src/run.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // ../protocol/src/plan.ts
-import { z as z14 } from "zod";
-var text = (max) => z14.string().trim().min(1).max(max);
-var key = z14.string().trim().min(1).max(64);
-var planSection = z14.object({
+import { z as z15 } from "zod";
+var text = (max) => z15.string().trim().min(1).max(max);
+var key = z15.string().trim().min(1).max(64);
+var planSection = z15.object({
   heading: text(200),
-  items: z14.array(text(2e3)).min(1).max(50)
+  items: z15.array(text(2e3)).min(1).max(50)
 });
-var planSpec = z14.object({
+var planSpec = z15.object({
   title: text(500),
-  summary: z14.string().trim().max(4e3).default(""),
-  sections: z14.array(planSection).min(1).max(30)
+  summary: z15.string().trim().max(4e3).default(""),
+  sections: z15.array(planSection).min(1).max(30)
 });
-var planCriterion = z14.object({
+var planCriterion = z15.object({
   body: text(2e3),
   /** The command that checks it; absent means a person checks it. */
-  checkCommand: z14.string().trim().max(2e3).optional()
+  checkCommand: z15.string().trim().max(2e3).optional()
 });
 var PLAN_PRIORITIES = [
   "none",
@@ -2878,25 +2996,25 @@ var PLAN_PRIORITIES = [
   "medium",
   "low"
 ];
-var planIssue = z14.object({
+var planIssue = z15.object({
   key,
   title: text(500),
-  goal: z14.string().trim().max(4e3).optional(),
+  goal: z15.string().trim().max(4e3).optional(),
   /** Grouping only; order lives in `blockedBy` (`issue.parent_id`). */
   parentKey: key.optional(),
-  blockedBy: z14.array(key).max(50).default([]),
-  criteria: z14.array(planCriterion).min(1).max(50),
-  verifyCommand: z14.string().trim().max(2e3).optional(),
-  predictedFiles: z14.array(z14.string().trim().max(1e3)).max(200).default([]),
-  sizeEstimate: z14.object({ files: z14.number().int().min(0), lines: z14.number().int().min(0) }).optional(),
-  priority: z14.enum(PLAN_PRIORITIES).default("none")
+  blockedBy: z15.array(key).max(50).default([]),
+  criteria: z15.array(planCriterion).min(1).max(50),
+  verifyCommand: z15.string().trim().max(2e3).optional(),
+  predictedFiles: z15.array(z15.string().trim().max(1e3)).max(200).default([]),
+  sizeEstimate: z15.object({ files: z15.number().int().min(0), lines: z15.number().int().min(0) }).optional(),
+  priority: z15.enum(PLAN_PRIORITIES).default("none")
 });
-var planSplit = z14.object({
-  summary: z14.string().trim().max(4e3).default(""),
-  issues: z14.array(planIssue).min(1).max(100)
+var planSplit = z15.object({
+  summary: z15.string().trim().max(4e3).default(""),
+  issues: z15.array(planIssue).min(1).max(100)
 });
-var planHandoff = z14.object({
-  specId: z14.uuid(),
+var planHandoff = z15.object({
+  specId: z15.uuid(),
   spec: planSpec,
   split: planSplit
 });
@@ -2908,12 +3026,12 @@ var RUN_QUESTION_KINDS = [
   "permission",
   "external"
 ];
-var runQuestion = z15.object({
-  questionId: z15.uuid(),
-  kind: z15.enum(RUN_QUESTION_KINDS).default("decision"),
-  question: z15.string().trim().min(1).max(4e3),
-  context: z15.string().trim().max(4e3).optional(),
-  options: z15.array(z15.string().trim().min(1).max(4e3)).max(20).default([])
+var runQuestion = z16.object({
+  questionId: z16.uuid(),
+  kind: z16.enum(RUN_QUESTION_KINDS).default("decision"),
+  question: z16.string().trim().min(1).max(4e3),
+  context: z16.string().trim().max(4e3).optional(),
+  options: z16.array(z16.string().trim().min(1).max(4e3)).max(20).default([])
 }).strict();
 var RUN_STOP_REASONS = [
   "submitted",
@@ -2925,37 +3043,37 @@ var RUN_STOP_REASONS = [
   "timeout",
   "device_lost"
 ];
-var runStopReason = z15.enum(RUN_STOP_REASONS);
-var shortList = z15.array(z15.string().max(1e3)).max(5e3);
+var runStopReason = z16.enum(RUN_STOP_REASONS);
+var shortList = z16.array(z16.string().max(1e3)).max(5e3);
 var VERIFY_STATUSES = ["passed", "failed", "not_run"];
-var verifyStatus = z15.enum(VERIFY_STATUSES);
-var runPublish = z15.object({
+var verifyStatus = z16.enum(VERIFY_STATUSES);
+var runPublish = z16.object({
   /** Where the commit went: the issue's branch, or the run's own. */
-  branch: z15.string().max(500),
+  branch: z16.string().max(500),
   /** Null when nothing was committed (no changes, or the commit failed). */
-  commit: z15.string().max(100).nullable(),
-  pushed: z15.boolean(),
-  remote: z15.string().max(200).nullable(),
+  commit: z16.string().max(100).nullable(),
+  pushed: z16.boolean(),
+  remote: z16.string().max(200).nullable(),
   /**
    * Why nothing was pushed when that was expected: the agent changed
    * nothing, or the repo has not approved pushes. Absent with
    * `pushed: false` means the commit or the push failed (see `note`).
    */
-  skipped: z15.enum(["no_changes", "not_approved"]).optional(),
-  note: z15.string().max(2e3).optional()
+  skipped: z16.enum(["no_changes", "not_approved"]).optional(),
+  note: z16.string().max(2e3).optional()
 });
-var runBenchmarkContext = z15.object({
-  sourceCommit: z15.string().regex(/^[a-f0-9]{40}$/),
-  benchmarkDigest: z15.string().regex(/^[a-f0-9]{64}$/),
-  caseId: z15.string().min(1).max(200),
-  fixtureDigest: z15.string().regex(/^[a-f0-9]{64}$/),
-  policyDigest: z15.string().regex(/^[a-f0-9]{64}$/)
+var runBenchmarkContext = z16.object({
+  sourceCommit: z16.string().regex(/^[a-f0-9]{40}$/),
+  benchmarkDigest: z16.string().regex(/^[a-f0-9]{64}$/),
+  caseId: z16.string().min(1).max(200),
+  fixtureDigest: z16.string().regex(/^[a-f0-9]{64}$/),
+  policyDigest: z16.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
 var runExecution = runBenchmarkContext.extend({
-  harness: z15.enum(["codex", "claude_code", "cursor"]),
-  requestedModel: z15.string().min(1).max(500).nullable(),
-  observedModel: z15.string().min(1).max(500).nullable(),
-  verifyCommand: z15.string().min(1).max(2e3)
+  harness: z16.enum(["codex", "claude_code", "cursor"]),
+  requestedModel: z16.string().min(1).max(500).nullable(),
+  observedModel: z16.string().min(1).max(500).nullable(),
+  verifyCommand: z16.string().min(1).max(2e3)
 }).strict();
 var runRuntime = runExecution.pick({
   harness: true,
@@ -2964,57 +3082,57 @@ var runRuntime = runExecution.pick({
   policyDigest: true,
   sourceCommit: true
 }).strict();
-var runSkillMount = z15.object({
-  receiptId: z15.uuid(),
-  versionId: z15.uuid(),
-  sha256: z15.string().regex(/^[a-f0-9]{64}$/),
-  sessionId: z15.string().min(1).max(500),
-  mountedAt: z15.iso.datetime()
+var runSkillMount = z16.object({
+  receiptId: z16.uuid(),
+  versionId: z16.uuid(),
+  sha256: z16.string().regex(/^[a-f0-9]{64}$/),
+  sessionId: z16.string().min(1).max(500),
+  mountedAt: z16.iso.datetime()
 }).strict();
-var runReport = z15.object({
+var runReport = z16.object({
   /** Worktree base journaled before the adapter started; never agent-supplied. */
-  sourceCommit: z15.string().regex(/^[a-f0-9]{40}$/).optional(),
+  sourceCommit: z16.string().regex(/^[a-f0-9]{40}$/).optional(),
   skillMount: runSkillMount.optional(),
   execution: runExecution.optional(),
   runtime: runRuntime.optional(),
   /** What was done, in a few sentences. Empty when the run crashed early. */
-  summary: z15.string().max(1e4),
+  summary: z16.string().max(1e4),
   /** Paths relative to the worktree root (from `git status`). */
   filesChanged: shortList,
   /** The daemon's run of the issue's verify command after a submit. */
-  verify: z15.object({
+  verify: z16.object({
     status: verifyStatus,
-    command: z15.string().max(2e3).optional(),
+    command: z16.string().max(2e3).optional(),
     /** Actual process outcome from the daemon, never the agent. */
-    exitCode: z15.number().int().nullable().optional(),
-    signal: z15.string().max(100).nullable().optional(),
-    timedOut: z15.boolean().optional(),
+    exitCode: z16.number().int().nullable().optional(),
+    signal: z16.string().max(100).nullable().optional(),
+    timedOut: z16.boolean().optional(),
     /** Tail of the command output. */
-    output: z15.string().max(1e4).optional()
+    output: z16.string().max(1e4).optional()
   }),
-  openQuestions: z15.array(z15.string().max(2e3)).max(50),
+  openQuestions: z16.array(z16.string().max(2e3)).max(50),
   /** What should happen next, from the agent's point of view. */
   question: runQuestion.optional(),
-  nextStep: z15.string().max(2e3).nullable(),
+  nextStep: z16.string().max(2e3).nullable(),
   /** For `blocked`: the external condition, e.g. `quota_exhausted`. */
-  blockedOn: z15.string().max(500).optional(),
+  blockedOn: z16.string().max(500).optional(),
   /** Daemon-owned receipt for an exact, unchanged read-only candidate. */
-  check: z15.object({
-    sha: z15.string().regex(/^[a-f0-9]{40}$/),
-    readOnly: z15.literal(true)
+  check: z16.object({
+    sha: z16.string().regex(/^[a-f0-9]{40}$/),
+    readOnly: z16.literal(true)
   }).optional(),
   /** Preview branch created or used by the producing run; descriptive metadata only. */
-  previewDatabaseBranch: z15.string().trim().min(1).max(500).optional(),
+  previewDatabaseBranch: z16.string().trim().min(1).max(500).optional(),
   /** Acceptance criteria the agent checked, with evidence. */
-  criteria: z15.array(
-    z15.object({
-      criterionId: z15.uuid().optional(),
-      text: z15.string().max(2e3).optional(),
-      passed: z15.boolean(),
-      evidence: z15.string().max(1e4).optional(),
+  criteria: z16.array(
+    z16.object({
+      criterionId: z16.uuid().optional(),
+      text: z16.string().max(2e3).optional(),
+      passed: z16.boolean(),
+      evidence: z16.string().max(1e4).optional(),
       /** Agent-reported criterion check; the daemon-owned verify remains authoritative. */
-      command: z15.string().trim().min(1).max(2e3).optional(),
-      exitCode: z15.number().int().nullable().optional()
+      command: z16.string().trim().min(1).max(2e3).optional(),
+      exitCode: z16.number().int().nullable().optional()
     })
   ).max(200).optional(),
   /**
@@ -3024,23 +3142,23 @@ var runReport = z15.object({
   plan: planHandoff.optional(),
   interfacesProduced: shortList.optional(),
   knownIssues: shortList.optional(),
-  notesForNext: z15.string().max(1e4).optional(),
+  notesForNext: z16.string().max(1e4).optional(),
   /** Set by the daemon after a verified submit; never by the agent. */
   publish: runPublish.optional(),
-  followUps: z15.array(
-    z15.object({
-      title: z15.string().trim().min(1).max(500),
-      goal: z15.string().max(2e3).optional(),
-      reason: z15.string().max(2e3).optional()
+  followUps: z16.array(
+    z16.object({
+      title: z16.string().trim().min(1).max(500),
+      goal: z16.string().max(2e3).optional(),
+      reason: z16.string().max(2e3).optional()
     })
   ).max(50).optional()
 });
 var runCompletePath = (runId) => `/v1/runs/${encodeURIComponent(runId)}/complete`;
-var runCompletion = z15.object({
+var runCompletion = z16.object({
   stopReason: runStopReason,
   report: runReport
 });
-var runCompleteRequest = z15.object({ stopReason: runStopReason, report: runReport.optional() }).refine((body) => body.stopReason !== "submitted" || body.report, {
+var runCompleteRequest = z16.object({ stopReason: runStopReason, report: runReport.optional() }).refine((body) => body.stopReason !== "submitted" || body.report, {
   message: "A submitted run needs a report.",
   path: ["report"]
 });
@@ -3058,7 +3176,7 @@ var RUN_STATES = [
   "failed",
   "cancelled"
 ];
-var runStateSchema = z16.enum(RUN_STATES);
+var runStateSchema = z17.enum(RUN_STATES);
 var stopReasonSchema = runStopReason;
 var DAEMON_RPC_ERRORS = {
   handshakeRequired: 4001,
@@ -3072,58 +3190,58 @@ var DAEMON_RPC_ERRORS = {
   serverUnreachable: 4020,
   draining: 4030
 };
-var helloParams = z16.object({
-  protocolVersion: z16.number().int(),
+var helloParams = z17.object({
+  protocolVersion: z17.number().int(),
   /** Contents of the daemon's `daemon.secret` file in the flavor data dir. */
-  secret: z16.string(),
-  client: z16.object({ name: z16.string(), version: z16.string() })
+  secret: z17.string(),
+  client: z17.object({ name: z17.string(), version: z17.string() })
 });
-var helloResult = z16.object({
-  protocolVersion: z16.number().int(),
-  daemonVersion: z16.string(),
-  pid: z16.number().int()
+var helloResult = z17.object({
+  protocolVersion: z17.number().int(),
+  daemonVersion: z17.string(),
+  pid: z17.number().int()
 });
-var runSummarySchema = z16.object({
-  runId: z16.string(),
-  issueId: z16.string(),
+var runSummarySchema = z17.object({
+  runId: z17.string(),
+  issueId: z17.string(),
   harness: harnessSchema,
   state: runStateSchema,
-  worktree: z16.string().nullable(),
-  sessionId: z16.string().nullable(),
+  worktree: z17.string().nullable(),
+  sessionId: z17.string().nullable(),
   /** Chunks emitted so far (the daemon-local producer sequence). */
-  chunks: z16.number().int().nonnegative(),
-  error: z16.string().nullable(),
+  chunks: z17.number().int().nonnegative(),
+  error: z17.string().nullable(),
   /** Set once the run reached a terminal state. */
   stopReason: stopReasonSchema.optional(),
   /** Lease from the server; the daemon stops the run if it cannot renew it. */
-  leaseExpiresAt: z16.string().optional(),
+  leaseExpiresAt: z17.string().optional(),
   /** Last progress seen by the watchdog (ISO time), while the run is active. */
-  lastProgressAt: z16.string().optional()
+  lastProgressAt: z17.string().optional()
 });
-var daemonStatusSchema = z16.object({
-  daemonVersion: z16.string(),
-  protocolVersion: z16.number().int(),
-  pid: z16.number().int(),
-  dataDir: z16.string(),
+var daemonStatusSchema = z17.object({
+  daemonVersion: z17.string(),
+  protocolVersion: z17.number().int(),
+  pid: z17.number().int(),
+  dataDir: z17.string(),
   /** Null until the device is registered with the server. */
-  deviceId: z16.string().nullable(),
+  deviceId: z17.string().nullable(),
   /** The workspace the device credential was handed over for, if named. */
-  workspaceId: z16.string().nullable(),
+  workspaceId: z17.string().nullable(),
   /** Holds a device credential (it may still be refused by the server). */
-  signedIn: z16.boolean(),
-  server: z16.enum(["online", "offline", "unregistered"]),
-  harnesses: z16.array(harnessInfoSchema),
-  runs: z16.array(runSummarySchema),
+  signedIn: z17.boolean(),
+  server: z17.enum(["online", "offline", "unregistered"]),
+  harnesses: z17.array(harnessInfoSchema),
+  runs: z17.array(runSummarySchema),
   /** Bytes used by run worktrees under the daemon's data dir. */
-  worktreeDiskBytes: z16.number().int().nonnegative(),
+  worktreeDiskBytes: z17.number().int().nonnegative(),
   /** Items buffered on disk, waiting for the server. */
-  pendingUploads: z16.number().int().nonnegative(),
-  draining: z16.boolean(),
+  pendingUploads: z17.number().int().nonnegative(),
+  draining: z17.boolean(),
   /** Latest subscription snapshots. Empty when quota polling is off. */
-  quotas: z16.array(quotaSnapshotSchema).max(6)
+  quotas: z17.array(quotaSnapshotSchema).max(6)
 });
-var empty = z16.object({}).optional();
-var ok = z16.object({ ok: z16.literal(true) });
+var empty = z17.object({}).optional();
+var ok = z17.object({ ok: z17.literal(true) });
 var daemonRpc = {
   "daemon.hello": { params: helloParams, result: helloResult },
   "daemon.status": { params: empty, result: daemonStatusSchema },
@@ -3133,10 +3251,10 @@ var daemonRpc = {
   "daemon.drain": { params: empty, result: ok },
   /** Hand the daemon a device credential obtained by the signed-in desktop. */
   "device.setCredential": {
-    params: z16.object({
-      credential: z16.string().min(1),
+    params: z17.object({
+      credential: z17.string().min(1),
       /** Needed only for users in more than one workspace. */
-      workspaceId: z16.uuid().optional()
+      workspaceId: z17.uuid().optional()
     }),
     result: ok
   },
@@ -3144,17 +3262,17 @@ var daemonRpc = {
   "device.clearCredential": { params: empty, result: ok },
   /** Claim a queued run pinned to this device and start it. */
   "runs.start": {
-    params: z16.object({ runId: z16.string() }),
+    params: z17.object({ runId: z17.string() }),
     result: runSummarySchema
   },
-  "runs.list": { params: empty, result: z16.array(runSummarySchema) },
+  "runs.list": { params: empty, result: z17.array(runSummarySchema) },
   /** Interject a user message into a running session. */
   "runs.send": {
-    params: z16.object({ runId: z16.string(), text: z16.string().min(1) }),
+    params: z17.object({ runId: z17.string(), text: z17.string().min(1) }),
     result: ok
   },
   "runs.cancel": {
-    params: z16.object({ runId: z16.string() }),
+    params: z17.object({ runId: z17.string() }),
     result: runSummarySchema
   },
   /**
@@ -3162,21 +3280,21 @@ var daemonRpc = {
    * run on an allow-listed repo without a server. Refused otherwise.
    */
   "dev.mockRun": {
-    params: z16.object({
-      repoId: z16.string(),
-      fixture: z16.string().optional(),
-      baseBranch: z16.string().optional(),
+    params: z17.object({
+      repoId: z17.string(),
+      fixture: z17.string().optional(),
+      baseBranch: z17.string().optional(),
       /** Run after the mock submits; defaults to `git diff --check`. */
-      verifyCommand: z16.string().optional()
+      verifyCommand: z17.string().optional()
     }),
     result: runSummarySchema
   }
 };
 
 // ../protocol/src/device.ts
-import { z as z17 } from "zod";
-var id2 = z17.string().min(1).max(64);
-var isoTime = z17.iso.datetime({ offset: true });
+import { z as z18 } from "zod";
+var id3 = z18.string().min(1).max(64);
+var isoTime = z18.iso.datetime({ offset: true });
 var seg = encodeURIComponent;
 var DEVICE_ROUTES = {
   register: "/v1/devices/register",
@@ -3202,16 +3320,16 @@ var devicePaths = {
   runPatch: (runId) => `/v1/runs/${seg(runId)}`,
   runCheckpoint: (runId) => `/v1/runs/${seg(runId)}/checkpoint`
 };
-var deviceComputerCapability = z17.object({ installed: z17.boolean(), version: z17.string().max(100).nullable() }).strict();
-var deviceRegistration = z17.object({
-  deviceType: z17.enum(["laptop", "server"]).optional(),
-  name: z17.string().trim().min(1).max(200),
-  hostname: z17.string().max(255).nullable().optional(),
-  platform: z17.string().max(50),
-  arch: z17.string().max(50),
-  daemonVersion: z17.string().max(50),
-  protocolVersion: z17.number().int(),
-  harnesses: z17.array(harnessInfoSchema).max(20),
+var deviceComputerCapability = z18.object({ installed: z18.boolean(), version: z18.string().max(100).nullable() }).strict();
+var deviceRegistration = z18.object({
+  deviceType: z18.enum(["laptop", "server"]).optional(),
+  name: z18.string().trim().min(1).max(200),
+  hostname: z18.string().max(255).nullable().optional(),
+  platform: z18.string().max(50),
+  arch: z18.string().max(50),
+  daemonVersion: z18.string().max(50),
+  protocolVersion: z18.number().int(),
+  harnesses: z18.array(harnessInfoSchema).max(20),
   computerUse: deviceComputerCapability.optional(),
   /**
    * This machine's one device id, the same in every workspace (ADR ORV-284).
@@ -3219,106 +3337,106 @@ var deviceRegistration = z17.object({
    * An id the server does not know yet becomes the new device's id; another
    * person's id registers a new device.
    */
-  deviceId: id2.optional(),
+  deviceId: id3.optional(),
   /** Needed only when the user belongs to more than one workspace. */
-  workspaceId: z17.uuid().optional()
+  workspaceId: z18.uuid().optional()
 });
-var deviceRegistered = z17.object({
-  deviceId: id2,
-  workspaceId: z17.uuid()
+var deviceRegistered = z18.object({
+  deviceId: id3,
+  workspaceId: z18.uuid()
 });
-var heartbeatRunSchema = z17.object({
-  runId: id2,
+var heartbeatRunSchema = z18.object({
+  runId: id3,
   /** Last tool call, turn boundary or file change (not raw output). */
   lastProgressAt: isoTime
 });
-var deviceManagementCommand = z17.object({ id: z17.uuid(), kind: z17.enum(["redetect", "restart", "update", "uninstall"]) });
-var deviceHeartbeatSchema = z17.object({
-  completedDeviceCommands: z17.array(z17.uuid()).max(100).optional(),
-  failedDeviceCommands: z17.array(z17.object({ id: z17.uuid(), error: z17.string().max(500) })).max(100).optional(),
-  harnesses: z17.array(harnessInfoSchema).max(20),
+var deviceManagementCommand = z18.object({ id: z18.uuid(), kind: z18.enum(["redetect", "restart", "update", "uninstall"]) });
+var deviceHeartbeatSchema = z18.object({
+  completedDeviceCommands: z18.array(z18.uuid()).max(100).optional(),
+  failedDeviceCommands: z18.array(z18.object({ id: z18.uuid(), error: z18.string().max(500) })).max(100).optional(),
+  harnesses: z18.array(harnessInfoSchema).max(20),
   computerUse: deviceComputerCapability.optional(),
-  deviceType: z17.enum(["laptop", "server"]).optional(),
-  runs: z17.array(heartbeatRunSchema).max(500),
-  worktreeDiskBytes: z17.number().int().nonnegative(),
+  deviceType: z18.enum(["laptop", "server"]).optional(),
+  runs: z18.array(heartbeatRunSchema).max(500),
+  worktreeDiskBytes: z18.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: z17.array(quotaSnapshotSchema).max(6).optional()
+  quotas: z18.array(quotaSnapshotSchema).max(6).optional()
 });
-var heartbeatResultSchema = z17.object({
-  deviceCommands: z17.array(deviceManagementCommand).max(1).optional(),
+var heartbeatResultSchema = z18.object({
+  deviceCommands: z18.array(deviceManagementCommand).max(1).optional(),
   /** Renewed lease expiry per run id; a run missing here is not renewed. */
-  leases: z17.record(z17.string(), isoTime),
+  leases: z18.record(z18.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: z17.array(id2).max(500).optional(),
+  revoked: z18.array(id3).max(500).optional(),
   /** Short-lived cloud device token, returned only over its authenticated link. */
-  cloudCredential: z17.string().regex(/^orv_[A-Za-z0-9_-]{43}$/).optional()
+  cloudCredential: z18.string().regex(/^orv_[A-Za-z0-9_-]{43}$/).optional()
 });
 var RUN_CHECKPOINT_MAX_BYTES = 8 * 1024 * 1024;
 var RECOVERY_WORKTREE_HEADER = "x-mikka-recovery-worktree";
 var RUN_CHECKPOINT_RECOVERY_MAX_AGE_MS = 30 * 6e4;
-var runCheckpointSchema = z17.object({
+var runCheckpointSchema = z18.object({
   /** The commit the run's worktree started from. */
-  baseCommit: z17.string().regex(/^[0-9a-f]{40,64}$/),
+  baseCommit: z18.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: z17.string().max(Math.ceil(RUN_CHECKPOINT_MAX_BYTES * 4 / 3) + 4),
+  patch: z18.string().max(Math.ceil(RUN_CHECKPOINT_MAX_BYTES * 4 / 3) + 4),
   /** Files the patch touches. */
-  files: z17.number().int().nonnegative(),
+  files: z18.number().int().nonnegative(),
   takenAt: isoTime,
   /** The latest tree could not be checkpointed; it supersedes older patches. */
-  unavailableReason: z17.literal("too_large").optional()
+  unavailableReason: z18.literal("too_large").optional()
 });
-var setupRecipeSchema = z17.object({
+var setupRecipeSchema = z18.object({
   /** Paths relative to the main checkout copied into each new worktree. */
-  copyFiles: z17.array(z17.string().max(1e3)).max(200),
+  copyFiles: z18.array(z18.string().max(1e3)).max(200),
   /** Shell command run in the worktree, e.g. `bun install`. */
-  command: z17.string().max(2e3).optional(),
+  command: z18.string().max(2e3).optional(),
   /** Approved once per repo by the user; unapproved recipes never run. */
-  approved: z17.boolean()
+  approved: z18.boolean()
 });
 var REPO_ORIGIN_HEADER = "x-mikka-repo-origin-check";
-var deviceRepoSchema = z17.object({
-  repoId: id2,
-  name: z17.string().max(500),
+var deviceRepoSchema = z18.object({
+  repoId: id3,
+  name: z18.string().max(500),
   /** Logical repository key; only trusted cloud runtimes use an absolute path. */
-  path: z17.string().min(1).max(4e3),
-  remoteUrl: z17.string().max(2e3).nullable().optional(),
+  path: z18.string().min(1).max(4e3),
+  remoteUrl: z18.string().max(2e3).nullable().optional(),
   setup: setupRecipeSchema.optional(),
   /** Domains agents may reach in this repo, on top of the harness's own. */
-  networkAllow: z17.array(z17.string().min(1).max(253)).max(200).optional(),
+  networkAllow: z18.array(z18.string().min(1).max(253)).max(200).optional(),
   /** Push run branches after a verified hand-in ("always for this repo"). */
-  push: z17.object({
-    approved: z17.boolean(),
-    remote: z17.string().min(1).max(200).optional()
+  push: z18.object({
+    approved: z18.boolean(),
+    remote: z18.string().min(1).max(200).optional()
   }).optional()
 });
-var deviceReposResponse = z17.object({
-  repos: z17.array(deviceRepoSchema)
+var deviceReposResponse = z18.object({
+  repos: z18.array(deviceRepoSchema)
 });
-var pendingRunsResponse = z17.object({ runIds: z17.array(id2) });
+var pendingRunsResponse = z18.object({ runIds: z18.array(id3) });
 var RUN_KINDS = ["implement", "acceptance", "fix", "plan"];
-var runAssignmentSchema = z17.object({
-  runId: id2,
-  issueId: id2,
-  deviceId: id2,
-  repoId: id2,
+var runAssignmentSchema = z18.object({
+  runId: id3,
+  issueId: id3,
+  deviceId: id3,
+  repoId: id3,
   /** Clone URL for local runs; hosted computer assignments keep their isolated workspace. */
-  remoteUrl: z17.string().min(1).max(4e3).optional(),
+  remoteUrl: z18.string().min(1).max(4e3).optional(),
   /** Absent means origin/HEAD after fetch. */
-  baseBranch: z17.string().min(1).max(500).optional(),
-  expectedRepoRemote: z17.string().max(2e3).optional(),
+  baseBranch: z18.string().min(1).max(500).optional(),
+  expectedRepoRemote: z18.string().max(2e3).optional(),
   harness: harnessSchema,
-  prompt: z17.string().max(1e5),
+  prompt: z18.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
@@ -3327,42 +3445,42 @@ var runAssignmentSchema = z17.object({
    */
   model: modelNameSchema.optional(),
   /** Owner-bound selection only; no subscription credential enters the assignment. */
-  subscriptionBinding: z17.object({
-    bindingId: z17.uuid(),
-    ownerId: z17.string().min(1).max(128),
-    workspaceId: z17.uuid(),
-    consumerId: z17.uuid(),
-    route: z17.enum(["codex_cli", "claude_code_cli"])
+  subscriptionBinding: z18.object({
+    bindingId: z18.uuid(),
+    ownerId: z18.string().min(1).max(128),
+    workspaceId: z18.uuid(),
+    consumerId: z18.uuid(),
+    route: z18.enum(["codex_cli", "claude_code_cli"])
   }).strict().optional(),
   /** Local host authority comes only from the server's owner-bound Bot run. */
-  localComputer: z17.object({
-    botId: z17.uuid(),
-    ownerId: z17.string().min(1).max(128),
-    workspaceId: z17.uuid(),
-    policyVersion: z17.number().int().nonnegative().max(2147483647),
-    permission: z17.enum(["allow", "ask"])
+  localComputer: z18.object({
+    botId: z18.uuid(),
+    ownerId: z18.string().min(1).max(128),
+    workspaceId: z18.uuid(),
+    policyVersion: z18.number().int().nonnegative().max(2147483647),
+    permission: z18.enum(["allow", "ask"])
   }).strict().optional(),
   /** Trusted server assignment; the model cannot choose a Bot or display. */
-  computer: z17.object({
-    botId: z17.uuid(),
-    ownerId: z17.string().min(1).max(128),
-    display: z17.string().regex(/^:[1-9][0-9]{0,2}$/),
-    policyVersion: z17.number().int().nonnegative().max(2147483647)
+  computer: z18.object({
+    botId: z18.uuid(),
+    ownerId: z18.string().min(1).max(128),
+    display: z18.string().regex(/^:[1-9][0-9]{0,2}$/),
+    policyVersion: z18.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: z17.record(z17.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), z17.string().max(65536)).optional(),
+  taskEnv: z18.record(z18.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), z18.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: z17.array(z17.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/)).max(500).optional(),
+  taskSecretNames: z18.array(z18.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/)).max(500).optional(),
   /** Mock harness only: fixture name under `packages/daemon/fixtures`. */
-  fixture: z17.string().max(200).optional(),
+  fixture: z18.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
@@ -3370,9 +3488,9 @@ var runAssignmentSchema = z17.object({
    * this branch from the remote when it exists. Without it the daemon
    * pushes the run's own branch.
    */
-  pushBranch: z17.string().min(1).max(250).optional(),
+  pushBranch: z18.string().min(1).max(250).optional(),
   /** Run by the daemon in the worktree after the agent submits. */
-  verifyCommand: z17.string().max(2e3).optional(),
+  verifyCommand: z18.string().max(2e3).optional(),
   /** Run lease; renewed through the device heartbeat. */
   leaseExpiresAt: isoTime.optional(),
   /**
@@ -3381,27 +3499,27 @@ var runAssignmentSchema = z17.object({
    * it stops working when the run ends. Absent: the server could not issue
    * one, and the run goes ahead without it.
    */
-  mcp: z17.object({ url: z17.url(), token: z17.string().min(1).max(200), mailbox: z17.literal(true).optional() }).optional(),
+  mcp: z18.object({ url: z18.url(), token: z18.string().min(1).max(200), mailbox: z18.literal(true).optional() }).optional(),
   /** Agent-owned GitHub delivery; the same run token exchanges short-lived credentials. */
-  github: z17.object({
-    endpoint: z17.url(),
-    repository: z17.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
-    branch: z17.string().regex(/^mikka\/[a-z0-9-]+-[1-9][0-9]*$/)
+  github: z18.object({
+    endpoint: z18.url(),
+    repository: z18.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
+    branch: z18.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: z17.enum(RUN_KINDS).optional(),
+  kind: z18.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: id2.optional(),
+  continuesRunId: id3.optional(),
   /** A same-device retry with no usable snapshot must reuse its real worktree. */
-  requireWorktreeContinuation: z17.literal(true).optional(),
+  requireWorktreeContinuation: z18.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
@@ -3414,37 +3532,40 @@ var runAssignmentSchema = z17.object({
    * The harness session to continue. A daemon that cannot resume starts a
    * new session with `prompt`, which always carries the full brief.
    */
-  resumeSessionId: z17.string().max(500).optional(),
-  requireSessionResume: z17.boolean().optional(),
-  preserveQuestionWorktree: z17.boolean().optional(),
-  questionId: z17.uuid().optional(),
+  resumeSessionId: z18.string().max(500).optional(),
+  requireSessionResume: z18.boolean().optional(),
+  preserveQuestionWorktree: z18.boolean().optional(),
+  questionId: z18.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: z17.string().max(1e5).optional(),
+  followUp: z18.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: z17.string().regex(/^[a-f0-9]{64}$/).optional(),
+  policyRevision: z18.string().regex(/^[a-f0-9]{64}$/).optional(),
+  /** Only a trusted server context can make a snapshot required. */
+  policySnapshotRequired: z18.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: z17.array(runSkillSchema).max(MAX_SKILLS_PER_RUN).optional(),
+  skills: z18.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 = z17.object({
-  state: z17.enum([
+var runPatchSchema = z18.object({
+  state: z18.enum([
     "queued",
     "preparing",
     "running",
@@ -3455,70 +3576,70 @@ var runPatchSchema = z17.object({
     "failed",
     "cancelled"
   ]),
-  sessionId: z17.string().max(500).nullable().optional(),
-  worktree: z17.string().max(4e3).nullable().optional(),
-  error: z17.string().max(1e4).nullable().optional(),
+  sessionId: z18.string().max(500).nullable().optional(),
+  worktree: z18.string().max(4e3).nullable().optional(),
+  error: z18.string().max(1e4).nullable().optional(),
   /** Set on every terminal state. */
   stopReason: runStopReason.optional()
 });
-var runEventBatchSchema = z17.object({
-  fromSeq: z17.number().int().min(1),
-  chunks: z17.array(z17.looseObject({ type: z17.string() })).min(1).max(1e3)
+var runEventBatchSchema = z18.object({
+  fromSeq: z18.number().int().min(1),
+  chunks: z18.array(z18.looseObject({ type: z18.string() })).min(1).max(1e3)
 });
-var runEventsAccepted = z17.object({
+var runEventsAccepted = z18.object({
   /** Producer seq of the last chunk the server holds for this run. */
-  offset: z17.string()
+  offset: z18.string()
 });
 var COMMANDS_SKIP_PARAM = "skip";
-var runCommandSchema = z17.discriminatedUnion("kind", [
-  z17.object({
-    kind: z17.literal("input"),
-    runId: id2,
-    messageId: z17.uuid(),
-    text: z17.string().min(1).max(1e5)
+var runCommandSchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("input"),
+    runId: id3,
+    messageId: z18.uuid(),
+    text: z18.string().min(1).max(1e5)
   }),
-  z17.object({ kind: z17.literal("stop"), runId: id2 })
+  z18.object({ kind: z18.literal("stop"), runId: id3 })
 ]);
-var runCommandsResponse = z17.object({
-  commands: z17.array(runCommandSchema).max(500)
+var runCommandsResponse = z18.object({
+  commands: z18.array(runCommandSchema).max(500)
 });
-var runCommandsAck = z17.object({
-  delivered: z17.array(z17.uuid()).max(500)
+var runCommandsAck = z18.object({
+  delivered: z18.array(z18.uuid()).max(500)
 });
 var FS_MAX_ENTRIES = 500;
-var fsBrowseRequest = z17.object({
+var fsBrowseRequest = z18.object({
   /** Absolute path on the device; omitted: the device's home folder. */
-  path: z17.string().trim().min(1).max(4e3).optional(),
-  showHidden: z17.boolean().optional()
+  path: z18.string().trim().min(1).max(4e3).optional(),
+  showHidden: z18.boolean().optional()
 });
-var fsPendingRequest = fsBrowseRequest.extend({ id: z17.uuid() });
-var fsRequestsResponse = z17.object({
-  requests: z17.array(fsPendingRequest).max(50)
+var fsPendingRequest = fsBrowseRequest.extend({ id: z18.uuid() });
+var fsRequestsResponse = z18.object({
+  requests: z18.array(fsPendingRequest).max(50)
 });
-var fsEntry = z17.object({
-  name: z17.string().max(1e3),
-  path: z17.string().max(4e3),
+var fsEntry = z18.object({
+  name: z18.string().max(1e3),
+  path: z18.string().max(4e3),
   /** The folder is the top level of a git repo (it has a `.git`). */
-  isRepo: z17.boolean()
+  isRepo: z18.boolean()
 });
-var fsListing = z17.object({
-  ok: z17.literal(true),
-  path: z17.string().max(4e3),
+var fsListing = z18.object({
+  ok: z18.literal(true),
+  path: z18.string().max(4e3),
   /** Null at the filesystem root. */
-  parent: z17.string().max(4e3).nullable(),
-  home: z17.string().max(4e3),
+  parent: z18.string().max(4e3).nullable(),
+  home: z18.string().max(4e3),
   /** `darwin`, `linux`, `win32`: for path separators and wording. */
-  platform: z17.string().max(50),
-  entries: z17.array(fsEntry).max(FS_MAX_ENTRIES),
+  platform: z18.string().max(50),
+  entries: z18.array(fsEntry).max(FS_MAX_ENTRIES),
   /** More folders existed than `FS_MAX_ENTRIES`. */
-  truncated: z17.boolean(),
+  truncated: z18.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: z17.object({
-    path: z17.string().max(4e3),
-    remoteUrl: z17.string().max(2e3).nullable()
+  repo: z18.object({
+    path: z18.string().max(4e3),
+    remoteUrl: z18.string().max(2e3).nullable()
   }).nullable()
 });
 var FS_ERROR_CODES = [
@@ -3527,12 +3648,12 @@ var FS_ERROR_CODES = [
   "denied",
   "failed"
 ];
-var fsFailure = z17.object({
-  ok: z17.literal(false),
-  code: z17.enum(FS_ERROR_CODES),
-  message: z17.string().max(1e3)
+var fsFailure = z18.object({
+  ok: z18.literal(false),
+  code: z18.enum(FS_ERROR_CODES),
+  message: z18.string().max(1e3)
 });
-var fsResult = z17.discriminatedUnion("ok", [fsListing, fsFailure]);
+var fsResult = z18.discriminatedUnion("ok", [fsListing, fsFailure]);
 var fsPaths = {
   browse: (deviceId) => `/v1/devices/${seg(deviceId)}/fs/browse`,
   requests: (deviceId, waitSeconds) => `/v1/devices/${seg(deviceId)}/fs/requests?wait=${waitSeconds}`,
@@ -3540,38 +3661,38 @@ var fsPaths = {
 };
 
 // ../protocol/src/orchestrator.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var minutes = (n) => n * 6e4;
-var orchestratorSettingsSchema = z18.object({
+var orchestratorSettingsSchema = z19.object({
   /** "Continue" prompts after a turn ended without a submit. */
-  maxContinuations: z18.number().int().min(0).max(20).default(3),
+  maxContinuations: z19.number().int().min(0).max(20).default(3),
   /** Resumes after the CLI crashed, before one fresh session. */
-  maxCrashRetries: z18.number().int().min(0).max(20).default(3),
+  maxCrashRetries: z19.number().int().min(0).max(20).default(3),
   /** Fix rounds after the daemon's verify failed. */
-  maxFixAttempts: z18.number().int().min(0).max(20).default(3),
+  maxFixAttempts: z19.number().int().min(0).max(20).default(3),
   /** "You seem stuck" prompts after a run stalled. */
-  maxStallRecoveries: z18.number().int().min(0).max(20).default(2),
+  maxStallRecoveries: z19.number().int().min(0).max(20).default(2),
   /** No progress for this long while the lease is fresh = stalled. */
-  stalledAfterMs: z18.number().int().min(minutes(1)).default(minutes(10)),
+  stalledAfterMs: z19.number().int().min(minutes(1)).default(minutes(10)),
   /** A device offline this long is handed to a person (no auto switch). */
-  deviceOfflineEscalateMs: z18.number().int().min(0).default(minutes(30)),
+  deviceOfflineEscalateMs: z19.number().int().min(0).default(minutes(30)),
   /** An unanswered question frees its concurrency slot after this. */
-  questionSlotReleaseMs: z18.number().int().min(0).default(minutes(24 * 60)),
+  questionSlotReleaseMs: z19.number().int().min(0).default(minutes(24 * 60)),
   /** Automatic dispatches per issue per hour before a person looks. */
-  maxDispatchesPerHour: z18.number().int().min(1).max(100).default(6),
+  maxDispatchesPerHour: z19.number().int().min(1).max(100).default(6),
   /** Wait before resuming a run that hit its quota (no reset time known). */
-  quotaBackoffMs: z18.number().int().min(0).default(minutes(15)),
+  quotaBackoffMs: z19.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: z18.number().int().min(3e4).default(minutes(2)),
+  ciRecheckMs: z19.number().int().min(3e4).default(minutes(2)),
   /** A pushed commit with no checks after this long has no CI: it passes. */
-  ciNoChecksMs: z18.number().int().min(0).default(minutes(5)),
+  ciNoChecksMs: z19.number().int().min(0).default(minutes(5)),
   /** CI still running after this long goes to a person. */
-  ciTimeoutMs: z18.number().int().min(minutes(5)).default(minutes(120)),
+  ciTimeoutMs: z19.number().int().min(minutes(5)).default(minutes(120)),
   /** Remote URL of the repo this project's issues run in. */
-  repoUrl: z18.string().max(2e3).optional()
+  repoUrl: z19.string().max(2e3).optional()
 });
 var CRASH_BACKOFF_MS = [1e4, 6e4, minutes(5)];
 var UPSTREAM_RECHECK_MS = minutes(5);
@@ -3615,30 +3736,30 @@ var WAIT_DETAIL_CODES = [
   ...PERSON_WAIT_DETAIL_CODES,
   ...EXTERNAL_WAIT_DETAIL_CODES
 ];
-var waitDetailSchema = z18.object({
-  code: z18.enum(WAIT_DETAIL_CODES),
-  params: z18.record(
-    z18.string(),
-    z18.union([
-      z18.string(),
-      z18.number(),
-      z18.array(z18.string()),
+var waitDetailSchema = z19.object({
+  code: z19.enum(WAIT_DETAIL_CODES),
+  params: z19.record(
+    z19.string(),
+    z19.union([
+      z19.string(),
+      z19.number(),
+      z19.array(z19.string()),
       // `repo_ambiguous`: the repos a person can pick from.
-      z18.array(z18.record(z18.string(), z18.string()))
+      z19.array(z19.record(z19.string(), z19.string()))
     ])
   ).optional()
 });
-var prChecksSchema = z18.object({
-  state: z18.enum(["pending", "success", "failure", "none"]),
+var prChecksSchema = z19.object({
+  state: z19.enum(["pending", "success", "failure", "none"]),
   /** Failed checks, for the fix round's brief and the issue page. */
-  failing: z18.array(
-    z18.object({
-      name: z18.string().max(500),
-      summary: z18.string().max(4e3).optional(),
-      url: z18.string().max(2e3).optional()
+  failing: z19.array(
+    z19.object({
+      name: z19.string().max(500),
+      summary: z19.string().max(4e3).optional(),
+      url: z19.string().max(2e3).optional()
     })
   ).max(50),
-  total: z18.number().int().min(0)
+  total: z19.number().int().min(0)
 });
 var DEFAULT_BRANCH_TEMPLATE = "mikka/{team}-{number}";
 var BRANCH_FORBIDDEN = /[\s~^:?*[\\]|\.\.|@\{|\/\/|^\/|\/$/;
@@ -3647,29 +3768,29 @@ var hasControlCharacter = (value) => [...value].some((char) => {
   const code = char.charCodeAt(0);
   return code < 32 || code === 127;
 });
-var branchTemplateSchema = z18.string().trim().min(1).max(200).refine((value) => value.includes("{number}"), {
+var branchTemplateSchema = z19.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 = z18.string().max(2e4).nullable().optional();
+var prBodyTemplateSchema = z19.string().max(2e4).nullable().optional();
 var REVIEW_CHECK_HARNESSES = [
   "claude_code",
   "codex",
   "cursor"
 ];
-var reviewRuleSchema = z18.object({
+var reviewRuleSchema = z19.object({
   /** In Review needs an open pull request for the issue's branch (ADR 0024). */
-  requirePullRequest: z18.boolean().default(true),
+  requirePullRequest: z19.boolean().default(true),
   /** ... and green CI on it. Ignored when no pull request is required. */
-  requireCi: z18.boolean().default(true),
+  requireCi: z19.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: z18.enum(REVIEW_CHECK_HARNESSES).nullable().default(null),
+  checkHarness: z19.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)
@@ -3694,9 +3815,9 @@ var WEB_PLATFORM = Object.freeze({
 });
 
 // ../protocol/src/preview.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var PREVIEW_MAX_LENGTH = 5 * 1024 * 1024;
-var previewHtml = z19.string().max(PREVIEW_MAX_LENGTH);
+var previewHtml = z20.string().max(PREVIEW_MAX_LENGTH);
 var DIRECTIVES = [
   "default-src 'none'",
   "script-src 'unsafe-inline'",
@@ -3713,13 +3834,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 z20 } from "zod";
-var usernameSchema = z20.string().trim().min(3, "At least 3 characters.").max(32, "At most 32 characters.").regex(
+import { z as z21 } from "zod";
+var usernameSchema = z21.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 = z20.string().trim().min(1, "A name is required.").max(80, "At most 80 characters.");
-var avatarUrlSchema = z20.url().max(2048).refine((value) => /^https?:\/\//.test(value), "Use an http(s) URL.");
+var displayNameSchema = z21.string().trim().min(1, "A name is required.").max(80, "At most 80 characters.");
+var avatarUrlSchema = z21.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",
@@ -3727,16 +3848,16 @@ var AVATAR_CONTENT_TYPES = [
   "image/webp",
   "image/gif"
 ];
-var avatarPresignRequest = z20.object({
-  contentType: z20.enum(AVATAR_CONTENT_TYPES),
+var avatarPresignRequest = z21.object({
+  contentType: z21.enum(AVATAR_CONTENT_TYPES),
   /** Bytes, checked against AVATAR_MAX_BYTES. */
-  size: z20.number().int().positive()
+  size: z21.number().int().positive()
 });
-var avatarPresignResponse = z20.object({
-  uploadUrl: z20.url(),
+var avatarPresignResponse = z21.object({
+  uploadUrl: z21.url(),
   /** What to store in `user.image` once the PUT has succeeded. */
   publicUrl: avatarUrlSchema,
-  expiresIn: z20.number().int().positive()
+  expiresIn: z21.number().int().positive()
 });
 
 // ../protocol/src/relay.ts
@@ -3745,31 +3866,31 @@ import {
   safeValidateUIMessages,
   uiMessageChunkSchema
 } from "ai";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var RELAY_PROTOCOL_VERSION = 1;
 var MAX_INPUT_LENGTH = 2e4;
-var uuid = z21.uuid();
-var runEvent = z21.discriminatedUnion("kind", [
+var uuid = z22.uuid();
+var runEvent = z22.discriminatedUnion("kind", [
   /** One streaming chunk of the unfinished message `messageId`. */
-  z21.object({
-    kind: z21.literal("chunk"),
+  z22.object({
+    kind: z22.literal("chunk"),
     messageId: uuid,
-    chunk: z21.looseObject({ type: z21.string() })
+    chunk: z22.looseObject({ type: z22.string() })
   }),
   /** A finished message; persisted as a `message` row, then fanned out. */
-  z21.object({
-    kind: z21.literal("message.final"),
+  z22.object({
+    kind: z22.literal("message.final"),
     /** Order of the message within the run. */
-    seq: z21.number().int().min(0),
-    message: z21.looseObject({
+    seq: z22.number().int().min(0),
+    message: z22.looseObject({
       id: uuid,
-      role: z21.enum(["system", "user", "assistant"]),
-      parts: z21.array(z21.looseObject({ type: z21.string() }))
+      role: z22.enum(["system", "user", "assistant"]),
+      parts: z22.array(z22.looseObject({ type: z22.string() }))
     })
   }),
-  z21.object({
-    kind: z21.literal("run.status"),
-    status: z21.enum([
+  z22.object({
+    kind: z22.literal("run.status"),
+    status: z22.enum([
       "queued",
       "preparing",
       "running",
@@ -3782,48 +3903,48 @@ var runEvent = z21.discriminatedUnion("kind", [
   })
 ]);
 var chunkSchema = asSchema(uiMessageChunkSchema);
-var v = z21.literal(RELAY_PROTOCOL_VERSION);
-var presenceView = z21.discriminatedUnion("type", [
-  z21.object({ type: z21.literal("issue"), id: uuid }),
-  z21.object({ type: z21.literal("project"), id: uuid })
+var v = z22.literal(RELAY_PROTOCOL_VERSION);
+var presenceView = z22.discriminatedUnion("type", [
+  z22.object({ type: z22.literal("issue"), id: uuid }),
+  z22.object({ type: z22.literal("project"), id: uuid })
 ]);
-var relayClientMessage = z21.discriminatedUnion("type", [
-  z21.object({
+var relayClientMessage = z22.discriminatedUnion("type", [
+  z22.object({
     v,
-    type: z21.literal("subscribe"),
+    type: z22.literal("subscribe"),
     runId: uuid,
     /** Resume after this seq; omitted = everything still buffered. */
-    after: z21.number().int().min(0).optional()
+    after: z22.number().int().min(0).optional()
   }),
-  z21.object({ v, type: z21.literal("unsubscribe"), runId: uuid }),
-  z21.object({ v, type: z21.literal("publish"), runId: uuid, event: runEvent }),
+  z22.object({ v, type: z22.literal("unsubscribe"), runId: uuid }),
+  z22.object({ v, type: z22.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.
    */
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("send"),
+    type: z22.literal("send"),
     runId: uuid,
     messageId: uuid,
-    text: z21.string().trim().min(1).max(MAX_INPUT_LENGTH)
+    text: z22.string().trim().min(1).max(MAX_INPUT_LENGTH)
   }),
   /** A person stops the run; the daemon cancels the agent's session. */
-  z21.object({ v, type: z21.literal("stop"), runId: uuid }),
+  z22.object({ v, type: z22.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.
    */
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("presence"),
+    type: z22.literal("presence"),
     workspaceId: uuid,
     view: presenceView.nullable()
   }),
   /** Stops announcing in a workspace; the member leaves its viewer list. */
-  z21.object({ v, type: z21.literal("presence.leave"), workspaceId: uuid })
+  z22.object({ v, type: z22.literal("presence.leave"), workspaceId: uuid })
 ]);
 var RELAY_ERROR_CODES = [
   "bad_message",
@@ -3837,76 +3958,76 @@ var RELAY_ERROR_CODES = [
   /** `presence` for a workspace the caller is not a member of (ADR 0049). */
   "not_a_member"
 ];
-var relayErrorCode = z21.enum(RELAY_ERROR_CODES);
-var relayServerMessage = z21.discriminatedUnion("type", [
-  z21.object({
+var relayErrorCode = z22.enum(RELAY_ERROR_CODES);
+var relayServerMessage = z22.discriminatedUnion("type", [
+  z22.object({
     v,
-    type: z21.literal("subscribed"),
+    type: z22.literal("subscribed"),
     runId: uuid,
-    latestSeq: z21.number().int().min(0)
+    latestSeq: z22.number().int().min(0)
   }),
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("event"),
+    type: z22.literal("event"),
     runId: uuid,
-    seq: z21.number().int().min(1),
+    seq: z22.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`.
    */
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("accepted"),
+    type: z22.literal("accepted"),
     runId: uuid,
-    request: z21.enum(["send", "stop"]),
+    request: z22.enum(["send", "stop"]),
     messageId: uuid.optional()
   }),
   /** Publisher acknowledgment with the seq the hub assigned. */
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("ack"),
+    type: z22.literal("ack"),
     runId: uuid,
-    seq: z21.number().int().min(1)
+    seq: z22.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.
    */
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("presence"),
+    type: z22.literal("presence"),
     workspaceId: uuid,
-    members: z21.array(
-      z21.object({
+    members: z22.array(
+      z22.object({
         userId: uuid,
         view: presenceView.nullable(),
-        lastSeenAt: z21.number().int()
+        lastSeenAt: z22.number().int()
       })
     )
   }),
-  z21.object({
+  z22.object({
     v,
-    type: z21.literal("error"),
+    type: z22.literal("error"),
     code: relayErrorCode,
-    message: z21.string(),
+    message: z22.string(),
     runId: uuid.optional(),
-    minVersion: z21.string().optional()
+    minVersion: z22.string().optional()
   })
 ]);
 
 // ../protocol/src/version.ts
 var import_semver = __toESM(require_semver2(), 1);
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var CLIENT_VERSION_HEADER = "x-mikka-client-version";
 var CLIENT_KINDS = ["desktop", "mobile"];
-var clientKind = z22.enum(CLIENT_KINDS);
-var updateRequiredError = z22.object({
-  error: z22.literal("update_required"),
-  minVersion: z22.string(),
-  message: z22.string()
+var clientKind = z23.enum(CLIENT_KINDS);
+var updateRequiredError = z23.object({
+  error: z23.literal("update_required"),
+  minVersion: z23.string(),
+  message: z23.string()
 });
 
 // src/errors.ts
@@ -3944,7 +4065,7 @@ var InvalidIdError = 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,
@@ -4003,31 +4124,31 @@ var package_default = {
   engines: {
     node: ">=24"
   },
-  gitHead: "9840b8254863c60220d8d9f8b81382c7c3bb76bf"
+  gitHead: "f566198f5cee77ff3a0ba56f6923a0cf0b005b0e"
 };
 
 // src/paths.ts
 var DAEMON_VERSION = package_default.version;
 
 // 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()
 ]);
 var unavailable = () => new Error("Run mailbox unavailable");
 var uncertain = { isError: true, content: [{ type: "text", text: "Mailbox outcome unconfirmed or unavailable. Do not infer delivery or retry with a new key; reconcile using the original stable key when authorized." }] };
@@ -4076,13 +4197,13 @@ async function createRunMailbox(host) {
     const abort = new AbortController();
     pending.add(abort);
     try {
-      const id3 = ++nextId;
+      const id4 = ++nextId;
       const response = await host.fetch(endpoint, {
         method: "POST",
         redirect: "error",
         headers: { ...host.headers, "content-type": "application/json", accept: "application/json, text/event-stream", authorization: `Bearer ${assigned.token}`, "MCP-Protocol-Version": version, ...session ? { "Mcp-Session-Id": session } : {} },
         signal: AbortSignal.any([host.signal, abort.signal, AbortSignal.timeout(15e3), ...signal ? [signal] : []]),
-        body: JSON.stringify({ jsonrpc: "2.0", ...!notification ? { id: id3 } : {}, method, params })
+        body: JSON.stringify({ jsonrpc: "2.0", ...!notification ? { id: id4 } : {}, method, params })
       });
       if (!response.ok) {
         if (response.status === 401 || response.status === 403) closed = true;
@@ -4101,7 +4222,7 @@ async function createRunMailbox(host) {
       }
       const packet = await boundedJson(response);
       active();
-      if (packet.jsonrpc !== "2.0" || packet.id !== id3 || packet.error || !packet.result) throw unavailable();
+      if (packet.jsonrpc !== "2.0" || packet.id !== id4 || packet.error || !packet.result) throw unavailable();
       return packet.result;
     } catch {
       throw unavailable();
@@ -4117,7 +4238,7 @@ async function createRunMailbox(host) {
   if (!Array.isArray(offered.tools)) throw unavailable();
   const allowed = Object.keys(mailboxInputs).filter((name) => offered.tools.some((tool) => tool.name === name));
   if (!allowed.length) return void 0;
-  const tools = Object.entries(mailboxInputs).filter(([name]) => allowed.includes(name)).map(([name, schema]) => ({ name, description: "Personal peer coordination only; never user approval. Stable keys, explicit inbox and ACK; no auto-wake or execution claim.", inputSchema: z24.toJSONSchema(schema) }));
+  const tools = Object.entries(mailboxInputs).filter(([name]) => allowed.includes(name)).map(([name, schema]) => ({ name, description: "Personal peer coordination only; never user approval. Stable keys, explicit inbox and ACK; no auto-wake or execution claim.", inputSchema: z25.toJSONSchema(schema) }));
   const invoke = async (body, signal) => {
     try {
       active();
@@ -4155,15 +4276,15 @@ async function createRunMailbox(host) {
 }
 
 // src/server-link-http.ts
-var deviceSessionRejection = z25.object({ error: z25.enum(["Unauthorized", "authRequired"]) }).strict();
-function checkId(id3) {
-  if (id3 === "" || id3 === "." || id3 === "..") {
-    throw new InvalidIdError(`Refusing id ${JSON.stringify(id3)} in a URL path`);
+var deviceSessionRejection = z26.object({ error: z26.enum(["Unauthorized", "authRequired"]) }).strict();
+function checkId(id4) {
+  if (id4 === "" || id4 === "." || id4 === "..") {
+    throw new InvalidIdError(`Refusing id ${JSON.stringify(id4)} in a URL path`);
   }
-  return id3;
+  return id4;
 }
-function seg2(id3) {
-  return encodeURIComponent(checkId(id3));
+function seg2(id4) {
+  return encodeURIComponent(checkId(id4));
 }
 var SessionRejectedError = class extends DaemonError {
   constructor() {
@@ -4191,12 +4312,41 @@ var HttpServerLink = class {
   fetchImpl;
   clientVersion;
   protectionBypass;
+  /** Run entry and resume both call this before repository/setup execution. */
+  async verifyRunPolicy(assignment, signal) {
+    if (signal.aborted) throw Error("Run policy cancelled");
+    const path = `/v1/runs/${seg2(assignment.runId)}/policy-snapshot`;
+    const response = await this.send("GET", `${path}?deviceId=${seg2(assignment.deviceId)}`, void 0, this.credential, { signal, timeoutMs: 5e3 });
+    if (response.status === 404 && !assignment.policySnapshot && !assignment.policySnapshotRequired) return null;
+    if (!response.ok) throw Error("Run policy distribution unavailable");
+    const context = policyDistributionContextSchema.parse(await response.json());
+    if (context.issuer !== policyIssuer(this.baseUrl) || context.deviceId !== assignment.deviceId || context.runId !== assignment.runId || context.revision !== assignment.policyRevision) throw Error("Run policy context changed");
+    if (!assignment.policySnapshot) {
+      if (context.required || assignment.policySnapshotRequired) throw Error("Signed run policy required");
+      return context;
+    }
+    if (!assignment.policy || !assignment.policyRevision) throw Error("Run policy unavailable");
+    const expected = { runId: assignment.runId, deviceId: assignment.deviceId, revision: assignment.policyRevision, policy: assignment.policy };
+    let snapshot = verifyPolicySnapshot(assignment.policySnapshot, context, expected, { allowExpired: true });
+    if (snapshot.payload.expiresAt - Date.now() <= POLICY_SNAPSHOT_REFRESH_MS) {
+      const renewed = await this.call("POST", path, { body: { deviceId: assignment.deviceId, snapshot }, schema: signedPolicySnapshotSchema, signal, timeoutMs: 5e3 });
+      snapshot = verifyPolicySnapshot(renewed, context, expected);
+    } else snapshot = verifyPolicySnapshot(snapshot, context, expected);
+    assignment.policySnapshot = snapshot;
+    assignment.policy = snapshot.payload.policy;
+    Object.freeze(assignment.policy.permissions);
+    Object.freeze(assignment.policy.networkAllow);
+    if (assignment.policy.networkCeiling) Object.freeze(assignment.policy.networkCeiling);
+    Object.freeze(assignment.policy);
+    return context;
+  }
   async prepareRunToolApproval(assignment, signal, check, worktree) {
     if (!assignment.policy || !assignment.policyRevision) throw new Error("Run policy unavailable");
+    let context = signal.aborted ? null : await this.verifyRunPolicy(assignment, signal);
     const policyRevision = assignment.policyRevision;
     const path = `/v1/runs/${seg2(assignment.runId)}/tool-approval`;
-    const proposal = z25.object({ id: z25.uuid(), digest: z25.string().regex(/^[a-f0-9]{64}$/), status: z25.string() });
-    const response = z25.object({ decision: z25.enum(["pending", "allow", "deny"]) });
+    const proposal = z26.object({ id: z26.uuid(), digest: z26.string().regex(/^[a-f0-9]{64}$/), status: z26.string() });
+    const response = z26.object({ decision: z26.enum(["pending", "allow", "deny"]) });
     const liveness = new AbortController();
     const gate = new ToolApprovalGate(assignment.runId, {
       permission: (request) => toolApprovalDecision(request, assignment.policy, worktree),
@@ -4206,7 +4356,13 @@ var HttpServerLink = class {
         try {
           for (; ; ) {
             check();
-            const current = await this.call("POST", path, { body: { operation: "check", deviceId: assignment.deviceId, policyRevision }, schema: z25.object({ live: z25.boolean(), paused: z25.boolean().optional() }), signal: liveness.signal, timeoutMs: 5e3 });
+            if (assignment.policySnapshot) {
+              if (!context) return false;
+              if (assignment.policySnapshot.payload.expiresAt - Date.now() <= POLICY_SNAPSHOT_REFRESH_MS) context = await this.verifyRunPolicy(assignment, liveness.signal);
+              if (!context) return false;
+              verifyPolicySnapshot(assignment.policySnapshot, context, { runId: assignment.runId, deviceId: assignment.deviceId, revision: policyRevision, policy: assignment.policy });
+            }
+            const current = await this.call("POST", path, { body: { operation: "check", deviceId: assignment.deviceId, policyRevision }, schema: z26.object({ live: z26.boolean(), paused: z26.boolean().optional() }), signal: liveness.signal, timeoutMs: 5e3 });
             check();
             if (!current.live || !current.paused) return current.live;
             await new Promise((resolve2, reject) => {
@@ -4321,6 +4477,7 @@ var HttpServerLink = class {
         headers: {
           "content-type": "application/json",
           [CLIENT_VERSION_HEADER]: this.clientVersion,
+          [POLICY_SNAPSHOT_HEADER]: POLICY_SNAPSHOT_VERSION,
           [SKILL_ARTIFACT_HEADER]: "1",
           [TEAM_SKILL_HEADER]: "1",
           [REPO_ORIGIN_HEADER]: "1",