@aspectlylabs/mikka 0.0.64 → 0.0.65

package/cli.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 z31 = options.includePrerelease ? "-0" : "";
+      const z32 = 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${z31} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z32} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
-          ret = `>=${M}.${m}.0${z31} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M}.${m}.0${z32} <${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 z31 = options.includePrerelease ? "-0" : "";
+      const z32 = 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${z31} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z32} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
           if (M === "0") {
-            ret = `>=${M}.${m}.0${z31} <${M}.${+m + 1}.0-0`;
+            ret = `>=${M}.${m}.0${z32} <${M}.${+m + 1}.0-0`;
           } else {
-            ret = `>=${M}.${m}.0${z31} <${+M + 1}.0.0-0`;
+            ret = `>=${M}.${m}.0${z32} <${+M + 1}.0.0-0`;
           }
         } else if (pr) {
           debug("replaceCaret pr", pr);
@@ -3210,37 +3210,91 @@ var daemonRpc = {
 };
 
 // ../protocol/src/device.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
+
+// ../protocol/src/policy-snapshot.ts
+import { z as z11 } from "zod";
+var POLICY_SNAPSHOT_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 = z11.string().min(1).max(128);
+var digest = z11.string().regex(/^[a-f0-9]{64}$/);
+var policyScopeSchema = z11.strictObject({
+  workspaceIds: z11.array(id).max(2),
+  hierarchy: z11.strictObject({ workspaceId: z11.uuid(), teamId: z11.uuid(), projectId: z11.uuid().nullable() }).nullable()
+});
+var policySnapshotPayloadSchema = z11.strictObject({
+  version: z11.literal(1),
+  issuer: z11.url().max(1e3),
+  ownerId: id,
+  deviceId: id,
+  runId: id,
+  revision: digest,
+  policyHash: digest,
+  scope: policyScopeSchema,
+  policy: runPolicySchema,
+  issuedAt: z11.number().int().nonnegative(),
+  expiresAt: z11.number().int().nonnegative()
+});
+var signedPolicySnapshotSchema = z11.strictObject({
+  algorithm: z11.literal("Ed25519"),
+  keyId: digest,
+  payload: policySnapshotPayloadSchema,
+  signature: z11.string().regex(/^[A-Za-z0-9_-]{86}$/)
+});
+var policyDistributionContextSchema = z11.strictObject({
+  version: z11.literal(1),
+  algorithm: z11.literal("Ed25519"),
+  keyId: digest,
+  publicKey: z11.string().regex(/^[A-Za-z0-9_-]{59}$/),
+  issuer: z11.url().max(1e3),
+  ownerId: id,
+  deviceId: id,
+  runId: id,
+  revision: digest,
+  scope: policyScopeSchema,
+  required: z11.boolean()
+});
+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/skill.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // ../protocol/src/skill-artifact.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var SKILL_ARTIFACT_HEADER = "x-mikka-skill-artifacts";
 var TEAM_SKILL_HEADER = "x-mikka-team-skills";
-var skillArtifactRefSchema = z11.object({
-  schemaVersion: z11.literal(1),
-  registryId: z11.enum(["mikka-builtin", "mikka-team"]),
-  skillId: z11.uuid(),
-  versionId: z11.uuid(),
-  format: z11.literal("single-skill-md-v1"),
-  sha256: z11.string().regex(/^[a-f0-9]{64}$/)
+var skillArtifactRefSchema = z12.object({
+  schemaVersion: z12.literal(1),
+  registryId: z12.enum(["mikka-builtin", "mikka-team"]),
+  skillId: z12.uuid(),
+  versionId: z12.uuid(),
+  format: z12.literal("single-skill-md-v1"),
+  sha256: z12.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var skillAssignmentReceiptSchema = z11.object({
-  id: z11.uuid(),
-  runId: z11.uuid(),
-  issueId: z11.uuid(),
-  agentId: z11.uuid(),
-  repoId: z11.uuid(),
-  deviceId: z11.uuid(),
-  leaseExpiresAt: z11.iso.datetime(),
-  assignedAt: z11.iso.datetime(),
+var skillAssignmentReceiptSchema = z12.object({
+  id: z12.uuid(),
+  runId: z12.uuid(),
+  issueId: z12.uuid(),
+  agentId: z12.uuid(),
+  repoId: z12.uuid(),
+  deviceId: z12.uuid(),
+  leaseExpiresAt: z12.iso.datetime(),
+  assignedAt: z12.iso.datetime(),
   artifact: skillArtifactRefSchema
 }).strict();
-var skillReceiptRevalidationSchema = z11.object({
+var skillReceiptRevalidationSchema = z12.object({
   skillReceipt: skillAssignmentReceiptSchema,
-  leaseExpiresAt: z11.iso.datetime()
+  leaseExpiresAt: z12.iso.datetime()
 }).strict();
 
 // ../protocol/src/skill.ts
@@ -3252,27 +3306,27 @@ var MAX_SKILL_FILES = 20;
 var MAX_SKILL_FILE_PATH_LENGTH = 200;
 var MAX_SKILL_FILE_CONTENT_LENGTH = 1e5;
 var SKILLS_HEADING = "Skills from your workspace (apply them on this task):";
-var skillFilePathSchema = z12.string().min(1).max(MAX_SKILL_FILE_PATH_LENGTH).refine(
+var skillFilePathSchema = z13.string().min(1).max(MAX_SKILL_FILE_PATH_LENGTH).refine(
   (path) => !path.startsWith("/") && !path.includes("\\") && !path.split("/").some((segment) => segment === ".." || segment === ""),
   { message: "A skill file path must be relative and stay inside the skill." }
 );
-var skillFileSchema = z12.object({
+var skillFileSchema = z13.object({
   path: skillFilePathSchema,
-  content: z12.string().max(MAX_SKILL_FILE_CONTENT_LENGTH)
+  content: z13.string().max(MAX_SKILL_FILE_CONTENT_LENGTH)
 });
-var skillFilesSchema = z12.array(skillFileSchema).max(MAX_SKILL_FILES);
-var skillNameSchema = z12.string().trim().min(1).max(MAX_SKILL_NAME_LENGTH);
-var skillDescriptionSchema = z12.string().trim().max(MAX_SKILL_DESCRIPTION_LENGTH);
-var skillInstructionsSchema = z12.string().trim().min(1).max(MAX_SKILL_INSTRUCTIONS_LENGTH);
-var runSkillSchema = z12.object({
-  id: z12.uuid(),
+var skillFilesSchema = z13.array(skillFileSchema).max(MAX_SKILL_FILES);
+var skillNameSchema = z13.string().trim().min(1).max(MAX_SKILL_NAME_LENGTH);
+var skillDescriptionSchema = z13.string().trim().max(MAX_SKILL_DESCRIPTION_LENGTH);
+var skillInstructionsSchema = z13.string().trim().min(1).max(MAX_SKILL_INSTRUCTIONS_LENGTH);
+var runSkillSchema = z13.object({
+  id: z13.uuid(),
   name: skillNameSchema,
-  description: z12.string().nullable(),
+  description: z13.string().nullable(),
   instructions: skillInstructionsSchema,
   files: skillFilesSchema
 });
-var runSkillRefSchema = z12.object({
-  id: z12.uuid(),
+var runSkillRefSchema = z13.object({
+  id: z13.uuid(),
   name: skillNameSchema
 });
 function skillSlug(name) {
@@ -3311,8 +3365,8 @@ function skillsPromptSection(skills, directory) {
 }
 
 // ../protocol/src/device.ts
-var id = z13.string().min(1).max(64);
-var isoTime = z13.iso.datetime({ offset: true });
+var id2 = z14.string().min(1).max(64);
+var isoTime = z14.iso.datetime({ offset: true });
 var RUN_LEASE_MS = 9e4;
 var seg = encodeURIComponent;
 var DEVICE_ROUTES = {
@@ -3339,16 +3393,16 @@ var devicePaths = {
   runPatch: (runId) => `/v1/runs/${seg(runId)}`,
   runCheckpoint: (runId) => `/v1/runs/${seg(runId)}/checkpoint`
 };
-var deviceComputerCapability = z13.object({ installed: z13.boolean(), version: z13.string().max(100).nullable() }).strict();
-var deviceRegistration = z13.object({
-  deviceType: z13.enum(["laptop", "server"]).optional(),
-  name: z13.string().trim().min(1).max(200),
-  hostname: z13.string().max(255).nullable().optional(),
-  platform: z13.string().max(50),
-  arch: z13.string().max(50),
-  daemonVersion: z13.string().max(50),
-  protocolVersion: z13.number().int(),
-  harnesses: z13.array(harnessInfoSchema).max(20),
+var deviceComputerCapability = z14.object({ installed: z14.boolean(), version: z14.string().max(100).nullable() }).strict();
+var deviceRegistration = z14.object({
+  deviceType: z14.enum(["laptop", "server"]).optional(),
+  name: z14.string().trim().min(1).max(200),
+  hostname: z14.string().max(255).nullable().optional(),
+  platform: z14.string().max(50),
+  arch: z14.string().max(50),
+  daemonVersion: z14.string().max(50),
+  protocolVersion: z14.number().int(),
+  harnesses: z14.array(harnessInfoSchema).max(20),
   computerUse: deviceComputerCapability.optional(),
   /**
    * This machine's one device id, the same in every workspace (ADR ORV-284).
@@ -3356,106 +3410,106 @@ var deviceRegistration = z13.object({
    * An id the server does not know yet becomes the new device's id; another
    * person's id registers a new device.
    */
-  deviceId: id.optional(),
+  deviceId: id2.optional(),
   /** Needed only when the user belongs to more than one workspace. */
-  workspaceId: z13.uuid().optional()
+  workspaceId: z14.uuid().optional()
 });
-var deviceRegistered = z13.object({
-  deviceId: id,
-  workspaceId: z13.uuid()
+var deviceRegistered = z14.object({
+  deviceId: id2,
+  workspaceId: z14.uuid()
 });
-var heartbeatRunSchema = z13.object({
-  runId: id,
+var heartbeatRunSchema = z14.object({
+  runId: id2,
   /** Last tool call, turn boundary or file change (not raw output). */
   lastProgressAt: isoTime
 });
-var deviceManagementCommand = z13.object({ id: z13.uuid(), kind: z13.enum(["redetect", "restart", "update", "uninstall"]) });
-var deviceHeartbeatSchema = z13.object({
-  completedDeviceCommands: z13.array(z13.uuid()).max(100).optional(),
-  failedDeviceCommands: z13.array(z13.object({ id: z13.uuid(), error: z13.string().max(500) })).max(100).optional(),
-  harnesses: z13.array(harnessInfoSchema).max(20),
+var deviceManagementCommand = z14.object({ id: z14.uuid(), kind: z14.enum(["redetect", "restart", "update", "uninstall"]) });
+var deviceHeartbeatSchema = z14.object({
+  completedDeviceCommands: z14.array(z14.uuid()).max(100).optional(),
+  failedDeviceCommands: z14.array(z14.object({ id: z14.uuid(), error: z14.string().max(500) })).max(100).optional(),
+  harnesses: z14.array(harnessInfoSchema).max(20),
   computerUse: deviceComputerCapability.optional(),
-  deviceType: z13.enum(["laptop", "server"]).optional(),
-  runs: z13.array(heartbeatRunSchema).max(500),
-  worktreeDiskBytes: z13.number().int().nonnegative(),
+  deviceType: z14.enum(["laptop", "server"]).optional(),
+  runs: z14.array(heartbeatRunSchema).max(500),
+  worktreeDiskBytes: z14.number().int().nonnegative(),
   /**
    * Subscription windows read on this device. Absent when the daemon is not
    * polling. Numbers only, never a vendor credential (ADR 0027).
    */
-  quotas: z13.array(quotaSnapshotSchema).max(6).optional()
+  quotas: z14.array(quotaSnapshotSchema).max(6).optional()
 });
-var heartbeatResultSchema = z13.object({
-  deviceCommands: z13.array(deviceManagementCommand).max(1).optional(),
+var heartbeatResultSchema = z14.object({
+  deviceCommands: z14.array(deviceManagementCommand).max(1).optional(),
   /** Renewed lease expiry per run id; a run missing here is not renewed. */
-  leases: z13.record(z13.string(), isoTime),
+  leases: z14.record(z14.string(), isoTime),
   /**
    * Runs the device reported that it no longer holds: they ended on the
    * server, or went to another attempt after the lease ran out. The daemon
    * stops them now instead of when their lease runs out.
    */
-  revoked: z13.array(id).max(500).optional(),
+  revoked: z14.array(id2).max(500).optional(),
   /** Short-lived cloud device token, returned only over its authenticated link. */
-  cloudCredential: z13.string().regex(/^orv_[A-Za-z0-9_-]{43}$/).optional()
+  cloudCredential: z14.string().regex(/^orv_[A-Za-z0-9_-]{43}$/).optional()
 });
 var RUN_CHECKPOINT_MAX_BYTES = 8 * 1024 * 1024;
 var RECOVERY_WORKTREE_HEADER = "x-mikka-recovery-worktree";
 var RUN_CHECKPOINT_RECOVERY_MAX_AGE_MS = 30 * 6e4;
-var runCheckpointSchema = z13.object({
+var runCheckpointSchema = z14.object({
   /** The commit the run's worktree started from. */
-  baseCommit: z13.string().regex(/^[0-9a-f]{40,64}$/),
+  baseCommit: z14.string().regex(/^[0-9a-f]{40,64}$/),
   /**
    * `git diff --binary` from `baseCommit` to the whole worktree (tracked
    * and untracked files, ignored ones left out, the agent's own commits
    * included), gzipped, base64.
    */
-  patch: z13.string().max(Math.ceil(RUN_CHECKPOINT_MAX_BYTES * 4 / 3) + 4),
+  patch: z14.string().max(Math.ceil(RUN_CHECKPOINT_MAX_BYTES * 4 / 3) + 4),
   /** Files the patch touches. */
-  files: z13.number().int().nonnegative(),
+  files: z14.number().int().nonnegative(),
   takenAt: isoTime,
   /** The latest tree could not be checkpointed; it supersedes older patches. */
-  unavailableReason: z13.literal("too_large").optional()
+  unavailableReason: z14.literal("too_large").optional()
 });
-var setupRecipeSchema = z13.object({
+var setupRecipeSchema = z14.object({
   /** Paths relative to the main checkout copied into each new worktree. */
-  copyFiles: z13.array(z13.string().max(1e3)).max(200),
+  copyFiles: z14.array(z14.string().max(1e3)).max(200),
   /** Shell command run in the worktree, e.g. `bun install`. */
-  command: z13.string().max(2e3).optional(),
+  command: z14.string().max(2e3).optional(),
   /** Approved once per repo by the user; unapproved recipes never run. */
-  approved: z13.boolean()
+  approved: z14.boolean()
 });
 var REPO_ORIGIN_HEADER = "x-mikka-repo-origin-check";
-var deviceRepoSchema = z13.object({
-  repoId: id,
-  name: z13.string().max(500),
+var deviceRepoSchema = z14.object({
+  repoId: id2,
+  name: z14.string().max(500),
   /** Logical repository key; only trusted cloud runtimes use an absolute path. */
-  path: z13.string().min(1).max(4e3),
-  remoteUrl: z13.string().max(2e3).nullable().optional(),
+  path: z14.string().min(1).max(4e3),
+  remoteUrl: z14.string().max(2e3).nullable().optional(),
   setup: setupRecipeSchema.optional(),
   /** Domains agents may reach in this repo, on top of the harness's own. */
-  networkAllow: z13.array(z13.string().min(1).max(253)).max(200).optional(),
+  networkAllow: z14.array(z14.string().min(1).max(253)).max(200).optional(),
   /** Push run branches after a verified hand-in ("always for this repo"). */
-  push: z13.object({
-    approved: z13.boolean(),
-    remote: z13.string().min(1).max(200).optional()
+  push: z14.object({
+    approved: z14.boolean(),
+    remote: z14.string().min(1).max(200).optional()
   }).optional()
 });
-var deviceReposResponse = z13.object({
-  repos: z13.array(deviceRepoSchema)
+var deviceReposResponse = z14.object({
+  repos: z14.array(deviceRepoSchema)
 });
-var pendingRunsResponse = z13.object({ runIds: z13.array(id) });
+var pendingRunsResponse = z14.object({ runIds: z14.array(id2) });
 var RUN_KINDS = ["implement", "acceptance", "fix", "plan"];
-var runAssignmentSchema = z13.object({
-  runId: id,
-  issueId: id,
-  deviceId: id,
-  repoId: id,
+var runAssignmentSchema = z14.object({
+  runId: id2,
+  issueId: id2,
+  deviceId: id2,
+  repoId: id2,
   /** Clone URL for local runs; hosted computer assignments keep their isolated workspace. */
-  remoteUrl: z13.string().min(1).max(4e3).optional(),
+  remoteUrl: z14.string().min(1).max(4e3).optional(),
   /** Absent means origin/HEAD after fetch. */
-  baseBranch: z13.string().min(1).max(500).optional(),
-  expectedRepoRemote: z13.string().max(2e3).optional(),
+  baseBranch: z14.string().min(1).max(500).optional(),
+  expectedRepoRemote: z14.string().max(2e3).optional(),
   harness: harnessSchema,
-  prompt: z13.string().max(1e5),
+  prompt: z14.string().max(1e5),
   /**
    * The model the harness's CLI is asked to run, from the per-harness
    * preference of the person this run works for (ADR 0060). Absent: the
@@ -3464,42 +3518,42 @@ var runAssignmentSchema = z13.object({
    */
   model: modelNameSchema.optional(),
   /** Owner-bound selection only; no subscription credential enters the assignment. */
-  subscriptionBinding: z13.object({
-    bindingId: z13.uuid(),
-    ownerId: z13.string().min(1).max(128),
-    workspaceId: z13.uuid(),
-    consumerId: z13.uuid(),
-    route: z13.enum(["codex_cli", "claude_code_cli"])
+  subscriptionBinding: z14.object({
+    bindingId: z14.uuid(),
+    ownerId: z14.string().min(1).max(128),
+    workspaceId: z14.uuid(),
+    consumerId: z14.uuid(),
+    route: z14.enum(["codex_cli", "claude_code_cli"])
   }).strict().optional(),
   /** Local host authority comes only from the server's owner-bound Bot run. */
-  localComputer: z13.object({
-    botId: z13.uuid(),
-    ownerId: z13.string().min(1).max(128),
-    workspaceId: z13.uuid(),
-    policyVersion: z13.number().int().nonnegative().max(2147483647),
-    permission: z13.enum(["allow", "ask"])
+  localComputer: z14.object({
+    botId: z14.uuid(),
+    ownerId: z14.string().min(1).max(128),
+    workspaceId: z14.uuid(),
+    policyVersion: z14.number().int().nonnegative().max(2147483647),
+    permission: z14.enum(["allow", "ask"])
   }).strict().optional(),
   /** Trusted server assignment; the model cannot choose a Bot or display. */
-  computer: z13.object({
-    botId: z13.uuid(),
-    ownerId: z13.string().min(1).max(128),
-    display: z13.string().regex(/^:[1-9][0-9]{0,2}$/),
-    policyVersion: z13.number().int().nonnegative().max(2147483647)
+  computer: z14.object({
+    botId: z14.uuid(),
+    ownerId: z14.string().min(1).max(128),
+    display: z14.string().regex(/^:[1-9][0-9]{0,2}$/),
+    policyVersion: z14.number().int().nonnegative().max(2147483647)
   }).strict().optional(),
   /**
    * 4e3: the task's explicit user variables (workspace + matching repository secrets/env, NAME -> value).
    * Cloud workers only. Passed into the task container through its own channel, never into the worker's
    * env, and never written to the run journal.
    */
-  taskEnv: z13.record(z13.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), z13.string().max(65536)).optional(),
+  taskEnv: z14.record(z14.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), z14.string().max(65536)).optional(),
   /**
    * Names in `taskEnv` that are secrets (kind 'secret'; env vars are not listed). The daemon masks
    * their values (raw + standard base64) in run output before anything is uploaded; the server
    * masks again. Older daemons strip this field and rely on server-side masking only.
    */
-  taskSecretNames: z13.array(z13.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/)).max(500).optional(),
+  taskSecretNames: z14.array(z14.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/)).max(500).optional(),
   /** Mock harness only: fixture name under `packages/daemon/fixtures`. */
-  fixture: z13.string().max(200).optional(),
+  fixture: z14.string().max(200).optional(),
   /**
    * The issue's branch (`mikka/<team>-<number>`, ADR 0024): every run of
    * the issue pushes its verified commit here, so one pull request follows
@@ -3507,9 +3561,9 @@ var runAssignmentSchema = z13.object({
    * this branch from the remote when it exists. Without it the daemon
    * pushes the run's own branch.
    */
-  pushBranch: z13.string().min(1).max(250).optional(),
+  pushBranch: z14.string().min(1).max(250).optional(),
   /** Run by the daemon in the worktree after the agent submits. */
-  verifyCommand: z13.string().max(2e3).optional(),
+  verifyCommand: z14.string().max(2e3).optional(),
   /** Run lease; renewed through the device heartbeat. */
   leaseExpiresAt: isoTime.optional(),
   /**
@@ -3518,27 +3572,27 @@ var runAssignmentSchema = z13.object({
    * it stops working when the run ends. Absent: the server could not issue
    * one, and the run goes ahead without it.
    */
-  mcp: z13.object({ url: z13.url(), token: z13.string().min(1).max(200), mailbox: z13.literal(true).optional() }).optional(),
+  mcp: z14.object({ url: z14.url(), token: z14.string().min(1).max(200), mailbox: z14.literal(true).optional() }).optional(),
   /** Agent-owned GitHub delivery; the same run token exchanges short-lived credentials. */
-  github: z13.object({
-    endpoint: z13.url(),
-    repository: z13.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
-    branch: z13.string().regex(/^mikka\/[a-z0-9-]+-[1-9][0-9]*$/)
+  github: z14.object({
+    endpoint: z14.url(),
+    repository: z14.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
+    branch: z14.string().regex(/^mikka\/[a-z0-9-]+-[1-9][0-9]*$/)
   }).strict().optional(),
   /** Question continuation must not silently open a different session. */
   /**
    * What the orchestrator dispatched this run for (ADR 0023). `plan` writes a
    * spec and proposes a split instead of changing code (ADR ORV-205).
    */
-  kind: z13.enum(RUN_KINDS).optional(),
+  kind: z14.enum(RUN_KINDS).optional(),
   /**
    * The earlier run this one continues (continue, fix, answer, a person's
    * message): the daemon works on in that run's worktree, on this run's
    * branch, so nothing the earlier run left uncommitted is lost.
    */
-  continuesRunId: id.optional(),
+  continuesRunId: id2.optional(),
   /** A same-device retry with no usable snapshot must reuse its real worktree. */
-  requireWorktreeContinuation: z13.literal(true).optional(),
+  requireWorktreeContinuation: z14.literal(true).optional(),
   /**
    * The latest checkpoint of the attempt this run takes over after its
    * machine went offline. Used only for a new worktree (another machine, or
@@ -3551,37 +3605,40 @@ var runAssignmentSchema = z13.object({
    * The harness session to continue. A daemon that cannot resume starts a
    * new session with `prompt`, which always carries the full brief.
    */
-  resumeSessionId: z13.string().max(500).optional(),
-  requireSessionResume: z13.boolean().optional(),
-  preserveQuestionWorktree: z13.boolean().optional(),
-  questionId: z13.uuid().optional(),
+  resumeSessionId: z14.string().max(500).optional(),
+  requireSessionResume: z14.boolean().optional(),
+  preserveQuestionWorktree: z14.boolean().optional(),
+  questionId: z14.uuid().optional(),
   /**
    * What this run adds on top of the brief (a person's message, an answer,
    * a fix request). A resumed session gets only this as its next message;
    * a new session gets `prompt`, which already includes it.
    */
-  followUp: z13.string().max(1e5).optional(),
+  followUp: z14.string().max(1e5).optional(),
   /**
    * The workspace's agent permissions and network allow-list (ADR 0028).
    * Absent from an older server: the daemon applies the ADR 0009 defaults.
    */
   policy: runPolicySchema.optional(),
   /** Trusted server revision for the exact run policy; older servers omit it. */
-  policyRevision: z13.string().regex(/^[a-f0-9]{64}$/).optional(),
+  policyRevision: z14.string().regex(/^[a-f0-9]{64}$/).optional(),
+  /** Only a trusted server context can make a snapshot required. */
+  policySnapshotRequired: z14.boolean().optional(),
+  policySnapshot: signedPolicySnapshotSchema.optional(),
   /**
    * The skills mounted on this run's agent and still enabled, resolved at
    * claim time the way `policy` is. The daemon inlines them into the agent's
    * brief and writes them under the run's directory. Absent from an older
    * server: the run simply has none.
    */
-  skills: z13.array(runSkillSchema).max(MAX_SKILLS_PER_RUN).optional(),
+  skills: z14.array(runSkillSchema).max(MAX_SKILLS_PER_RUN).optional(),
   /** Server-minted assignment provenance; does not grant any policy permission. */
   skillReceipt: skillAssignmentReceiptSchema.optional(),
   /** Frozen by the server benchmark ledger; never extracted from model output. */
   benchmark: runBenchmarkContext.optional()
 });
-var runPatchSchema = z13.object({
-  state: z13.enum([
+var runPatchSchema = z14.object({
+  state: z14.enum([
     "queued",
     "preparing",
     "running",
@@ -3592,73 +3649,73 @@ var runPatchSchema = z13.object({
     "failed",
     "cancelled"
   ]),
-  sessionId: z13.string().max(500).nullable().optional(),
-  worktree: z13.string().max(4e3).nullable().optional(),
-  error: z13.string().max(1e4).nullable().optional(),
+  sessionId: z14.string().max(500).nullable().optional(),
+  worktree: z14.string().max(4e3).nullable().optional(),
+  error: z14.string().max(1e4).nullable().optional(),
   /** Set on every terminal state. */
   stopReason: runStopReason.optional()
 });
-var runEventBatchSchema = z13.object({
-  fromSeq: z13.number().int().min(1),
-  chunks: z13.array(z13.looseObject({ type: z13.string() })).min(1).max(1e3)
+var runEventBatchSchema = z14.object({
+  fromSeq: z14.number().int().min(1),
+  chunks: z14.array(z14.looseObject({ type: z14.string() })).min(1).max(1e3)
 });
-var runEventsAccepted = z13.object({
+var runEventsAccepted = z14.object({
   /** Producer seq of the last chunk the server holds for this run. */
-  offset: z13.string()
+  offset: z14.string()
 });
 var COMMANDS_MAX_WAIT_SECONDS = 25;
 var COMMANDS_SKIP_PARAM = "skip";
 var COMMANDS_MAX_SKIP = 100;
-var runCommandSchema = z13.discriminatedUnion("kind", [
-  z13.object({
-    kind: z13.literal("input"),
-    runId: id,
-    messageId: z13.uuid(),
-    text: z13.string().min(1).max(1e5)
+var runCommandSchema = z14.discriminatedUnion("kind", [
+  z14.object({
+    kind: z14.literal("input"),
+    runId: id2,
+    messageId: z14.uuid(),
+    text: z14.string().min(1).max(1e5)
   }),
-  z13.object({ kind: z13.literal("stop"), runId: id })
+  z14.object({ kind: z14.literal("stop"), runId: id2 })
 ]);
-var runCommandsResponse = z13.object({
-  commands: z13.array(runCommandSchema).max(500)
+var runCommandsResponse = z14.object({
+  commands: z14.array(runCommandSchema).max(500)
 });
-var runCommandsAck = z13.object({
-  delivered: z13.array(z13.uuid()).max(500)
+var runCommandsAck = z14.object({
+  delivered: z14.array(z14.uuid()).max(500)
 });
 var FS_REQUESTS_MAX_WAIT_SECONDS = 25;
 var FS_MAX_ENTRIES = 500;
-var fsBrowseRequest = z13.object({
+var fsBrowseRequest = z14.object({
   /** Absolute path on the device; omitted: the device's home folder. */
-  path: z13.string().trim().min(1).max(4e3).optional(),
-  showHidden: z13.boolean().optional()
+  path: z14.string().trim().min(1).max(4e3).optional(),
+  showHidden: z14.boolean().optional()
 });
-var fsPendingRequest = fsBrowseRequest.extend({ id: z13.uuid() });
-var fsRequestsResponse = z13.object({
-  requests: z13.array(fsPendingRequest).max(50)
+var fsPendingRequest = fsBrowseRequest.extend({ id: z14.uuid() });
+var fsRequestsResponse = z14.object({
+  requests: z14.array(fsPendingRequest).max(50)
 });
-var fsEntry = z13.object({
-  name: z13.string().max(1e3),
-  path: z13.string().max(4e3),
+var fsEntry = z14.object({
+  name: z14.string().max(1e3),
+  path: z14.string().max(4e3),
   /** The folder is the top level of a git repo (it has a `.git`). */
-  isRepo: z13.boolean()
+  isRepo: z14.boolean()
 });
-var fsListing = z13.object({
-  ok: z13.literal(true),
-  path: z13.string().max(4e3),
+var fsListing = z14.object({
+  ok: z14.literal(true),
+  path: z14.string().max(4e3),
   /** Null at the filesystem root. */
-  parent: z13.string().max(4e3).nullable(),
-  home: z13.string().max(4e3),
+  parent: z14.string().max(4e3).nullable(),
+  home: z14.string().max(4e3),
   /** `darwin`, `linux`, `win32`: for path separators and wording. */
-  platform: z13.string().max(50),
-  entries: z13.array(fsEntry).max(FS_MAX_ENTRIES),
+  platform: z14.string().max(50),
+  entries: z14.array(fsEntry).max(FS_MAX_ENTRIES),
   /** More folders existed than `FS_MAX_ENTRIES`. */
-  truncated: z13.boolean(),
+  truncated: z14.boolean(),
   /**
    * The git repo `path` is in, if any: its top level and `origin` (or the
    * first remote). This is what `device.addRepo` should be given.
    */
-  repo: z13.object({
-    path: z13.string().max(4e3),
-    remoteUrl: z13.string().max(2e3).nullable()
+  repo: z14.object({
+    path: z14.string().max(4e3),
+    remoteUrl: z14.string().max(2e3).nullable()
   }).nullable()
 });
 var FS_ERROR_CODES = [
@@ -3667,12 +3724,12 @@ var FS_ERROR_CODES = [
   "denied",
   "failed"
 ];
-var fsFailure = z13.object({
-  ok: z13.literal(false),
-  code: z13.enum(FS_ERROR_CODES),
-  message: z13.string().max(1e3)
+var fsFailure = z14.object({
+  ok: z14.literal(false),
+  code: z14.enum(FS_ERROR_CODES),
+  message: z14.string().max(1e3)
 });
-var fsResult = z13.discriminatedUnion("ok", [fsListing, fsFailure]);
+var fsResult = z14.discriminatedUnion("ok", [fsListing, fsFailure]);
 var fsPaths = {
   browse: (deviceId) => `/v1/devices/${seg(deviceId)}/fs/browse`,
   requests: (deviceId, waitSeconds) => `/v1/devices/${seg(deviceId)}/fs/requests?wait=${waitSeconds}`,
@@ -3680,38 +3737,38 @@ var fsPaths = {
 };
 
 // ../protocol/src/orchestrator.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var minutes = (n) => n * 6e4;
-var orchestratorSettingsSchema = z14.object({
+var orchestratorSettingsSchema = z15.object({
   /** "Continue" prompts after a turn ended without a submit. */
-  maxContinuations: z14.number().int().min(0).max(20).default(3),
+  maxContinuations: z15.number().int().min(0).max(20).default(3),
   /** Resumes after the CLI crashed, before one fresh session. */
-  maxCrashRetries: z14.number().int().min(0).max(20).default(3),
+  maxCrashRetries: z15.number().int().min(0).max(20).default(3),
   /** Fix rounds after the daemon's verify failed. */
-  maxFixAttempts: z14.number().int().min(0).max(20).default(3),
+  maxFixAttempts: z15.number().int().min(0).max(20).default(3),
   /** "You seem stuck" prompts after a run stalled. */
-  maxStallRecoveries: z14.number().int().min(0).max(20).default(2),
+  maxStallRecoveries: z15.number().int().min(0).max(20).default(2),
   /** No progress for this long while the lease is fresh = stalled. */
-  stalledAfterMs: z14.number().int().min(minutes(1)).default(minutes(10)),
+  stalledAfterMs: z15.number().int().min(minutes(1)).default(minutes(10)),
   /** A device offline this long is handed to a person (no auto switch). */
-  deviceOfflineEscalateMs: z14.number().int().min(0).default(minutes(30)),
+  deviceOfflineEscalateMs: z15.number().int().min(0).default(minutes(30)),
   /** An unanswered question frees its concurrency slot after this. */
-  questionSlotReleaseMs: z14.number().int().min(0).default(minutes(24 * 60)),
+  questionSlotReleaseMs: z15.number().int().min(0).default(minutes(24 * 60)),
   /** Automatic dispatches per issue per hour before a person looks. */
-  maxDispatchesPerHour: z14.number().int().min(1).max(100).default(6),
+  maxDispatchesPerHour: z15.number().int().min(1).max(100).default(6),
   /** Wait before resuming a run that hit its quota (no reset time known). */
-  quotaBackoffMs: z14.number().int().min(0).default(minutes(15)),
+  quotaBackoffMs: z15.number().int().min(0).default(minutes(15)),
   /**
    * How often an issue waiting on its pull request or CI asks GitHub again
    * when no webhook arrived (ADR 0024).
    */
-  ciRecheckMs: z14.number().int().min(3e4).default(minutes(2)),
+  ciRecheckMs: z15.number().int().min(3e4).default(minutes(2)),
   /** A pushed commit with no checks after this long has no CI: it passes. */
-  ciNoChecksMs: z14.number().int().min(0).default(minutes(5)),
+  ciNoChecksMs: z15.number().int().min(0).default(minutes(5)),
   /** CI still running after this long goes to a person. */
-  ciTimeoutMs: z14.number().int().min(minutes(5)).default(minutes(120)),
+  ciTimeoutMs: z15.number().int().min(minutes(5)).default(minutes(120)),
   /** Remote URL of the repo this project's issues run in. */
-  repoUrl: z14.string().max(2e3).optional()
+  repoUrl: z15.string().max(2e3).optional()
 });
 var CRASH_BACKOFF_MS = [1e4, 6e4, minutes(5)];
 var UPSTREAM_RECHECK_MS = minutes(5);
@@ -3755,30 +3812,30 @@ var WAIT_DETAIL_CODES = [
   ...PERSON_WAIT_DETAIL_CODES,
   ...EXTERNAL_WAIT_DETAIL_CODES
 ];
-var waitDetailSchema = z14.object({
-  code: z14.enum(WAIT_DETAIL_CODES),
-  params: z14.record(
-    z14.string(),
-    z14.union([
-      z14.string(),
-      z14.number(),
-      z14.array(z14.string()),
+var waitDetailSchema = z15.object({
+  code: z15.enum(WAIT_DETAIL_CODES),
+  params: z15.record(
+    z15.string(),
+    z15.union([
+      z15.string(),
+      z15.number(),
+      z15.array(z15.string()),
       // `repo_ambiguous`: the repos a person can pick from.
-      z14.array(z14.record(z14.string(), z14.string()))
+      z15.array(z15.record(z15.string(), z15.string()))
     ])
   ).optional()
 });
-var prChecksSchema = z14.object({
-  state: z14.enum(["pending", "success", "failure", "none"]),
+var prChecksSchema = z15.object({
+  state: z15.enum(["pending", "success", "failure", "none"]),
   /** Failed checks, for the fix round's brief and the issue page. */
-  failing: z14.array(
-    z14.object({
-      name: z14.string().max(500),
-      summary: z14.string().max(4e3).optional(),
-      url: z14.string().max(2e3).optional()
+  failing: z15.array(
+    z15.object({
+      name: z15.string().max(500),
+      summary: z15.string().max(4e3).optional(),
+      url: z15.string().max(2e3).optional()
     })
   ).max(50),
-  total: z14.number().int().min(0)
+  total: z15.number().int().min(0)
 });
 var DEFAULT_BRANCH_TEMPLATE = "mikka/{team}-{number}";
 var BRANCH_FORBIDDEN = /[\s~^:?*[\\]|\.\.|@\{|\/\/|^\/|\/$/;
@@ -3787,29 +3844,29 @@ var hasControlCharacter = (value) => [...value].some((char) => {
   const code = char.charCodeAt(0);
   return code < 32 || code === 127;
 });
-var branchTemplateSchema = z14.string().trim().min(1).max(200).refine((value) => value.includes("{number}"), {
+var branchTemplateSchema = z15.string().trim().min(1).max(200).refine((value) => value.includes("{number}"), {
   message: "The template must contain {number}."
 }).refine(
   (value) => !BRANCH_FORBIDDEN.test(value) && !hasControlCharacter(value),
   { message: BRANCH_FORBIDDEN_HINT }
 );
-var prBodyTemplateSchema = z14.string().max(2e4).nullable().optional();
+var prBodyTemplateSchema = z15.string().max(2e4).nullable().optional();
 var REVIEW_CHECK_HARNESSES = [
   "claude_code",
   "codex",
   "cursor"
 ];
-var reviewRuleSchema = z14.object({
+var reviewRuleSchema = z15.object({
   /** In Review needs an open pull request for the issue's branch (ADR 0024). */
-  requirePullRequest: z14.boolean().default(true),
+  requirePullRequest: z15.boolean().default(true),
   /** ... and green CI on it. Ignored when no pull request is required. */
-  requireCi: z14.boolean().default(true),
+  requireCi: z15.boolean().default(true),
   /**
    * The harness that must run the read-only check (ADR 0046). Null: any
    * second agent on the device. A configured harness the device does not run
    * means no check runs, exactly as if the device had no second agent.
    */
-  checkHarness: z14.enum(REVIEW_CHECK_HARNESSES).nullable().default(null),
+  checkHarness: z15.enum(REVIEW_CHECK_HARNESSES).nullable().default(null),
   branchTemplate: branchTemplateSchema.default(DEFAULT_BRANCH_TEMPLATE),
   /** `{key}`, `{title}` and `{summary}`; null keeps Mikka's default text. */
   prBodyTemplate: prBodyTemplateSchema.default(null)
@@ -3834,9 +3891,9 @@ var WEB_PLATFORM = Object.freeze({
 });
 
 // ../protocol/src/preview.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var PREVIEW_MAX_LENGTH = 5 * 1024 * 1024;
-var previewHtml = z15.string().max(PREVIEW_MAX_LENGTH);
+var previewHtml = z16.string().max(PREVIEW_MAX_LENGTH);
 var DIRECTIVES = [
   "default-src 'none'",
   "script-src 'unsafe-inline'",
@@ -3853,13 +3910,13 @@ var PREVIEW_CSP_HEADER = ["sandbox allow-scripts", ...DIRECTIVES].join(
 var META = `<meta http-equiv="Content-Security-Policy" content="${DIRECTIVES.join("; ")}">`;
 
 // ../protocol/src/profile.ts
-import { z as z16 } from "zod";
-var usernameSchema = z16.string().trim().min(3, "At least 3 characters.").max(32, "At most 32 characters.").regex(
+import { z as z17 } from "zod";
+var usernameSchema = z17.string().trim().min(3, "At least 3 characters.").max(32, "At most 32 characters.").regex(
   /^[a-z0-9][a-z0-9_-]*$/,
   "Start with a letter or digit; lowercase letters, digits, - and _ only."
 );
-var displayNameSchema = z16.string().trim().min(1, "A name is required.").max(80, "At most 80 characters.");
-var avatarUrlSchema = z16.url().max(2048).refine((value) => /^https?:\/\//.test(value), "Use an http(s) URL.");
+var displayNameSchema = z17.string().trim().min(1, "A name is required.").max(80, "At most 80 characters.");
+var avatarUrlSchema = z17.url().max(2048).refine((value) => /^https?:\/\//.test(value), "Use an http(s) URL.");
 var AVATAR_MAX_BYTES = 5 * 1024 * 1024;
 var AVATAR_CONTENT_TYPES = [
   "image/png",
@@ -3867,16 +3924,16 @@ var AVATAR_CONTENT_TYPES = [
   "image/webp",
   "image/gif"
 ];
-var avatarPresignRequest = z16.object({
-  contentType: z16.enum(AVATAR_CONTENT_TYPES),
+var avatarPresignRequest = z17.object({
+  contentType: z17.enum(AVATAR_CONTENT_TYPES),
   /** Bytes, checked against AVATAR_MAX_BYTES. */
-  size: z16.number().int().positive()
+  size: z17.number().int().positive()
 });
-var avatarPresignResponse = z16.object({
-  uploadUrl: z16.url(),
+var avatarPresignResponse = z17.object({
+  uploadUrl: z17.url(),
   /** What to store in `user.image` once the PUT has succeeded. */
   publicUrl: avatarUrlSchema,
-  expiresIn: z16.number().int().positive()
+  expiresIn: z17.number().int().positive()
 });
 
 // ../protocol/src/relay.ts
@@ -3885,31 +3942,31 @@ import {
   safeValidateUIMessages,
   uiMessageChunkSchema
 } from "ai";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var RELAY_PROTOCOL_VERSION = 1;
 var MAX_INPUT_LENGTH = 2e4;
-var uuid = z17.uuid();
-var runEvent = z17.discriminatedUnion("kind", [
+var uuid = z18.uuid();
+var runEvent = z18.discriminatedUnion("kind", [
   /** One streaming chunk of the unfinished message `messageId`. */
-  z17.object({
-    kind: z17.literal("chunk"),
+  z18.object({
+    kind: z18.literal("chunk"),
     messageId: uuid,
-    chunk: z17.looseObject({ type: z17.string() })
+    chunk: z18.looseObject({ type: z18.string() })
   }),
   /** A finished message; persisted as a `message` row, then fanned out. */
-  z17.object({
-    kind: z17.literal("message.final"),
+  z18.object({
+    kind: z18.literal("message.final"),
     /** Order of the message within the run. */
-    seq: z17.number().int().min(0),
-    message: z17.looseObject({
+    seq: z18.number().int().min(0),
+    message: z18.looseObject({
       id: uuid,
-      role: z17.enum(["system", "user", "assistant"]),
-      parts: z17.array(z17.looseObject({ type: z17.string() }))
+      role: z18.enum(["system", "user", "assistant"]),
+      parts: z18.array(z18.looseObject({ type: z18.string() }))
     })
   }),
-  z17.object({
-    kind: z17.literal("run.status"),
-    status: z17.enum([
+  z18.object({
+    kind: z18.literal("run.status"),
+    status: z18.enum([
       "queued",
       "preparing",
       "running",
@@ -3922,48 +3979,48 @@ var runEvent = z17.discriminatedUnion("kind", [
   })
 ]);
 var chunkSchema = asSchema(uiMessageChunkSchema);
-var v = z17.literal(RELAY_PROTOCOL_VERSION);
-var presenceView = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("issue"), id: uuid }),
-  z17.object({ type: z17.literal("project"), id: uuid })
+var v = z18.literal(RELAY_PROTOCOL_VERSION);
+var presenceView = z18.discriminatedUnion("type", [
+  z18.object({ type: z18.literal("issue"), id: uuid }),
+  z18.object({ type: z18.literal("project"), id: uuid })
 ]);
-var relayClientMessage = z17.discriminatedUnion("type", [
-  z17.object({
+var relayClientMessage = z18.discriminatedUnion("type", [
+  z18.object({
     v,
-    type: z17.literal("subscribe"),
+    type: z18.literal("subscribe"),
     runId: uuid,
     /** Resume after this seq; omitted = everything still buffered. */
-    after: z17.number().int().min(0).optional()
+    after: z18.number().int().min(0).optional()
   }),
-  z17.object({ v, type: z17.literal("unsubscribe"), runId: uuid }),
-  z17.object({ v, type: z17.literal("publish"), runId: uuid, event: runEvent }),
+  z18.object({ v, type: z18.literal("unsubscribe"), runId: uuid }),
+  z18.object({ v, type: z18.literal("publish"), runId: uuid, event: runEvent }),
   /**
    * A person's message to the running agent (ADR 0018). Saved as a `user`
    * message row with this id (a re-send with the same id is applied once),
    * then handed to the run's daemon, which marks it delivered.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("send"),
+    type: z18.literal("send"),
     runId: uuid,
     messageId: uuid,
-    text: z17.string().trim().min(1).max(MAX_INPUT_LENGTH)
+    text: z18.string().trim().min(1).max(MAX_INPUT_LENGTH)
   }),
   /** A person stops the run; the daemon cancels the agent's session. */
-  z17.object({ v, type: z17.literal("stop"), runId: uuid }),
+  z18.object({ v, type: z18.literal("stop"), runId: uuid }),
   /**
    * Says where this connection is looking, in one workspace (ADR 0049). Sent
    * once when a page opens and again every `PRESENCE_HEARTBEAT_MS`; `view`
    * null keeps the member online without naming a page. Never persisted.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("presence"),
+    type: z18.literal("presence"),
     workspaceId: uuid,
     view: presenceView.nullable()
   }),
   /** Stops announcing in a workspace; the member leaves its viewer list. */
-  z17.object({ v, type: z17.literal("presence.leave"), workspaceId: uuid })
+  z18.object({ v, type: z18.literal("presence.leave"), workspaceId: uuid })
 ]);
 var RELAY_ERROR_CODES = [
   "bad_message",
@@ -3977,215 +4034,215 @@ var RELAY_ERROR_CODES = [
   /** `presence` for a workspace the caller is not a member of (ADR 0049). */
   "not_a_member"
 ];
-var relayErrorCode = z17.enum(RELAY_ERROR_CODES);
-var relayServerMessage = z17.discriminatedUnion("type", [
-  z17.object({
+var relayErrorCode = z18.enum(RELAY_ERROR_CODES);
+var relayServerMessage = z18.discriminatedUnion("type", [
+  z18.object({
     v,
-    type: z17.literal("subscribed"),
+    type: z18.literal("subscribed"),
     runId: uuid,
-    latestSeq: z17.number().int().min(0)
+    latestSeq: z18.number().int().min(0)
   }),
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("event"),
+    type: z18.literal("event"),
     runId: uuid,
-    seq: z17.number().int().min(1),
+    seq: z18.number().int().min(1),
     event: runEvent
   }),
   /**
    * `send` / `stop` was saved and is on its way to the run's device.
    * `messageId` is set for `send`.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("accepted"),
+    type: z18.literal("accepted"),
     runId: uuid,
-    request: z17.enum(["send", "stop"]),
+    request: z18.enum(["send", "stop"]),
     messageId: uuid.optional()
   }),
   /** Publisher acknowledgment with the seq the hub assigned. */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("ack"),
+    type: z18.literal("ack"),
     runId: uuid,
-    seq: z17.number().int().min(1)
+    seq: z18.number().int().min(1)
   }),
   /**
    * Everyone the server sees online in this workspace, and where each is
    * looking (ADR 0049). A snapshot after every change, so a client never has
    * to merge deltas; `lastSeenAt` is the server's clock.
    */
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("presence"),
+    type: z18.literal("presence"),
     workspaceId: uuid,
-    members: z17.array(
-      z17.object({
+    members: z18.array(
+      z18.object({
         userId: uuid,
         view: presenceView.nullable(),
-        lastSeenAt: z17.number().int()
+        lastSeenAt: z18.number().int()
       })
     )
   }),
-  z17.object({
+  z18.object({
     v,
-    type: z17.literal("error"),
+    type: z18.literal("error"),
     code: relayErrorCode,
-    message: z17.string(),
+    message: z18.string(),
     runId: uuid.optional(),
-    minVersion: z17.string().optional()
+    minVersion: z18.string().optional()
   })
 ]);
 
 // ../protocol/src/version.ts
 var import_semver = __toESM(require_semver2(), 1);
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var CLIENT_VERSION_HEADER = "x-mikka-client-version";
 var CLIENT_KINDS = ["desktop", "mobile"];
-var clientKind = z18.enum(CLIENT_KINDS);
-var updateRequiredError = z18.object({
-  error: z18.literal("update_required"),
-  minVersion: z18.string(),
-  message: z18.string()
+var clientKind = z19.enum(CLIENT_KINDS);
+var updateRequiredError = z19.object({
+  error: z19.literal("update_required"),
+  minVersion: z19.string(),
+  message: z19.string()
 });
 
 // ../protocol/src/coordinator.ts
-import { z as z19 } from "zod";
-var coordinatorRuntimeSchema = z19.discriminatedUnion("harness", [
-  z19.object({ harness: z19.literal("ai_sdk") }).strict(),
-  z19.object({ harness: z19.enum(["claude_code", "codex"]), deviceId: z19.uuid(), model: z19.string().trim().min(1).max(120).optional() }).strict()
+import { z as z20 } from "zod";
+var coordinatorRuntimeSchema = z20.discriminatedUnion("harness", [
+  z20.object({ harness: z20.literal("ai_sdk") }).strict(),
+  z20.object({ harness: z20.enum(["claude_code", "codex"]), deviceId: z20.uuid(), model: z20.string().trim().min(1).max(120).optional() }).strict()
 ]);
-var coordinatorToolSpecSchema = z19.object({
-  name: z19.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/),
-  description: z19.string().max(2e4),
-  inputSchema: z19.record(z19.string(), z19.unknown())
+var coordinatorToolSpecSchema = z20.object({
+  name: z20.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/),
+  description: z20.string().max(2e4),
+  inputSchema: z20.record(z20.string(), z20.unknown())
 });
-var nativeCoordinatorJobSchema = z19.object({
-  id: z19.uuid(),
-  harness: z19.enum(["claude_code", "codex"]),
-  model: z19.string().optional(),
-  instructions: z19.string().min(1).max(2e5),
-  context: z19.string().min(1).max(5e5),
-  tools: z19.array(coordinatorToolSpecSchema).max(100),
-  expiresAt: z19.iso.datetime()
+var nativeCoordinatorJobSchema = z20.object({
+  id: z20.uuid(),
+  harness: z20.enum(["claude_code", "codex"]),
+  model: z20.string().optional(),
+  instructions: z20.string().min(1).max(2e5),
+  context: z20.string().min(1).max(5e5),
+  tools: z20.array(coordinatorToolSpecSchema).max(100),
+  expiresAt: z20.iso.datetime()
 });
-var nativeCoordinatorClaimSchema = z19.object({ job: nativeCoordinatorJobSchema.nullable() });
-var nativeCoordinatorCommandSchema = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("tool"), callId: z19.string().min(1).max(200), name: z19.string().min(1).max(64), input: z19.record(z19.string(), z19.unknown()) }).strict(),
-  z19.object({ type: z19.literal("complete"), text: z19.string().min(1).max(2e5).refine((value) => value.trim().length > 0) }).strict(),
-  z19.object({ type: z19.literal("failed") }).strict()
+var nativeCoordinatorClaimSchema = z20.object({ job: nativeCoordinatorJobSchema.nullable() });
+var nativeCoordinatorCommandSchema = z20.discriminatedUnion("type", [
+  z20.object({ type: z20.literal("tool"), callId: z20.string().min(1).max(200), name: z20.string().min(1).max(64), input: z20.record(z20.string(), z20.unknown()) }).strict(),
+  z20.object({ type: z20.literal("complete"), text: z20.string().min(1).max(2e5).refine((value) => value.trim().length > 0) }).strict(),
+  z20.object({ type: z20.literal("failed") }).strict()
 ]);
-var nativeCoordinatorToolResultSchema = z19.discriminatedUnion("status", [
-  z19.object({ status: z19.literal("pending") }),
-  z19.object({ status: z19.literal("done"), output: z19.unknown() })
+var nativeCoordinatorToolResultSchema = z20.discriminatedUnion("status", [
+  z20.object({ status: z20.literal("pending") }),
+  z20.object({ status: z20.literal("done"), output: z20.unknown() })
 ]);
 
 // ../protocol/src/computer.ts
-import { z as z20 } from "zod";
-var machineStateSchema = z20.enum(["sleeping", "waking", "running", "error"]);
-var controlStateSchema = z20.enum(["agent", "user", "idle"]);
-var computerToolSchema = z20.enum(["click", "type", "key", "scroll", "screenshot"]);
-var screenRectSchema = z20.object({ x: z20.number(), y: z20.number(), w: z20.number().nonnegative(), h: z20.number().nonnegative() });
-var computerActionSchema = z20.object({ tool: computerToolSchema, x: z20.number().optional(), y: z20.number().optional(), text: z20.string().optional(), rect: screenRectSchema.optional() });
-var lastActionSchema = computerActionSchema.omit({ text: true }).extend({ at: z20.iso.datetime() });
-var approvalViewSchema = z20.object({
-  id: z20.string(),
-  digest: z20.string(),
-  runId: z20.string(),
-  botId: z20.string(),
+import { z as z21 } from "zod";
+var machineStateSchema = z21.enum(["sleeping", "waking", "running", "error"]);
+var controlStateSchema = z21.enum(["agent", "user", "idle"]);
+var computerToolSchema = z21.enum(["click", "type", "key", "scroll", "screenshot"]);
+var screenRectSchema = z21.object({ x: z21.number(), y: z21.number(), w: z21.number().nonnegative(), h: z21.number().nonnegative() });
+var computerActionSchema = z21.object({ tool: computerToolSchema, x: z21.number().optional(), y: z21.number().optional(), text: z21.string().optional(), rect: screenRectSchema.optional() });
+var lastActionSchema = computerActionSchema.omit({ text: true }).extend({ at: z21.iso.datetime() });
+var approvalViewSchema = z21.object({
+  id: z21.string(),
+  digest: z21.string(),
+  runId: z21.string(),
+  botId: z21.string(),
   action: computerActionSchema,
-  summary: z20.string(),
-  expiresAt: z20.iso.datetime()
+  summary: z21.string(),
+  expiresAt: z21.iso.datetime()
 });
-var computerStateSchema = z20.object({
+var computerStateSchema = z21.object({
   machine: machineStateSchema,
   control: controlStateSchema,
-  controlledBy: z20.object({ userId: z20.string() }).optional(),
+  controlledBy: z21.object({ userId: z21.string() }).optional(),
   lastAction: lastActionSchema.optional(),
   pendingApproval: approvalViewSchema.optional()
 });
-var viewerModeSchema = z20.enum(["view", "control"]);
-var viewerRequestSchema = z20.object({ mode: viewerModeSchema }).strict();
-var viewerGrantSchema = z20.object({ url: z20.url({ protocol: /^wss$/ }), expiresAt: z20.iso.datetime() });
-var createBotSchema = z20.object({ name: z20.string().trim().min(1).max(120) }).strict();
-var botViewSchema = z20.object({ id: z20.uuid(), name: z20.string().min(1).max(120) });
-var approvalDecisionSchema = z20.object({ digest: z20.string(), decision: z20.enum(["approve", "deny"]), scope: z20.enum(["once", "run"]) }).strict();
-var computerTaskStateSchema = z20.enum(["working", "approval", "done", "failed"]);
-var computerTaskSchema = z20.object({ botId: z20.string(), runId: z20.string(), task: z20.string(), state: computerTaskStateSchema, approvalId: z20.string().optional() });
-var computerEventSchema = z20.discriminatedUnion("type", [
-  z20.object({ type: z20.literal("computer.machine"), state: machineStateSchema }),
-  z20.object({ type: z20.literal("computer.control"), botId: z20.string(), control: controlStateSchema, controlledBy: z20.object({ userId: z20.string() }).optional() }),
-  z20.object({ type: z20.literal("computer.action"), botId: z20.string(), lastAction: lastActionSchema }),
-  z20.object({ type: z20.literal("computer.approval"), botId: z20.string(), approval: approvalViewSchema.nullable() })
+var viewerModeSchema = z21.enum(["view", "control"]);
+var viewerRequestSchema = z21.object({ mode: viewerModeSchema }).strict();
+var viewerGrantSchema = z21.object({ url: z21.url({ protocol: /^wss$/ }), expiresAt: z21.iso.datetime() });
+var createBotSchema = z21.object({ name: z21.string().trim().min(1).max(120) }).strict();
+var botViewSchema = z21.object({ id: z21.uuid(), name: z21.string().min(1).max(120) });
+var approvalDecisionSchema = z21.object({ digest: z21.string(), decision: z21.enum(["approve", "deny"]), scope: z21.enum(["once", "run"]) }).strict();
+var computerTaskStateSchema = z21.enum(["working", "approval", "done", "failed"]);
+var computerTaskSchema = z21.object({ botId: z21.string(), runId: z21.string(), task: z21.string(), state: computerTaskStateSchema, approvalId: z21.string().optional() });
+var computerEventSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("computer.machine"), state: machineStateSchema }),
+  z21.object({ type: z21.literal("computer.control"), botId: z21.string(), control: controlStateSchema, controlledBy: z21.object({ userId: z21.string() }).optional() }),
+  z21.object({ type: z21.literal("computer.action"), botId: z21.string(), lastAction: lastActionSchema }),
+  z21.object({ type: z21.literal("computer.approval"), botId: z21.string(), approval: approvalViewSchema.nullable() })
 ]);
-var reviewDigestSchema = z20.string().regex(/^[a-f0-9]{64}$/);
-var localComputerCall = z20.discriminatedUnion("name", [
-  z20.object({ name: z20.literal("get_desktop_state"), arguments: z20.object({}).strict() }).strict(),
-  z20.object({ name: z20.literal("click"), arguments: z20.object({ x: z20.number().int().min(0).max(1e5), y: z20.number().int().min(0).max(1e5) }).strict() }).strict(),
-  z20.object({ name: z20.literal("type_text"), arguments: z20.object({ text: z20.string().min(1).max(8e3) }).strict() }).strict(),
-  z20.object({ name: z20.literal("press_key"), arguments: z20.object({
-    key: z20.string().regex(/^(?:[\x20-\x7e]|enter|return|tab|escape|space|backspace|delete|insert|home|end|pageup|pagedown|up|down|left|right|f(?:[1-9]|1[0-2]))$/),
-    modifiers: z20.array(z20.enum(["ctrl", "shift", "alt", "super"])).max(4).refine((items) => new Set(items).size === items.length).optional()
+var reviewDigestSchema = z21.string().regex(/^[a-f0-9]{64}$/);
+var localComputerCall = z21.discriminatedUnion("name", [
+  z21.object({ name: z21.literal("get_desktop_state"), arguments: z21.object({}).strict() }).strict(),
+  z21.object({ name: z21.literal("click"), arguments: z21.object({ x: z21.number().int().min(0).max(1e5), y: z21.number().int().min(0).max(1e5) }).strict() }).strict(),
+  z21.object({ name: z21.literal("type_text"), arguments: z21.object({ text: z21.string().min(1).max(8e3) }).strict() }).strict(),
+  z21.object({ name: z21.literal("press_key"), arguments: z21.object({
+    key: z21.string().regex(/^(?:[\x20-\x7e]|enter|return|tab|escape|space|backspace|delete|insert|home|end|pageup|pagedown|up|down|left|right|f(?:[1-9]|1[0-2]))$/),
+    modifiers: z21.array(z21.enum(["ctrl", "shift", "alt", "super"])).max(4).refine((items) => new Set(items).size === items.length).optional()
   }).strict() }).strict(),
-  z20.object({ name: z20.literal("scroll"), arguments: z20.object({ direction: z20.enum(["up", "down", "left", "right"]), amount: z20.number().int().min(1).max(50), x: z20.number().int().min(0).max(1e5), y: z20.number().int().min(0).max(1e5) }).strict() }).strict()
+  z21.object({ name: z21.literal("scroll"), arguments: z21.object({ direction: z21.enum(["up", "down", "left", "right"]), amount: z21.number().int().min(1).max(50), x: z21.number().int().min(0).max(1e5), y: z21.number().int().min(0).max(1e5) }).strict() }).strict()
 ]);
-var localComputerRequest = z20.object({
-  id: z20.uuid(),
-  runId: z20.uuid(),
+var localComputerRequest = z21.object({
+  id: z21.uuid(),
+  runId: z21.uuid(),
   target: reviewDigestSchema,
-  display: z20.string().regex(/^:[1-9][0-9]{0,2}$/).optional(),
+  display: z21.string().regex(/^:[1-9][0-9]{0,2}$/).optional(),
   call: localComputerCall,
-  expiresAt: z20.number().int().positive(),
+  expiresAt: z21.number().int().positive(),
   digest: reviewDigestSchema
 }).strict();
-var localComputerDecision = z20.object({ id: z20.uuid(), digest: reviewDigestSchema, approve: z20.boolean() }).strict();
-var computerSyncBody = z20.object({ requests: z20.array(localComputerRequest).max(20) }).strict();
-var computerSyncResponse = z20.object({ decisions: z20.array(localComputerDecision).max(20) }).strict();
+var localComputerDecision = z21.object({ id: z21.uuid(), digest: reviewDigestSchema, approve: z21.boolean() }).strict();
+var computerSyncBody = z21.object({ requests: z21.array(localComputerRequest).max(20) }).strict();
+var computerSyncResponse = z21.object({ decisions: z21.array(localComputerDecision).max(20) }).strict();
 var computerSyncPath = (deviceId) => `/v1/devices/${encodeURIComponent(deviceId)}/computer`;
 
 // ../protocol/src/subscription.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var HOSTED_NATIVE_IMAGE = "node@sha256:6449e19d8184d84062525b6a7524def03146c2cb04a7f08b076680d0e8e4240a";
-var id2 = z21.string().min(1).max(128);
-var subscriptionRouteSchema = z21.enum([
+var id3 = z22.string().min(1).max(128);
+var subscriptionRouteSchema = z22.enum([
   "codex_cli",
   "claude_code_cli",
   "codex_cpa",
   "claude_cpa",
   "openai_siwc"
 ]);
-var subscriptionConnectionSchema = z21.object({
-  id: id2,
-  ownerId: id2,
-  workspaceId: id2,
-  provider: z21.enum(["openai", "anthropic"]),
-  state: z21.enum([
+var subscriptionConnectionSchema = z22.object({
+  id: id3,
+  ownerId: id3,
+  workspaceId: id3,
+  provider: z22.enum(["openai", "anthropic"]),
+  state: z22.enum([
     "pending",
     "connected",
     "reconnect_required",
     "disconnected"
   ]),
   // Increment on reconnect/disconnect. Old bindings cannot become valid again.
-  revision: z21.number().int().positive(),
+  revision: z22.number().int().positive(),
   quota: quotaSnapshotSchema
 }).strict();
-var subscriptionBindingSchema = z21.object({
-  id: id2,
-  ownerId: id2,
-  workspaceId: id2,
+var subscriptionBindingSchema = z22.object({
+  id: id3,
+  ownerId: id3,
+  workspaceId: id3,
   // An agent or assistant session selected explicitly by the owner.
-  consumerId: id2,
-  connectionId: id2,
-  connectionRevision: z21.number().int().positive(),
+  consumerId: id3,
+  connectionId: id3,
+  connectionRevision: z22.number().int().positive(),
   route: subscriptionRouteSchema
 }).strict();
-var nativeBrokerContextSchema = z21.object({
-  route: z21.enum(["codex_cli", "claude_code_cli"]),
-  modelId: z21.string().min(1).max(128),
-  revision: z21.number().int().positive(),
-  accountId: z21.string().min(1).max(512),
-  plan: z21.string().max(40).optional(),
-  expiresAt: z21.iso.datetime()
+var nativeBrokerContextSchema = z22.object({
+  route: z22.enum(["codex_cli", "claude_code_cli"]),
+  modelId: z22.string().min(1).max(128),
+  revision: z22.number().int().positive(),
+  accountId: z22.string().min(1).max(512),
+  plan: z22.string().max(40).optional(),
+  expiresAt: z22.iso.datetime()
 }).strict();
 
 // ../protocol/src/repository.ts
@@ -4242,7 +4299,7 @@ function normalizeRepository(input, options = {}) {
 }
 
 // src/login.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/errors.ts
 var DaemonError = class extends Error {
@@ -4309,7 +4366,7 @@ import { join as join3 } from "node:path";
 // package.json
 var package_default = {
   name: "@mikka/daemon",
-  version: "0.0.64",
+  version: "0.0.65",
   description: "Local Mikka daemon: runs agents through the user's own CLIs",
   type: "module",
   private: true,
@@ -4368,7 +4425,7 @@ var package_default = {
   engines: {
     node: ">=24"
   },
-  gitHead: "d2f1f5235d5ca8e84c1cabdc973b19956a248c5d"
+  gitHead: "f566198f5cee77ff3a0ba56f6923a0cf0b005b0e"
 };
 
 // src/paths.ts
@@ -4407,7 +4464,7 @@ function daemonPaths(dataDir) {
 }
 
 // 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";
@@ -4527,6 +4584,20 @@ function requireRunToolApproval(runId, gate) {
   return gate;
 }
 
+// ../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";
 import {
@@ -4719,7 +4790,7 @@ function toolApprovalDecision(request, policy, worktree) {
 }
 
 // ../protocol/src/capture.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var CAPTURE_CONTENT_TYPES = [
   "image/png",
   "image/jpeg",
@@ -4762,44 +4833,44 @@ function captureProblem(bytes, declared) {
 function cleanCaptureTitle(title2) {
   return title2.replace(/\s+/g, " ").trim().slice(0, CAPTURE_TITLE_MAX);
 }
-var sha256 = z22.string().regex(/^[a-f0-9]{64}$/);
-var title = z22.string().trim().min(1).max(CAPTURE_TITLE_MAX);
-var captureUploadRequest = z22.object({
+var sha256 = z23.string().regex(/^[a-f0-9]{64}$/);
+var title = z23.string().trim().min(1).max(CAPTURE_TITLE_MAX);
+var captureUploadRequest = z23.object({
   /** Stable client id, persisted before the first network attempt. */
-  captureId: z22.uuid().optional(),
+  captureId: z23.uuid().optional(),
   title,
-  contentType: z22.enum(CAPTURE_CONTENT_TYPES),
-  size: z22.number().int().min(1).max(CAPTURE_MAX_BYTES.video),
+  contentType: z23.enum(CAPTURE_CONTENT_TYPES),
+  size: z23.number().int().min(1).max(CAPTURE_MAX_BYTES.video),
   sha256
 }).strict();
-var captureUploadTarget = z22.discriminatedUnion("target", [
-  z22.object({ target: z22.literal("storage"), url: z22.url({ protocol: /^https$/ }), headers: z22.record(z22.string(), z22.string()) }),
-  z22.object({ target: z22.literal("server") })
+var captureUploadTarget = z23.discriminatedUnion("target", [
+  z23.object({ target: z23.literal("storage"), url: z23.url({ protocol: /^https$/ }), headers: z23.record(z23.string(), z23.string()) }),
+  z23.object({ target: z23.literal("server") })
 ]);
-var captureUploadResponse = z22.object({
-  captureId: z22.uuid(),
+var captureUploadResponse = z23.object({
+  captureId: z23.uuid(),
   upload: captureUploadTarget
 });
-var captureView = z22.object({
-  id: z22.uuid(),
-  kind: z22.enum(CAPTURE_KINDS),
-  contentType: z22.enum(CAPTURE_CONTENT_TYPES),
-  title: z22.string(),
-  size: z22.number().int().nonnegative(),
-  durationMs: z22.number().int().nonnegative().nullable(),
-  source: z22.enum(CAPTURE_SOURCES),
-  createdAt: z22.iso.datetime()
+var captureView = z23.object({
+  id: z23.uuid(),
+  kind: z23.enum(CAPTURE_KINDS),
+  contentType: z23.enum(CAPTURE_CONTENT_TYPES),
+  title: z23.string(),
+  size: z23.number().int().nonnegative(),
+  durationMs: z23.number().int().nonnegative().nullable(),
+  source: z23.enum(CAPTURE_SOURCES),
+  createdAt: z23.iso.datetime()
 });
-var captureCompleteResponse = z22.object({ capture: captureView });
-var screenCaptureRequest = z22.discriminatedUnion("action", [
-  z22.object({ action: z22.literal("screenshot"), title }).strict(),
-  z22.object({ action: z22.literal("start_recording"), title, maxSeconds: z22.number().int().min(5).max(RECORDING_MAX_SECONDS).optional() }).strict(),
-  z22.object({ action: z22.literal("stop_recording") }).strict()
+var captureCompleteResponse = z23.object({ capture: captureView });
+var screenCaptureRequest = z23.discriminatedUnion("action", [
+  z23.object({ action: z23.literal("screenshot"), title }).strict(),
+  z23.object({ action: z23.literal("start_recording"), title, maxSeconds: z23.number().int().min(5).max(RECORDING_MAX_SECONDS).optional() }).strict(),
+  z23.object({ action: z23.literal("stop_recording") }).strict()
 ]);
-var screenCaptureResponse = z22.discriminatedUnion("action", [
-  z22.object({ action: z22.literal("screenshot"), capture: captureView }),
-  z22.object({ action: z22.literal("start_recording"), recordingId: z22.uuid(), stopsAt: z22.iso.datetime() }),
-  z22.object({ action: z22.literal("stop_recording"), capture: captureView })
+var screenCaptureResponse = z23.discriminatedUnion("action", [
+  z23.object({ action: z23.literal("screenshot"), capture: captureView }),
+  z23.object({ action: z23.literal("start_recording"), recordingId: z23.uuid(), stopsAt: z23.iso.datetime() }),
+  z23.object({ action: z23.literal("stop_recording"), capture: captureView })
 ]);
 var capturePaths = {
   begin: (runId) => `/v1/runs/${encodeURIComponent(runId)}/captures`,
@@ -4809,24 +4880,24 @@ var capturePaths = {
 };
 
 // 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");
 function assertMailboxRunAuthority(input) {
@@ -4883,13 +4954,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;
@@ -4908,7 +4979,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();
@@ -4924,7 +4995,7 @@ async function createRunMailbox(host) {
   if (!Array.isArray(offered.tools)) throw unavailable();
   const allowed = Object.keys(mailboxInputs).filter((name) => offered.tools.some((tool2) => tool2.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();
@@ -4962,15 +5033,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() {
@@ -4998,12 +5069,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),
@@ -5013,7 +5113,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((resolve11, reject) => {
@@ -5128,6 +5234,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",
@@ -5349,16 +5456,16 @@ var HttpServerLink = class {
 var DEVICE_CODE_PATH = `${AUTH_BASE_PATH}/device/code`;
 var DEVICE_TOKEN_PATH = `${AUTH_BASE_PATH}/device/token`;
 var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
-var deviceCodeResponse = z26.object({
-  device_code: z26.string().min(1),
-  user_code: z26.string().min(1),
-  verification_uri: z26.string(),
-  verification_uri_complete: z26.string().optional(),
-  expires_in: z26.number().positive(),
-  interval: z26.number().positive().default(5)
+var deviceCodeResponse = z27.object({
+  device_code: z27.string().min(1),
+  user_code: z27.string().min(1),
+  verification_uri: z27.string(),
+  verification_uri_complete: z27.string().optional(),
+  expires_in: z27.number().positive(),
+  interval: z27.number().positive().default(5)
 });
-var tokenResponse = z26.object({ access_token: z26.string().regex(/^orv_[A-Za-z0-9_-]{43}$/) });
-var errorResponse = z26.object({ error: z26.string() });
+var tokenResponse = z27.object({ access_token: z27.string().regex(/^orv_[A-Za-z0-9_-]{43}$/) });
+var errorResponse = z27.object({ error: z27.string() });
 var LoginError = class extends DaemonError {
   constructor(reason, message) {
     super(4003, message);
@@ -5450,7 +5557,7 @@ async function registrationLogin(options) {
 import { mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, rmSync as rmSync9, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname7, join as join11 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/env.ts
 var BASE_ENV_ALLOW = [
@@ -6546,11 +6653,11 @@ import { homedir as homedir4 } from "node:os";
 import { dirname as dirname6, join as join10, resolve as resolve6 } from "node:path";
 
 // src/agents/skill-artifact.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { lstatSync as lstatSync5, readFileSync as readFileSync6 } from "node:fs";
 function verifyAssignedSkills(skills, receipt) {
   if (!receipt) return;
-  if (skills?.length !== 1 || skills[0].id !== receipt.artifact.skillId || skills[0].files.length !== 0 || createHash("sha256").update(skillMarkdown(skills[0]), "utf8").digest("hex") !== receipt.artifact.sha256)
+  if (skills?.length !== 1 || skills[0].id !== receipt.artifact.skillId || skills[0].files.length !== 0 || createHash2("sha256").update(skillMarkdown(skills[0]), "utf8").digest("hex") !== receipt.artifact.sha256)
     throw new Error("Assigned Skill artifact digest mismatch");
 }
 function verifySkillAssignment(assignment) {
@@ -6561,7 +6668,7 @@ function verifySkillAssignment(assignment) {
   verifyAssignedSkills(assignment.skills, receipt);
 }
 function verifyMountedSkill(file, receipt) {
-  if (!lstatSync5(file).isFile() || lstatSync5(file).isSymbolicLink() || lstatSync5(file).nlink !== 1 || createHash("sha256").update(readFileSync6(file)).digest("hex") !== receipt.artifact.sha256)
+  if (!lstatSync5(file).isFile() || lstatSync5(file).isSymbolicLink() || lstatSync5(file).nlink !== 1 || createHash2("sha256").update(readFileSync6(file)).digest("hex") !== receipt.artifact.sha256)
     throw new Error("Mounted Skill artifact digest mismatch");
 }
 function verifySkillResume(assignment, current) {
@@ -6571,7 +6678,7 @@ function verifySkillResume(assignment, current) {
 }
 
 // src/captures.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { closeSync as closeSync2, constants, fstatSync, lstatSync as lstatSync6, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync7 } from "node:fs";
 import { join as join9 } from "node:path";
 var CAPTURES_DIR = "captures";
@@ -6592,34 +6699,34 @@ function readPlain(path, max) {
     closeSync2(fd);
   }
 }
-var drop = (dir, id3) => {
-  for (const name of [`${id3}.json`, ...EXTENSIONS.map((ext) => `${id3}.${ext}`)]) rmSync7(join9(dir, name), { force: true });
+var drop = (dir, id4) => {
+  for (const name of [`${id4}.json`, ...EXTENSIONS.map((ext) => `${id4}.${ext}`)]) rmSync7(join9(dir, name), { force: true });
 };
 async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly = false) {
   if (!link.beginCapture || !link.sendCapture || !link.completeCapture) return 0;
   if (!lstatSync6(dir, { throwIfNoEntry: false })?.isDirectory()) return 0;
   let sent = 0;
   for (const name of readdirSync3(dir).sort()) {
-    const id3 = name.endsWith(".json") ? name.slice(0, -5) : "";
-    if (!ID.test(id3)) continue;
+    const id4 = name.endsWith(".json") ? name.slice(0, -5) : "";
+    if (!ID.test(id4)) continue;
     const meta = readPlain(join9(dir, name), 4096);
     let title2 = "";
     try {
       title2 = cleanCaptureTitle(String(JSON.parse(new TextDecoder().decode(meta ?? new Uint8Array())).title ?? ""));
     } catch {
     }
-    const file = EXTENSIONS.map((ext) => join9(dir, `${id3}.${ext}`)).find((path) => lstatSync6(path, { throwIfNoEntry: false }));
+    const file = EXTENSIONS.map((ext) => join9(dir, `${id4}.${ext}`)).find((path) => lstatSync6(path, { throwIfNoEntry: false }));
     const bytes = file ? readPlain(file, CAPTURE_MAX_BYTES.video) : null;
     const problem = !title2 ? "no title" : !bytes ? "no regular file" : captureProblem(bytes);
     const contentType = bytes && sniffCaptureType(bytes);
     if (problem || !bytes || !contentType) {
-      log.warn({ run_id: runId, capture: id3, problem }, "capture dropped");
-      drop(dir, id3);
+      log.warn({ run_id: runId, capture: id4, problem }, "capture dropped");
+      drop(dir, id4);
       continue;
     }
     try {
-      const sha2562 = createHash2("sha256").update(bytes).digest("hex");
-      const pendingPath = pendingDir ? join9(pendingDir, `${id3}.json`) : null;
+      const sha2562 = createHash3("sha256").update(bytes).digest("hex");
+      const pendingPath = pendingDir ? join9(pendingDir, `${id4}.json`) : null;
       let pending;
       if (pendingPath) {
         try {
@@ -6633,7 +6740,7 @@ async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly =
       if (pending) {
         try {
           await link.completeCapture(runId, pending.captureId);
-          drop(dir, id3);
+          drop(dir, id4);
           if (pendingPath) rmSync7(pendingPath, { force: true });
           sent += 1;
           continue;
@@ -6650,33 +6757,33 @@ async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly =
       } else {
         if (pendingPath) {
           mkdirSync7(pendingDir, { recursive: true, mode: 448 });
-          writeJsonAtomic(pendingPath, { captureId: id3, sha256: sha2562 });
+          writeJsonAtomic(pendingPath, { captureId: id4, sha256: sha2562 });
         }
-        target = await link.beginCapture(runId, { ...pendingPath ? { captureId: id3 } : {}, title: title2, contentType, size: bytes.length, sha256: sha2562 });
-        if (pendingPath && target.captureId !== id3) throw new Error("Capture reservation id changed");
+        target = await link.beginCapture(runId, { ...pendingPath ? { captureId: id4 } : {}, title: title2, contentType, size: bytes.length, sha256: sha2562 });
+        if (pendingPath && target.captureId !== id4) throw new Error("Capture reservation id changed");
       }
       const { captureId, upload } = target;
       await link.sendCapture(runId, captureId, upload, bytes, contentType);
       await link.completeCapture(runId, captureId);
-      drop(dir, id3);
+      drop(dir, id4);
       if (pendingPath) rmSync7(pendingPath, { force: true });
       sent += 1;
     } catch (error) {
       if (error instanceof ServerUnreachableError) {
-        log.warn({ run_id: runId, capture: id3 }, "capture upload deferred");
+        log.warn({ run_id: runId, capture: id4 }, "capture upload deferred");
         return sent;
       }
       if (error instanceof DaemonError && (error.code === 401 || error.code === 403 || error.code === 404 || error.code === 409 || error.code === DAEMON_RPC_ERRORS.unauthorized)) {
-        log.warn({ run_id: runId, capture: id3, status: error.code }, "capture reservation unavailable; retry stopped");
+        log.warn({ run_id: runId, capture: id4, status: error.code }, "capture reservation unavailable; retry stopped");
         if (pendingDir) {
           mkdirSync7(pendingDir, { recursive: true, mode: 448 });
           writeJsonAtomic(join9(pendingDir, "blocked.json"), { status: error.code });
         }
         return sent;
       }
-      log.warn({ run_id: runId, capture: id3, status: error instanceof DaemonError ? error.code : void 0 }, "capture refused");
-      drop(dir, id3);
-      if (pendingDir) rmSync7(join9(pendingDir, `${id3}.json`), { force: true });
+      log.warn({ run_id: runId, capture: id4, status: error instanceof DaemonError ? error.code : void 0 }, "capture refused");
+      drop(dir, id4);
+      if (pendingDir) rmSync7(join9(pendingDir, `${id4}.json`), { force: true });
     }
   }
   return sent;
@@ -6762,19 +6869,20 @@ function daemonSecrets(dataDir) {
   ];
 }
 function runPaths(stateDir, runId) {
-  const id3 = assertSafeId("run id", runId);
+  const id4 = assertSafeId("run id", runId);
   return {
     /** The daemon's data dir (`stateDir` is `<dataDir>/adapters`). */
     privateDir: resolve6(stateDir, ".."),
     /** Writable from the sandbox. */
-    runDir: join10(stateDir, "runs", id3),
+    runDir: join10(stateDir, "runs", id4),
     /** Daemon only. */
-    pidFile: join10(stateDir, "pids", `${id3}.pgid`)
+    pidFile: join10(stateDir, "pids", `${id4}.pgid`)
   };
 }
 var RunContext = class {
   constructor(options) {
     this.options = options;
+    if (options.policyHash && (!options.policy || policySnapshotHash(options.policy) !== options.policyHash)) throw new Error("Run child policy hash mismatch");
     this.worktree = realpathSync7(options.worktree);
     this.gitDir = realpathSync7(
       execFileSync("git", ["rev-parse", "--absolute-git-dir"], {
@@ -6928,7 +7036,7 @@ var RunContext = class {
    * and zsh writes here-docs to `$TMPPREFIX` (default `/tmp/zsh`).
    */
   tempEnv() {
-    return { TMPDIR: this.tmpDir, TMPPREFIX: join10(this.tmpDir, "zsh"), ...this.githubEnv };
+    return { TMPDIR: this.tmpDir, TMPPREFIX: join10(this.tmpDir, "zsh"), ...this.githubEnv, ...this.options.policyHash ? { MIKKA_POLICY_HASH: this.options.policyHash } : {} };
   }
   /** A hand-in from an earlier session would end this one at once. */
   clearHandoff() {
@@ -7052,7 +7160,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import { createSdkMcpServer, query, tool } from "@anthropic-ai/claude-agent-sdk";
 
 // src/coordinator/contract.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var COORDINATOR_DEFAULT_TIMEOUT_MS = 12e4;
 var COORDINATOR_DEFAULT_TOOL_LIMIT = 40;
 var MAX_REPLY_CHARS = 2e5;
@@ -7105,7 +7213,7 @@ var CoordinatorToolHost = class {
     if (!callId || callId.length > 200) return Promise.reject(new Error("coordinatorCallIdInvalid"));
     const tool2 = this.tools.get(name);
     if (!tool2) return Promise.reject(new Error("coordinatorToolUnavailable"));
-    const parsed = z27.object(tool2.inputSchema).strict().safeParse(input);
+    const parsed = z28.object(tool2.inputSchema).strict().safeParse(input);
     if (!parsed.success) return Promise.reject(new Error("coordinatorToolInputInvalid"));
     const key2 = JSON.stringify([name, parsed.data]);
     const prior = this.calls.get(callId);
@@ -7193,7 +7301,7 @@ async function runClaudeCoordinator(input, host) {
 }
 
 // src/coordinator/codex.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var CODEX_COORDINATOR_APPROVAL_POLICY = "on-request";
 function codexCoordinatorThread(input, host, tools) {
   return {
@@ -7207,12 +7315,12 @@ function codexCoordinatorThread(input, host, tools) {
     dynamicTools: [...tools.tools.values()].map((definition) => ({
       name: definition.name,
       description: definition.description,
-      inputSchema: z28.toJSONSchema(z28.object(definition.inputSchema).strict(), { target: "draft-7" })
+      inputSchema: z29.toJSONSchema(z29.object(definition.inputSchema).strict(), { target: "draft-7" })
     })),
     ...input.model ? { model: input.model } : {}
   };
 }
-var toolRequest = z28.object({ threadId: z28.string(), turnId: z28.string(), callId: z28.string(), tool: z28.string(), arguments: z28.unknown() });
+var toolRequest = z29.object({ threadId: z29.string(), turnId: z29.string(), callId: z29.string(), tool: z29.string(), arguments: z29.unknown() });
 async function runCodexCoordinator(input, host) {
   const deadline = coordinatorDeadline(input);
   const signal = deadline.controller.signal;
@@ -7266,7 +7374,7 @@ async function runCodexCoordinator(input, host) {
     rpc.onRequest("item/tool/requestUserInput", () => ({ answers: {} }));
     rpc.onRequest("mcpServer/elicitation/request", () => ({ action: "decline", content: null }));
     rpc.onNotification("item/completed", (raw) => {
-      const parsed = z28.object({ threadId: z28.string(), turnId: z28.string(), item: z28.object({ id: z28.string(), type: z28.string(), text: z28.string().optional(), phase: z28.string().nullable().optional() }) }).safeParse(raw);
+      const parsed = z29.object({ threadId: z29.string(), turnId: z29.string(), item: z29.object({ id: z29.string(), type: z29.string(), text: z29.string().optional(), phase: z29.string().nullable().optional() }) }).safeParse(raw);
       if (!parsed.success || parsed.data.threadId !== threadId || turnId && parsed.data.turnId !== turnId) return;
       turnId ??= parsed.data.turnId;
       const item = parsed.data.item;
@@ -7279,7 +7387,7 @@ async function runCodexCoordinator(input, host) {
       }
     });
     rpc.onNotification("turn/completed", (raw) => {
-      const parsed = z28.object({ threadId: z28.string(), turn: z28.object({ id: z28.string(), status: z28.string() }) }).safeParse(raw);
+      const parsed = z29.object({ threadId: z29.string(), turn: z29.object({ id: z29.string(), status: z29.string() }) }).safeParse(raw);
       if (!parsed.success || parsed.data.threadId !== threadId || turnId && parsed.data.turn.id !== turnId) return;
       turnId ??= parsed.data.turn.id;
       acceptingTools = false;
@@ -7291,11 +7399,11 @@ async function runCodexCoordinator(input, host) {
     await request("initialize", { clientInfo: { name: "mikka_coordinator", version: "1.0.0" }, capabilities: { experimentalApi: true } });
     await rpc.sendNotification("initialized");
     const thread = await request("thread/start", codexCoordinatorThread(input, host, tools));
-    threadId = z28.string().min(1).parse(thread.thread.id);
+    threadId = z29.string().min(1).parse(thread.thread.id);
     acceptingTools = true;
     const turn = await request("turn/start", { threadId, input: [{ type: "text", text: input.context, text_elements: [] }] });
     if (turnId && turnId !== turn.turn.id) throw new Error("coordinatorCodexTurnMismatch");
-    turnId = z28.string().min(1).parse(turn.turn.id);
+    turnId = z29.string().min(1).parse(turn.turn.id);
     await Promise.race([ended, cancellation]);
     signal.throwIfAborted();
     const items = [...messages.values()];
@@ -7334,8 +7442,8 @@ async function runNativeCoordinatorJob(job, options) {
   mkdirSync9(cwd, { mode: 448 });
   try {
     const tools = job.tools.map((spec) => {
-      const schema = z29.fromJSONSchema(spec.inputSchema);
-      if (!(schema instanceof z29.ZodObject)) throw new Error("coordinatorToolSchemaUnsupported");
+      const schema = z30.fromJSONSchema(spec.inputSchema);
+      if (!(schema instanceof z30.ZodObject)) throw new Error("coordinatorToolSchemaUnsupported");
       return {
         name: spec.name,
         description: spec.description,
@@ -7572,33 +7680,33 @@ run sandbox group termination failed: ${String(error)}`;
       return;
     }
     if (value.type !== "network" || !Number.isSafeInteger(value.id) || value.id < 1 || pending.has(value.id)) return;
