@brainervirus/workit-codex 2.1.5 → 2.2.1

package/dist/launch-mcp.js

@@ -6625,7 +6625,7 @@ import { existsSync as existsSync8, realpathSync as realpathSync9, statSync as s
 import path16 from "node:path";
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { existsSync as existsSync5, realpathSync as realpathSync7 } from "node:fs";
 import path11 from "node:path";
 
@@ -14487,7 +14487,8 @@ var hostSchema = _enum([
   "codex_cli",
   "codex_desktop",
   "pi",
-  "workit_cli"
+  "workit_cli",
+  "claude_code"
 ]);
 var assuranceSchema = _enum(["enforced", "agent_guided", "unavailable"]);
 var outcomeSchema = _enum(["verified", "accepted_limitations", "stopped"]);
@@ -14937,15 +14938,70 @@ var taskRecordSchema = object({
   decisions: array(entrySchema(decisionSchema)),
   actionProgress: actionProgressListSchema.optional(),
   findings: array(entrySchema(findingSchema)),
-  workers: array(entrySchema(workerSchema))
+  workers: array(entrySchema(workerSchema)),
+  critical: array(nonEmpty).optional()
 }).strict();
+var stripCount = (strips) => strips.reduce((sum, strip) => sum + strip.keys.length, 0);
+var strippable = (issues, prefix = []) => {
+  const strips = [];
+  for (const issue of issues) {
+    if (issue.code === "unrecognized_keys") {
+      strips.push({ path: [...prefix, ...issue.path], keys: issue.keys });
+      continue;
+    }
+    if (issue.code !== "invalid_union")
+      return null;
+    const branch = issue.errors.map((errors) => strippable(errors, [...prefix, ...issue.path])).filter((found) => found !== null && found.length > 0).reduce((best, found) => best === null || stripCount(found) < stripCount(best) ? found : best, null);
+    if (!branch)
+      return null;
+    strips.push(...branch);
+  }
+  return strips;
+};
+var recordPath = (path) => path.map((key) => typeof key === "number" ? "*" : String(key)).join(".");
+var overlaps = (left, right) => left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+var parseStoredRecord = (schema, value) => {
+  let parsed = schema.safeParse(value);
+  if (parsed.success)
+    return { success: true, data: parsed.data, stripped: [] };
+  const first = { success: false, error: parsed.error, critical: [] };
+  const declared = typeof value === "object" && value !== null && Array.isArray(value.critical) ? value.critical.filter((item) => typeof item === "string").map((item) => item.split(".").map((key) => /^\d+$/.test(key) ? "*" : key).join(".")) : [];
+  const stripped = [];
+  let current = structuredClone(value);
+  for (let round = 0;round < 8 && !parsed.success; round++) {
+    const strips = strippable(parsed.error.issues);
+    if (strips === null || strips.length === 0)
+      return first;
+    for (const strip of strips) {
+      let target = current;
+      for (const key of strip.path)
+        target = typeof target === "object" && target !== null ? target[key] : undefined;
+      if (typeof target !== "object" || target === null)
+        return first;
+      for (const key of strip.keys) {
+        stripped.push(recordPath([...strip.path, key]));
+        delete target[key];
+      }
+    }
+    parsed = schema.safeParse(current);
+  }
+  if (!parsed.success)
+    return first;
+  const critical = [
+    ...new Set(stripped.filter((item) => declared.some((path) => overlaps(item, path))))
+  ];
+  if (critical.length > 0)
+    return { ...first, critical };
+  return { success: true, data: parsed.data, stripped: [...new Set(stripped)] };
+};
 var workspaceRecordSchema = object({
   schemaVersion: literal(1),
   id,
   revision,
   root: nonEmpty,
   runtime: runtimeSchema.optional(),
-  writer: object({ state: _enum(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc }).strict().nullable()
+  writer: object({ state: _enum(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc }).strict().nullable(),
+  critical: array(nonEmpty).optional()
 }).strict();
 var capabilitySchema = object({
   name: nonEmpty,
@@ -15183,6 +15239,11 @@ var operationSchemas = {
   writer: discriminatedUnion("action", Object.values(writerOperations)),
   state: discriminatedUnion("action", Object.values(stateOperations))
 };
+var { recover: _unadvertisedRecover, ...advertisedStateOperations } = stateOperations;
+var advertisedOperationSchemas = {
+  ...operationSchemas,
+  state: discriminatedUnion("action", Object.values(advertisedStateOperations))
+};
 var compiledOperationSchemas = Object.fromEntries(OPERATION_FAMILIES.map((family) => [family, compile(operationSchemas[family])]));
 var success = (revisionValue, workspaceRevisionValue, data) => ({
   ok: true,
@@ -15206,7 +15267,7 @@ function parseOperation(family, input) {
   return failure2("invalid_input", "operation input is invalid", { fields });
 }
 function operationJsonSchema(family) {
-  return toJSONSchema(operationSchemas[family], { target: "draft-2020-12" });
+  return toJSONSchema(advertisedOperationSchemas[family], { target: "draft-2020-12" });
 }
 var OPERATION_SCHEMA_DEPTH = 1;
 var schemaShapeDescription = (value, depth = 0) => {
@@ -15398,8 +15459,7 @@ function requirementId(input) {
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
-import * as fs4 from "node:fs";
-import { hostname } from "node:os";
+import * as fs5 from "node:fs";
 import path4 from "node:path";
 
 // packages/workit-core/src/core/package-root.ts
@@ -16022,13 +16082,10 @@ function acquireFileLockSync(targetPath, options) {
     }
   }
 }
-// packages/workit-core/src/core/task-store.ts
-var processEvidenceSchema = object({
-  state: _enum(["stopped", "accounted_for"]),
-  pid: number2().int().nonnegative(),
-  processStart: string2().nullable(),
-  ownerDigest: string2().regex(/^[0-9a-f]{64}$/).nullable()
-}).strict();
+// packages/workit-core/src/core/store-lock.ts
+import { spawnSync } from "node:child_process";
+import fs4 from "node:fs";
+import { hostname } from "node:os";
 var metadataLockSchema = object({
   pid: number2().int().nonnegative().safe(),
   processStart: string2().nullable(),
@@ -16036,6 +16093,143 @@ var metadataLockSchema = object({
   nonce: string2().min(1),
   externalAction: literal(true).optional()
 }).strict();
+var FOREIGN_LOCK_TTL_MS = 10 * 60000;
+var UNREADABLE_LOCK_TTL_MS = 30000;
+var RECLAIM_GUARD_TTL_MS = 30000;
+var defaultLockTimeoutMs = 250;
+var defaultLockTimeout = () => defaultLockTimeoutMs;
+var parseMetadataLock = (raw) => {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw Object.assign(new Error("metadata lock is invalid"), { code: "metadata_lock_invalid" });
+  }
+  const parsed = metadataLockSchema.safeParse(value);
+  if (!parsed.success)
+    throw Object.assign(new Error("metadata lock is invalid"), { code: "metadata_lock_invalid" });
+  return parsed.data;
+};
+var parseMetadataLockOrNull = (raw) => {
+  try {
+    return parseMetadataLock(raw);
+  } catch {
+    return null;
+  }
+};
+var sameMetadataLock = (left, right) => {
+  const parsed = metadataLockSchema.safeParse(left);
+  return parsed.success && canonicalJson(parsed.data) === canonicalJson(right);
+};
+var parseProcStatStart = (stat) => {
+  const close = stat.lastIndexOf(")");
+  if (close < 0)
+    return null;
+  return stat.slice(close + 1).trim().split(/\s+/)[19] ?? null;
+};
+var processStartOf = (pid) => {
+  if (process.platform === "linux") {
+    try {
+      return parseProcStatStart(fs4.readFileSync(`/proc/${pid}/stat`, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  if (process.platform === "darwin" || process.platform === "freebsd") {
+    try {
+      const run = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+        encoding: "utf8",
+        timeout: 1000
+      });
+      const value = run.status === 0 ? run.stdout.trim() : "";
+      return value || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+};
+var readTrimmed = (file) => {
+  try {
+    return fs4.readFileSync(file, "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+};
+var cachedLockHost = null;
+var localLockHost = () => {
+  if (cachedLockHost !== null)
+    return cachedLockHost;
+  let pidns = null;
+  try {
+    pidns = /\[(\d+)\]/.exec(fs4.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
+  } catch {}
+  const boot = readTrimmed("/proc/sys/kernel/random/boot_id");
+  cachedLockHost = pidns || boot ? `${hostname()}#${pidns ?? "?"}:${boot ?? "?"}` : hostname();
+  return cachedLockHost;
+};
+var pidAlive = (pid) => {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var classifyLockOwner = (payload, ageMs, localHost = localLockHost()) => {
+  const lock = metadataLockSchema.safeParse(payload);
+  if (!lock.success)
+    return ageMs !== null && ageMs > UNREADABLE_LOCK_TTL_MS ? { state: "stale", reason: "unreadable lock left behind" } : { state: "unknown", reason: "lock is being written" };
+  const { pid, processStart, host } = lock.data;
+  const [lockName, lockSpace] = host.split("#");
+  const [localName, localSpace] = localHost.split("#");
+  if (lockSpace && localSpace && lockName === localName) {
+    const [lockNs, lockBoot] = lockSpace.split(":");
+    const [localNs, localBoot] = localSpace.split(":");
+    if (lockNs === localNs && lockNs !== "?" && lockBoot !== "?" && lockBoot !== localBoot)
+      return { state: "stale", reason: "lock was taken before this machine rebooted" };
+  }
+  if (host !== localHost)
+    return ageMs !== null && ageMs > FOREIGN_LOCK_TTL_MS ? { state: "stale", reason: `lock from ${host} is older than its TTL` } : { state: "unknown", reason: `lock is held from ${host}; its pid cannot be checked here` };
+  if (!pidAlive(pid))
+    return { state: "stale", reason: `pid ${pid} is not running` };
+  const currentStart = processStartOf(pid);
+  if (processStart !== null && currentStart !== null && processStart !== currentStart)
+    return { state: "stale", reason: `pid ${pid} now belongs to a different process` };
+  return { state: "live", reason: `held by running pid ${pid}` };
+};
+var ageOf = (file, nowMs) => {
+  try {
+    return nowMs - fs4.lstatSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+};
+var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
+  const guard = `${lockPath}.reclaim`;
+  const age = ageOf(guard, nowMs);
+  if (age === null || age <= RECLAIM_GUARD_TTL_MS)
+    return false;
+  try {
+    fs4.rmdirSync(guard);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// packages/workit-core/src/core/task-store.ts
+var RECOVERY_COPIES_PER_RECORD = 3;
+var STALE_TEMPORARY_MS = 60 * 60000;
+var RECOVERY_NAME = /^(task|workspace)\.([^.]+)\.([0-9a-f]{64})\.json$/;
+var processEvidenceSchema = object({
+  state: _enum(["stopped", "accounted_for"]),
+  pid: number2().int().nonnegative(),
+  processStart: string2().nullable(),
+  ownerDigest: string2().regex(/^[0-9a-f]{64}$/).nullable()
+}).strict();
 var INDEX_VERSION = 1;
 var hostSession = (value) => isObject2(value) && value.kind === "host" && typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
 var indexEntry = (task, file) => {
@@ -16063,7 +16257,7 @@ var indexEntry = (task, file) => {
 };
 var fileSignature = (file) => {
   try {
-    const stat = fs4.statSync(file, { bigint: true });
+    const stat = fs5.statSync(file, { bigint: true });
     return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
   } catch {
     return null;
@@ -16080,7 +16274,7 @@ var cachedRuntimeVersion = null;
 var runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs4.readFileSync(path4.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs5.readFileSync(path4.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -16109,36 +16303,20 @@ var digestBytes = (value) => createHash2("sha256").update(value).digest("hex");
 var isObject2 = (value) => typeof value === "object" && value !== null;
 var validId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
 var validDigest = (value) => /^[0-9a-f]{64}$/.test(value);
-var parseMetadataLock = (raw) => {
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch {
-    throw Object.assign(new Error("metadata lock is invalid"), { code: "metadata_lock_invalid" });
-  }
-  const parsed = metadataLockSchema.safeParse(value);
-  if (!parsed.success)
-    throw Object.assign(new Error("metadata lock is invalid"), { code: "metadata_lock_invalid" });
-  return parsed.data;
-};
-var sameMetadataLock = (left, right) => {
-  const parsed = metadataLockSchema.safeParse(left);
-  return parsed.success && canonicalJson(parsed.data) === canonicalJson(right);
-};
 var sameDirectoryIdentity = (left, right) => {
   if (!path4.isAbsolute(left) || !path4.isAbsolute(right))
     return false;
   const normalizedLeft = path4.resolve(left);
   const normalizedRight = path4.resolve(right);
   try {
-    const a = fs4.statSync(normalizedLeft, { bigint: true });
-    const b = fs4.statSync(normalizedRight, { bigint: true });
+    const a = fs5.statSync(normalizedLeft, { bigint: true });
+    const b = fs5.statSync(normalizedRight, { bigint: true });
     if (!a.isDirectory() || !b.isDirectory())
       return false;
     if (process.platform === "win32" ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase() : normalizedLeft === normalizedRight)
       return true;
-    const canonicalLeft = fs4.realpathSync(normalizedLeft);
-    const canonicalRight = fs4.realpathSync(normalizedRight);
+    const canonicalLeft = fs5.realpathSync(normalizedLeft);
+    const canonicalRight = fs5.realpathSync(normalizedRight);
     if (process.platform === "win32" ? canonicalLeft.toLowerCase() === canonicalRight.toLowerCase() : canonicalLeft === canonicalRight)
       return true;
     return a.dev === b.dev && a.ino !== 0n && a.ino === b.ino;
@@ -16146,12 +16324,47 @@ var sameDirectoryIdentity = (left, right) => {
     return false;
   }
 };
+var TRANSIENT_WINDOWS_CODES = new Set(["EPERM", "EACCES", "EBUSY"]);
+var isTransientWindowsError = (error) => {
+  if (process.platform !== "win32")
+    return false;
+  const code = error?.code;
+  return typeof code === "string" && TRANSIENT_WINDOWS_CODES.has(code);
+};
+var retryTransient = (run) => {
+  if (process.platform !== "win32")
+    return run();
+  for (let attempt = 0;; attempt += 1) {
+    try {
+      return run();
+    } catch (error) {
+      if (attempt >= 20 || !isTransientWindowsError(error))
+        throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5 * (attempt + 1));
+    }
+  }
+};
 var externalActionLockRoots = new AsyncLocalStorage;
+var heldInProcess = new Map;
+var holdRoot = (root) => heldInProcess.set(root, (heldInProcess.get(root) ?? 0) + 1);
+var dropRoot = (root) => {
+  const count = (heldInProcess.get(root) ?? 1) - 1;
+  if (count > 0)
+    heldInProcess.set(root, count);
+  else
+    heldInProcess.delete(root);
+};
+var dedupeCandidates = (candidates) => {
+  const last = new Map(candidates.map((candidate, index) => [candidate.id, index]));
+  return candidates.filter((candidate, index) => last.get(candidate.id) === index);
+};
 
 class TaskStore {
   root;
-  constructor(root) {
-    this.root = fs4.existsSync(root) ? fs4.realpathSync(root) : path4.resolve(root);
+  lockTimeoutMs;
+  constructor(root, options = {}) {
+    this.root = fs5.existsSync(root) ? fs5.realpathSync(root) : path4.resolve(root);
+    this.lockTimeoutMs = options.lockTimeoutMs ?? defaultLockTimeout();
   }
   readTask(taskId) {
     if (!validId(taskId))
@@ -16171,11 +16384,11 @@ class TaskStore {
     return result.result;
   }
   listTasks() {
-    if (!fs4.existsSync(this.tasksDir))
+    if (!fs5.existsSync(this.tasksDir))
       return success(null, null, []);
     let names;
     try {
-      names = fs4.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
+      names = fs5.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
     } catch (error) {
       return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
         path: this.tasksDir
@@ -16204,11 +16417,11 @@ class TaskStore {
     return success(null, null, tasks);
   }
   listTaskIndex() {
-    if (!fs4.existsSync(this.tasksDir))
+    if (!fs5.existsSync(this.tasksDir))
       return success(null, null, []);
     let names;
     try {
-      names = fs4.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
+      names = fs5.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
     } catch (error) {
       return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
         path: this.tasksDir
@@ -16470,7 +16683,7 @@ class TaskStore {
       if (!current.data)
         return failure2("not_found", "workspace not found");
       if (current.data.revision !== expected)
-        return this.conflict(expected, current.data.revision);
+        return this.workspaceConflict(expected, current.data.revision);
       const previousBytes = this.snapshotBytes(this.workspacePath);
       if (!previousBytes)
         return failure2("storage_error", "workspace snapshot disappeared during mutation");
@@ -16513,7 +16726,7 @@ class TaskStore {
       if (task.data.revision !== expected)
         return this.conflict(expected, task.data.revision);
       if (workspace.data.revision !== input.expectedWorkspaceRevision)
-        return this.conflict(input.expectedWorkspaceRevision, workspace.data.revision);
+        return this.workspaceConflict(input.expectedWorkspaceRevision, workspace.data.revision);
       const previousWorkspaceBytes = this.snapshotBytes(this.workspacePath);
       const previousTaskBytes = this.snapshotBytes(this.taskPath(input.taskId));
       if (!previousWorkspaceBytes || !previousTaskBytes)
@@ -16576,12 +16789,12 @@ class TaskStore {
     });
   }
   recoveryCandidates() {
-    if (!fs4.existsSync(this.recoveryDir))
+    if (!fs5.existsSync(this.recoveryDir))
       return success(null, null, []);
     try {
       const candidates = [];
-      for (const name of fs4.readdirSync(this.recoveryDir)) {
-        const match = /^(task|workspace)\.([^.]+)\.([0-9a-f]{64})\.json$/.exec(name);
+      for (const name of fs5.readdirSync(this.recoveryDir)) {
+        const match = RECOVERY_NAME.exec(name);
         if (match)
           candidates.push({
             target: match[1],
@@ -16629,7 +16842,7 @@ class TaskStore {
           return failure2("recovery_required", "validated recovery snapshot not found");
         selectedBytes = candidate;
       }
-      const selectedRecord = target === "workspace" ? this.parseBytes(selectedBytes, workspaceRecordSchema) : this.parseBytes(selectedBytes, taskRecordSchema);
+      const selectedRecord = target === "workspace" ? this.parseBytes(selectedBytes, workspaceRecordSchema, "rewrite") : this.parseBytes(selectedBytes, taskRecordSchema, "rewrite");
       if (!selectedRecord.ok)
         return selectedRecord;
       if (target === "workspace") {
@@ -16675,14 +16888,14 @@ class TaskStore {
             return this.conflict(input.expectedWorkspaceRevision, currentWorkspace.data.revision);
         }
         if (target === "workspace") {
-          const parsed = this.parseBytes(selectedBytes, workspaceRecordSchema);
+          const parsed = this.parseBytes(selectedBytes, workspaceRecordSchema, "rewrite");
           if (!parsed.ok)
             return parsed;
           const value = { ...parsed.data, revision: newRevision(), writer: null };
           const replaced = this.replaceSnapshot(file, value, reacquiredBytes);
           return replaced.ok ? success(value.revision, value.revision, value) : replaced;
         }
-        const parsed = this.parseBytes(selectedBytes, taskRecordSchema);
+        const parsed = this.parseBytes(selectedBytes, taskRecordSchema, "rewrite");
         if (!parsed.ok)
           return parsed;
         const value = {
@@ -16693,7 +16906,7 @@ class TaskStore {
         };
         const replaced = this.replaceSnapshot(file, value, reacquiredBytes);
         return replaced.ok ? success(value.revision, null, value) : replaced;
-      }, this.recoveryLockOptions(lock.data, evidence.data, recoveryGate));
+      }, this.recoveryLockOptions(lock.data, evidence.data, recoveryGate), "recovery_required");
       return result;
     } catch (error) {
       return failure2("recovery_required", `recovery protocol failed: ${String(error)}`);
@@ -16728,12 +16941,12 @@ class TaskStore {
   }
   readLockSnapshot() {
     try {
-      const stat = fs4.lstatSync(this.lockPath);
+      const stat = fs5.lstatSync(this.lockPath);
       if (!stat.isFile() || stat.isSymbolicLink())
         return failure2("recovery_required", "metadata lock is not a regular file", {
           path: this.lockPath
         });
-      const raw = fs4.readFileSync(this.lockPath, "utf8");
+      const raw = fs5.readFileSync(this.lockPath, "utf8");
       return success(null, null, { raw, data: parseMetadataLock(raw) });
     } catch (error) {
       if (error?.code === "ENOENT")
@@ -16744,22 +16957,50 @@ class TaskStore {
     }
   }
   metadataLockOptions() {
+    const inProcess = heldInProcess.has(this.root);
     return {
       lockPath: this.lockPath,
       staleMs: Number.MAX_SAFE_INTEGER,
-      timeoutMs: 0,
-      retry: { retries: 0 },
-      staleRecovery: "fail-closed",
-      shouldReclaim: () => false,
-      parsePayload: parseMetadataLock,
+      timeoutMs: inProcess ? 0 : this.lockTimeoutMs,
+      retry: inProcess ? { retries: 0 } : { minTimeout: 5, maxTimeout: 100, factor: 1.5, randomize: true },
+      staleRecovery: "remove-if-unchanged",
+      shouldReclaim: ({ payload, nowMs }) => {
+        let ageMs = null;
+        try {
+          ageMs = nowMs - fs5.lstatSync(this.lockPath).mtimeMs;
+        } catch {}
+        return classifyLockOwner(payload, ageMs).state === "stale";
+      },
+      shouldRemoveStaleLock: () => true,
+      parsePayload: parseMetadataLockOrNull,
       payload: () => ({
         pid: process.pid,
-        processStart: this.processStart(process.pid),
-        host: hostname(),
+        processStart: processStartOf(process.pid),
+        host: localLockHost(),
         nonce: randomUUID2()
       })
     };
   }
+  acquireMetadataLock(options) {
+    clearAbandonedReclaimGuard(this.lockPath);
+    const deadline = Date.now() + (options.timeoutMs ?? 0);
+    while (true) {
+      try {
+        return acquireFileLockSync(this.workspacePath, {
+          ...options,
+          timeoutMs: Math.max(0, deadline - Date.now())
+        });
+      } catch (error) {
+        const code = error?.code;
+        if (code !== "file_lock_stale" && !isTransientWindowsError(error) || Date.now() >= deadline)
+          throw error;
+        if (code !== "file_lock_stale" && !this.lockHolderPresent() && !this.lockDirWritable())
+          throw error;
+        if (code !== "file_lock_stale")
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+      }
+    }
+  }
   externalActionLockOptions() {
     const options = this.metadataLockOptions();
     return { ...options, payload: () => ({ ...options.payload(), externalAction: true }) };
@@ -16777,10 +17018,11 @@ class TaskStore {
     }
     let handle;
     try {
-      handle = acquireFileLockSync(this.workspacePath, this.externalActionLockOptions());
+      handle = this.acquireMetadataLock(this.externalActionLockOptions());
     } catch (error) {
       return this.lockFailure(error);
     }
+    holdRoot(this.root);
     let result;
     try {
       if (!handle.verifyStillHeld())
@@ -16815,8 +17057,9 @@ class TaskStore {
         path: this.lockPath
       });
     }
+    dropRoot(this.root);
     try {
-      handle.release();
+      retryTransient(() => handle.release());
     } catch (error) {
       const released = this.lockFailure(error);
       const releaseError = released.ok ? "metadata lock release failed" : released.error;
@@ -16829,6 +17072,9 @@ class TaskStore {
   }
   recoveryLockOptions(observed, evidence, gate) {
     const options = this.metadataLockOptions();
+    options.timeoutMs = 0;
+    options.retry = { retries: 0 };
+    options.parsePayload = parseMetadataLock;
     options.staleRecovery = "remove-if-unchanged";
     options.shouldReclaim = ({ payload }) => Boolean(observed && sameMetadataLock(payload, observed.data) && (evidence.state === "stopped" || evidence.state === "accounted_for"));
     options.shouldRemoveStaleLock = ({ raw, payload }) => {
@@ -16850,7 +17096,7 @@ class TaskStore {
     };
     this.replaceSnapshot(this.workspacePath, value, workspace);
   }
-  withLock(operation, options = this.metadataLockOptions()) {
+  withLock(operation, options = this.metadataLockOptions(), contention = "busy") {
     try {
       this.initializeMutationStorage();
     } catch (error) {
@@ -16861,10 +17107,12 @@ class TaskStore {
     let handle;
     let result = failure2("storage_error", "metadata lock operation did not produce a result");
     try {
-      handle = acquireFileLockSync(this.workspacePath, options);
+      handle = this.acquireMetadataLock(options);
     } catch (error) {
-      result = this.lockFailure(error);
+      result = this.lockFailure(error, contention);
     }
+    if (handle)
+      holdRoot(this.root);
     if (handle) {
       try {
         if (!handle.verifyStillHeld())
@@ -16883,8 +17131,9 @@ class TaskStore {
       }
     }
     if (handle) {
+      dropRoot(this.root);
       try {
-        handle.release();
+        retryTransient(() => handle.release());
       } catch (error) {
         const releaseFailure = this.lockFailure(error);
         const releaseError = releaseFailure.ok ? "metadata lock release failed" : releaseFailure.error;
@@ -16893,25 +17142,65 @@ class TaskStore {
     }
     return result;
   }
-  lockFailure(error) {
+  lockDirWritable() {
+    const probe = `${this.lockPath}.${process.pid}.${randomUUID2()}.probe`;
+    try {
+      fs5.closeSync(fs5.openSync(probe, "wx", 384));
+    } catch {
+      return false;
+    }
+    try {
+      fs5.rmSync(probe, { force: true });
+    } catch {}
+    return true;
+  }
+  lockHolderPresent() {
+    try {
+      fs5.lstatSync(this.lockPath);
+      return true;
+    } catch (error) {
+      return error?.code !== "ENOENT";
+    }
+  }
+  lockFailure(error, contention = "busy") {
     const value = error;
     const code = typeof value?.code === "string" ? value.code : "";
-    if (code === "EEXIST" || code === "file_lock_timeout") {
-      const lock = this.readLockSnapshot();
-      if (lock.ok && lock.data?.data.externalAction)
+    if (isTransientWindowsError(error) && !this.lockHolderPresent() && !this.lockDirWritable())
+      return failure2("storage_error", `cannot create the workspace metadata lock (${code}); no other Workit call holds it`, {
+        path: this.lockPath,
+        guidance: `Check permissions and the read-only attribute on ${path4.dirname(this.lockPath)}.`
+      });
+    if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
+      let lock = null;
+      try {
+        lock = parseMetadataLockOrNull(fs5.readFileSync(this.lockPath, "utf8"));
+      } catch {}
+      if (lock?.externalAction)
         return failure2("writer_conflict", "workspace is reserved by a managed external action", {
           outcome: "not_started",
           path: this.lockPath
         });
+      if (contention === "busy")
+        return failure2("busy", `workspace metadata lock is held by another Workit call${lock ? ` (pid ${lock.pid} on ${lock.host})` : ""}; retry shortly`, {
+          outcome: "not_started",
+          path: this.lockPath,
+          guidance: "Retry the same call. If it stays busy, run `workit doctor --fix-lock` to clear a lock left by a dead process."
+        });
     }
     const recovery = code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || code === "metadata_lock_invalid" || code === "not-file" || /metadata lock|file lock|reclaim/i.test(String(value?.message ?? error));
     return failure2(recovery ? "recovery_required" : "storage_error", `metadata lock operation failed: ${String(error)}`, { path: this.lockPath });
   }
   initializeMutationStorage() {
-    fs4.mkdirSync(this.tasksDir, { recursive: true });
-    fs4.mkdirSync(this.recoveryDir, { recursive: true });
-    fs4.writeFileSync(this.gitignorePath, `*
-`);
+    retryTransient(() => fs5.mkdirSync(this.tasksDir, { recursive: true }));
+    retryTransient(() => fs5.mkdirSync(this.recoveryDir, { recursive: true }));
+    let current = null;
+    try {
+      current = retryTransient(() => fs5.readFileSync(this.gitignorePath, "utf8"));
+    } catch {}
+    if (current !== `*
+`)
+      retryTransient(() => fs5.writeFileSync(this.gitignorePath, `*
+`));
   }
   replaceSnapshot(file, value, previous) {
     let temporary;
@@ -16923,14 +17212,14 @@ class TaskStore {
       else if (typeof previous === "string")
         this.saveRecovery(file, previous);
       temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
-      const fd = fs4.openSync(temporary, "wx", 384);
+      const fd = fs5.openSync(temporary, "wx", 384);
       try {
-        fs4.writeSync(fd, jsonBytes(value));
-        fs4.fsyncSync(fd);
+        fs5.writeSync(fd, jsonBytes(value));
+        fs5.fsyncSync(fd);
       } finally {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       }
-      fs4.renameSync(temporary, file);
+      retryTransient(() => fs5.renameSync(temporary, file));
       temporary = undefined;
       this.fsyncDirectory(path4.dirname(file));
       if (path4.dirname(file) === this.tasksDir)
@@ -16943,13 +17232,13 @@ class TaskStore {
     } finally {
       if (temporary)
         try {
-          fs4.unlinkSync(temporary);
+          fs5.unlinkSync(temporary);
         } catch {}
     }
   }
   readIndex(workspaceId) {
     try {
-      const value = JSON.parse(fs4.readFileSync(this.indexPath, "utf8"));
+      const value = JSON.parse(fs5.readFileSync(this.indexPath, "utf8"));
       if (!isObject2(value) || value.version !== INDEX_VERSION || value.workspaceId !== workspaceId || !isObject2(value.tasks))
         return {};
       const tasks = {};
@@ -16964,15 +17253,15 @@ class TaskStore {
   writeIndex(workspaceId, entries) {
     const temporary = `${this.indexPath}.${process.pid}.${randomUUID2()}.tmp`;
     try {
-      fs4.writeFileSync(temporary, JSON.stringify({
+      fs5.writeFileSync(temporary, JSON.stringify({
         version: INDEX_VERSION,
         workspaceId,
         tasks: Object.fromEntries(entries.map((entry) => [entry.id, entry]))
       }), { mode: 384, flag: "wx" });
-      fs4.renameSync(temporary, this.indexPath);
+      retryTransient(() => fs5.renameSync(temporary, this.indexPath));
     } catch {
       try {
-        fs4.unlinkSync(temporary);
+        fs5.unlinkSync(temporary);
       } catch {}
     }
   }
@@ -16990,33 +17279,153 @@ class TaskStore {
     const target = path4.basename(file) === "workspace.json" ? "workspace" : "task";
     const id = target === "task" ? path4.basename(file, ".json") : "workspace";
     const destination = path4.join(this.recoveryDir, `${target}.${id}.${digestBytes(bytes)}.json`);
-    if (fs4.existsSync(destination)) {
-      if (digestBytes(fs4.readFileSync(destination)) === digestBytes(bytes))
-        return;
-      throw new Error("recovery copy already exists with different bytes");
+    if (fs5.existsSync(destination)) {
+      if (digestBytes(retryTransient(() => fs5.readFileSync(destination))) !== digestBytes(bytes))
+        throw new Error("recovery copy already exists with different bytes");
+      const stamp = new Date;
+      retryTransient(() => fs5.utimesSync(destination, stamp, stamp));
+      this.pruneRecovery(`${target}.${id}.`, destination);
+      return;
     }
     let temporary;
     try {
       temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
-      const fd = fs4.openSync(temporary, "wx", 384);
+      const fd = fs5.openSync(temporary, "wx", 384);
       try {
-        fs4.writeSync(fd, bytes);
-        fs4.fsyncSync(fd);
+        fs5.writeSync(fd, bytes);
+        fs5.fsyncSync(fd);
       } finally {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       }
-      fs4.renameSync(temporary, destination);
+      retryTransient(() => fs5.renameSync(temporary, destination));
       temporary = undefined;
       this.fsyncDirectory(this.recoveryDir);
+      this.pruneRecovery(`${target}.${id}.`, destination);
     } finally {
       if (temporary)
         try {
-          fs4.unlinkSync(temporary);
+          fs5.unlinkSync(temporary);
         } catch {}
     }
   }
+  pruneRecovery(prefix, keep) {
+    try {
+      const copies = this.recoveryCopies(prefix);
+      const surplus = this.surplusCopies(copies, path4.basename(keep));
+      for (const copy of surplus)
+        fs5.rmSync(copy.path, { force: true });
+    } catch {}
+  }
+  recoveryCopies(prefix = "") {
+    if (!fs5.existsSync(this.recoveryDir))
+      return [];
+    const copies = [];
+    for (const name of fs5.readdirSync(this.recoveryDir)) {
+      if (!name.startsWith(prefix))
+        continue;
+      const match = RECOVERY_NAME.exec(name);
+      if (!match)
+        continue;
+      const file = path4.join(this.recoveryDir, name);
+      try {
+        const stat = fs5.lstatSync(file, { bigint: true });
+        if (!stat.isFile())
+          continue;
+        copies.push({ name, path: file, group: `${match[1]}.${match[2]}`, mtimeNs: stat.mtimeNs });
+      } catch {}
+    }
+    return copies;
+  }
+  surplusCopies(copies, keep) {
+    const ordered = copies.toSorted((left, right) => left.name === keep ? -1 : right.name === keep ? 1 : left.mtimeNs === right.mtimeNs ? left.name.localeCompare(right.name) : left.mtimeNs > right.mtimeNs ? -1 : 1);
+    return ordered.slice(RECOVERY_COPIES_PER_RECORD);
+  }
+  collectGarbage(options = {}) {
+    const dryRun = options.dryRun === true;
+    const report = {
+      dryRun,
+      recovery: { removed: 0, removedBytes: 0, kept: 0 },
+      temporary: { removed: 0 },
+      candidates: { removed: 0, tasks: [], skippedActive: [], skippedClosed: [], failed: [] }
+    };
+    if (!fs5.existsSync(this.workitDir))
+      return success(null, null, report);
+    const sweep = () => {
+      try {
+        const groups = new Map;
+        for (const copy of this.recoveryCopies())
+          groups.set(copy.group, [...groups.get(copy.group) ?? [], copy]);
+        for (const copies of groups.values()) {
+          const surplus = this.surplusCopies(copies);
+          report.recovery.kept += copies.length - surplus.length;
+          for (const copy of surplus) {
+            report.recovery.removed += 1;
+            try {
+              report.recovery.removedBytes += fs5.statSync(copy.path).size;
+            } catch {}
+            if (!dryRun)
+              fs5.rmSync(copy.path, { force: true });
+          }
+        }
+        const nowMs = Date.now();
+        for (const directory of [this.recoveryDir, this.tasksDir, this.workitDir]) {
+          if (!fs5.existsSync(directory))
+            continue;
+          for (const name of fs5.readdirSync(directory)) {
+            if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
+              continue;
+            const file = path4.join(directory, name);
+            const stat = fs5.lstatSync(file);
+            if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
+              continue;
+            report.temporary.removed += 1;
+            if (!dryRun)
+              fs5.rmSync(file, { force: true });
+          }
+        }
+        return success(null, null, null);
+      } catch (error) {
+        return failure2("storage_error", `garbage collection failed: ${String(error)}`, {
+          path: this.recoveryDir
+        });
+      }
+    };
+    const pruned = dryRun ? sweep() : this.withLock(sweep);
+    if (!pruned.ok)
+      return pruned;
+    const tasks = this.listTasks();
+    if (!tasks.ok)
+      return tasks;
+    for (const task of tasks.data) {
+      const deduped = dedupeCandidates(task.candidates);
+      const removed = task.candidates.length - deduped.length;
+      if (removed === 0)
+        continue;
+      if (task.status === "active") {
+        report.candidates.skippedActive.push(task.id);
+        continue;
+      }
+      if (task.status === "closed") {
+        report.candidates.skippedClosed.push(task.id);
+        continue;
+      }
+      if (!dryRun) {
+        const written = this.mutateTask(task.id, task.revision, (current) => success(current.revision, null, {
+          ...current,
+          candidates: dedupeCandidates(current.candidates)
+        }));
+        if (!written.ok) {
+          report.candidates.failed.push(task.id);
+          continue;
+        }
+      }
+      report.candidates.removed += removed;
+      report.candidates.tasks.push(task.id);
+    }
+    return success(null, null, report);
+  }
   findRecovery(target, taskId, digest, workspace) {
-    if (!fs4.existsSync(this.recoveryDir))
+    if (!fs5.existsSync(this.recoveryDir))
       return null;
     const workspaceId = workspace?.id ?? this.trustedWorkspaceId();
     if (target === "workspace" && !workspaceId)
@@ -17028,9 +17437,9 @@ class TaskStore {
       if (candidate.target !== target || candidate.digest !== digest)
         continue;
       try {
-        if (!fs4.lstatSync(candidate.path).isFile())
+        if (!fs5.lstatSync(candidate.path).isFile())
           continue;
-        const bytes = fs4.readFileSync(candidate.path);
+        const bytes = fs5.readFileSync(candidate.path);
         if (digestBytes(bytes) !== digest)
           continue;
         if (target === "workspace") {
@@ -17048,11 +17457,11 @@ class TaskStore {
   }
   fsyncDirectory(directory) {
     try {
-      const fd = fs4.openSync(directory, "r");
+      const fd = fs5.openSync(directory, "r");
       try {
-        fs4.fsyncSync(fd);
+        fs5.fsyncSync(fd);
       } finally {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       }
     } catch (error) {
       if (process.platform !== "win32")
@@ -17060,14 +17469,14 @@ class TaskStore {
     }
   }
   trustedWorkspaceId() {
-    if (!fs4.existsSync(this.tasksDir))
+    if (!fs5.existsSync(this.tasksDir))
       return null;
     const ids = new Set;
     try {
-      for (const name of fs4.readdirSync(this.tasksDir)) {
+      for (const name of fs5.readdirSync(this.tasksDir)) {
         if (!name.endsWith(".json") || !validId(name.slice(0, -5)))
           return null;
-        const parsed = this.parseBytes(fs4.readFileSync(path4.join(this.tasksDir, name)), taskRecordSchema);
+        const parsed = this.parseBytes(fs5.readFileSync(path4.join(this.tasksDir, name)), taskRecordSchema);
         if (!parsed.ok || parsed.data.id !== name.slice(0, -5))
           return null;
         ids.add(parsed.data.workspaceId);
@@ -17079,14 +17488,14 @@ class TaskStore {
   }
   snapshotBytes(file) {
     try {
-      return fs4.readFileSync(file);
+      return retryTransient(() => fs5.readFileSync(file));
     } catch {
       return null;
     }
   }
   readRecord(file, schema) {
     try {
-      const bytes = fs4.readFileSync(file, "utf8");
+      const bytes = retryTransient(() => fs5.readFileSync(file, "utf8"));
       return { exists: true, result: this.parseBytes(bytes, schema) };
     } catch (error) {
       if (error?.code === "ENOENT")
@@ -17099,7 +17508,7 @@ class TaskStore {
       };
     }
   }
-  parseBytes(bytes, schema) {
+  parseBytes(bytes, schema, mode = "read") {
     let value;
     try {
       value = JSON.parse(typeof bytes === "string" ? bytes : bytes.toString("utf8"));
@@ -17108,27 +17517,28 @@ class TaskStore {
     }
     if (isObject2(value) && "schemaVersion" in value && value.schemaVersion !== SCHEMA_VERSION)
       return failure2("unsupported_version", "unsupported snapshot schema version");
-    const parsed = schema.safeParse(value);
-    if (parsed.success)
+    const parsed = parseStoredRecord(schema, value);
+    if (parsed.success && (mode === "read" || parsed.stripped.length === 0))
       return success(null, null, parsed.data);
     const writerVersion = isObject2(value) && isObject2(value.runtime) ? value.runtime.updatedWith : null;
+    const upgrade = `upgrade Workit before ${parsed.success ? "recovering" : "mutating"} this checkout`;
+    if (parsed.success)
+      return failure2("recovery_required", `snapshot carries fields this Workit cannot preserve (${parsed.stripped.join(", ")}); ${upgrade}`);
+    if (parsed.critical.length > 0)
+      return failure2("recovery_required", `snapshot requires fields this Workit cannot read (${parsed.critical.join(", ")}); ${upgrade}`);
     if (typeof writerVersion === "string" && isNewerVersion(writerVersion, runtimeVersion()))
       return failure2("recovery_required", `snapshot was written by workit ${writerVersion}; upgrade Workit before mutating this checkout`);
     return failure2("recovery_required", "snapshot does not satisfy its schema");
   }
-  processStart(pid) {
-    try {
-      return fs4.readFileSync(`/proc/${pid}/stat`, "utf8").split(" ")[21] ?? null;
-    } catch {
-      return null;
-    }
-  }
   conflict(expected, actual) {
     return failure2("revision_conflict", "snapshot revision does not match; omit expectedRevision to use the current record", {
       expectedRevision: expected,
       actualRevision: actual
     });
   }
+  workspaceConflict(expected, actual) {
+    return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
+  }
   taskPath(taskId) {
     return path4.join(this.tasksDir, `${taskId}.json`);
   }
@@ -17154,53 +17564,116 @@ class TaskStore {
     return path4.join(this.workitDir, ".gitignore");
   }
 }
-// packages/workit-core/src/core/task-engine.ts
-import { realpathSync as realpathSync6 } from "node:fs";
-
-// packages/workit-core/src/core/authority.ts
-import { createHash as createHash5 } from "node:crypto";
-import * as fs6 from "node:fs";
-import path9 from "node:path";
-
-// packages/workit-core/src/core/auto-approval.ts
-import { createHash as createHash4 } from "node:crypto";
-import { readFileSync as readFileSync4, realpathSync as realpathSync3 } from "node:fs";
-import path8 from "node:path";
-
-// packages/workit-core/src/core/workspaces.ts
-import { createHash as createHash3 } from "node:crypto";
-import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path6 from "node:path";
-
-// packages/workit-core/src/core/config.ts
-import {
-  copyFileSync,
-  cpSync,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync2,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import os from "node:os";
-import path5 from "node:path";
-
-// packages/workit-core/src/core/boundary.ts
-import { statSync as statSync2 } from "node:fs";
-var EVENT = {
-  initialization: "initialization",
-  provenance: "provenance",
-  assets: "assets",
-  configurationSource: "configuration_source",
-  hooks: "hooks",
-  mcpConnection: "mcp_connection",
-  migration: "migration",
-  installSteps: "install_steps",
-  uncaughtFailure: "uncaught_failure",
-  toolsFailed: "tools_failed",
-  doctor: "doctor"
+// packages/workit-core/src/core/workers.ts
+var same = (left, right) => {
+  try {
+    return canonicalJson(left) === canonicalJson(right);
+  } catch {
+    return false;
+  }
 };
-var errorDetail = (err) => {
+var UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
+var isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state);
+var workerBlocksTransition = (transition, state) => transition === "pause" ? false : isUncertainWorker(state);
+var callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor };
+var validPath = (value) => typeof value === "string" && value.length > 0 && !Array.from(value).some((char) => {
+  const code = char.charCodeAt(0);
+  return code < 32 || code === 127;
+}) && !value.split(/[\\/]/).includes("..");
+var callerValue = (value) => ({ host: value.host, actor: value.actor });
+var workerIdOf = (value) => value.workerId ?? null;
+var currentWriterOwnsTask = (task, workspace, caller) => {
+  const owner = workspace.writer?.owner;
+  return task.status === "active" && task.workspaceId === workspace.id && owner?.taskId === task.id && owner.session.host === caller.host && owner.session.handle === caller.actor;
+};
+function assertProductWriteAllowed(input) {
+  if (!Array.isArray(input.paths) || input.paths.some((path) => !validPath(path)))
+    return failure2("invalid_input", "invalid product write path");
+  if (!input.store)
+    return failure2("permission_denied", "write authorization requires core state");
+  const task = input.store.readTask(input.task.id);
+  if (!task.ok)
+    return task;
+  const workspace = input.store.readWorkspace();
+  if (!workspace.ok)
+    return workspace;
+  if (!workspace.data)
+    return failure2("not_found", "workspace not found");
+  const workspaceRecord = workspace.data;
+  if (task.data.status !== "active")
+    return failure2("invalid_transition", "paused or closed tasks cannot own product writes");
+  if (workspaceRecord.id !== task.data.workspaceId || workspaceRecord.root.length === 0)
+    return failure2("recovery_required", "task and workspace bindings are invalid");
+  const writer = workspaceRecord.writer;
+  if (!writer)
+    return failure2("permission_denied", "checkout has no writer owner");
+  if (writer.state === "uncertain")
+    return failure2("recovery_required", "checkout writer requires recovery", {
+      owner: writer.owner
+    });
+  const caller = callerValue(input.caller);
+  const workerId = workerIdOf(input.caller);
+  const owner = writer.owner;
+  if (owner.taskId !== task.data.id || owner.workerId !== workerId || owner.session.host !== caller.host || owner.session.handle !== caller.actor)
+    return failure2("writer_conflict", "checkout is owned by another validated actor", { owner });
+  const worker = workerId === null ? null : task.data.workers.find((entry) => entry.id === workerId);
+  if (workerId !== null && (!worker || worker.data.assignment.role !== "implementer"))
+    return failure2("permission_denied", "only implementers can own product writes");
+  if (workerId !== null && (!worker?.data.session || worker.data.state === "cancelling" || worker.data.state === "unknown" || worker.data.state === "stopped" || !same(worker.data.session, callerSession(input.caller))))
+    return failure2("recovery_required", "worker session is not an active writer");
+  return success(null, workspaceRecord.revision, owner);
+}
+
+// packages/workit-core/src/core/task-evaluation.ts
+import { createHash as createHash6 } from "node:crypto";
+import * as fs8 from "node:fs";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import path10 from "node:path";
+
+// packages/workit-core/src/core/authority.ts
+import { createHash as createHash5 } from "node:crypto";
+import * as fs7 from "node:fs";
+import path9 from "node:path";
+
+// packages/workit-core/src/core/auto-approval.ts
+import { createHash as createHash4 } from "node:crypto";
+import { readFileSync as readFileSync4, realpathSync as realpathSync3 } from "node:fs";
+import path8 from "node:path";
+
+// packages/workit-core/src/core/workspaces.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
+import path6 from "node:path";
+
+// packages/workit-core/src/core/config.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import os from "node:os";
+import path5 from "node:path";
+
+// packages/workit-core/src/core/boundary.ts
+import { statSync as statSync2 } from "node:fs";
+var EVENT = {
+  initialization: "initialization",
+  provenance: "provenance",
+  assets: "assets",
+  configurationSource: "configuration_source",
+  hooks: "hooks",
+  mcpConnection: "mcp_connection",
+  migration: "migration",
+  installSteps: "install_steps",
+  uncaughtFailure: "uncaught_failure",
+  toolsFailed: "tools_failed",
+  doctor: "doctor"
+};
+var errorDetail = (err) => {
   if (err instanceof Error) {
     return { error_name: err.name, error: err.message };
   }
@@ -17829,13 +18302,13 @@ var gitContext = (workspaceRoot, paths = []) => {
 };
 
 // packages/workit-core/src/core/vcs-config.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import path7 from "node:path";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path7.join(configDir(), "vcs.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync2("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -17872,7 +18345,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync("ssh", ["-G", host], {
+  const resolved = spawnSync2("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -17922,7 +18395,7 @@ var readVcsConfig = () => {
   const file = vcsConfigPath();
   let raw;
   try {
-    raw = fs5.readFileSync(file, "utf8");
+    raw = fs6.readFileSync(file, "utf8");
   } catch {
     return { status: "missing", path: file, config: {} };
   }
@@ -18023,7 +18496,7 @@ function vcsCliIdentity(cwd) {
     PATH: process.env.PATH ?? "",
     ...provider === "github" ? { GH_HOST: host } : { GITLAB_HOST: host }
   };
-  const result = spawnSync(bin, ["api", "user"], {
+  const result = spawnSync2(bin, ["api", "user"], {
     cwd: root,
     encoding: "utf8",
     env
@@ -18065,7 +18538,7 @@ function mergedPrStyle(limit = 6, cwd) {
 `).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
     descriptionPreview: desc.slice(0, 600)
   });
-  const remoteResult = spawnSync("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const remoteResult = spawnSync2("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -18081,7 +18554,7 @@ function mergedPrStyle(limit = 6, cwd) {
   if (!hostingApiHostMatches(remote, host))
     return { ok: false, error: "PR style target does not match the provider host" };
   if (provider === "gitlab") {
-    const run = (args) => spawnSync("glab", ["api", ...args], {
+    const run = (args) => spawnSync2("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -18101,7 +18574,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync("gh", [
+    const r = spawnSync2("gh", [
       "pr",
       "list",
       "--repo",
@@ -18160,66 +18633,6 @@ var verifyPushIdentity = (root, provider, account) => {
   return { ok: true };
 };
 
-// packages/workit-core/src/core/workers.ts
-var same = (left, right) => {
-  try {
-    return canonicalJson(left) === canonicalJson(right);
-  } catch {
-    return false;
-  }
-};
-var UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
-var isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state);
-var workerBlocksTransition = (transition, state) => transition === "pause" ? false : isUncertainWorker(state);
-var callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor };
-var validPath = (value) => typeof value === "string" && value.length > 0 && !Array.from(value).some((char) => {
-  const code = char.charCodeAt(0);
-  return code < 32 || code === 127;
-}) && !value.split(/[\\/]/).includes("..");
-var callerValue = (value) => ({ host: value.host, actor: value.actor });
-var workerIdOf = (value) => value.workerId ?? null;
-var currentWriterOwnsTask = (task, workspace, caller) => {
-  const owner = workspace.writer?.owner;
-  return task.status === "active" && task.workspaceId === workspace.id && owner?.taskId === task.id && owner.session.host === caller.host && owner.session.handle === caller.actor;
-};
-function assertProductWriteAllowed(input) {
-  if (!Array.isArray(input.paths) || input.paths.some((path) => !validPath(path)))
-    return failure2("invalid_input", "invalid product write path");
-  if (!input.store)
-    return failure2("permission_denied", "write authorization requires core state");
-  const task = input.store.readTask(input.task.id);
-  if (!task.ok)
-    return task;
-  const workspace = input.store.readWorkspace();
-  if (!workspace.ok)
-    return workspace;
-  if (!workspace.data)
-    return failure2("not_found", "workspace not found");
-  const workspaceRecord = workspace.data;
-  if (task.data.status !== "active")
-    return failure2("invalid_transition", "paused or closed tasks cannot own product writes");
-  if (workspaceRecord.id !== task.data.workspaceId || workspaceRecord.root.length === 0)
-    return failure2("recovery_required", "task and workspace bindings are invalid");
-  const writer = workspaceRecord.writer;
-  if (!writer)
-    return failure2("permission_denied", "checkout has no writer owner");
-  if (writer.state === "uncertain")
-    return failure2("recovery_required", "checkout writer requires recovery", {
-      owner: writer.owner
-    });
-  const caller = callerValue(input.caller);
-  const workerId = workerIdOf(input.caller);
-  const owner = writer.owner;
-  if (owner.taskId !== task.data.id || owner.workerId !== workerId || owner.session.host !== caller.host || owner.session.handle !== caller.actor)
-    return failure2("writer_conflict", "checkout is owned by another validated actor", { owner });
-  const worker = workerId === null ? null : task.data.workers.find((entry) => entry.id === workerId);
-  if (workerId !== null && (!worker || worker.data.assignment.role !== "implementer"))
-    return failure2("permission_denied", "only implementers can own product writes");
-  if (workerId !== null && (!worker?.data.session || worker.data.state === "cancelling" || worker.data.state === "unknown" || worker.data.state === "stopped" || !same(worker.data.session, callerSession(input.caller))))
-    return failure2("recovery_required", "worker session is not an active writer");
-  return success(null, workspaceRecord.revision, owner);
-}
-
 // packages/workit-core/src/core/auto-approval.ts
 var AUTO_CLASSES = ["branch", "commit", "push", "pr", "merge"];
 var OPERATION_CLASS = {
@@ -18506,7 +18919,7 @@ var digestBytes2 = (bytes) => createHash5("sha256").update(bytes).digest("hex");
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs6.realpathSync(checkoutRoot);
+    root = fs7.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -18529,8 +18942,8 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         if (!segment)
           continue;
         current = path9.join(current, segment);
-        const stat = fs6.lstatSync(current);
-        const real = fs6.realpathSync(current);
+        const stat = fs7.lstatSync(current);
+        const real = fs7.realpathSync(current);
         if (real !== root && !real.startsWith(`${root}${path9.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
@@ -18547,7 +18960,7 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         if (current !== target && !stat.isDirectory())
           return failure2("invalid_input", "document reference ancestor is not a directory");
       }
-      if (digestBytes2(fs6.readFileSync(target)) !== reference.digest)
+      if (digestBytes2(fs7.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "approved document bytes have changed");
     } catch {
       return failure2("invalid_input", "approved document is unavailable");
@@ -18910,18 +19323,41 @@ function reconcileAction(input) {
 var bindingCovers = scopeCovers;
 var verifyDecisionContent = verifyContentRefs;
 
-// packages/workit-core/src/core/policy-resolver.ts
-var resolverInputSchema = object({
-  intent: intentSchema,
-  assessment: assessmentSchema,
-  constraints: array(constraintSchema),
-  prior: object({
-    decisions: array(decisionSchema),
-    findings: array(findingSchema),
-    requirements: array(requirementSchema)
-  }).strict(),
-  preferences: object({ fast: boolean2().optional(), thorough: boolean2().optional() }).strict().optional()
-}).strict();
+// packages/workit-core/src/core/task-evaluation.ts
+var digestBytes3 = (value) => createHash6("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path10.sep}`);
+var relative = (root, candidate) => path10.relative(root, candidate).split(path10.sep).join("/") || ".";
+var canonicalPath = (value) => {
+  if (typeof value !== "string" || !value)
+    return null;
+  if (value.includes("\\") || value.split("/").includes(".."))
+    return null;
+  const normalized = path10.posix.normalize(value);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+    return null;
+  return normalized === "." ? "." : normalized.replace(/\/$/, "");
+};
+var canonicalScope = (scope) => {
+  const paths = scope.paths.length ? scope.paths : ["."];
+  const normalizedPaths = paths.map(canonicalPath);
+  const normalizedExclusions = scope.exclusions.map(canonicalPath);
+  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
+    return null;
+  return {
+    description: scope.description,
+    paths: [...new Set(normalizedPaths)],
+    exclusions: [...new Set(normalizedExclusions)]
+  };
+};
+var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
+var scopeMatches = (value, scope) => {
+  const normalized = canonicalScope(scope);
+  if (!normalized)
+    return false;
+  const paths = normalized.paths;
+  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
+};
+var pathRelevant = (value, scope) => scopeMatches(value, scope);
 var compareCodeUnits2 = (left, right) => {
   const length = Math.min(left.length, right.length);
   for (let index = 0;index < length; index += 1) {
@@ -18931,362 +19367,8 @@ var compareCodeUnits2 = (left, right) => {
   }
   return left.length - right.length;
 };
-var stableUnique = (values) => [...new Set(values)].toSorted(compareCodeUnits2);
-var stableList = (values) => [...values].toSorted((left, right) => compareCodeUnits2(canonicalJson(left), canonicalJson(right)));
-var normalizedScope = (scope) => ({
-  description: scope.description,
-  paths: stableUnique(scope.paths),
-  exclusions: stableUnique(scope.exclusions)
-});
-var normalizedRefList = (values) => stableList(values);
-var normalizeAssessment = (assessment) => ({
-  facts: stableList(assessment.facts.map((fact) => ({ ...fact, refs: normalizedRefList(fact.refs) }))),
-  signals: Object.fromEntries(Object.entries(assessment.signals).map(([name, signal]) => [
-    name,
-    { ...signal, refs: normalizedRefList(signal.refs) }
-  ])),
-  consequences: stableList(assessment.consequences.map((consequence) => ({
-    ...consequence,
-    fact: { ...consequence.fact, refs: normalizedRefList(consequence.fact.refs) }
-  }))),
-  verification: stableList(assessment.verification.map((verification) => ({
-    ...verification,
-    scope: normalizedScope(verification.scope),
-    availableChecks: normalizedRefList(verification.availableChecks),
-    gaps: stableUnique(verification.gaps)
-  })))
-});
-var normalizeConstraint = (constraint) => ({
-  ...constraint,
-  source: constraint.source,
-  requires: stableList(constraint.requires.map((requirement) => ({
-    ...requirement,
-    scope: normalizedScope(requirement.scope),
-    refs: normalizedRefList(requirement.refs)
-  })))
-});
-var normalizeDecision = (decision) => ({
-  ...decision,
-  binding: {
-    ...decision.binding,
-    scope: normalizedScope(decision.binding.scope),
-    contentRefs: normalizedRefList(decision.binding.contentRefs)
-  },
-  requirementIds: stableUnique(decision.requirementIds)
-});
-var normalizeIntent = (intent) => ({
-  ...intent,
-  scope: normalizedScope(intent.scope),
-  authorityRefs: normalizedRefList(intent.authorityRefs)
-});
-var normalizePrior = (prior) => ({
-  decisions: stableList(prior.decisions.map(normalizeDecision)),
-  findings: stableList(prior.findings.map((finding) => ({
-    ...finding,
-    scope: normalizedScope(finding.scope),
-    refs: normalizedRefList(finding.refs),
-    resolution: finding.resolution ? {
-      ...finding.resolution,
-      evidenceIds: stableUnique(finding.resolution.evidenceIds),
-      decisionIds: stableUnique(finding.resolution.decisionIds)
-    } : null
-  }))),
-  requirements: stableList(prior.requirements.map((requirement) => ({
-    ...requirement,
-    scope: normalizedScope(requirement.scope)
-  })))
-});
-var invalidFields = (error) => ({
-  fields: error.issues.map((issue) => ({
-    path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
-    reason: issue.message
-  }))
-});
-function normalizeResolverInput(input) {
-  const parsed = resolverInputSchema.safeParse(input);
-  if (!parsed.success)
-    return failure2("invalid_input", "resolver input is invalid", invalidFields(parsed.error));
-  const value = parsed.data;
-  const signals = value.assessment.signals;
-  if (signals.behaviorChange.value === true && signals.mechanicalLowRisk.value === true)
-    return failure2("invalid_input", "behavioral change cannot be wholly mechanical", {
-      fields: [
-        {
-          path: "assessment.signals",
-          reason: "contradictory behaviorChange and mechanicalLowRisk"
-        }
-      ]
-    });
-  const ids = value.constraints.map((constraint) => constraint.id);
-  if (new Set(ids).size !== ids.length)
-    return failure2("invalid_input", "constraint IDs must be unique", {
-      fields: [{ path: "constraints", reason: "duplicate constraint id" }]
-    });
-  if (value.preferences?.fast && value.preferences.thorough)
-    return failure2("invalid_input", "fast and thorough preferences contradict", {
-      fields: [{ path: "preferences", reason: "fast and thorough cannot both be enabled" }]
-    });
-  const normalized = {
-    intent: normalizeIntent(value.intent),
-    assessment: normalizeAssessment(value.assessment),
-    constraints: stableList(value.constraints.map(normalizeConstraint)),
-    prior: normalizePrior(value.prior),
-    ...value.preferences ? { preferences: { ...value.preferences } } : {},
-    policyVersion: POLICY_VERSION
-  };
-  return success(null, null, normalized);
-}
-var requirement = (spec) => ({
-  ...spec,
-  id: requirementId({
-    ruleId: spec.ruleId,
-    scope: spec.scope,
-    satisfaction: spec.satisfaction,
-    before: spec.before,
-    dependentAction: spec.dependentAction
-  })
-});
-var signalReason = (input, name) => input.assessment.signals[name].reason;
-function resolveRequirements(input) {
-  const { signals } = input.assessment;
-  const scope = input.intent.scope;
-  const requirements = [];
-  const hasUnknownSignal = Object.values(signals).some((signal) => signal.value === "unknown");
-  const hasUnknownFact = [
-    ...input.assessment.facts,
-    ...input.assessment.consequences.map(({ fact }) => fact)
-  ].some((fact) => fact.basis === "unknown");
-  if (hasUnknownSignal || hasUnknownFact)
-    requirements.push(requirement({
-      ruleId: "consequential-unknown",
-      dimension: "investigation",
-      scope,
-      reason: `Resolve consequential uncertainty before the dependent action: ${[
-        ...Object.entries(signals).filter(([, signal]) => signal.value === "unknown").map(([name]) => name),
-        ...hasUnknownFact ? ["unknown fact"] : []
-      ].join(", ")}`,
-      satisfaction: "An observed or inferred fact resolves the uncertainty and records its supporting references.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: false
-    }));
-  if (signals.productChoiceOpen.value === true)
-    requirements.push(requirement({
-      ruleId: "product-decision",
-      dimension: "decisions",
-      scope,
-      reason: `A consequential product choice remains open: ${signalReason(input, "productChoiceOpen")}`,
-      satisfaction: "Present the material alternatives and record the user's decision before the dependent action.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: false
-    }));
-  const independentBehaviorReview = input.preferences?.thorough === true || input.assessment.consequences.some((consequence) => ["security", "data", "public_contract", "operations"].includes(consequence.area));
-  if (signals.behaviorChange.value === true)
-    requirements.push(requirement({
-      ruleId: "behavioral-verification",
-      dimension: "testing",
-      scope,
-      reason: `Behavior, side effects, permissions, or data handling may change: ${signalReason(input, "behaviorChange")}`,
-      satisfaction: "A useful behavioral check passes against the affected behavior and current candidate.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: false
-    }), requirement({
-      ruleId: independentBehaviorReview ? "fresh-context-review" : "self-review",
-      dimension: "review",
-      scope,
-      reason: independentBehaviorReview ? "Consequential behavior or the thorough preference requires fresh-context review." : "Bounded behavior changes use self-review unless consequential risks or trusted rules require more.",
-      satisfaction: independentBehaviorReview ? "A separate review context examines the current candidate and records its result." : "The lead reviews the resulting diff and records the relevant scope and checks.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: !independentBehaviorReview
-    }));
-  else if (signals.mechanicalLowRisk.value === true)
-    requirements.push(requirement({
-      ruleId: "mechanical-existing-checks",
-      dimension: "verification",
-      scope,
-      reason: `The change is demonstrably mechanical and low-risk: ${signalReason(input, "mechanicalLowRisk")}`,
-      satisfaction: "Run the relevant existing checks for affected consumers; do not add tautological tests.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }), requirement({
-      ruleId: input.preferences?.thorough ? "fresh-context-review" : "self-review",
-      dimension: "review",
-      scope,
-      reason: input.preferences?.thorough ? "The thorough preference upgrades mechanical self-review to fresh-context review." : "Mechanical low-risk work uses self-review rather than mandatory fresh-context review.",
-      satisfaction: input.preferences?.thorough ? "A separate review context examines the current candidate and records its result." : "The lead reviews the resulting diff and records the relevant scope and checks.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: !input.preferences?.thorough
-    }));
-  if (signals.behaviorChange.value === true || signals.mechanicalLowRisk.value === true)
-    requirements.push(requirement({
-      ruleId: "pre-pr-cleanup",
-      dimension: "verification",
-      scope,
-      reason: "Implementation output must be deslopped before it is delivered.",
-      satisfaction: "Run the workit-deslop pass and record passing check evidence, or record an approved limitation decision waiving cleanup.",
-      before: "dependent_action",
-      dependentAction: "hosting.pull_request",
-      acceptanceAllowed: true
-    }));
-  if (signals.durableAgreementNeeded.value === true)
-    requirements.push(requirement({
-      ruleId: "durable-spec",
-      dimension: "artifacts",
-      scope,
-      reason: `The work needs a durable agreement about intended behavior: ${signalReason(input, "durableAgreementNeeded")}`,
-      satisfaction: "Record the agreed behavior in a durable specification before implementation writes.",
-      before: "write",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }));
-  if (signals.coordinationPlanNeeded.value === true)
-    requirements.push(requirement({
-      ruleId: "coordination-plan",
-      dimension: "continuity",
-      scope,
-      reason: `Dependencies, sequencing, or resumption need durable coordination: ${signalReason(input, "coordinationPlanNeeded")}`,
-      satisfaction: "Record useful sequencing, dependencies, and the next action in a compact plan.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }));
-  if (signals.helperUseful.value === true && !input.preferences?.fast)
-    requirements.push(requirement({
-      ruleId: "helper-usefulness",
-      dimension: "delegation",
-      scope,
-      reason: `Independent judgment or investigation justifies a scoped helper: ${signalReason(input, "helperUseful")}`,
-      satisfaction: "Use a bounded helper only for the independent objective and reconcile its result.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }));
-  for (const constraint of input.constraints)
-    for (const obligation of constraint.requires) {
-      const dimension = obligation.method ?? (obligation.kind === "check" ? "verification" : obligation.kind === "decision" ? "decisions" : "challenge");
-      requirements.push(requirement({
-        ruleId: `project-constraint:${constraint.id}:${obligation.kind}:${sha256({
-          kind: obligation.kind,
-          scope: normalizedScope(obligation.scope),
-          refs: normalizedRefList(obligation.refs),
-          method: obligation.method,
-          before: obligation.before,
-          dependentAction: obligation.dependentAction
-        })}`,
-        dimension,
-        scope: obligation.scope,
-        reason: `${constraint.kind} constraint requires ${obligation.kind}: ${constraint.statement}`,
-        satisfaction: `Satisfy the constraint obligation using its referenced ${obligation.kind}.`,
-        before: obligation.before,
-        dependentAction: obligation.dependentAction,
-        acceptanceAllowed: constraint.acceptanceAllowed && obligation.kind !== "decision"
-      }));
-    }
-  const seen = new Set;
-  return requirements.filter((item) => {
-    if (seen.has(item.id))
-      return false;
-    seen.add(item.id);
-    return true;
-  });
-}
-function resolvePolicy(input) {
-  const normalized = normalizeResolverInput(input);
-  if (!normalized.ok)
-    return normalized;
-  const requirements = resolveRequirements(normalized.data);
-  const policy = {
-    policyVersion: POLICY_VERSION,
-    inputDigest: sha256(canonicalJson(normalized.data)),
-    requirements
-  };
-  const parsed = policySchema.safeParse(policy);
-  if (!parsed.success)
-    return failure2("invalid_input", "resolved policy is invalid", invalidFields(parsed.error));
-  return success(null, null, parsed.data);
-}
-function diffPolicy(previous, next, reason, now) {
-  if (!policySchema.safeParse(previous).success && previous !== null)
-    throw new TypeError("previous policy is invalid");
-  if (!policySchema.safeParse(next).success)
-    throw new TypeError("next policy is invalid");
-  const oldIds = new Set(previous?.requirements.map((item) => item.id) ?? []);
-  const newIds = new Set(next.requirements.map((item) => item.id));
-  const added = [...newIds].filter((id) => !oldIds.has(id)).toSorted(compareCodeUnits2);
-  const retired = [...oldIds].filter((id) => !newIds.has(id)).toSorted(compareCodeUnits2);
-  if (added.length === 0 && retired.length === 0)
-    return null;
-  const normalizedReason = reason.trim();
-  const changeReason = retired.length ? `${normalizedReason || "policy reassessed"} (retired: ${retired.join(",")})` : normalizedReason || "policy reassessed";
-  const change = {
-    recordedAt: now,
-    fromInputDigest: previous?.inputDigest ?? null,
-    toInputDigest: next.inputDigest,
-    added,
-    retired,
-    reason: changeReason
-  };
-  const parsed = policyChangeSchema.safeParse(change);
-  if (!parsed.success)
-    throw new TypeError("policy change is invalid");
-  return parsed.data;
-}
-
-// packages/workit-core/src/core/task-evaluation.ts
-import { createHash as createHash6 } from "node:crypto";
-import * as fs7 from "node:fs";
-import { spawnSync as spawnSync2 } from "node:child_process";
-import path10 from "node:path";
-var digestBytes3 = (value) => createHash6("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path10.sep}`);
-var relative = (root, candidate) => path10.relative(root, candidate).split(path10.sep).join("/") || ".";
-var canonicalPath = (value) => {
-  if (typeof value !== "string" || !value)
-    return null;
-  if (value.includes("\\") || value.split("/").includes(".."))
-    return null;
-  const normalized = path10.posix.normalize(value);
-  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
-    return null;
-  return normalized === "." ? "." : normalized.replace(/\/$/, "");
-};
-var canonicalScope = (scope) => {
-  const paths = scope.paths.length ? scope.paths : ["."];
-  const normalizedPaths = paths.map(canonicalPath);
-  const normalizedExclusions = scope.exclusions.map(canonicalPath);
-  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
-    return null;
-  return {
-    description: scope.description,
-    paths: [...new Set(normalizedPaths)],
-    exclusions: [...new Set(normalizedExclusions)]
-  };
-};
-var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
-var scopeMatches = (value, scope) => {
-  const normalized = canonicalScope(scope);
-  if (!normalized)
-    return false;
-  const paths = normalized.paths;
-  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
-};
-var pathRelevant = (value, scope) => scopeMatches(value, scope);
-var compareCodeUnits3 = (left, right) => {
-  const length = Math.min(left.length, right.length);
-  for (let index = 0;index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
-  }
-  return left.length - right.length;
-};
 var gitPaths = (root) => {
-  const result = spawnSync2("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync3("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -19299,7 +19381,7 @@ var gitPaths = (root) => {
     };
   }
   const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path10.sep).join("/")) : [];
-  const stagedDeleted = spawnSync2("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  const stagedDeleted = spawnSync3("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
@@ -19312,7 +19394,7 @@ var gitPaths = (root) => {
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs7.readdirSync(directory);
+    names = fs8.readdirSync(directory);
   } catch {
     return true;
   }
@@ -19323,7 +19405,7 @@ var walk = (root, directory, output) => {
     const target = path10.join(directory, name);
     let stat;
     try {
-      stat = fs7.lstatSync(target);
+      stat = fs8.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -19342,10 +19424,10 @@ var scopeRoots = (root, scope) => {
     if (!inside(root, target))
       return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
     let ancestor = target;
-    while (!fs7.existsSync(ancestor) && ancestor !== root)
+    while (!fs8.existsSync(ancestor) && ancestor !== root)
       ancestor = path10.dirname(ancestor);
     try {
-      if (!inside(root, fs7.realpathSync(ancestor)))
+      if (!inside(root, fs8.realpathSync(ancestor)))
         return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
     } catch {
       return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
@@ -19357,7 +19439,7 @@ var scopeRoots = (root, scope) => {
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs7.realpathSync(root);
+    checkout = fs8.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -19375,11 +19457,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs7.existsSync(target))
+    if (!fs8.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs7.lstatSync(target);
+      stat = fs8.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -19397,15 +19479,15 @@ function captureCandidate(root, scope, environment = []) {
       continue;
     const target = path10.join(checkout, item);
     try {
-      const stat = fs7.lstatSync(target);
+      const stat = fs8.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs7.readlinkSync(target);
+        const link = fs8.readlinkSync(target);
         files.push({ path: item, kind: "symlink", digest: digestBytes3(link), executable: null });
       } else if (stat.isFile()) {
         files.push({
           path: item,
           kind: "file",
-          digest: digestBytes3(fs7.readFileSync(target)),
+          digest: digestBytes3(fs8.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -19427,10 +19509,10 @@ function captureCandidate(root, scope, environment = []) {
   const namesByEnvironment = supplied.map(({ name }) => name);
   if (new Set(namesByEnvironment).size !== namesByEnvironment.length || namesByEnvironment.some((name) => typeof name !== "string" || !name))
     return failure2("invalid_input", "candidate environment names must be unique and non-empty");
-  const values = supplied.toSorted((left, right) => compareCodeUnits3(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
+  const values = supplied.toSorted((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
   if (values.some(({ value }) => value === null))
     completeness = "uncertain";
-  const headResult = spawnSync2("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync3("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
   if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
     completeness = "uncertain";
   const head = headResult.status === 0 ? headResult.stdout.trim() : null;
@@ -19735,166 +19817,608 @@ function evaluateClosure(requestedOutcome, view) {
   });
 }
 
-// packages/workit-core/src/core/methods.ts
-var METHODS = {
-  "workit-challenge": { dimensions: ["challenge", "decisions"] },
-  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
-  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
-  "workit-plan": { dimensions: ["artifacts", "continuity"] },
-  "workit-implement": { dimensions: ["delegation"] },
-  "workit-debug": {},
-  "workit-handoff": {},
-  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
-};
-var methodMatches = (definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true || definition.ruleIds?.includes(requirement.ruleId) === true;
-var assuranceFor = (id, definition, capabilities) => {
-  const keys = new Set([
-    id,
-    ...definition.dimensions ?? [],
-    ...definition.ruleIds ?? []
-  ]);
-  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
-  if (id === "workit-review" && matches.length === 0)
-    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
-  if (matches.some((capability) => capability.assurance === "unavailable"))
-    return {
-      assurance: "unavailable",
-      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
-    };
-  if (matches.some((capability) => capability.assurance === "enforced"))
-    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
-  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
+// packages/workit-core/src/core/methods.ts
+var METHODS = {
+  "workit-challenge": { dimensions: ["challenge", "decisions"] },
+  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
+  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
+  "workit-plan": { dimensions: ["artifacts", "continuity"] },
+  "workit-implement": { dimensions: ["delegation"] },
+  "workit-debug": {},
+  "workit-handoff": {},
+  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
+};
+var methodMatches = (definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true || definition.ruleIds?.includes(requirement.ruleId) === true;
+var assuranceFor = (id, definition, capabilities) => {
+  const keys = new Set([
+    id,
+    ...definition.dimensions ?? [],
+    ...definition.ruleIds ?? []
+  ]);
+  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
+  if (id === "workit-review" && matches.length === 0)
+    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
+  if (matches.some((capability) => capability.assurance === "unavailable"))
+    return {
+      assurance: "unavailable",
+      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
+    };
+  if (matches.some((capability) => capability.assurance === "enforced"))
+    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
+  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
+};
+function selectMethods(policy, capabilities) {
+  return Object.entries(METHODS).flatMap(([id, definition]) => {
+    const requirements = policy.requirements.filter((requirement) => methodMatches(definition, requirement));
+    if (requirements.length === 0)
+      return [];
+    const capability = assuranceFor(id, definition, capabilities);
+    const reasons = [
+      ...new Set(requirements.map((requirement) => requirement.reason)),
+      ...capability.reasons
+    ];
+    if (capability.assurance === "unavailable")
+      reasons.unshift("required capability is unavailable");
+    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
+  });
+}
+
+// packages/workit-core/src/core/task-context.ts
+function reconcileResume(view, observations = []) {
+  if (observations.length > 0)
+    return failure2("permission_denied", "worker observations require native host verification");
+  const candidate = captureCandidate(view.workspace.root, view.task.intent.data.scope, []);
+  if (!candidate.ok)
+    return candidate;
+  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
+  const blockers = [...view.task.progress.blockers];
+  if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
+    blockers.push({
+      reason: "worker state requires reconciliation",
+      dependentAction: "resume",
+      refs: []
+    });
+  return success(null, null, {
+    candidate: candidate.data,
+    staleEvidenceIds,
+    workerUpdates: [],
+    blockers,
+    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
+  });
+}
+var COMPACT_MAX_BYTES = 4096;
+var COMPACT_MAX_ITEMS = 8;
+var COMPACT_TEXT_BYTES = 128;
+var sensitiveUrl = /\bhttps?:\/\/[^/\s:@]+:[^@\s]+@/gi;
+var sensitiveValue = /(?:token|secret|password|passwd|api[-_ ]?key|private[-_ ]?key|authorization)\s*[:=]\s*(?:bearer\s+)?\S+|\bbearer\s+\S+/gi;
+var privateKey = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi;
+var compactText = (value, limit) => value === null ? null : value.replace(privateKey, "<redacted-private-key>").replace(sensitiveUrl, "<redacted-url>").replace(sensitiveValue, (match) => {
+  const separator = match.search(/[:=]/u);
+  if (separator >= 0)
+    return `${match.slice(0, separator)}=<redacted>`;
+  const space = match.search(/\s/u);
+  return `${match.slice(0, space)} <redacted>`;
+}).slice(0, limit);
+var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
+var compactTimestamp = (value) => `${value.slice(0, 19)}.${value.slice(20, -1).padEnd(9, "0")}`;
+var compactDecisionChoice = (entry) => {
+  const stated = entry.data.binding.statedChoice?.text;
+  const approved = entry.data.response === "approved" ? entry.data.binding.approvedContent : "";
+  const source = stated?.trim() || approved.trim() || null;
+  return compactText(source, COMPACT_TEXT_BYTES);
+};
+var compactReference = (ref) => {
+  if (ref.kind === "file")
+    return {
+      kind: "file",
+      path: compactText(ref.path, COMPACT_TEXT_BYTES) ?? ""
+    };
+  if (ref.kind === "record")
+    return {
+      kind: "record",
+      collection: ref.collection,
+      id: ref.id
+    };
+  return { kind: ref.kind };
+};
+function compactTaskContext(view) {
+  const decisions = view.task.decisions.slice().toSorted((left, right) => {
+    const leftAt = compactTimestamp(left.recordedAt);
+    const rightAt = compactTimestamp(right.recordedAt);
+    if (leftAt !== rightAt)
+      return leftAt > rightAt ? -1 : 1;
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+  }).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
+    id: entry.id,
+    purpose: entry.data.purpose,
+    status: entry.data.response,
+    digest: entry.data.digest,
+    choice: compactDecisionChoice(entry) || `task.inspect taskId=${view.task.id} view=full; decision=${entry.id}`,
+    references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
+  }));
+  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
+    id: method.id,
+    assurance: method.assurance,
+    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
+  })) : [];
+  const gaps = Array.from(new Set([
+    ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
+    ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
+    ...view.task.progress.blockers.map((entry) => entry.reason)
+  ])).toSorted().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
+  const context = {
+    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
+    status: view.task.status,
+    decisions,
+    methods,
+    gaps,
+    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
+  };
+  let encoded = JSON.stringify(context);
+  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
+    if (context.gaps.length)
+      context.gaps.pop();
+    else if (context.decisions.length)
+      context.decisions.pop();
+    else
+      context.methods.pop();
+    encoded = JSON.stringify(context);
+  }
+  if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
+    context.objective = compactText(context.objective, 64) ?? "";
+    context.nextAction = compactText(context.nextAction, 64);
+    encoded = JSON.stringify(context);
+  }
+  return encoded;
+}
+var exportDigest = (bundle) => sha256({
+  schemaVersion: bundle.schemaVersion,
+  exportedAt: bundle.exportedAt,
+  sourceWorkspaceId: bundle.sourceWorkspaceId,
+  task: bundle.task
+});
+// packages/workit-core/src/core/external-action.ts
+var chainStepSchema = union([
+  string2().min(1),
+  object({ branch: string2().min(1) }).strict(),
+  object({ pr: literal(true) }).strict()
+]);
+var externalActionSchema = discriminatedUnion("operation", [
+  object({
+    operation: literal("git.branch_setup"),
+    payload: object({
+      action: _enum(["setup", "reapply_stash"]).optional(),
+      sdd_dir: string2().optional(),
+      target_branch: string2().optional(),
+      stash: _enum(["yes", "no"]).optional(),
+      cwd: string2().min(1).optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("git.commit"),
+    payload: object({
+      message: string2().min(1).optional(),
+      plan_steps: array(chainStepSchema).min(1).max(32).optional(),
+      plan_branch: string2().min(1).optional(),
+      cwd: string2().min(1).optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("git.push"),
+    payload: object({ branch: string2().min(1).optional(), cwd: string2().min(1).optional() }).strict()
+  }).strict(),
+  object({
+    operation: literal("hosting.pull_request"),
+    payload: object({
+      title: string2().min(1),
+      body: string2().optional(),
+      draft: boolean2().optional(),
+      target_branch: string2().optional(),
+      babysit: boolean2().optional(),
+      cwd: string2().min(1).optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("hosting.merge"),
+    payload: object({
+      target_branch: string2().min(1).optional(),
+      source_branch: string2().min(1).optional(),
+      cwd: string2().min(1).optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("hosting.delete_branch"),
+    payload: object({ branch: string2().min(1), cwd: string2().min(1).optional() }).strict()
+  }).strict(),
+  object({
+    operation: literal("youtrack.update"),
+    payload: object({
+      issueId: string2().min(1),
+      markdown: string2().min(1),
+      minutes: number2().positive().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("youtrack.time"),
+    payload: object({
+      issueId: string2().min(1),
+      minutes: number2().positive(),
+      text: string2().optional(),
+      dateMs: number2().finite().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("youtrack.meeting"),
+    payload: object({
+      issueId: string2().min(1),
+      minutes: number2().positive(),
+      text: string2().min(1)
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("changelog.apply"),
+    payload: object({
+      entries: union([
+        record(string2(), array(string2())),
+        array(object({ category: string2().min(1), text: string2().min(1) }).strict())
+      ]).optional(),
+      path: string2().optional(),
+      normalize_only: boolean2().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("context.read"),
+    payload: object({
+      kind: _enum([
+        "git",
+        "pr",
+        "youtrack",
+        "github_issue",
+        "gitlab_issue",
+        "changelog",
+        "release",
+        "affected"
+      ]),
+      range: string2().optional(),
+      issueId: string2().optional(),
+      issueUrl: string2().optional(),
+      issueRef: string2().optional(),
+      mode: string2().optional(),
+      specPath: string2().optional(),
+      planPath: string2().optional(),
+      cwd: string2().min(1).optional()
+    }).strict()
+  }).strict()
+]);
+// packages/workit-core/src/core/task-engine.ts
+import { realpathSync as realpathSync6 } from "node:fs";
+
+// packages/workit-core/src/core/policy-resolver.ts
+var resolverInputSchema = object({
+  intent: intentSchema,
+  assessment: assessmentSchema,
+  constraints: array(constraintSchema),
+  prior: object({
+    decisions: array(decisionSchema),
+    findings: array(findingSchema),
+    requirements: array(requirementSchema)
+  }).strict(),
+  preferences: object({ fast: boolean2().optional(), thorough: boolean2().optional() }).strict().optional()
+}).strict();
+var compareCodeUnits3 = (left, right) => {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0;index < length; index += 1) {
+    const difference = left.charCodeAt(index) - right.charCodeAt(index);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.length - right.length;
 };
-function selectMethods(policy, capabilities) {
-  return Object.entries(METHODS).flatMap(([id, definition]) => {
-    const requirements = policy.requirements.filter((requirement) => methodMatches(definition, requirement));
-    if (requirements.length === 0)
-      return [];
-    const capability = assuranceFor(id, definition, capabilities);
-    const reasons = [
-      ...new Set(requirements.map((requirement) => requirement.reason)),
-      ...capability.reasons
-    ];
-    if (capability.assurance === "unavailable")
-      reasons.unshift("required capability is unavailable");
-    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
-  });
-}
-
-// packages/workit-core/src/core/task-context.ts
-function reconcileResume(view, observations = []) {
-  if (observations.length > 0)
-    return failure2("permission_denied", "worker observations require native host verification");
-  const candidate = captureCandidate(view.workspace.root, view.task.intent.data.scope, []);
-  if (!candidate.ok)
-    return candidate;
-  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
-  const blockers = [...view.task.progress.blockers];
-  if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
-    blockers.push({
-      reason: "worker state requires reconciliation",
-      dependentAction: "resume",
-      refs: []
+var stableUnique = (values) => [...new Set(values)].toSorted(compareCodeUnits3);
+var stableList = (values) => [...values].toSorted((left, right) => compareCodeUnits3(canonicalJson(left), canonicalJson(right)));
+var normalizedScope = (scope) => ({
+  description: scope.description,
+  paths: stableUnique(scope.paths),
+  exclusions: stableUnique(scope.exclusions)
+});
+var normalizedRefList = (values) => stableList(values);
+var normalizeAssessment = (assessment) => ({
+  facts: stableList(assessment.facts.map((fact) => ({ ...fact, refs: normalizedRefList(fact.refs) }))),
+  signals: Object.fromEntries(Object.entries(assessment.signals).map(([name, signal]) => [
+    name,
+    { ...signal, refs: normalizedRefList(signal.refs) }
+  ])),
+  consequences: stableList(assessment.consequences.map((consequence) => ({
+    ...consequence,
+    fact: { ...consequence.fact, refs: normalizedRefList(consequence.fact.refs) }
+  }))),
+  verification: stableList(assessment.verification.map((verification) => ({
+    ...verification,
+    scope: normalizedScope(verification.scope),
+    availableChecks: normalizedRefList(verification.availableChecks),
+    gaps: stableUnique(verification.gaps)
+  })))
+});
+var normalizeConstraint = (constraint) => ({
+  ...constraint,
+  source: constraint.source,
+  requires: stableList(constraint.requires.map((requirement) => ({
+    ...requirement,
+    scope: normalizedScope(requirement.scope),
+    refs: normalizedRefList(requirement.refs)
+  })))
+});
+var normalizeDecision = (decision) => ({
+  ...decision,
+  binding: {
+    ...decision.binding,
+    scope: normalizedScope(decision.binding.scope),
+    contentRefs: normalizedRefList(decision.binding.contentRefs)
+  },
+  requirementIds: stableUnique(decision.requirementIds)
+});
+var normalizeIntent = (intent) => ({
+  ...intent,
+  scope: normalizedScope(intent.scope),
+  authorityRefs: normalizedRefList(intent.authorityRefs)
+});
+var normalizePrior = (prior) => ({
+  decisions: stableList(prior.decisions.map(normalizeDecision)),
+  findings: stableList(prior.findings.map((finding) => ({
+    ...finding,
+    scope: normalizedScope(finding.scope),
+    refs: normalizedRefList(finding.refs),
+    resolution: finding.resolution ? {
+      ...finding.resolution,
+      evidenceIds: stableUnique(finding.resolution.evidenceIds),
+      decisionIds: stableUnique(finding.resolution.decisionIds)
+    } : null
+  }))),
+  requirements: stableList(prior.requirements.map((requirement) => ({
+    ...requirement,
+    scope: normalizedScope(requirement.scope)
+  })))
+});
+var invalidFields = (error) => ({
+  fields: error.issues.map((issue) => ({
+    path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
+    reason: issue.message
+  }))
+});
+function normalizeResolverInput(input) {
+  const parsed = resolverInputSchema.safeParse(input);
+  if (!parsed.success)
+    return failure2("invalid_input", "resolver input is invalid", invalidFields(parsed.error));
+  const value = parsed.data;
+  const signals = value.assessment.signals;
+  if (signals.behaviorChange.value === true && signals.mechanicalLowRisk.value === true)
+    return failure2("invalid_input", "behavioral change cannot be wholly mechanical", {
+      fields: [
+        {
+          path: "assessment.signals",
+          reason: "contradictory behaviorChange and mechanicalLowRisk"
+        }
+      ]
     });
-  return success(null, null, {
-    candidate: candidate.data,
-    staleEvidenceIds,
-    workerUpdates: [],
-    blockers,
-    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
-  });
+  const ids = value.constraints.map((constraint) => constraint.id);
+  if (new Set(ids).size !== ids.length)
+    return failure2("invalid_input", "constraint IDs must be unique", {
+      fields: [{ path: "constraints", reason: "duplicate constraint id" }]
+    });
+  if (value.preferences?.fast && value.preferences.thorough)
+    return failure2("invalid_input", "fast and thorough preferences contradict", {
+      fields: [{ path: "preferences", reason: "fast and thorough cannot both be enabled" }]
+    });
+  const normalized = {
+    intent: normalizeIntent(value.intent),
+    assessment: normalizeAssessment(value.assessment),
+    constraints: stableList(value.constraints.map(normalizeConstraint)),
+    prior: normalizePrior(value.prior),
+    ...value.preferences ? { preferences: { ...value.preferences } } : {},
+    policyVersion: POLICY_VERSION
+  };
+  return success(null, null, normalized);
 }
-var COMPACT_MAX_BYTES = 4096;
-var COMPACT_MAX_ITEMS = 8;
-var COMPACT_TEXT_BYTES = 128;
-var sensitiveUrl = /\bhttps?:\/\/[^/\s:@]+:[^@\s]+@/gi;
-var sensitiveValue = /(?:token|secret|password|passwd|api[-_ ]?key|private[-_ ]?key|authorization)\s*[:=]\s*(?:bearer\s+)?\S+|\bbearer\s+\S+/gi;
-var privateKey = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi;
-var compactText = (value, limit) => value === null ? null : value.replace(privateKey, "<redacted-private-key>").replace(sensitiveUrl, "<redacted-url>").replace(sensitiveValue, (match) => {
-  const separator = match.search(/[:=]/u);
-  if (separator >= 0)
-    return `${match.slice(0, separator)}=<redacted>`;
-  const space = match.search(/\s/u);
-  return `${match.slice(0, space)} <redacted>`;
-}).slice(0, limit);
-var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
-var compactTimestamp = (value) => `${value.slice(0, 19)}.${value.slice(20, -1).padEnd(9, "0")}`;
-var compactDecisionChoice = (entry) => {
-  const stated = entry.data.binding.statedChoice?.text;
-  const approved = entry.data.response === "approved" ? entry.data.binding.approvedContent : "";
-  const source = stated?.trim() || approved.trim() || null;
-  return compactText(source, COMPACT_TEXT_BYTES);
-};
-var compactReference = (ref) => {
-  if (ref.kind === "file")
-    return {
-      kind: "file",
-      path: compactText(ref.path, COMPACT_TEXT_BYTES) ?? ""
-    };
-  if (ref.kind === "record")
-    return {
-      kind: "record",
-      collection: ref.collection,
-      id: ref.id
-    };
-  return { kind: ref.kind };
-};
-function compactTaskContext(view) {
-  const decisions = view.task.decisions.slice().toSorted((left, right) => {
-    const leftAt = compactTimestamp(left.recordedAt);
-    const rightAt = compactTimestamp(right.recordedAt);
-    if (leftAt !== rightAt)
-      return leftAt > rightAt ? -1 : 1;
-    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
-  }).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
-    id: entry.id,
-    purpose: entry.data.purpose,
-    status: entry.data.response,
-    digest: entry.data.digest,
-    choice: compactDecisionChoice(entry) || `task.inspect taskId=${view.task.id} view=full; decision=${entry.id}`,
-    references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
-  }));
-  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
-    id: method.id,
-    assurance: method.assurance,
-    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
-  })) : [];
-  const gaps = Array.from(new Set([
-    ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
-    ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
-    ...view.task.progress.blockers.map((entry) => entry.reason)
-  ])).toSorted().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
-  const context = {
-    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
-    status: view.task.status,
-    decisions,
-    methods,
-    gaps,
-    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
+var requirement = (spec) => ({
+  ...spec,
+  id: requirementId({
+    ruleId: spec.ruleId,
+    scope: spec.scope,
+    satisfaction: spec.satisfaction,
+    before: spec.before,
+    dependentAction: spec.dependentAction
+  })
+});
+var signalReason = (input, name) => input.assessment.signals[name].reason;
+function resolveRequirements(input) {
+  const { signals } = input.assessment;
+  const scope = input.intent.scope;
+  const requirements = [];
+  const hasUnknownSignal = Object.values(signals).some((signal) => signal.value === "unknown");
+  const hasUnknownFact = [
+    ...input.assessment.facts,
+    ...input.assessment.consequences.map(({ fact }) => fact)
+  ].some((fact) => fact.basis === "unknown");
+  if (hasUnknownSignal || hasUnknownFact)
+    requirements.push(requirement({
+      ruleId: "consequential-unknown",
+      dimension: "investigation",
+      scope,
+      reason: `Resolve consequential uncertainty before the dependent action: ${[
+        ...Object.entries(signals).filter(([, signal]) => signal.value === "unknown").map(([name]) => name),
+        ...hasUnknownFact ? ["unknown fact"] : []
+      ].join(", ")}`,
+      satisfaction: "An observed or inferred fact resolves the uncertainty and records its supporting references.",
+      before: "dependent_action",
+      dependentAction: null,
+      acceptanceAllowed: false
+    }));
+  if (signals.productChoiceOpen.value === true)
+    requirements.push(requirement({
+      ruleId: "product-decision",
+      dimension: "decisions",
+      scope,
+      reason: `A consequential product choice remains open: ${signalReason(input, "productChoiceOpen")}`,
+      satisfaction: "Present the material alternatives and record the user's decision before the dependent action.",
+      before: "dependent_action",
+      dependentAction: null,
+      acceptanceAllowed: false
+    }));
+  const independentBehaviorReview = input.preferences?.thorough === true || input.assessment.consequences.some((consequence) => ["security", "data", "public_contract", "operations"].includes(consequence.area));
+  if (signals.behaviorChange.value === true)
+    requirements.push(requirement({
+      ruleId: "behavioral-verification",
+      dimension: "testing",
+      scope,
+      reason: `Behavior, side effects, permissions, or data handling may change: ${signalReason(input, "behaviorChange")}`,
+      satisfaction: "A useful behavioral check passes against the affected behavior and current candidate.",
+      before: "close",
+      dependentAction: null,
+      acceptanceAllowed: false
+    }), requirement({
+      ruleId: independentBehaviorReview ? "fresh-context-review" : "self-review",
+      dimension: "review",
+      scope,
+      reason: independentBehaviorReview ? "Consequential behavior or the thorough preference requires fresh-context review." : "Bounded behavior changes use self-review unless consequential risks or trusted rules require more.",
+      satisfaction: independentBehaviorReview ? "A separate review context examines the current candidate and records its result." : "The lead reviews the resulting diff and records the relevant scope and checks.",
+      before: "close",
+      dependentAction: null,
+      acceptanceAllowed: !independentBehaviorReview
+    }));
+  else if (signals.mechanicalLowRisk.value === true)
+    requirements.push(requirement({
+      ruleId: "mechanical-existing-checks",
+      dimension: "verification",
+      scope,
+      reason: `The change is demonstrably mechanical and low-risk: ${signalReason(input, "mechanicalLowRisk")}`,
+      satisfaction: "Run the relevant existing checks for affected consumers; do not add tautological tests.",
+      before: "close",
+      dependentAction: null,
+      acceptanceAllowed: true
+    }), requirement({
+      ruleId: input.preferences?.thorough ? "fresh-context-review" : "self-review",
+      dimension: "review",
+      scope,
+      reason: input.preferences?.thorough ? "The thorough preference upgrades mechanical self-review to fresh-context review." : "Mechanical low-risk work uses self-review rather than mandatory fresh-context review.",
+      satisfaction: input.preferences?.thorough ? "A separate review context examines the current candidate and records its result." : "The lead reviews the resulting diff and records the relevant scope and checks.",
+      before: "close",
+      dependentAction: null,
+      acceptanceAllowed: !input.preferences?.thorough
+    }));
+  if (signals.behaviorChange.value === true || signals.mechanicalLowRisk.value === true)
+    requirements.push(requirement({
+      ruleId: "pre-pr-cleanup",
+      dimension: "verification",
+      scope,
+      reason: "Implementation output must be deslopped before it is delivered.",
+      satisfaction: "Run the workit-deslop pass and record passing check evidence, or record an approved limitation decision waiving cleanup.",
+      before: "dependent_action",
+      dependentAction: "hosting.pull_request",
+      acceptanceAllowed: true
+    }));
+  if (signals.durableAgreementNeeded.value === true)
+    requirements.push(requirement({
+      ruleId: "durable-spec",
+      dimension: "artifacts",
+      scope,
+      reason: `The work needs a durable agreement about intended behavior: ${signalReason(input, "durableAgreementNeeded")}`,
+      satisfaction: "Record the agreed behavior in a durable specification before implementation writes.",
+      before: "write",
+      dependentAction: null,
+      acceptanceAllowed: true
+    }));
+  if (signals.coordinationPlanNeeded.value === true)
+    requirements.push(requirement({
+      ruleId: "coordination-plan",
+      dimension: "continuity",
+      scope,
+      reason: `Dependencies, sequencing, or resumption need durable coordination: ${signalReason(input, "coordinationPlanNeeded")}`,
+      satisfaction: "Record useful sequencing, dependencies, and the next action in a compact plan.",
+      before: "dependent_action",
+      dependentAction: null,
+      acceptanceAllowed: true
+    }));
+  if (signals.helperUseful.value === true && !input.preferences?.fast)
+    requirements.push(requirement({
+      ruleId: "helper-usefulness",
+      dimension: "delegation",
+      scope,
+      reason: `Independent judgment or investigation justifies a scoped helper: ${signalReason(input, "helperUseful")}`,
+      satisfaction: "Use a bounded helper only for the independent objective and reconcile its result.",
+      before: "dependent_action",
+      dependentAction: null,
+      acceptanceAllowed: true
+    }));
+  for (const constraint of input.constraints)
+    for (const obligation of constraint.requires) {
+      const dimension = obligation.method ?? (obligation.kind === "check" ? "verification" : obligation.kind === "decision" ? "decisions" : "challenge");
+      requirements.push(requirement({
+        ruleId: `project-constraint:${constraint.id}:${obligation.kind}:${sha256({
+          kind: obligation.kind,
+          scope: normalizedScope(obligation.scope),
+          refs: normalizedRefList(obligation.refs),
+          method: obligation.method,
+          before: obligation.before,
+          dependentAction: obligation.dependentAction
+        })}`,
+        dimension,
+        scope: obligation.scope,
+        reason: `${constraint.kind} constraint requires ${obligation.kind}: ${constraint.statement}`,
+        satisfaction: `Satisfy the constraint obligation using its referenced ${obligation.kind}.`,
+        before: obligation.before,
+        dependentAction: obligation.dependentAction,
+        acceptanceAllowed: constraint.acceptanceAllowed && obligation.kind !== "decision"
+      }));
+    }
+  const seen = new Set;
+  return requirements.filter((item) => {
+    if (seen.has(item.id))
+      return false;
+    seen.add(item.id);
+    return true;
+  });
+}
+function resolvePolicy(input) {
+  const normalized = normalizeResolverInput(input);
+  if (!normalized.ok)
+    return normalized;
+  const requirements = resolveRequirements(normalized.data);
+  const policy = {
+    policyVersion: POLICY_VERSION,
+    inputDigest: sha256(canonicalJson(normalized.data)),
+    requirements
   };
-  let encoded = JSON.stringify(context);
-  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
-    if (context.gaps.length)
-      context.gaps.pop();
-    else if (context.decisions.length)
-      context.decisions.pop();
-    else
-      context.methods.pop();
-    encoded = JSON.stringify(context);
-  }
-  if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
-    context.objective = compactText(context.objective, 64) ?? "";
-    context.nextAction = compactText(context.nextAction, 64);
-    encoded = JSON.stringify(context);
-  }
-  return encoded;
+  const parsed = policySchema.safeParse(policy);
+  if (!parsed.success)
+    return failure2("invalid_input", "resolved policy is invalid", invalidFields(parsed.error));
+  return success(null, null, parsed.data);
+}
+function diffPolicy(previous, next, reason, now) {
+  if (!policySchema.safeParse(previous).success && previous !== null)
+    throw new TypeError("previous policy is invalid");
+  if (!policySchema.safeParse(next).success)
+    throw new TypeError("next policy is invalid");
+  const oldIds = new Set(previous?.requirements.map((item) => item.id) ?? []);
+  const newIds = new Set(next.requirements.map((item) => item.id));
+  const added = [...newIds].filter((id) => !oldIds.has(id)).toSorted(compareCodeUnits3);
+  const retired = [...oldIds].filter((id) => !newIds.has(id)).toSorted(compareCodeUnits3);
+  if (added.length === 0 && retired.length === 0)
+    return null;
+  const normalizedReason = reason.trim();
+  const changeReason = retired.length ? `${normalizedReason || "policy reassessed"} (retired: ${retired.join(",")})` : normalizedReason || "policy reassessed";
+  const change = {
+    recordedAt: now,
+    fromInputDigest: previous?.inputDigest ?? null,
+    toInputDigest: next.inputDigest,
+    added,
+    retired,
+    reason: changeReason
+  };
+  const parsed = policyChangeSchema.safeParse(change);
+  if (!parsed.success)
+    throw new TypeError("policy change is invalid");
+  return parsed.data;
 }
-var exportDigest = (bundle) => sha256({
-  schemaVersion: bundle.schemaVersion,
-  exportedAt: bundle.exportedAt,
-  sourceWorkspaceId: bundle.sourceWorkspaceId,
-  task: bundle.task
-});
 
 // packages/workit-core/src/core/task-engine.ts
 var provenance = (context, kind = context.provenanceKind ?? "host_observed") => ({
@@ -20067,6 +20591,29 @@ var applyWorkerLifecycle = (input) => {
   return updated ? success(changed.data.task.revision, changed.data.workspace.revision, updated) : failure2("recovery_required", "worker disappeared during lifecycle observation");
 };
 var refsWithinScope = (refs, scope) => refs.every((ref) => ref.kind !== "file" || bindingCovers(scope, { description: "", paths: [ref.path], exclusions: [] }));
+var REVISION_RETRY_ATTEMPTS = 8;
+var retryPause = new Int32Array(new SharedArrayBuffer(4));
+var filledRevisions = (request) => {
+  const value = typeof request === "object" && request !== null ? request : {};
+  return {
+    task: value.expectedRevision === undefined,
+    workspace: value.expectedWorkspaceRevision === undefined
+  };
+};
+var filledConflict = (result, filled) => !result.ok && result.code === "revision_conflict" && (("actualRevision" in result.details) && filled.task || ("actualWorkspaceRevision" in result.details) && filled.workspace);
+var retryFilledRevisions = (filled, run) => {
+  if (!filled.task && !filled.workspace)
+    return run();
+  let result = run();
+  const deadline = Date.now() + defaultLockTimeout();
+  for (let attempt = 1;filledConflict(result, filled); attempt += 1) {
+    if (attempt >= REVISION_RETRY_ATTEMPTS || Date.now() >= deadline)
+      return failure2("busy", "records kept changing under concurrent writers; retry the call");
+    Atomics.wait(retryPause, 0, 0, Math.floor(Math.random() * 4 * attempt) + 1);
+    result = run();
+  }
+  return result;
+};
 var trustedNow = (context) => typeof context.now === "function" ? context.now() : context.now;
 var mapRef = (ref, ids) => {
   if (ref.kind !== "record")
@@ -20314,6 +20861,9 @@ class WorkitCore {
     if (input.expectedWorkspaceRevision === undefined)
       input.expectedWorkspaceRevision = workspace ? workspace.revision : null;
   }
+  retryOmittedRevisions(request, run) {
+    return retryFilledRevisions(filledRevisions(request), run);
+  }
   helperEntry(task, requireSession = false, requireActive = false) {
     const workerId = this.context.workerId ?? null;
     if (workerId === null)
@@ -20345,6 +20895,9 @@ class WorkitCore {
     return null;
   }
   state(request) {
+    return request?.action === "import" ? this.retryOmittedRevisions(request, () => this.stateOnce(request)) : this.stateOnce(request);
+  }
+  stateOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -20446,6 +20999,9 @@ class WorkitCore {
     });
   }
   task(request) {
+    return this.retryOmittedRevisions(request, () => this.taskOnce(request));
+  }
+  taskOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -20545,6 +21101,9 @@ class WorkitCore {
     }
   }
   policy(request) {
+    return this.retryOmittedRevisions(request, () => this.policyOnce(request));
+  }
+  policyOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -20591,6 +21150,9 @@ class WorkitCore {
     return success(changed.data.revision, null, changed.data.policy);
   }
   evidence(request) {
+    return this.retryOmittedRevisions(request, () => this.evidenceOnce(request));
+  }
+  evidenceOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -20675,6 +21237,23 @@ class WorkitCore {
   observeStandingDecision(request) {
     return this.recordDecision(request, undefined, true, true);
   }
+  commitTask(taskId, expected, filled, recheck, update) {
+    let revision = expected;
+    let first = true;
+    return retryFilledRevisions({ task: filled, workspace: false }, () => {
+      if (!first) {
+        const fresh = this.store.readTask(taskId);
+        if (!fresh.ok)
+          return fresh;
+        const checked = recheck(fresh.data);
+        if (!checked.ok)
+          return checked;
+        revision = fresh.data.revision;
+      }
+      first = false;
+      return this.store.mutateTask(taskId, revision, update, trustedNow(this.context));
+    });
+  }
   recordDecision(request, nativeObservation, nativeRequired = false, standing = false) {
     const root = this.contextRootError();
     if (!root.ok)
@@ -20699,6 +21278,7 @@ class WorkitCore {
       return task;
     if ((this.context.workerId ?? null) !== null)
       return failure2("permission_denied", "helpers cannot record or revoke decisions");
+    const filled = input.expectedRevision === undefined;
     this.fillRevisions(input, task.data);
     if (input.action === "record") {
       if (task.data.status === "closed")
@@ -20747,7 +21327,20 @@ class WorkitCore {
       const nativeProvenance = native?.ok ? retireNativeAuthority(native.data) : null;
       if (native?.ok && !nativeProvenance)
         return failure2("permission_denied", "native decision authority was retired");
-      const changed = this.store.mutateTask(task.data.id, input.expectedRevision, (current, mutation) => {
+      let standingProvenance = standingApproval?.ok === true ? standingApproval.data : null;
+      const recheck = (fresh) => {
+        if (fresh.status === "closed")
+          return failure2("invalid_transition", "closed task cannot record a decision");
+        if (!standingProvenance)
+          return success(null, null, null);
+        const again = verifyStandingApproval(this.store.root, fresh, this.context.caller, input.binding);
+        if (again.ok)
+          standingProvenance = again.data;
+        return again;
+      };
+      const changed = this.commitTask(task.data.id, input.expectedRevision, filled, recheck, (current, mutation) => {
+        if (current.status === "closed")
+          return failure2("invalid_transition", "closed task cannot record a decision");
         const latestContent = verifyDecisionContent(this.store, input.binding);
         if (!latestContent.ok)
           return latestContent;
@@ -20759,14 +21352,14 @@ class WorkitCore {
         const entry = {
           id: newId(),
           recordedAt: mutation.now,
-          provenance: standingApproval?.ok === true ? standingApproval.data : nativeProvenance ?? provenance(this.context, "agent_reported"),
+          provenance: standingProvenance ?? nativeProvenance ?? provenance(this.context, "agent_reported"),
           data
         };
         return success(mutation.revision, null, {
           ...current,
           decisions: [...current.decisions, entry]
         });
-      }, trustedNow(this.context));
+      });
       if (!changed.ok)
         return changed;
       return success(changed.data.revision, null, changed.data.decisions.at(-1));
@@ -20780,7 +21373,7 @@ class WorkitCore {
       return failure2("invalid_transition", "decision is already revoked");
     if (decision.data.consumption)
       return failure2("permission_denied", "consumed decision cannot be revoked");
-    const changed = this.store.mutateTask(task.data.id, input.expectedRevision, (current, mutation) => {
+    const changed = this.commitTask(task.data.id, input.expectedRevision, filled, () => success(null, null, null), (current, mutation) => {
       const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
       if (!entry)
         return failure2("not_found", "decision not found");
@@ -20797,13 +21390,16 @@ class WorkitCore {
         ...current,
         decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? updated : candidate)
       });
-    }, trustedNow(this.context));
+    });
     if (!changed.ok)
       return changed;
     const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
     return entry ? success(changed.data.revision, null, entry) : failure2("recovery_required", "decision disappeared");
   }
   finding(request) {
+    return this.retryOmittedRevisions(request, () => this.findingOnce(request));
+  }
+  findingOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -20927,6 +21523,9 @@ class WorkitCore {
     return entry ? success(changed.data.revision, null, entry) : failure2("recovery_required", "finding disappeared");
   }
   worker(request) {
+    return this.retryOmittedRevisions(request, () => this.workerOnce(request));
+  }
+  workerOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -21274,6 +21873,9 @@ class WorkitCore {
     return applied;
   }
   writer(request) {
+    return this.retryOmittedRevisions(request, () => this.writerOnce(request));
+  }
+  writerOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -21876,122 +22478,6 @@ class WorkitCore {
     return this.summary(changed.data.task);
   }
 }
-
-// packages/workit-core/src/core/session-context.ts
-var cache = new Map;
-// packages/workit-core/src/core/external-action.ts
-var chainStepSchema = union([
-  string2().min(1),
-  object({ branch: string2().min(1) }).strict(),
-  object({ pr: literal(true) }).strict()
-]);
-var externalActionSchema = discriminatedUnion("operation", [
-  object({
-    operation: literal("git.branch_setup"),
-    payload: object({
-      action: _enum(["setup", "reapply_stash"]).optional(),
-      sdd_dir: string2().optional(),
-      target_branch: string2().optional(),
-      stash: _enum(["yes", "no"]).optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("git.commit"),
-    payload: object({
-      message: string2().min(1).optional(),
-      plan_steps: array(chainStepSchema).min(1).max(32).optional(),
-      plan_branch: string2().min(1).optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("git.push"),
-    payload: object({ branch: string2().min(1).optional(), cwd: string2().min(1).optional() }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.pull_request"),
-    payload: object({
-      title: string2().min(1),
-      body: string2().optional(),
-      draft: boolean2().optional(),
-      target_branch: string2().optional(),
-      babysit: boolean2().optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.merge"),
-    payload: object({
-      target_branch: string2().min(1).optional(),
-      source_branch: string2().min(1).optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.delete_branch"),
-    payload: object({ branch: string2().min(1), cwd: string2().min(1).optional() }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.update"),
-    payload: object({
-      issueId: string2().min(1),
-      markdown: string2().min(1),
-      minutes: number2().positive().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.time"),
-    payload: object({
-      issueId: string2().min(1),
-      minutes: number2().positive(),
-      text: string2().optional(),
-      dateMs: number2().finite().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.meeting"),
-    payload: object({
-      issueId: string2().min(1),
-      minutes: number2().positive(),
-      text: string2().min(1)
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("changelog.apply"),
-    payload: object({
-      entries: union([
-        record(string2(), array(string2())),
-        array(object({ category: string2().min(1), text: string2().min(1) }).strict())
-      ]).optional(),
-      path: string2().optional(),
-      normalize_only: boolean2().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("context.read"),
-    payload: object({
-      kind: _enum([
-        "git",
-        "pr",
-        "youtrack",
-        "github_issue",
-        "gitlab_issue",
-        "changelog",
-        "release",
-        "affected"
-      ]),
-      range: string2().optional(),
-      issueId: string2().optional(),
-      issueUrl: string2().optional(),
-      issueRef: string2().optional(),
-      mode: string2().optional(),
-      specPath: string2().optional(),
-      planPath: string2().optional(),
-      cwd: string2().min(1).optional()
-    }).strict()
-  }).strict()
-]);
 // packages/workit-core/src/core.ts
 var revision2 = /^[A-Za-z0-9@][A-Za-z0-9@._/~^{}-]*$/;
 function gitRevisionParts(value) {
@@ -22035,7 +22521,7 @@ function resolveInside(root, candidate) {
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync7(root);
-  const result = spawnSync3(executable, args, {
+  const result = spawnSync4(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -24495,9 +24981,9 @@ var applyPatterns = (value) => {
 var redactSecrets = (value) => applyPatterns(value);
 
 // packages/workit-core/src/core/pr-create.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path12 from "node:path";
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
   return m ? m[1] : String(value).trim().replace(/^#/, "");
@@ -24510,7 +24996,7 @@ function whichOnPath(tool) {
     for (const name of names) {
       const candidate = path12.join(dir, name);
       try {
-        fs8.accessSync(candidate, fs8.constants.X_OK);
+        fs9.accessSync(candidate, fs9.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -24519,7 +25005,7 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 var pushRemote = (cwd) => {
-  const result = spawnSync4("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync5("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -24530,7 +25016,7 @@ var pushRemote = (cwd) => {
 };
 
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
 import path13 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
@@ -24559,7 +25045,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync5("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync6("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -24732,7 +25218,7 @@ var documentationFiles = (cwd) => {
   walk(cwd, 1);
   return matches.toSorted().slice(0, 200);
 };
-var readTrimmed = (file, maxLines) => {
+var readTrimmed2 = (file, maxLines) => {
   if (!existsSync6(file))
     return "";
   const lines = readFileSync7(file, "utf8").split(`
@@ -24799,7 +25285,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed(path13.join(cwd, template), 220);
+    stdout += readTrimmed2(path13.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -24871,7 +25357,7 @@ function changelogContext(root, range) {
   stdout += printSection("Existing CHANGELOG.md");
   const changelogPath = path13.join(cwd, "CHANGELOG.md");
   if (existsSync6(changelogPath)) {
-    stdout += readTrimmed(changelogPath, 260) + `
+    stdout += readTrimmed2(changelogPath, 260) + `
 `;
   } else {
     stdout += `CHANGELOG.md not found.
@@ -24913,7 +25399,7 @@ function docsRefreshContext(root, range) {
   stdout += printSection("README Preview");
   const readme = path13.join(cwd, "README.md");
   if (existsSync6(readme)) {
-    stdout += readTrimmed(readme, 220) + `
+    stdout += readTrimmed2(readme, 220) + `
 `;
   } else {
     stdout += `README.md not found.
@@ -25000,7 +25486,7 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 var repoPathFromRemote = (remote) => {
   let rest = (remote || "").trim().replace(/\/+$/, "");
   if (!rest)
@@ -25021,7 +25507,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync6(bin, args, {
+    const out = spawnSync7(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -25099,7 +25585,7 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 
 // packages/workit-core/src/core/youtrack.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import path14 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
@@ -25118,17 +25604,17 @@ var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? p
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs9.statSync(p).mode & 511;
+  const mode = fs10.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs9.existsSync(cfgPath)) {
+  if (!fs10.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs9.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs10.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -25139,11 +25625,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs9.existsSync(cfgPath))
+  if (!fs10.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs9.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs10.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -25183,11 +25669,11 @@ var youTrackToken = () => {
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
   const tokenPath = tokenFile ? path14.isAbsolute(tokenFile) ? path14.resolve(tokenFile) : path14.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs9.existsSync(tokenPath))
+  if (!tokenPath || !fs10.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs9.readFileSync(tokenPath, "utf8").trim();
+  const token = fs10.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -25252,9 +25738,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs9.existsSync(full))
+    if (!fs10.existsSync(full))
       continue;
-    const text = fs9.readFileSync(full, "utf8");
+    const text = fs10.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -25797,123 +26283,166 @@ async function runStdioServer(host, contextProvider = defaultContextProvider(hos
   await server.connect(new StdioServerTransport);
   return server;
 }
+// packages/workit-core/src/hooks/descriptor.ts
+var support = (descriptor, axis) => {
+  if (axis.startsWith("event:"))
+    return descriptor.events[axis.slice("event:".length)].support;
+  if (axis === "shellPolicy.deny")
+    return descriptor.shellPolicy.deny;
+  if (axis === "stopControl" || axis === "shellAvailable")
+    return descriptor[axis];
+  const [group, key] = axis.split(".");
+  return descriptor[group][key];
+};
+var usable = (value) => value === "native" || value === "partial";
+var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map((rule) => {
+  const levels = rule.requires.map((axis) => support(descriptor, axis));
+  const available = rule.assurance !== "unavailable" && levels.every(usable) && (rule.observed ?? []).every((flag) => observed[flag] === true);
+  const assurance = !available ? "unavailable" : rule.assurance === "enforced" && (levels.length === 0 || levels.some((level) => level !== "native")) ? "agent_guided" : rule.assurance;
+  return {
+    name: rule.name,
+    surface: rule.surface,
+    assurance,
+    reason: assurance === "unavailable" ? rule.unavailableReason ?? rule.reason : rule.reason,
+    refs: rule.refs.map((handle) => ({ kind: "host", host: descriptor.host, handle }))
+  };
+});
+// packages/workit-core/src/hooks/context.ts
+var cache = new Map;
+// packages/workit-core/src/hooks/handle.ts
+var offered = new Set;
+// packages/workit-core/src/hooks/hosts/fields.ts
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
 
-// packages/workit-codex/hooks/workit-hook.ts
-var ref = (host, handle) => ({ kind: "host", host, handle });
+// packages/workit-core/src/hooks/hosts/claude-code.ts
+var SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
+var SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
+var CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit", "SubagentStart"]);
+
+// packages/workit-core/src/hooks/hosts/codex.ts
 function detectCodexSurface(env) {
   return env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || Boolean(env.CODEX_ELECTRON_RESOURCES_PATH) ? "codex_desktop" : "codex_cli";
 }
-var codexCapabilities = (host, availability = {}) => {
-  const has = (key) => availability[key] === true;
-  return [
+var undocumented = { support: "undocumented", native: null };
+var CODEX_DESCRIPTOR = {
+  host: "codex_cli",
+  label: "Codex",
+  verifiedAgainst: "codex-cli 0.153.4; Codex Desktop 26.901.20858",
+  docs: ["https://developers.openai.com/codex/hooks"],
+  transport: "hook-process",
+  events: {
+    "session.start": { support: "native", native: "SessionStart" },
+    "context.turn": undocumented,
+    "shell.pre": { support: "native", native: "PreToolUse" },
+    "tool.pre": { support: "native", native: "PreToolUse" },
+    "shell.post": undocumented,
+    "subagent.start": { support: "native", native: "SubagentStart" },
+    "subagent.stop": { support: "native", native: "SubagentStop" },
+    "prompt.submit": undocumented,
+    "compact.pre": { support: "none", native: null },
+    stop: undocumented
+  },
+  shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
+  context: {
+    sessionStart: "native",
+    perTurn: "undocumented",
+    afterCompact: "native",
+    task: "single-active"
+  },
+  subagents: {
+    identity: "native",
+    parentBinding: "none",
+    blockStart: "none",
+    worktreeIsolation: "undocumented",
+    maxConcurrency: "undocumented"
+  },
+  provenance: { sessionId: "native", agentIdOnTool: "partial", postToolObserve: "undocumented" },
+  interaction: { questions: "none", writeBoundary: "partial" },
+  stopControl: "undocumented",
+  shellAvailable: "native",
+  perEventCost: "low",
+  capabilities: [
     {
       name: "interactive_decision",
       surface: "Question",
+      refs: ["Question"],
+      requires: [],
       assurance: "agent_guided",
-      reason: "Codex hooks expose no native arbitrary-question answer receipt",
-      refs: [ref(host, "Question")]
+      reason: "Codex hooks expose no native arbitrary-question answer receipt"
     },
     {
       name: "known_product_writes",
       surface: "PreToolUse",
+      refs: ["PreToolUse"],
+      requires: [],
       assurance: "unavailable",
-      reason: "file writes are host-policy; PreToolUse allows write tools",
-      refs: [ref(host, "PreToolUse")]
+      reason: "file writes are host-policy; PreToolUse allows write tools"
     },
     {
       name: "fresh-context-review",
       surface: "SubagentStart",
-      assurance: has("subagentStart") ? "agent_guided" : "unavailable",
-      reason: has("subagentStart") ? "independent review runs as a bounded subagent; evidence evaluation enforces reviewer exclusivity, and stops remain untrusted" : "Codex subagent lifecycle hooks are unavailable for independent review",
-      refs: [ref(host, "SubagentStart")]
+      refs: ["SubagentStart"],
+      requires: ["event:subagent.start"],
+      observed: ["subagent.start"],
+      assurance: "agent_guided",
+      reason: "independent review runs as a bounded subagent; evidence evaluation enforces reviewer exclusivity, and stops remain untrusted",
+      unavailableReason: "Codex subagent lifecycle hooks are unavailable for independent review"
     },
     {
       name: "native_subagents",
       surface: "SubagentStart/SubagentStop",
-      assurance: has("subagentStart") && has("subagentStop") ? "agent_guided" : "unavailable",
-      reason: has("subagentStart") && has("subagentStop") ? "Codex reports stable child identities, but cannot block creation or bind a writer" : "Codex subagent lifecycle hooks are untrusted or incomplete",
-      refs: [ref(host, "SubagentStart"), ref(host, "SubagentStop")]
+      refs: ["SubagentStart", "SubagentStop"],
+      requires: ["event:subagent.start", "event:subagent.stop"],
+      observed: ["subagent.start", "subagent.stop"],
+      assurance: "agent_guided",
+      reason: "Codex reports stable child identities, but cannot block creation or bind a writer",
+      unavailableReason: "Codex subagent lifecycle hooks are untrusted or incomplete"
     },
     {
       name: "native_subagent_start",
       surface: "SubagentStart",
-      assurance: has("subagentStart") ? "agent_guided" : "unavailable",
-      reason: has("subagentStart") ? "SubagentStart supplies identity and bounded read-only guidance; continue:false cannot stop creation" : "SubagentStart hook is untrusted or unavailable",
-      refs: [ref(host, "SubagentStart")]
+      refs: ["SubagentStart"],
+      requires: ["event:subagent.start"],
+      observed: ["subagent.start"],
+      assurance: "agent_guided",
+      reason: "SubagentStart supplies identity and bounded read-only guidance; continue:false cannot stop creation",
+      unavailableReason: "SubagentStart hook is untrusted or unavailable"
     },
     {
       name: "arbitrary_shell_write",
       surface: "unobservable_shell",
+      refs: ["PreToolUse"],
+      requires: [],
       assurance: "unavailable",
-      reason: "Only covered known tool inputs are interceptable; specialized and write_stdin paths are not complete",
-      refs: [ref(host, "PreToolUse")]
+      reason: "Only covered known tool inputs are interceptable; specialized and write_stdin paths are not complete"
     },
     {
       name: "compact_context",
       surface: "SessionStart",
-      assurance: has("sessionStart") ? "agent_guided" : "unavailable",
-      reason: "SessionStart source=compact is the single restore path",
-      refs: [ref(host, "SessionStart")]
+      refs: ["SessionStart"],
+      requires: ["context.afterCompact"],
+      observed: ["session.start"],
+      assurance: "agent_guided",
+      reason: "SessionStart source=compact is the single restore path"
     }
-  ];
-};
-var events = new Set([
-  "SessionStart",
-  "PreToolUse",
-  "SubagentStart",
-  "SubagentStop"
-]);
-var allowedKeys = {
-  SessionStart: new Set([
-    "hook_event_name",
-    "session_id",
-    "cwd",
-    "model",
-    "permission_mode",
-    "transcript_path",
-    "source"
-  ]),
-  PreToolUse: new Set([
-    "hook_event_name",
-    "session_id",
-    "cwd",
-    "model",
-    "permission_mode",
-    "transcript_path",
-    "turn_id",
-    "tool_name",
-    "tool_input",
-    "tool_use_id",
-    "agent_id",
-    "agent_type"
-  ]),
-  SubagentStart: new Set([
-    "hook_event_name",
-    "session_id",
-    "cwd",
-    "model",
-    "permission_mode",
-    "transcript_path",
-    "turn_id",
-    "agent_id",
-    "agent_type"
-  ]),
-  SubagentStop: new Set([
-    "hook_event_name",
-    "session_id",
-    "cwd",
-    "model",
-    "permission_mode",
-    "transcript_path",
-    "turn_id",
-    "agent_id",
-    "agent_type",
-    "agent_transcript_path",
-    "last_assistant_message",
-    "stop_hook_active"
-  ])
+  ]
 };
-var historyOfferSessions = new Set;
+var codexDescriptor = (host) => ({ ...CODEX_DESCRIPTOR, host });
+var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
+var SOURCES2 = new Set(["startup", "resume", "clear", "compact"]);
+
+// packages/workit-core/src/hooks/hosts/cursor.ts
+var BLOCKING = new Set(["preToolUse", "beforeShellExecution", "subagentStart"]);
+
+// packages/workit-core/src/hooks/run.ts
+if (false) {}
+// packages/workit-codex/hooks/workit-hook.ts
+var codexCapabilities = (host, availability = {}) => capabilitiesFor(codexDescriptor(host), {
+  "session.start": availability.sessionStart,
+  "shell.pre": availability.preToolUse,
+  "subagent.start": availability.subagentStart,
+  "subagent.stop": availability.subagentStop
+});
 if (false)
   ;