-    const id3 = value.id;
+    const id4 = value.id;
     const request = {
       host: typeof value.host === "string" ? value.host : "",
       port: typeof value.port === "number" ? value.port : 0
     };
     if (typeof value.port !== "number" || stopped || lifetime.signal.aborted || pending.size >= MAX_PENDING_NETWORK || !matchesRunSandboxDomain(request, maximum)) {
-      send({ type: "decision", id: id3, allow: false });
+      send({ type: "decision", id: id4, allow: false });
       return;
     }
     const controller = new AbortController();
     const timer = setTimeout(() => {
-      if (!pending.delete(id3)) return;
+      if (!pending.delete(id4)) return;
       controller.abort();
-      send({ type: "decision", id: id3, allow: false });
+      send({ type: "decision", id: id4, allow: false });
     }, NETWORK_DECISION_MS);
-    pending.set(id3, { controller, timer });
+    pending.set(id4, { controller, timer });
     void Promise.resolve().then(() => {
       if (stopped || lifetime.signal.aborted) return false;
       return onNetwork(request, controller.signal);
     }).then((allow) => {
-      if (!pending.delete(id3)) return;
+      if (!pending.delete(id4)) return;
       clearTimeout(timer);
-      send({ type: "decision", id: id3, allow: allow === true && !stopped && !lifetime.signal.aborted && !controller.signal.aborted });
+      send({ type: "decision", id: id4, allow: allow === true && !stopped && !lifetime.signal.aborted && !controller.signal.aborted });
     }, () => {
-      if (pending.delete(id3)) {
+      if (pending.delete(id4)) {
         clearTimeout(timer);
-        send({ type: "decision", id: id3, allow: false });
+        send({ type: "decision", id: id4, allow: false });
       }
     });
   });
@@ -7843,18 +7951,18 @@ function claudeChunks(message) {
   const chunks = [];
   if (message.type === "assistant") {
     message.message.content.forEach((block, index) => {
-      const id3 = `${message.message.id ?? randomUUID3()}-${index}`;
+      const id4 = `${message.message.id ?? randomUUID3()}-${index}`;
       if (block.type === "text" && block.text) {
         chunks.push(
-          { type: "text-start", id: id3 },
-          { type: "text-delta", id: id3, delta: block.text },
-          { type: "text-end", id: id3 }
+          { type: "text-start", id: id4 },
+          { type: "text-delta", id: id4, delta: block.text },
+          { type: "text-end", id: id4 }
         );
       } else if (block.type === "thinking" && block.thinking) {
         chunks.push(
-          { type: "reasoning-start", id: id3 },
-          { type: "reasoning-delta", id: id3, delta: block.thinking },
-          { type: "reasoning-end", id: id3 }
+          { type: "reasoning-start", id: id4 },
+          { type: "reasoning-delta", id: id4, delta: block.thinking },
+          { type: "reasoning-end", id: id4 }
         );
       } else if (block.type === "tool_use") {
         chunks.push({
@@ -8067,6 +8175,7 @@ var ClaudeAdapter = class {
       gitWritePaths: options.gitWritePaths,
       networkAllow: options.networkAllow,
       policy: options.policy,
+      policyHash: options.policyHash,
       skills: options.skills,
       skillReceipt: options.skillReceipt,
       runDir,
@@ -8508,6 +8617,7 @@ var CodexAdapter = class {
       gitWritePaths: options.gitWritePaths,
       networkAllow: options.networkAllow,
       policy: options.policy,
+      policyHash: options.policyHash,
       skills: options.skills,
       skillReceipt: options.skillReceipt,
       runDir,
@@ -8739,7 +8849,7 @@ var CodexAdapter = class {
     });
     rpc.listen();
     const turnCompleted = async (turn) => {
-      for (const [id3, item] of pendingMcp) if (item.turnId === turn.id) pendingMcp.delete(id3);
+      for (const [id4, item] of pendingMcp) if (item.turnId === turn.id) pendingMcp.delete(id4);
       queue.chunk({
         type: "data-usage",
         data: {
@@ -8974,24 +9084,24 @@ var AcpChunker = class {
   /** Closes an open text or reasoning part. */
   close() {
     if (!this.open) return [];
-    const { kind, id: id3 } = this.open;
+    const { kind, id: id4 } = this.open;
     this.open = null;
-    return [{ type: kind === "text" ? "text-end" : "reasoning-end", id: id3 }];
+    return [{ type: kind === "text" ? "text-end" : "reasoning-end", id: id4 }];
   }
   part(kind, delta) {
     const chunks = [];
     if (this.open?.kind !== kind) {
       chunks.push(...this.close());
-      const id4 = `${this.prefix}-${++this.count}`;
-      this.open = { kind, id: id4 };
+      const id5 = `${this.prefix}-${++this.count}`;
+      this.open = { kind, id: id5 };
       chunks.push({
         type: kind === "text" ? "text-start" : "reasoning-start",
-        id: id4
+        id: id5
       });
     }
-    const id3 = this.open?.id;
+    const id4 = this.open?.id;
     chunks.push(
-      kind === "text" ? { type: "text-delta", id: id3, delta } : { type: "reasoning-delta", id: id3, delta }
+      kind === "text" ? { type: "text-delta", id: id4, delta } : { type: "reasoning-delta", id: id4, delta }
     );
     return chunks;
   }
@@ -9094,6 +9204,7 @@ var CursorAdapter = class {
       gitWritePaths: options.gitWritePaths,
       networkAllow: options.networkAllow,
       policy: options.policy,
+      policyHash: options.policyHash,
       skills: options.skills,
       skillReceipt: options.skillReceipt,
       runDir,
@@ -9443,13 +9554,13 @@ var MockAdapter = class {
         }
         while (inbox.length > 0) {
           const text3 = inbox.shift();
-          const id3 = `ack-${randomUUID4()}`;
-          yield { type: "chunk", chunk: { type: "text-start", id: id3 } };
+          const id4 = `ack-${randomUUID4()}`;
+          yield { type: "chunk", chunk: { type: "text-start", id: id4 } };
           yield {
             type: "chunk",
-            chunk: { type: "text-delta", id: id3, delta: `Noted: ${text3}` }
+            chunk: { type: "text-delta", id: id4, delta: `Noted: ${text3}` }
           };
-          yield { type: "chunk", chunk: { type: "text-end", id: id3 } };
+          yield { type: "chunk", chunk: { type: "text-end", id: id4 } };
         }
         if (line.hang) {
           if (!abort.signal.aborted) {
@@ -10165,7 +10276,7 @@ var Outbox = class {
     }
   }
   async flushAll() {
-    await Promise.all(this.runIds().map((id3) => this.flush(id3)));
+    await Promise.all(this.runIds().map((id4) => this.flush(id4)));
   }
   /** Serialized per run so items always leave in append order. */
   flush(runId) {
@@ -11246,7 +11357,7 @@ function withoutTaskEnv(assignment) {
 
 // src/runs/journal.ts
 function persisted(entries) {
-  return Object.fromEntries(Object.entries(entries).map(([id3, entry]) => [id3, { ...entry, assignment: withoutTaskEnv(entry.assignment) }]));
+  return Object.fromEntries(Object.entries(entries).map(([id4, entry]) => [id4, { ...entry, assignment: withoutTaskEnv(entry.assignment) }]));
 }
 var RunJournal = class {
   constructor(file) {
@@ -11386,9 +11497,9 @@ function createRunMasker(secrets) {
     pending.delete(key2);
     if (!held) return null;
     const sep = key2.indexOf(":");
-    const prefix = key2.slice(0, sep), id3 = key2.slice(sep + 1);
+    const prefix = key2.slice(0, sep), id4 = key2.slice(sep + 1);
     const masked = text3(held);
-    return prefix === "tool" ? { type: "tool-input-delta", toolCallId: id3, inputTextDelta: masked } : { type: DELTA_FOR_PREFIX[prefix], id: id3, delta: masked };
+    return prefix === "tool" ? { type: "tool-input-delta", toolCallId: id4, inputTextDelta: masked } : { type: DELTA_FOR_PREFIX[prefix], id: id4, delta: masked };
   };
   const flush = () => {
     const out = [];
@@ -11441,7 +11552,7 @@ function createRunMasker(secrets) {
 }
 
 // src/runs/supervisor.ts
-import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
 import { join as join23, resolve as resolve9 } from "node:path";
 import { execa as execa12 } from "execa";
 
@@ -11662,7 +11773,7 @@ var MemoryServer = class {
       registerDevice: async (credential, info, knownDeviceId) => {
         this.check();
         const existing = [...this.devices].find(
-          ([id3, d]) => d.credential === credential && (!knownDeviceId || id3 === knownDeviceId)
+          ([id4, d]) => d.credential === credential && (!knownDeviceId || id4 === knownDeviceId)
         );
         const deviceId = existing?.[0] ?? this.fixedDeviceId ?? randomUUID5();
         this.devices.set(deviceId, { credential, info });
@@ -11692,7 +11803,7 @@ var MemoryServer = class {
       },
       pendingRuns: async (deviceId) => {
         this.check();
-        return [...this.runs].filter(([, r]) => r.deviceId === deviceId && r.state === "queued").map(([id3]) => id3);
+        return [...this.runs].filter(([, r]) => r.deviceId === deviceId && r.state === "queued").map(([id4]) => id4);
       },
       claimRun: async (deviceId, runId) => {
         this.check();
@@ -11759,8 +11870,8 @@ var MemoryServer = class {
       },
       ackCommands: async (_deviceId, delivered) => {
         this.check();
-        for (const id3 of delivered) {
-          const input = this.inputs.get(id3);
+        for (const id4 of delivered) {
+          const input = this.inputs.get(id4);
           if (input && !input.deliveredAt) input.deliveredAt = Date.now();
         }
       }
@@ -12543,6 +12654,8 @@ var RunSupervisor = class {
     const log = this.deps.log.child({ run_id: runId });
     let entry = this.deps.journal.get(runId);
     const { assignment } = entry;
+    if ((assignment.policySnapshotRequired || assignment.policySnapshot) && !this.deps.verifyRunPolicy) throw new Error("Run policy verification unavailable");
+    await this.deps.verifyRunPolicy?.(assignment, AbortSignal.any([this.stopController.signal, run2.abort.signal]));
     verifySkillAssignment(assignment);
     if (assignment.skillReceipt && (this.leases.get(runId) ?? 0) <= Date.now())
       throw new Error("Receipted Skill assignment requires a current server lease");
@@ -12667,6 +12780,7 @@ var RunSupervisor = class {
       networkAllow: repo.networkAllow,
       gitWritePaths: await worktreeGitWritePaths(repo.path, worktree, runId),
       policy: assignment.policy,
+      policyHash: assignment.policySnapshot?.payload.policyHash,
       skills: assignment.skills,
       skillReceipt: assignment.skillReceipt,
       onRuntimeModel: assignment.skillReceipt ? (sessionId, observedModel) => {
@@ -12692,13 +12806,13 @@ var RunSupervisor = class {
     if (assignment.requireSessionResume && (assignment.subscriptionBinding || !assignment.resumeSessionId || !assignment.continuesRunId || !adapter.capabilities.supportsResume || !resuming && !continueSession || resuming && entry.sessionId !== assignment.resumeSessionId))
       throw new Error("factory_question_session_resume_required");
     const benchmark = assignment.benchmark;
-    const policyDigest = assignment.skillReceipt ? createHash3("sha256").update(runPolicyDigestInput(assignment.policy)).digest("hex") : void 0;
+    const policyDigest = assignment.skillReceipt ? createHash4("sha256").update(runPolicyDigestInput(assignment.policy)).digest("hex") : void 0;
     if (benchmark && (!assignment.skillReceipt || assignment.harness === "mock" || !assignment.verifyCommand || benchmark.sourceCommit !== this.deps.journal.get(runId)?.baseCommit || policyDigest !== benchmark.policyDigest)) throw new Error("Frozen benchmark execution configuration mismatch");
     let fixtureDigest;
     if (benchmark) {
       if (runPolicy(assignment.policy).readOnly !== true) throw new Error("Benchmark fixture must be read-only");
       const fixed = await fixedCheckSnapshot(repo.path, worktree, benchmark.sourceCommit);
-      fixtureDigest = createHash3("sha256").update(fixed.sha).digest("hex");
+      fixtureDigest = createHash4("sha256").update(fixed.sha).digest("hex");
       if (fixtureDigest !== benchmark.fixtureDigest) throw new Error("Frozen benchmark fixture digest mismatch");
     }
     const previousMount = entry.skillMount;
@@ -12838,7 +12952,7 @@ var RunSupervisor = class {
         const error = event.error ?? (stopReason === "turn_ended" ? "Session ended without a submission" : stopReason === "timeout" ? "No progress before the watchdog limit" : stopReason === "device_lost" ? "Run lease expired; the server could not be reached" : void 0);
         if (assignment.benchmark) {
           const fixed = await fixedCheckSnapshot(repo.path, worktree, assignment.benchmark.sourceCommit);
-          if (createHash3("sha256").update(fixed.sha).digest("hex") !== assignment.benchmark.fixtureDigest)
+          if (createHash4("sha256").update(fixed.sha).digest("hex") !== assignment.benchmark.fixtureDigest)
             throw new Error("Benchmark fixture changed during model execution");
         }
         const outcome = await this.report(
@@ -12993,7 +13107,7 @@ function fixedCandidateCheck(assignment) {
 }
 
 // src/repositories.ts
-import { createHash as createHash4, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID7 } from "node:crypto";
 import { existsSync as existsSync5, lstatSync as lstatSync8, mkdirSync as mkdirSync14, readdirSync as readdirSync5, realpathSync as realpathSync10, renameSync as renameSync2, rmSync as rmSync15 } from "node:fs";
 import { dirname as dirname10, join as join24, resolve as resolve10 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -13010,7 +13124,7 @@ var RepositoryCache = class {
   retainResources;
   pathFor(remoteUrl) {
     const { key: key2 } = normalizeRepository(remoteUrl, { allowFile: this.allowFile });
-    const path = resolve10(this.root, "v2", createHash4("sha256").update(key2).digest("hex"));
+    const path = resolve10(this.root, "v2", createHash5("sha256").update(key2).digest("hex"));
     if (!isInside(resolve10(this.root), path) || path === resolve10(this.root)) throw new Error("Invalid repository cache path");
     return path;
   }
@@ -13130,8 +13244,8 @@ import { join as join25 } from "node:path";
 import { BlockList, isIP as isIP2 } from "node:net";
 
 // ../../lib/search/url-schema.ts
-import { z as z30 } from "zod";
-var webUrlSchema = z30.string().max(2048).url().refine((value) => {
+import { z as z31 } from "zod";
+var webUrlSchema = z31.string().max(2048).url().refine((value) => {
   const url = new URL(value);
   return url.protocol === "https:" && !url.username && !url.password && !url.port && !url.hostname.includes(":") && !/^\d+\.\d+\.\d+\.\d+$/.test(url.hostname) && url.hostname.includes(".") && !/(?:^|\.)(?:localhost|local|internal|test|invalid|example|onion)\.?$/i.test(url.hostname);
 }, "\u53EA\u5141\u8BB8\u8BFB\u53D6\u516C\u5F00 HTTPS \u7F51\u9875\uFF0C\u4E0D\u652F\u6301\u51ED\u636E\u3001IP \u5730\u5740\u6216\u81EA\u5B9A\u4E49\u7AEF\u53E3\u3002");
@@ -13380,10 +13494,10 @@ async function createHostedBotRunner(host) {
       }
       throw new Error("native_runtime_cleanup_unconfirmed");
     }
-    const [id3, labels] = described.stdout.trim().split("|").map((part) => JSON.parse(part));
-    if (labels?.["com.mikka.native.resource"] !== record.nonce || record.id && record.id !== id3)
+    const [id4, labels] = described.stdout.trim().split("|").map((part) => JSON.parse(part));
+    if (labels?.["com.mikka.native.resource"] !== record.nonce || record.id && record.id !== id4)
       throw unavailable2();
-    await exec2("docker", ["rm", "-f", id3], { env: bareEnv, timeout: 3e4 });
+    await exec2("docker", ["rm", "-f", id4], { env: bareEnv, timeout: 3e4 });
     if (record.assets?.startsWith(join26(host.stateDir, "native-verify-git-")))
       rmSync16(record.assets, { recursive: true, force: true });
     rmSync16(file, { force: true });
@@ -13996,7 +14110,7 @@ async function createHostedBotRunner(host) {
 import {
   randomBytes as randomBytes2,
   randomUUID as randomUUID9,
-  createHash as createHash6,
+  createHash as createHash7,
   timingSafeEqual as timingSafeEqual2
 } from "node:crypto";
 import { chmodSync as chmodSync3 } from "node:fs";
@@ -14006,7 +14120,7 @@ import { createServer as createServer4 } from "node:net";
 import { spawn as spawn5 } from "node:child_process";
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
 import { createInterface } from "node:readline";
 var exec3 = promisify5(execFile5);
@@ -14023,7 +14137,7 @@ async function detectComputerDriver(binary = "cua-driver") {
       installed: true,
       version,
       path,
-      fingerprint: createHash5("sha256").update(await readFile2(path)).digest("hex")
+      fingerprint: createHash6("sha256").update(await readFile2(path)).digest("hex")
     };
   } catch {
     return null;
@@ -14078,7 +14192,7 @@ async function executeDriver(driver, input, display, leaseGuard, assertLive = ()
   if (display !== void 0 && !/^:[1-9][0-9]{0,3}$/.test(display))
     throw new Error("Invalid desktop display");
   const call = normalizeCall(input);
-  const fingerprint = createHash5("sha256").update(await readFile2(driver.path)).digest("hex");
+  const fingerprint = createHash6("sha256").update(await readFile2(driver.path)).digest("hex");
   if (fingerprint !== driver.fingerprint)
     throw new Error("Driver changed; restart and approve a new request");
   const args = driverArguments(call);
@@ -14105,7 +14219,7 @@ async function executeDriver(driver, input, display, leaseGuard, assertLive = ()
     env: { ...env, ...display === void 0 ? {} : { DISPLAY: display } },
     stdio: ["pipe", "pipe", "pipe"]
   });
-  let id3 = 0, bytes = 0;
+  let id4 = 0, bytes = 0;
   const pending = /* @__PURE__ */ new Map();
   const fail = (error) => {
     for (const p of pending.values()) p.reject(error);
@@ -14141,7 +14255,7 @@ async function executeDriver(driver, input, display, leaseGuard, assertLive = ()
     )
   );
   const request = (method, params) => new Promise((resolve11, reject) => {
-    const n = ++id3;
+    const n = ++id4;
     pending.set(n, { resolve: resolve11, reject });
     child.stdin.write(
       JSON.stringify({ jsonrpc: "2.0", id: n, method, params }) + "\n"
@@ -14276,7 +14390,7 @@ var ComputerBroker = class {
       call,
       expiresAt: this.now() + this.ttl
     };
-    const digest = createHash6("sha256").update(JSON.stringify(request)).digest("hex");
+    const digest2 = createHash7("sha256").update(JSON.stringify(request)).digest("hex");
     return new Promise((resolve11, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(request.id);
@@ -14293,7 +14407,7 @@ var ComputerBroker = class {
         token,
         assertLive,
         cleanup: () => signal?.removeEventListener("abort", cancel),
-        request: { ...request, digest },
+        request: { ...request, digest: digest2 },
         resolve: resolve11,
         reject,
         timer
@@ -14321,21 +14435,21 @@ var ComputerBroker = class {
   }
   revoke(token) {
     this.grants.delete(token);
-    for (const [id3, row] of this.pending) {
+    for (const [id4, row] of this.pending) {
       if (row.token !== token) continue;
-      this.pending.delete(id3);
+      this.pending.delete(id4);
       clearTimeout(row.timer);
       row.cleanup();
       row.reject(new Error("Run ended; approval discarded"));
     }
   }
-  async decide(id3, digest, approve) {
-    const row = this.pending.get(id3);
+  async decide(id4, digest2, approve) {
+    const row = this.pending.get(id4);
     if (!row) throw new Error("Request expired or already consumed");
-    const left = Buffer.from(row.request.digest), right = Buffer.from(digest);
+    const left = Buffer.from(row.request.digest), right = Buffer.from(digest2);
     if (left.length !== right.length || !timingSafeEqual2(left, right))
       throw new Error("Review changed");
-    this.pending.delete(id3);
+    this.pending.delete(id4);
     row.cleanup();
     clearTimeout(row.timer);
     const { runId, call, expiresAt, target, display } = row.request;
@@ -14350,7 +14464,7 @@ var ComputerBroker = class {
           throw new Error("Not permitted");
       };
       assertLive();
-      row.resolve(await this.execute(this.driver, call, display, runId, { actionId: id3, assertLive }));
+      row.resolve(await this.execute(this.driver, call, display, runId, { actionId: id4, assertLive }));
     } catch (error) {
       row.reject(error);
     }
@@ -14376,16 +14490,16 @@ var ComputerBroker = class {
 };
 
 // src/computer/credential-executor.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function credentialAwareExecutor(deps) {
   return async (driver, call, display, runId, context) => {
-    const digest = createHash7("sha256").update(JSON.stringify(call)).digest("hex");
-    const resolved = await deps.consumeMatchingIntent(runId, context.actionId, digest);
+    const digest2 = createHash8("sha256").update(JSON.stringify(call)).digest("hex");
+    const resolved = await deps.consumeMatchingIntent(runId, context.actionId, digest2);
     context.assertLive();
     if (resolved.kind === "ordinary") return deps.executeOrdinary(driver, call, display, runId, context.assertLive);
     if (resolved.kind !== "credential") throw new Error("Credential action already consumed");
     const { intent } = resolved;
-    if (![intent.actionId, intent.runId, intent.userId, intent.workspaceId, intent.botId, intent.subagentId, intent.targetId, intent.loaderId].every((value) => typeof value === "string" && value.length > 0) || intent.actionId !== context.actionId || !Number.isSafeInteger(intent.epoch) || intent.epoch < 0 || !Number.isSafeInteger(intent.policyVersion) || intent.policyVersion < 0 || intent.runId !== runId || intent.callDigest !== digest || intent.driverFingerprint !== driver.fingerprint || intent.display !== display || !Number.isSafeInteger(intent.backendNodeId) || intent.backendNodeId < 1 || !["username", "password"].includes(intent.role) || !Number.isSafeInteger(intent.expiresAt) || intent.expiresAt <= (deps.now ?? Date.now)()) throw new Error("Credential action unavailable");
+    if (![intent.actionId, intent.runId, intent.userId, intent.workspaceId, intent.botId, intent.subagentId, intent.targetId, intent.loaderId].every((value) => typeof value === "string" && value.length > 0) || intent.actionId !== context.actionId || !Number.isSafeInteger(intent.epoch) || intent.epoch < 0 || !Number.isSafeInteger(intent.policyVersion) || intent.policyVersion < 0 || intent.runId !== runId || intent.callDigest !== digest2 || intent.driverFingerprint !== driver.fingerprint || intent.display !== display || !Number.isSafeInteger(intent.backendNodeId) || intent.backendNodeId < 1 || !["username", "password"].includes(intent.role) || !Number.isSafeInteger(intent.expiresAt) || intent.expiresAt <= (deps.now ?? Date.now)()) throw new Error("Credential action unavailable");
     const url = new URL(intent.origin);
     if (url.protocol !== "https:" || url.username || url.password || url.origin !== intent.origin) throw new Error("Credential action unavailable");
     return deps.withCurrentLease(intent, async (live) => {
@@ -14467,7 +14581,7 @@ function loadDeviceFile(raw) {
   const { deviceIds, ...file } = raw;
   if (!file.deviceId && deviceIds && typeof deviceIds === "object") {
     const first = Object.values(deviceIds).find(
-      (id3) => typeof id3 === "string"
+      (id4) => typeof id4 === "string"
     );
     if (first) file.deviceId = first;
   }
@@ -14678,6 +14792,11 @@ var Daemon = class {
       startSubscription: hosted?.start,
       prepareRunMailbox: this.options.link.prepareRunMailbox?.bind(this.options.link),
       prepareRunToolApproval: this.options.link.prepareRunToolApproval?.bind(this.options.link),
+      verifyRunPolicy: this.options.link.verifyRunPolicy ? async (assignment, signal) => {
+        if (!this.device.credential) throw new Error("Current policy device credential unavailable");
+        if (!this.registered || !this.device.deviceId) await this.register(this.device.credential);
+        return this.options.link.verifyRunPolicy(assignment, signal);
+      } : void 0,
       bootstrap: hosted ? async (worktree, repo) => {
         if (repo.setup?.copyFiles.some(
           (path) => /(^|\/)(\.git|\.codex\/auth\.json|\.claude\/\.credentials\.json)(\/|$)/.test(
@@ -14824,7 +14943,7 @@ var Daemon = class {
         if (this.unacked.size > 0) {
           const ids = [...this.unacked];
           await link.ackCommands(deviceId, ids);
-          for (const id3 of ids) this.unacked.delete(id3);
+          for (const id4 of ids) this.unacked.delete(id4);
         }
         const skipRuns = [...this.stopping, ...this.ended].slice(
           0,
@@ -14886,13 +15005,13 @@ var Daemon = class {
           if (remaining > 0) await this.pauseCommands(remaining, signal);
         }
         await Promise.all(
-          requests.map(async ({ id: id3, ...request }) => {
+          requests.map(async ({ id: id4, ...request }) => {
             const result = await browseFolder(request).catch(() => ({
               ok: false,
               code: "failed",
               message: "Could not read that folder."
             }));
-            await link.answerFsRequest(deviceId, id3, result);
+            await link.answerFsRequest(deviceId, id4, result);
           })
         );
       } catch (error) {