@brainervirus/workit-cursor 8.12.3 → 8.13.1

package/dist/mcp-server.js

@@ -6622,15 +6622,15 @@ var require_dist = __commonJS(function(exports, module) {
 
 // packages/workit-cursor/mcp/run-server.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 
 // packages/workit-mcp/src/index.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path22 from "node:path";
+import path23 from "node:path";
 
 // packages/workit-mcp/src/server.ts
 import { existsSync as existsSync8, readFileSync as readFileSync6, realpathSync as realpathSync6 } from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 
 // node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
@@ -16582,7 +16582,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync14 } from "node:child_process";
 import { existsSync as existsSync7, realpathSync as realpathSync5 } from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -17837,9 +17837,9 @@ function parseAdvertisedOperation(family, input, host) {
   });
 }
 // packages/workit-core/src/core/task-store.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
-import * as fs7 from "node:fs";
-import path7 from "node:path";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
+import * as fs8 from "node:fs";
+import path8 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -18442,6 +18442,11 @@ function acquireFileLockSync(targetPath, options) {
     }
   }
 }
+// packages/workit-core/src/host-session.ts
+import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import fs5 from "node:fs";
+import path5 from "node:path";
+
 // packages/workit-core/src/core/logger.ts
 import os from "node:os";
 import path3 from "node:path";
@@ -18824,30 +18829,113 @@ function hostSessionFromEnv(env) {
   }
   return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
 }
+var hash = (value) => createHash3("sha256").update(value).digest("hex").slice(0, 32);
+var userIssuedRoot = () => path5.join(resolveStateDir(), "issued");
+var userTokenRoot = () => path5.join(resolveStateDir(), "issued-tokens");
+function migrateRepoIssued(cwd) {
+  if (cwd === undefined)
+    return;
+  let old;
+  try {
+    const location = resolveStore(cwd);
+    if (location instanceof Error)
+      return;
+    old = path5.join(location.dir, "hooks", "issued");
+    if (!fs5.existsSync(old))
+      return;
+  } catch {
+    return;
+  }
+  for (const lead of safeList(old)) {
+    try {
+      const from = path5.join(old, lead);
+      if (!fs5.statSync(from).isDirectory())
+        continue;
+      const to = path5.join(userIssuedRoot(), lead);
+      fs5.mkdirSync(to, { recursive: true, mode: 448 });
+      for (const id of fs5.readdirSync(from)) {
+        try {
+          fs5.copyFileSync(path5.join(from, id), path5.join(to, id), fs5.constants.COPYFILE_EXCL);
+        } catch (error) {
+          if (error.code !== "EEXIST")
+            throw error;
+        }
+        fs5.rmSync(path5.join(from, id), { force: true });
+      }
+      removeIfEmpty(from);
+    } catch {}
+  }
+  removeIfEmpty(old);
+}
+var safeList = (dir) => {
+  try {
+    return fs5.readdirSync(dir);
+  } catch {
+    return [];
+  }
+};
+var removeIfEmpty = (dir) => {
+  try {
+    fs5.rmdirSync(dir);
+  } catch {}
+};
+var issuedRecord = (cwd, claimed) => {
+  const cut = claimed.lastIndexOf(":");
+  if (cut <= 0)
+    return null;
+  migrateRepoIssued(cwd);
+  try {
+    return fs5.readFileSync(path5.join(userIssuedRoot(), hash(claimed.slice(0, cut)), hash(claimed)), "utf8");
+  } catch {
+    return null;
+  }
+};
+var TOKEN_HASH = /^([0-9a-f]{64})$/mu;
+var issuedToken = (claimed) => {
+  const cut = claimed.lastIndexOf(":");
+  if (cut <= 0)
+    return { stored: null, leadBound: false };
+  const dir = path5.join(userTokenRoot(), hash(claimed.slice(0, cut)));
+  try {
+    const text = fs5.readFileSync(path5.join(dir, hash(claimed)), "utf8");
+    return { stored: TOKEN_HASH.exec(text)?.[1] ?? null, leadBound: true };
+  } catch {
+    return { stored: null, leadBound: safeList(dir).length > 0 };
+  }
+};
+function issuedBinding(cwd, claimed) {
+  const record = issuedRecord(cwd, claimed);
+  const { stored, leadBound } = issuedToken(claimed);
+  if (stored)
+    return "token";
+  if (record === null)
+    return null;
+  return leadBound ? "token" : "legacy";
+}
 var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
 
 // packages/workit-core/src/core/package-root.ts
 import { existsSync } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path5.dirname(fileURLToPath(import.meta.url));
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path5.dirname(dir);
-    if (existsSync(path5.join(dir, "package.json")) || parent === dir)
+    const parent = path6.dirname(dir);
+    if (existsSync(path6.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
 };
 var assetRoot = () => {
   const root = packageRoot();
-  const assets = path5.join(root, "assets");
+  const assets = path6.join(root, "assets");
   return existsSync(assets) ? assets : root;
 };
 
 // packages/workit-core/src/core/store-lock.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import { hostname } from "node:os";
 var metadataLockSchema = object2({
   pid: number2().int().nonnegative().safe(),
@@ -18859,8 +18947,10 @@ var metadataLockSchema = object2({
 var FOREIGN_LOCK_TTL_MS = 10 * 60000;
 var UNREADABLE_LOCK_TTL_MS = 30000;
 var RECLAIM_GUARD_TTL_MS = 30000;
-var defaultLockTimeoutMs = 250;
+var IN_PROCESS_LOCK_TIMEOUT_MS = 250;
+var defaultLockTimeoutMs = IN_PROCESS_LOCK_TIMEOUT_MS;
 var defaultLockTimeout = () => defaultLockTimeoutMs;
+var hostAwareLockTimeout = (cliMs) => defaultLockTimeoutMs > IN_PROCESS_LOCK_TIMEOUT_MS ? cliMs : IN_PROCESS_LOCK_TIMEOUT_MS;
 var parseMetadataLock = (raw) => {
   let value;
   try {
@@ -18889,7 +18979,7 @@ var parseProcStatStart = (stat) => {
 var processStartOf = (pid) => {
   if (process.platform === "linux") {
     try {
-      return parseProcStatStart(fs5.readFileSync(`/proc/${pid}/stat`, "utf8"));
+      return parseProcStatStart(fs6.readFileSync(`/proc/${pid}/stat`, "utf8"));
     } catch {
       return null;
     }
@@ -18910,7 +19000,7 @@ var processStartOf = (pid) => {
 };
 var readTrimmed = (file) => {
   try {
-    return fs5.readFileSync(file, "utf8").trim() || null;
+    return fs6.readFileSync(file, "utf8").trim() || null;
   } catch {
     return null;
   }
@@ -18921,7 +19011,7 @@ var localLockHost = () => {
     return cachedLockHost;
   let pidns = null;
   try {
-    pidns = /\[(\d+)\]/.exec(fs5.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
+    pidns = /\[(\d+)\]/.exec(fs6.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
   } catch {}
   const boot = readTrimmed("/proc/sys/kernel/random/boot_id");
   cachedLockHost = pidns || boot ? `${hostname()}#${pidns ?? "?"}:${boot ?? "?"}` : hostname();
@@ -18967,7 +19057,7 @@ var classifyLockOwner = (payload, ageMs, localHost = localLockHost(), options =
 };
 var ageOf = (file, nowMs) => {
   try {
-    return nowMs - fs5.lstatSync(file).mtimeMs;
+    return nowMs - fs6.lstatSync(file).mtimeMs;
   } catch {
     return null;
   }
@@ -18978,7 +19068,7 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
   if (age === null || age <= RECLAIM_GUARD_TTL_MS)
     return false;
   try {
-    fs5.rmdirSync(guard);
+    fs6.rmdirSync(guard);
     return true;
   } catch {
     return false;
@@ -18987,8 +19077,8 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
 
 // packages/workit-core/src/store/event-log.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 var EVENT_VERSION = 1;
 
 class LogDamage extends Error {
@@ -19017,7 +19107,7 @@ var parseEvent = (line, file, offset) => {
 function readLog(file, from = 0, expectSeq = null) {
   let fd;
   try {
-    fd = fs6.openSync(file, "r");
+    fd = fs7.openSync(file, "r");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -19026,13 +19116,13 @@ function readLog(file, from = 0, expectSeq = null) {
   let bytes;
   let size;
   try {
-    size = fs6.fstatSync(fd).size;
+    size = fs7.fstatSync(fd).size;
     if (from > size)
       throw new LogDamage(`${file}: shorter than its snapshot`);
     bytes = Buffer.alloc(size - from);
     let read = 0;
     while (read < bytes.length) {
-      const got = fs6.readSync(fd, bytes, read, bytes.length - read, from + read);
+      const got = fs7.readSync(fd, bytes, read, bytes.length - read, from + read);
       if (got === 0)
         break;
       read += got;
@@ -19040,7 +19130,7 @@ function readLog(file, from = 0, expectSeq = null) {
     bytes = bytes.subarray(0, read);
     size = from + read;
   } finally {
-    fs6.closeSync(fd);
+    fs7.closeSync(fd);
   }
   const events = [];
   let start = 0;
@@ -19065,11 +19155,11 @@ function readLog(file, from = 0, expectSeq = null) {
 }
 var fsyncDirectory = (dir) => {
   try {
-    const fd = fs6.openSync(dir, "r");
+    const fd = fs7.openSync(dir, "r");
     try {
-      fs6.fsyncSync(fd);
+      fs7.fsyncSync(fd);
     } finally {
-      fs6.closeSync(fd);
+      fs7.closeSync(fd);
     }
   } catch (error) {
     if (process.platform !== "win32")
@@ -19079,46 +19169,46 @@ var fsyncDirectory = (dir) => {
 function appendEvent(file, event, validEnd) {
   const line = Buffer.from(`${JSON.stringify(event)}
 `, "utf8");
-  const created = !fs6.existsSync(file);
-  if (!created && fs6.statSync(file).size !== validEnd) {
-    const cut = fs6.openSync(file, "r+");
+  const created = !fs7.existsSync(file);
+  if (!created && fs7.statSync(file).size !== validEnd) {
+    const cut = fs7.openSync(file, "r+");
     try {
-      fs6.ftruncateSync(cut, validEnd);
-      fs6.fsyncSync(cut);
+      fs7.ftruncateSync(cut, validEnd);
+      fs7.fsyncSync(cut);
     } finally {
-      fs6.closeSync(cut);
+      fs7.closeSync(cut);
     }
   }
-  const fd = fs6.openSync(file, "a", 384);
+  const fd = fs7.openSync(file, "a", 384);
   try {
     let written = 0;
     while (written < line.length)
-      written += fs6.writeSync(fd, line, written, line.length - written);
-    fs6.fsyncSync(fd);
+      written += fs7.writeSync(fd, line, written, line.length - written);
+    fs7.fsyncSync(fd);
   } finally {
-    fs6.closeSync(fd);
+    fs7.closeSync(fd);
   }
   if (created)
-    fsyncDirectory(path6.dirname(file));
+    fsyncDirectory(path7.dirname(file));
   return validEnd;
 }
 function replaceFile(file, bytes, durable) {
   const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
   try {
-    const fd = fs6.openSync(temporary, "wx", 384);
+    const fd = fs7.openSync(temporary, "wx", 384);
     try {
-      fs6.writeSync(fd, bytes);
+      fs7.writeSync(fd, bytes);
       if (durable)
-        fs6.fsyncSync(fd);
+        fs7.fsyncSync(fd);
     } finally {
-      fs6.closeSync(fd);
+      fs7.closeSync(fd);
     }
     renameWithRetry(temporary, file);
     if (durable)
-      fsyncDirectory(path6.dirname(file));
+      fsyncDirectory(path7.dirname(file));
   } catch (error) {
     try {
-      fs6.unlinkSync(temporary);
+      fs7.unlinkSync(temporary);
     } catch {}
     throw error;
   }
@@ -19143,7 +19233,7 @@ var retryTransient = (run) => {
     }
   }
 };
-var renameWithRetry = (from, to) => retryTransient(() => fs6.renameSync(from, to));
+var renameWithRetry = (from, to) => retryTransient(() => fs7.renameSync(from, to));
 
 // packages/workit-core/src/store/patch.ts
 var isPlainObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -19256,7 +19346,7 @@ var isPatch = (value) => Array.isArray(value) && value.every((op) => {
 });
 
 // packages/workit-core/src/store/reduce.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var OPENING_TYPES = new Set([
   "task.opened",
   "task.imported",
@@ -19285,7 +19375,7 @@ var isObject4 = (value) => typeof value === "object" && value !== null && !Array
 var isKey = (value) => isObject4(value) && typeof value.key === "string" && (value.kind === "branch" || value.kind === "detached" || value.kind === "dir") && (value.branch === null || typeof value.branch === "string");
 var BLOB_REF = "$blob";
 var blobRef = (value) => isObject4(value) && Object.keys(value).length === 1 && typeof value[BLOB_REF] === "string" && /^[0-9a-f]{64}$/.test(value[BLOB_REF]) ? value[BLOB_REF] : null;
-var blobDigest = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
+var blobDigest = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
 var toBlob = (value, blobs) => {
   if (!isObject4(value))
     return value;
@@ -19440,7 +19530,7 @@ var indexEntry = (task, key, legacy, file) => {
 };
 var fileSignature = (file) => {
   try {
-    const stat = fs7.statSync(file, { bigint: true });
+    const stat = fs8.statSync(file, { bigint: true });
     return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
   } catch {
     return null;
@@ -19458,7 +19548,7 @@ var cachedRuntimeVersion = null;
 var runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs7.readFileSync(path7.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs8.readFileSync(path8.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -19484,14 +19574,14 @@ var isNewerVersion = (candidate, current) => {
 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 readText = (file) => {
   try {
-    return fs7.readFileSync(file, "utf8");
+    return fs8.readFileSync(file, "utf8");
   } catch {
     return "";
   }
 };
 var REFLOG_LINE = /^[0-9a-f]+ ([0-9a-f]+) .* (\d+) [+-]\d{4}\t(.*)$/u;
 var branchStart = (location, branch, aliases) => {
-  const first = readText(path7.join(path7.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+  const first = readText(path8.join(path8.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
 `, 1)[0];
   const created = REFLOG_LINE.exec(first);
   const start = created && /^branch: Created from (\S+)$/u.exec(created[3])?.[1];
@@ -19501,7 +19591,7 @@ var branchStart = (location, branch, aliases) => {
     return start;
   if (!location.git)
     return null;
-  for (const line of readText(path7.join(location.git.gitDir, "logs", "HEAD")).split(`
+  for (const line of readText(path8.join(location.git.gitDir, "logs", "HEAD")).split(`
 `)) {
     const entry = REFLOG_LINE.exec(line);
     const moved = entry && /^checkout: moving from (\S+) to (\S+)$/u.exec(entry[3]);
@@ -19511,23 +19601,23 @@ var branchStart = (location, branch, aliases) => {
   }
   return null;
 };
-var refExists = (common, ref) => fs7.existsSync(path7.join(common, ref)) || readText(path7.join(common, "packed-refs")).includes(` ${ref}
+var refExists = (common, ref) => fs8.existsSync(path8.join(common, ref)) || readText(path8.join(common, "packed-refs")).includes(` ${ref}
 `);
 var origins = new Map;
 var sameDirectoryIdentity = (left, right) => {
-  if (!path7.isAbsolute(left) || !path7.isAbsolute(right))
+  if (!path8.isAbsolute(left) || !path8.isAbsolute(right))
     return false;
-  const normalizedLeft = path7.resolve(left);
-  const normalizedRight = path7.resolve(right);
+  const normalizedLeft = path8.resolve(left);
+  const normalizedRight = path8.resolve(right);
   try {
-    const a = fs7.statSync(normalizedLeft, { bigint: true });
-    const b = fs7.statSync(normalizedRight, { bigint: true });
+    const a = fs8.statSync(normalizedLeft, { bigint: true });
+    const b = fs8.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 = fs7.realpathSync(normalizedLeft);
-    const canonicalRight = fs7.realpathSync(normalizedRight);
+    const canonicalLeft = fs8.realpathSync(normalizedLeft);
+    const canonicalRight = fs8.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;
@@ -19564,8 +19654,8 @@ class TaskStore {
   migrationChecked = false;
   compactDue = new Set;
   constructor(root, options = {}) {
-    const resolved = path7.resolve(root);
-    this.origin = fs7.existsSync(resolved) ? fs7.realpathSync(resolved) : resolved;
+    const resolved = path8.resolve(root);
+    this.origin = fs8.existsSync(resolved) ? fs8.realpathSync(resolved) : resolved;
     this.located = resolveStore(this.origin);
     this.root = checkoutRootOf(this.origin, this.located);
     this.lockTimeoutMs = options.lockTimeoutMs ?? defaultLockTimeout();
@@ -19573,7 +19663,7 @@ class TaskStore {
     this.migrateOnRead = options.migrateOnRead;
   }
   location() {
-    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs7.existsSync(path7.join(this.root, ".git"))) {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs8.existsSync(path8.join(this.root, ".git"))) {
       this.located = undefined;
       this.migrationChecked = false;
     }
@@ -19637,7 +19727,7 @@ class TaskStore {
     const tasksDir = this.paths().tasks;
     let names;
     try {
-      names = fs7.existsSync(tasksDir) ? fs7.readdirSync(tasksDir).filter((name) => validId(name)) : [];
+      names = fs8.existsSync(tasksDir) ? fs8.readdirSync(tasksDir).filter((name) => validId(name)) : [];
     } catch (error) {
       return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
         path: tasksDir
@@ -19678,7 +19768,7 @@ class TaskStore {
     const file = this.paths().workspace;
     let bytes;
     try {
-      bytes = retryTransient(() => fs7.readFileSync(file, "utf8"));
+      bytes = retryTransient(() => fs8.readFileSync(file, "utf8"));
     } catch (error) {
       if (error.code === "ENOENT")
         return success(null, null, null);
@@ -19729,7 +19819,7 @@ class TaskStore {
         const moved = this.bindLocked(again.data.id, key, input.now);
         return moved.ok ? success(moved.data.revision, null, { task: moved.data, created: false, key }) : moved;
       }
-      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path7.basename(this.root) || this.root;
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path8.basename(this.root) || this.root;
       const intent = {
         objective: input.objective?.trim() || `Work on ${label}`,
         scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
@@ -19789,14 +19879,14 @@ class TaskStore {
     const branch = key.ok ? key.data.branch : null;
     if (!branch || !location.ok)
       return success(null, null, null);
-    const common = path7.dirname(location.data.dir);
-    const heads = path7.join(common, "logs", "refs", "heads");
-    const headLog = location.data.git ? path7.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    const common = path8.dirname(location.data.dir);
+    const heads = path8.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path8.join(location.data.git.gitDir, "logs", "HEAD") : "";
     const signatures = [
-      path7.join(heads, branch),
+      path8.join(heads, branch),
       headLog,
       heads,
-      path7.join(common, "packed-refs")
+      path8.join(common, "packed-refs")
     ].map((file) => fileSignature(file) ?? "-");
     const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
     let resolved = origins.get(slot);
@@ -19808,7 +19898,7 @@ class TaskStore {
           aliases.push(rename.from);
       const start = branchStart(location.data, branch, aliases);
       const slash = start?.indexOf("/") ?? -1;
-      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path7.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path8.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
       const name = start && (remote ? start.slice(slash + 1) : start);
       resolved = {
         signature: signatures.join("|"),
@@ -20046,13 +20136,13 @@ class TaskStore {
     if (!ready.ok)
       return ready;
     const dirs = this.paths();
-    const recovery = path7.join(this.root, ".workit", "recovery");
-    if (fs7.existsSync(recovery)) {
+    const recovery = path8.join(this.root, ".workit", "recovery");
+    if (fs8.existsSync(recovery)) {
       let files = 0;
       let bytes = 0;
       try {
-        for (const name of fs7.readdirSync(recovery)) {
-          const stat = fs7.lstatSync(path7.join(recovery, name));
+        for (const name of fs8.readdirSync(recovery)) {
+          const stat = fs8.lstatSync(path8.join(recovery, name));
           if (!stat.isFile())
             continue;
           files += 1;
@@ -20061,17 +20151,17 @@ class TaskStore {
       } catch {}
       const remove = options.pruneRecovery === true && !dryRun;
       if (remove)
-        fs7.rmSync(recovery, { recursive: true, force: true });
+        fs8.rmSync(recovery, { recursive: true, force: true });
       report.legacyRecovery = { path: recovery, files, bytes, removed: remove };
     }
-    if (!fs7.existsSync(dirs.tasks))
+    if (!fs8.existsSync(dirs.tasks))
       return success(null, null, report);
-    const names = fs7.readdirSync(dirs.tasks).filter((name) => validId(name));
+    const names = fs8.readdirSync(dirs.tasks).filter((name) => validId(name));
     for (const name of names) {
       const file = this.eventsPath(name);
       let size = 0;
       try {
-        size = fs7.statSync(file).size;
+        size = fs8.statSync(file).size;
       } catch {
         continue;
       }
@@ -20099,16 +20189,16 @@ class TaskStore {
       const references = new Set;
       for (const name of names)
         try {
-          for (const match of fs7.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
+          for (const match of fs8.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
             references.add(match[1]);
         } catch {}
-      if (fs7.existsSync(dirs.blobs))
-        for (const name of fs7.readdirSync(dirs.blobs)) {
+      if (fs8.existsSync(dirs.blobs))
+        for (const name of fs8.readdirSync(dirs.blobs)) {
           const digest = name.replace(/\.json$/, "");
-          const file = path7.join(dirs.blobs, name);
+          const file = path8.join(dirs.blobs, name);
           let stat;
           try {
-            stat = fs7.lstatSync(file);
+            stat = fs8.lstatSync(file);
           } catch {
             continue;
           }
@@ -20119,11 +20209,11 @@ class TaskStore {
           report.blobs.removed += 1;
           report.blobs.removedBytes += stat.size;
           if (!dryRun)
-            fs7.rmSync(file, { force: true });
+            fs8.rmSync(file, { force: true });
         }
       return success(null, null, null);
     };
-    const swept = dryRun ? sweep() : this.withLock(path7.join(dirs.dir, "gc.lock"), sweep);
+    const swept = dryRun ? sweep() : this.withLock(path8.join(dirs.dir, "gc.lock"), sweep);
     if (!swept.ok)
       return swept;
     const temporaryDirs = [
@@ -20131,17 +20221,17 @@ class TaskStore {
       dirs.tasks,
       dirs.blobs,
       dirs.checkout,
-      ...names.map((name) => path7.join(dirs.tasks, name))
+      ...names.map((name) => path8.join(dirs.tasks, name))
     ];
     for (const directory of temporaryDirs) {
-      if (!fs7.existsSync(directory))
+      if (!fs8.existsSync(directory))
         continue;
-      for (const name of fs7.readdirSync(directory)) {
+      for (const name of fs8.readdirSync(directory)) {
         if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
           continue;
-        const file = path7.join(directory, name);
+        const file = path8.join(directory, name);
         try {
-          const stat = fs7.lstatSync(file);
+          const stat = fs8.lstatSync(file);
           if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
             continue;
         } catch {
@@ -20149,37 +20239,37 @@ class TaskStore {
         }
         report.temporary.removed += 1;
         if (!dryRun)
-          fs7.rmSync(file, { force: true });
+          fs8.rmSync(file, { force: true });
       }
     }
     return success(null, null, report);
   }
   paths() {
     const location = this.location();
-    const dir = location.ok ? location.data.dir : path7.join(this.root, ".workit");
-    const checkout = path7.join(dir, "checkouts", checkoutSlug(this.root));
+    const dir = location.ok ? location.data.dir : path8.join(this.root, ".workit");
+    const checkout = path8.join(dir, "checkouts", checkoutSlug(this.root));
     return {
       dir,
       shared: location.ok ? location.data.shared : false,
-      marker: path7.join(dir, "store.json"),
+      marker: path8.join(dir, "store.json"),
       checkout,
-      workspace: path7.join(checkout, "workspace.json"),
-      checkoutLock: path7.join(checkout, "metadata.lock"),
-      tasks: path7.join(dir, "tasks"),
-      index: path7.join(dir, "task-index.json"),
-      blobs: path7.join(dir, "blobs", "candidates"),
-      legacy: path7.join(dir, "legacy", checkoutSlug(this.root), "v2"),
-      v2: path7.join(this.root, ".workit")
+      workspace: path8.join(checkout, "workspace.json"),
+      checkoutLock: path8.join(checkout, "metadata.lock"),
+      tasks: path8.join(dir, "tasks"),
+      index: path8.join(dir, "task-index.json"),
+      blobs: path8.join(dir, "blobs", "candidates"),
+      legacy: path8.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path8.join(this.root, ".workit")
     };
   }
   eventsPath(taskId) {
-    return path7.join(this.paths().tasks, taskId, "events.jsonl");
+    return path8.join(this.paths().tasks, taskId, "events.jsonl");
   }
   snapshotPath(taskId) {
-    return path7.join(this.paths().tasks, taskId, "snapshot.json");
+    return path8.join(this.paths().tasks, taskId, "snapshot.json");
   }
   taskLockPath(taskId) {
-    return path7.join(this.paths().tasks, taskId, "lock");
+    return path8.join(this.paths().tasks, taskId, "lock");
   }
   ready(write = false) {
     const location = this.location();
@@ -20189,7 +20279,7 @@ class TaskStore {
       return success(null, null, null);
     const dirs = this.paths();
     try {
-      const marker = JSON.parse(fs7.readFileSync(dirs.marker, "utf8"));
+      const marker = JSON.parse(fs8.readFileSync(dirs.marker, "utf8"));
       if (typeof marker.version === "number" && marker.version > STORE_FORMAT)
         return failure2("recovery_required", `the workit store at ${dirs.dir} has format ${marker.version}; upgrade Workit to use it`, { path: dirs.marker });
     } catch {}
@@ -20218,21 +20308,21 @@ class TaskStore {
     return {
       read: (digest) => {
         try {
-          return JSON.parse(fs7.readFileSync(path7.join(dir, `${digest}.json`), "utf8"));
+          return JSON.parse(fs8.readFileSync(path8.join(dir, `${digest}.json`), "utf8"));
         } catch (error) {
           throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
         }
       },
       write: (digest, value) => {
-        const file = path7.join(dir, `${digest}.json`);
-        if (fs7.existsSync(file)) {
+        const file = path8.join(dir, `${digest}.json`);
+        if (fs8.existsSync(file)) {
           const stamp = new Date;
           try {
-            fs7.utimesSync(file, stamp, stamp);
+            fs8.utimesSync(file, stamp, stamp);
             return;
           } catch {}
         }
-        fs7.mkdirSync(dir, { recursive: true });
+        fs8.mkdirSync(dir, { recursive: true });
         replaceFile(file, JSON.stringify(value), true);
       }
     };
@@ -20314,7 +20404,7 @@ class TaskStore {
   }
   readSnapshot(taskId) {
     try {
-      const value = JSON.parse(fs7.readFileSync(this.snapshotPath(taskId), "utf8"));
+      const value = JSON.parse(fs8.readFileSync(this.snapshotPath(taskId), "utf8"));
       if (!isObject5(value) || value.v !== 1 || value.task !== taskId || typeof value.seq !== "number" || typeof value.lastId !== "string" || typeof value.lastStart !== "number" || typeof value.end !== "number" || !isObject5(value.record))
         return null;
       return value;
@@ -20416,8 +20506,8 @@ class TaskStore {
     }
   }
   openTask(record, type, key, legacy = null) {
-    const dir = path7.join(this.paths().tasks, record.id);
-    fs7.mkdirSync(dir, { recursive: true });
+    const dir = path8.join(this.paths().tasks, record.id);
+    fs8.mkdirSync(dir, { recursive: true });
     const blobs = this.blobStore();
     const bound = key ? { ...key, boundAt: key.boundAt ?? new Date().toISOString() } : null;
     const event = this.event(record.id, 1, type, {
@@ -20469,11 +20559,11 @@ class TaskStore {
         } catch {}
         if (!latest || latest.events[0]?.id !== last.id)
           return failure2("busy", "the task log changed during compaction; retry", { taskId });
-        const appended = fs7.readFileSync(file).subarray(log.end, latest.end);
+        const appended = fs8.readFileSync(file).subarray(log.end, latest.end);
         const bytes = Buffer.concat([Buffer.from(prefix, "utf8"), appended]);
         replaceFile(file, bytes.toString("utf8"), true);
         try {
-          fs7.rmSync(this.snapshotPath(taskId), { force: true });
+          fs8.rmSync(this.snapshotPath(taskId), { force: true });
         } catch {}
         const reloaded = this.load(taskId);
         if (reloaded.ok && reloaded.data)
@@ -20486,7 +20576,7 @@ class TaskStore {
   }
   countEvents(file) {
     try {
-      const bytes = fs7.readFileSync(file);
+      const bytes = fs8.readFileSync(file);
       let count = 0;
       for (let index = bytes.indexOf(10);index >= 0; index = bytes.indexOf(10, index + 1))
         count += 1;
@@ -20508,8 +20598,8 @@ class TaskStore {
     return bound.ok ? success(null, null, bound.data[0] ?? null) : bound;
   }
   withKeyLock(key, operation) {
-    const digest = createHash4("sha256").update(key).digest("hex").slice(0, 32);
-    return this.withLock(path7.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+    const digest = createHash5("sha256").update(key).digest("hex").slice(0, 32);
+    return this.withLock(path8.join(this.paths().dir, "keys", `${digest}.lock`), operation);
   }
   bindLocked(taskId, key, timestamp) {
     const current = this.readWorkspace();
@@ -20650,7 +20740,7 @@ class TaskStore {
   writeWorkspace(record) {
     const file = this.paths().workspace;
     try {
-      fs7.mkdirSync(path7.dirname(file), { recursive: true });
+      fs8.mkdirSync(path8.dirname(file), { recursive: true });
       replaceFile(file, `${canonicalJson(record)}
 `, true);
       return success(null, null, null);
@@ -20660,7 +20750,7 @@ class TaskStore {
   }
   readIndex() {
     try {
-      const value = JSON.parse(fs7.readFileSync(this.paths().index, "utf8"));
+      const value = JSON.parse(fs8.readFileSync(this.paths().index, "utf8"));
       if (!isObject5(value) || value.version !== INDEX_VERSION || !isObject5(value.tasks))
         return {};
       const tasks = {};
@@ -20674,7 +20764,7 @@ class TaskStore {
   }
   writeIndex(entries) {
     try {
-      fs7.mkdirSync(this.paths().tasks, { recursive: true });
+      fs8.mkdirSync(this.paths().tasks, { recursive: true });
       replaceFile(this.paths().index, JSON.stringify({
         version: INDEX_VERSION,
         tasks: Object.fromEntries(entries.map((entry) => [entry.id, entry]))
@@ -20728,23 +20818,23 @@ class TaskStore {
     return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
   }
   v2Dirs() {
-    return [...new Set([this.root, this.origin])].map((dir) => path7.join(dir, ".workit"));
+    return [...new Set([this.root, this.origin])].map((dir) => path8.join(dir, ".workit"));
   }
   pendingMigrations() {
     return this.v2Dirs().filter((dir) => {
-      const raw = this.readV2Workspace(path7.join(dir, "workspace.json"));
+      const raw = this.readV2Workspace(path8.join(dir, "workspace.json"));
       return raw !== null && raw !== TOMBSTONE;
     });
   }
   migrateV2(v2) {
     const dirs = this.paths();
-    const v2Workspace = path7.join(v2, "workspace.json");
-    const v2Tasks = path7.join(v2, "tasks");
-    const legacy = path7.join(dirs.dir, "legacy", checkoutSlug(path7.dirname(v2)), "v2");
+    const v2Workspace = path8.join(v2, "workspace.json");
+    const v2Tasks = path8.join(v2, "tasks");
+    const legacy = path8.join(dirs.dir, "legacy", checkoutSlug(path8.dirname(v2)), "v2");
     const raw = this.readV2Workspace(v2Workspace);
     if (raw === null || raw === TOMBSTONE)
       return success(null, null, null);
-    return this.withLock(dirs.checkoutLock, () => this.withLock(path7.join(v2, "metadata.lock"), () => {
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path8.join(v2, "metadata.lock"), () => {
       const workspace = this.readV2Workspace(v2Workspace);
       if (workspace === null || workspace === TOMBSTONE)
         return success(null, null, null);
@@ -20753,7 +20843,7 @@ class TaskStore {
         return failure2("recovery_required", `cannot migrate the 2.x store at ${v2}: ${parsedWorkspace.error}; move it aside to start fresh`, { path: v2Workspace });
       let files = [];
       try {
-        files = fs7.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path7.join(v2Tasks, name)));
+        files = fs8.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path8.join(v2Tasks, name)));
       } catch {}
       const current = this.readWorkspace();
       if (!current.ok)
@@ -20771,22 +20861,22 @@ class TaskStore {
       let skipped = 0;
       const done = new Map;
       try {
-        fs7.mkdirSync(path7.join(legacy, "tasks"), { recursive: true });
+        fs8.mkdirSync(path8.join(legacy, "tasks"), { recursive: true });
         for (const name of ["workspace.json", "index.json"])
-          if (fs7.existsSync(path7.join(v2, name)))
-            fs7.copyFileSync(path7.join(v2, name), path7.join(legacy, name));
+          if (fs8.existsSync(path8.join(v2, name)))
+            fs8.copyFileSync(path8.join(v2, name), path8.join(legacy, name));
         for (const name of files) {
           const id = name.slice(0, -5);
-          const file = path7.join(v2Tasks, name);
-          const bytes = fs7.readFileSync(file, "utf8");
+          const file = path8.join(v2Tasks, name);
+          const bytes = fs8.readFileSync(file, "utf8");
           const digest = sha256(bytes);
-          fs7.writeFileSync(path7.join(legacy, "tasks", name), bytes);
+          fs8.writeFileSync(path8.join(legacy, "tasks", name), bytes);
           const parsed = this.parseRecord(bytes, taskRecordSchema, "2.x task");
           if (!parsed.ok || parsed.data.id !== id)
             return failure2("recovery_required", `cannot migrate 2.x task ${id}: ${parsed.ok ? "file name and record ID differ" : parsed.error}; move ${file} aside to continue`, { path: file });
           const record = { ...parsed.data, workspaceId: target.id };
-          const origin = { path: path7.join(legacy, "tasks", name), digest };
-          if (!fs7.existsSync(this.eventsPath(id))) {
+          const origin = { path: path8.join(legacy, "tasks", name), digest };
+          if (!fs8.existsSync(this.eventsPath(id))) {
             this.openTask(record, "migrated.from_v2", null, origin);
             migrated += 1;
           } else {
@@ -20821,8 +20911,8 @@ class TaskStore {
       try {
         let complete = true;
         for (const [name, digest] of done) {
-          const file = path7.join(v2Tasks, name);
-          if (sha256(fs7.readFileSync(file, "utf8")) !== digest) {
+          const file = path8.join(v2Tasks, name);
+          if (sha256(fs8.readFileSync(file, "utf8")) !== digest) {
             complete = false;
             continue;
           }
@@ -20832,7 +20922,7 @@ class TaskStore {
           return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
             path: v2
           });
-        fs7.rmSync(path7.join(v2, "index.json"), { force: true });
+        fs8.rmSync(path8.join(v2, "index.json"), { force: true });
         this.writeTombstone(v2, target.id);
       } catch (error) {
         return failure2("storage_error", `cannot finish the 2.x migration: ${String(error)}`, {
@@ -20852,45 +20942,45 @@ class TaskStore {
   }
   adoptLocalStore() {
     const dirs = this.paths();
-    const marker = path7.join(dirs.v2, "store.json");
-    if (!dirs.shared || !fs7.existsSync(marker))
+    const marker = path8.join(dirs.v2, "store.json");
+    if (!dirs.shared || !fs8.existsSync(marker))
       return success(null, null, null);
     return this.withLock(dirs.checkoutLock, () => {
-      if (!fs7.existsSync(marker))
+      if (!fs8.existsSync(marker))
         return success(null, null, null);
       let tasks = 0;
       try {
         const merge = (from, to) => {
-          if (!fs7.existsSync(to)) {
-            fs7.mkdirSync(path7.dirname(to), { recursive: true });
+          if (!fs8.existsSync(to)) {
+            fs8.mkdirSync(path8.dirname(to), { recursive: true });
             try {
-              fs7.renameSync(from, to);
+              fs8.renameSync(from, to);
             } catch {
-              fs7.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
-              fs7.rmSync(from, { recursive: true, force: true });
+              fs8.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
+              fs8.rmSync(from, { recursive: true, force: true });
             }
             return;
           }
-          if (fs7.lstatSync(from).isDirectory() && fs7.lstatSync(to).isDirectory())
-            for (const name of fs7.readdirSync(from))
-              merge(path7.join(from, name), path7.join(to, name));
+          if (fs8.lstatSync(from).isDirectory() && fs8.lstatSync(to).isDirectory())
+            for (const name of fs8.readdirSync(from))
+              merge(path8.join(from, name), path8.join(to, name));
         };
         for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
-          const from = path7.join(dirs.v2, sub);
-          if (!fs7.existsSync(from))
+          const from = path8.join(dirs.v2, sub);
+          if (!fs8.existsSync(from))
             continue;
           if (sub === "tasks") {
-            for (const name of fs7.readdirSync(from))
-              if (validId(name) && !fs7.existsSync(path7.join(dirs.dir, sub, name)))
+            for (const name of fs8.readdirSync(from))
+              if (validId(name) && !fs8.existsSync(path8.join(dirs.dir, sub, name)))
                 tasks += 1;
           }
-          merge(from, path7.join(dirs.dir, sub));
+          merge(from, path8.join(dirs.dir, sub));
         }
-        const ledger = path7.join(dirs.v2, "ledger");
-        if (fs7.existsSync(ledger) && !fs7.existsSync(path7.join(dirs.dir, "ledger")))
-          merge(ledger, path7.join(dirs.dir, "ledger"));
-        fs7.rmSync(path7.join(dirs.v2, "task-index.json"), { force: true });
-        fs7.renameSync(marker, path7.join(dirs.v2, "store.moved.json"));
+        const ledger = path8.join(dirs.v2, "ledger");
+        if (fs8.existsSync(ledger) && !fs8.existsSync(path8.join(dirs.dir, "ledger")))
+          merge(ledger, path8.join(dirs.dir, "ledger"));
+        fs8.rmSync(path8.join(dirs.v2, "task-index.json"), { force: true });
+        fs8.renameSync(marker, path8.join(dirs.v2, "store.moved.json"));
       } catch (error) {
         return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
           path: dirs.v2
@@ -20910,7 +21000,7 @@ class TaskStore {
   readV2Workspace(file) {
     let bytes;
     try {
-      bytes = fs7.readFileSync(file, "utf8");
+      bytes = fs8.readFileSync(file, "utf8");
     } catch {
       return null;
     }
@@ -20928,7 +21018,7 @@ class TaskStore {
       schemaVersion: SCHEMA_VERSION,
       id: workspaceId ?? newId(),
       revision: newRevision(),
-      root: path7.dirname(v2),
+      root: path8.dirname(v2),
       runtime: { createdWith: version, updatedWith: version },
       writer: null,
       store: {
@@ -20939,12 +21029,12 @@ class TaskStore {
       },
       critical: ["store"]
     };
-    fs7.mkdirSync(v2, { recursive: true });
-    const ignore = path7.join(v2, ".gitignore");
-    if (!fs7.existsSync(ignore))
-      fs7.writeFileSync(ignore, `*
+    fs8.mkdirSync(v2, { recursive: true });
+    const ignore = path8.join(v2, ".gitignore");
+    if (!fs8.existsSync(ignore))
+      fs8.writeFileSync(ignore, `*
 `);
-    replaceFile(path7.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+    replaceFile(path8.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
 `, true);
   }
   stubFor(taskId) {
@@ -20960,7 +21050,7 @@ class TaskStore {
   }
   isStub(file) {
     try {
-      const value = JSON.parse(fs7.readFileSync(file, "utf8"));
+      const value = JSON.parse(fs8.readFileSync(file, "utf8"));
       return isObject5(value) && isObject5(value.store) && value.store.format === "workit-store";
     } catch {
       return false;
@@ -20968,32 +21058,32 @@ class TaskStore {
   }
   writeTombstoneIfMissing() {
     try {
-      const v2 = path7.join(this.root, ".workit");
-      if (fs7.existsSync(path7.join(v2, "workspace.json")))
+      const v2 = path8.join(this.root, ".workit");
+      if (fs8.existsSync(path8.join(v2, "workspace.json")))
         return;
       let id = null;
       try {
-        id = JSON.parse(fs7.readFileSync(this.paths().workspace, "utf8")).id ?? null;
+        id = JSON.parse(fs8.readFileSync(this.paths().workspace, "utf8")).id ?? null;
       } catch {}
       this.writeTombstone(v2, id);
     } catch {}
   }
   initializeStorage() {
     const dirs = this.paths();
-    retryTransient(() => fs7.mkdirSync(dirs.checkout, { recursive: true }));
-    retryTransient(() => fs7.mkdirSync(dirs.tasks, { recursive: true }));
-    if (!fs7.existsSync(dirs.marker))
+    retryTransient(() => fs8.mkdirSync(dirs.checkout, { recursive: true }));
+    retryTransient(() => fs8.mkdirSync(dirs.tasks, { recursive: true }));
+    if (!fs8.existsSync(dirs.marker))
       replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
 `, false);
     if (!dirs.shared) {
-      const ignore = path7.join(dirs.dir, ".gitignore");
+      const ignore = path8.join(dirs.dir, ".gitignore");
       let current = null;
       try {
-        current = fs7.readFileSync(ignore, "utf8");
+        current = fs8.readFileSync(ignore, "utf8");
       } catch {}
       if (current !== `*
 `)
-        retryTransient(() => fs7.writeFileSync(ignore, `*
+        retryTransient(() => fs8.writeFileSync(ignore, `*
 `));
     }
     this.writeTombstoneIfMissing();
@@ -21009,7 +21099,7 @@ class TaskStore {
       shouldReclaim: ({ payload, nowMs }) => {
         let ageMs = null;
         try {
-          ageMs = nowMs - fs7.lstatSync(lockPath).mtimeMs;
+          ageMs = nowMs - fs8.lstatSync(lockPath).mtimeMs;
         } catch {}
         return classifyLockOwner(payload, ageMs, localLockHost(), TASK_STORE_LOCK).state === "stale";
       },
@@ -21046,7 +21136,7 @@ class TaskStore {
   withLock(lockPath, operation) {
     try {
       this.initializeStorage();
-      fs7.mkdirSync(path7.dirname(lockPath), { recursive: true });
+      fs8.mkdirSync(path8.dirname(lockPath), { recursive: true });
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
         path: this.paths().dir
@@ -21086,18 +21176,18 @@ class TaskStore {
   lockDirWritable(lockPath) {
     const probe = `${lockPath}.${process.pid}.${randomUUID3()}.probe`;
     try {
-      fs7.closeSync(fs7.openSync(probe, "wx", 384));
+      fs8.closeSync(fs8.openSync(probe, "wx", 384));
     } catch {
       return false;
     }
     try {
-      fs7.rmSync(probe, { force: true });
+      fs8.rmSync(probe, { force: true });
     } catch {}
     return true;
   }
   lockHolderPresent(lockPath) {
     try {
-      fs7.lstatSync(lockPath);
+      fs8.lstatSync(lockPath);
       return true;
     } catch (error) {
       return error?.code !== "ENOENT";
@@ -21109,12 +21199,12 @@ class TaskStore {
     if (isTransientWindowsError(error) && !this.lockHolderPresent(lockPath) && !this.lockDirWritable(lockPath))
       return failure2("storage_error", `cannot create the workit lock (${code}); no other Workit call holds it`, {
         path: lockPath,
-        guidance: `Check permissions and the read-only attribute on ${path7.dirname(lockPath)}.`
+        guidance: `Check permissions and the read-only attribute on ${path8.dirname(lockPath)}.`
       });
     if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
       let lock = null;
       try {
-        lock = parseMetadataLockOrNull(fs7.readFileSync(lockPath, "utf8"));
+        lock = parseMetadataLockOrNull(fs8.readFileSync(lockPath, "utf8"));
       } catch {}
       return failure2("busy", `workit lock is held by another Workit call${lock ? ` (pid ${lock.pid} on ${lock.host})` : ""}; retry shortly`, {
         outcome: "not_started",
@@ -21132,15 +21222,15 @@ var isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state);
 var workerBlocksTransition = (transition, state) => transition === "pause" ? false : isUncertainWorker(state);
 
 // packages/workit-core/src/core/task-evaluation.ts
-import { createHash as createHash9 } from "node:crypto";
-import * as fs12 from "node:fs";
+import { createHash as createHash10 } from "node:crypto";
+import * as fs13 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import fs8 from "node:fs";
-import path8 from "node:path";
+import fs9 from "node:fs";
+import path9 from "node:path";
 var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
 var CHECKS_FILE = "workit.checks.json";
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -21193,10 +21283,10 @@ var git = (cwd, args) => {
   return value || null;
 };
 function checkRoot(cwd) {
-  return path8.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+  return path9.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
 }
 var packageManager = (root) => {
-  const has = (file) => fs8.existsSync(path8.join(root, file));
+  const has = (file) => fs9.existsSync(path9.join(root, file));
   if (has("bun.lock") || has("bun.lockb"))
     return "bun";
   if (has("pnpm-lock.yaml"))
@@ -21216,7 +21306,7 @@ var CHECK_NAME = /^[a-z0-9][a-z0-9:._-]{0,63}$/u;
 function detectedChecks(root) {
   const read = (file) => {
     try {
-      return fs8.readFileSync(path8.join(root, file), "utf8");
+      return fs9.readFileSync(path9.join(root, file), "utf8");
     } catch {
       return null;
     }
@@ -21255,7 +21345,7 @@ function detectedChecks(root) {
 var GATES = ["testing", "verification"];
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = path8.join(root, CHECKS_FILE);
+  const file = path9.join(root, CHECKS_FILE);
   const none = (error = null) => ({
     source: error ? CHECKS_FILE : "none",
     root,
@@ -21265,7 +21355,7 @@ function loadCheckConfig(cwd) {
   });
   let text = null;
   try {
-    text = fs8.readFileSync(file, "utf8");
+    text = fs9.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT")
       return none(`cannot read ${CHECKS_FILE}: ${error.message}`);
@@ -21328,10 +21418,10 @@ function workitAvailable(env = process.env) {
     return workitOnPath;
   const windows = process.platform === "win32";
   const exts = windows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-  const dirs = (env.PATH ?? env.Path ?? "").split(path8.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path9.delimiter).filter(Boolean);
   workitOnPath = dirs.some((dir) => exts.some((ext) => {
     try {
-      return fs8.statSync(path8.join(dir, `workit${ext}`)).isFile();
+      return fs9.statSync(path9.join(dir, `workit${ext}`)).isFile();
     } catch {
       return false;
     }
@@ -21344,10 +21434,10 @@ function checkCommand(args, version, onPath = workitAvailable()) {
 
 // packages/workit-core/src/git/rev.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
-import fs9 from "node:fs";
+import { createHash as createHash6 } from "node:crypto";
+import fs10 from "node:fs";
 import os2 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 var MAX_BUFFER = 256 * 1024 * 1024;
 var GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
 var git2 = (cwd, args, options = {}) => {
@@ -21382,10 +21472,10 @@ function headSha(cwd) {
 var emptyTree = (cwd) => line(git2(cwd, ["mktree"], { input: "" }));
 var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
 var seedIndex = (from, to) => {
-  fs9.copyFileSync(from, to);
-  const { atimeNs, mtimeNs } = fs9.statSync(from, { bigint: true });
+  fs10.copyFileSync(from, to);
+  const { atimeNs, mtimeNs } = fs10.statSync(from, { bigint: true });
   const seconds = (ns) => (Number(ns / 1000n) - 1) / 1e6;
-  fs9.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
+  fs10.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
 };
 function worktreeTree(cwd, options = {}) {
   const top = line(git2(cwd, ["rev-parse", "--show-toplevel"]));
@@ -21394,10 +21484,10 @@ function worktreeTree(cwd, options = {}) {
     return null;
   const cap = options.maxUntrackedBytes ?? MAX_UNTRACKED_BYTES;
   const timeoutMs = options.timeoutMs ?? GIT_TIMEOUTS.worktree;
-  const scratch = fs9.mkdtempSync(path9.join(os2.tmpdir(), "workit-tree-"));
+  const scratch = fs10.mkdtempSync(path10.join(os2.tmpdir(), "workit-tree-"));
   try {
-    const tempIndex = path9.join(scratch, "index");
-    if (fs9.existsSync(indexPath))
+    const tempIndex = path10.join(scratch, "index");
+    if (fs10.existsSync(indexPath))
       seedIndex(indexPath, tempIndex);
     const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
     const untracked = git2(top, ["ls-files", "--others", "--exclude-standard", "-z"], {
@@ -21409,7 +21499,7 @@ function worktreeTree(cwd, options = {}) {
     const skipped = [];
     for (const file of untracked.stdout.split("\x00").filter(Boolean)) {
       try {
-        const stat = fs9.statSync(path9.join(top, file));
+        const stat = fs10.statSync(path10.join(top, file));
         if (stat.isFile() && stat.size > cap)
           skipped.push({ path: file, size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) });
       } catch {}
@@ -21426,10 +21516,10 @@ function worktreeTree(cwd, options = {}) {
     if (!tree)
       return null;
     const base = line(git2(top, ["rev-parse", "--verify", "-q", "HEAD^{tree}"])) ?? emptyTree(top);
-    const key = skipped.length ? `sha256:${createHash5("sha256").update(JSON.stringify({ tree, skipped })).digest("hex")}` : tree;
+    const key = skipped.length ? `sha256:${createHash6("sha256").update(JSON.stringify({ tree, skipped })).digest("hex")}` : tree;
     return { tree, key, dirty: tree !== base || skipped.length > 0, skipped };
   } finally {
-    fs9.rmSync(scratch, { recursive: true, force: true });
+    fs10.rmSync(scratch, { recursive: true, force: true });
   }
 }
 function worktreeSignal(cwd, options = {}) {
@@ -21449,16 +21539,16 @@ function worktreeSignal(cwd, options = {}) {
   });
   if (!status.ok)
     return null;
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   hash.update(`${headSha(top) ?? "unborn"}\x00`);
   for (const entry of status.stdout.split("\x00")) {
     if (entry.length < 4)
       continue;
     const file = entry.slice(3);
-    const absolute = path9.join(top, file);
+    const absolute = path10.join(top, file);
     let stat = "-";
     try {
-      const info = fs9.lstatSync(absolute, { bigint: true });
+      const info = fs10.lstatSync(absolute, { bigint: true });
       stat = `${info.mode.toString(8)}:${info.size}:${info.mtimeNs}`;
       if (info.isDirectory())
         stat += `:${headSha(absolute) ?? "-"}`;
@@ -21525,17 +21615,17 @@ function pushRemoteName(cwd, branch) {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { createHash as createHash8, randomBytes as randomBytes2 } from "node:crypto";
-import fs11 from "node:fs";
-import path13 from "node:path";
+import { createHash as createHash9, randomBytes as randomBytes3 } from "node:crypto";
+import fs12 from "node:fs";
+import path14 from "node:path";
 
 // packages/workit-core/src/core/vcs-config.ts
-import fs10 from "node:fs";
-import path12 from "node:path";
+import fs11 from "node:fs";
+import path13 from "node:path";
 import { spawnSync as spawnSync8 } from "node:child_process";
 
 // packages/workit-core/src/core/config.ts
@@ -21549,7 +21639,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import os3 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 import { statSync as statSync2 } from "node:fs";
@@ -21608,7 +21698,7 @@ var mergePreset = (preset, input = {}, current = {
     protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
   };
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path10.join(process.env.XDG_CONFIG_HOME || path10.join(os3.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path11.join(process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -21618,7 +21708,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os3.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path11.join(process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config"), "workflow-toolkit");
   if (!existsSync3(legacy)) {
     migratedDir = dir;
     return dir;
@@ -21631,8 +21721,8 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync2(legacy, { withFileTypes: true })) {
-    const src = path10.join(legacy, entry.name);
-    const dest = path10.join(dir, entry.name);
+    const src = path11.join(legacy, entry.name);
+    const dest = path11.join(dir, entry.name);
     if (existsSync3(dest))
       continue;
     try {
@@ -21704,7 +21794,7 @@ var parseConfigResult = (raw, file) => {
   return { status: "valid", path: file, config };
 };
 var readConfigTyped = (dir) => {
-  const file = path10.join(dir ?? configDir(), "config.json");
+  const file = path11.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -21713,7 +21803,7 @@ var readConfig = () => {
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
 };
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.join(configDir(), "vcs.json");
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path11.join(configDir(), "vcs.json");
 var branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
 var resolveBranchPolicy = (config, workspace, repoPreset) => {
   const wp = workspace?.branchPolicy ?? {};
@@ -21745,9 +21835,9 @@ var COMMIT_PRESETS = [
 
 // packages/workit-core/src/core/workspaces.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // packages/workit-core/src/core/branch-policy.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -21872,7 +21962,7 @@ var releaseTrackSchema = object2({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource?.kind === "package-json" && (path11.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource?.kind === "package-json" && (path12.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -21933,7 +22023,7 @@ var workspacesFileSchema = object2({ workspaces: array(workspaceConfigSchema).op
     names.add(workspace.name);
   }
 });
-var workspacesRevision = (contents) => createHash6("sha256").update(contents ?? "<missing>").digest("hex");
+var workspacesRevision = (contents) => createHash7("sha256").update(contents ?? "<missing>").digest("hex");
 var validateWorkspacesDocument = (parsed, file) => {
   if (!isConfigObject(parsed)) {
     return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
@@ -21971,7 +22061,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path11.join(dir, "workspaces.json");
+  const file = path12.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -22082,9 +22172,9 @@ var mainCheckoutOf = (cwd) => {
   let main = null;
   const dirs = git(["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
   const [gitDir, common] = (dirs ?? "").trim().split(/\r?\n/u);
-  if (gitDir && common && path11.resolve(gitDir) !== path11.resolve(common)) {
+  if (gitDir && common && path12.resolve(gitDir) !== path12.resolve(common)) {
     const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
-    main = listed?.trim() || (path11.basename(common) === ".git" ? path11.dirname(common) : common);
+    main = listed?.trim() || (path12.basename(common) === ".git" ? path12.dirname(common) : common);
   }
   mainCheckouts.set(cwd, main);
   return main;
@@ -22175,7 +22265,7 @@ var runtimeWorkspaceIndexSchema = object2({
   workspaces: array(object2({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
 var matchRuntimeWorkspace = (cwd, dir = configDir()) => {
-  const file = path11.join(dir, "workspaces.json");
+  const file = path12.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -22250,7 +22340,7 @@ function workspaceDefaultTarget(cwd, globalDefault) {
 }
 
 // packages/workit-core/src/core/release-tracks.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { spawnSync as spawnSync7 } from "node:child_process";
 var KNOWN_FIELDS = new Set([
   "strategy",
@@ -22620,7 +22710,7 @@ function resolveTrackFor(cwd, options) {
       ]) ?? "",
       git3(cwd, ["config", "--get", recordedBaseKey(branch)]) ?? ""
     ] : [];
-    key = createHash7("sha256").update(JSON.stringify({ cwd, input, refs, head, own })).digest("hex");
+    key = createHash8("sha256").update(JSON.stringify({ cwd, input, refs, head, own })).digest("hex");
     const hit = memo2.get(key);
     if (hit)
       return hit;
@@ -22635,7 +22725,7 @@ function resolveTrackFor(cwd, options) {
 }
 
 // packages/workit-core/src/core/vcs-config.ts
-var workspacesPath = () => path12.join(configDir(), "workspaces.json");
+var workspacesPath = () => path13.join(configDir(), "workspaces.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
   const r = spawnSync8("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
@@ -22725,7 +22815,7 @@ var readVcsConfig = () => {
   const file = vcsConfigPath();
   let raw;
   try {
-    raw = fs10.readFileSync(file, "utf8");
+    raw = fs11.readFileSync(file, "utf8");
   } catch {
     return { status: "missing", path: file, config: {} };
   }
@@ -22810,7 +22900,7 @@ function vcsConfig(mode, cwd, options = {}) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path12.resolve(cfgPath),
+    configPath: path13.resolve(cfgPath),
     provider,
     defaultTargetBranch: workspaceDefault,
     pr: cfg.pr ?? {},
@@ -23021,7 +23111,7 @@ function diffHash(cwd, base, head) {
   ], GIT_TIMEOUTS.worktree);
   if (!diff.ok || !diff.stdout)
     return null;
-  const hash = createHash8("sha256");
+  const hash = createHash9("sha256");
   for (const line of diff.stdout.split(`
 `)) {
     if (line.startsWith("index "))
@@ -23033,16 +23123,16 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path13.resolve(cwd));
+  const location = resolveStore(path14.resolve(cwd));
   if (location instanceof Error)
     return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
   return { ok: true, value: { root: location.dir, shared: location.shared } };
 }
 function ledgerPath(cwd) {
   const root = storeRoot(cwd);
-  return root.ok ? { ok: true, value: path13.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path14.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
-var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
+var newId2 = () => `${Date.now().toString(36)}-${randomBytes3(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
   26985,
   20859,
@@ -23060,7 +23150,7 @@ var onNetworkFs = (dir) => {
   if (process.platform !== "linux")
     return false;
   try {
-    return isNetworkFsType(fs11.statfsSync(dir).type);
+    return isNetworkFsType(fs12.statfsSync(dir).type);
   } catch {
     return false;
   }
@@ -23070,15 +23160,15 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs11.readFileSync(path13.join(lock, LOCK_OWNER), "utf8");
+    return fs12.readFileSync(path14.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path13.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path14.join(lock, LOCK_OWNER), lock]) {
     try {
-      return Date.now() - fs11.statSync(target).mtimeMs;
+      return Date.now() - fs12.statSync(target).mtimeMs;
     } catch {}
   }
   return null;
@@ -23086,55 +23176,55 @@ var lockAgeMs = (lock) => {
 var ledgerLock = {
   acquire(lock) {
     try {
-      fs11.mkdirSync(lock);
+      fs12.mkdirSync(lock);
     } catch (error) {
       if (error.code === "EEXIST")
         return null;
       throw error;
     }
-    const token = `${process.pid}-${randomBytes2(8).toString("hex")}`;
-    fs11.writeFileSync(path13.join(lock, LOCK_OWNER), token);
+    const token = `${process.pid}-${randomBytes3(8).toString("hex")}`;
+    fs12.writeFileSync(path14.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
     if (lockToken(lock) !== token)
       return false;
-    const tomb = `${lock}.release-${randomBytes2(6).toString("hex")}`;
+    const tomb = `${lock}.release-${randomBytes3(6).toString("hex")}`;
     try {
-      fs11.renameSync(lock, tomb);
+      fs12.renameSync(lock, tomb);
     } catch {
       return false;
     }
     if (lockToken(tomb) !== token) {
       try {
-        fs11.renameSync(tomb, lock);
+        fs12.renameSync(tomb, lock);
       } catch {}
       return false;
     }
-    fs11.rmSync(tomb, { recursive: true, force: true });
+    fs12.rmSync(tomb, { recursive: true, force: true });
     return true;
   },
   token: lockToken,
   reap(lock, observed) {
-    const tomb = `${lock}.reap-${randomBytes2(6).toString("hex")}`;
+    const tomb = `${lock}.reap-${randomBytes3(6).toString("hex")}`;
     try {
-      fs11.renameSync(lock, tomb);
+      fs12.renameSync(lock, tomb);
     } catch {
       return false;
     }
     if (lockToken(tomb) === observed) {
-      fs11.rmSync(tomb, { recursive: true, force: true });
+      fs12.rmSync(tomb, { recursive: true, force: true });
       return true;
     }
     try {
-      fs11.renameSync(tomb, lock);
+      fs12.renameSync(tomb, lock);
     } catch {
-      fs11.rmSync(tomb, { recursive: true, force: true });
+      fs12.rmSync(tomb, { recursive: true, force: true });
     }
     return false;
   }
 };
-function withLedgerLock(file, fn, waitMs = LOCK_WAIT_MS) {
+function withLedgerLock(file, fn, waitMs = hostAwareLockTimeout(LOCK_WAIT_MS)) {
   const lock = `${file}.lock`;
   const deadline = Date.now() + waitMs;
   let token = null;
@@ -23156,14 +23246,14 @@ function withLedgerLock(file, fn, waitMs = LOCK_WAIT_MS) {
     ledgerLock.release(lock, token);
   }
 }
-var sha2562 = (text) => createHash8("sha256").update(text).digest("hex");
+var sha2562 = (text) => createHash9("sha256").update(text).digest("hex");
 var chainHash = (prevHash, body) => sha2562(`${prevHash ?? ""}
 ${body}`);
 var TAIL_BYTES = 64 * 1024;
 var lastLine = (fd, size) => {
   for (let span = Math.min(size, TAIL_BYTES);span > 0; span = Math.min(size, span * 2)) {
     const buffer = Buffer.alloc(span);
-    fs11.readSync(fd, buffer, 0, span, size - span);
+    fs12.readSync(fd, buffer, 0, span, size - span);
     const end = buffer.lastIndexOf(10);
     if (end < 0) {
       if (span === size)
@@ -23192,15 +23282,23 @@ var lastLine = (fd, size) => {
   }
   return null;
 };
+var tighten = (fd) => {
+  try {
+    if ((fs12.fstatSync(fd).mode & 63) !== 0)
+      fs12.fchmodSync(fd, 384);
+  } catch {}
+};
 function appendLine(file, build, options) {
   const write = () => {
-    const fd = fs11.openSync(file, "a+");
+    const fd = fs12.openSync(file, "a+", 384);
     try {
-      const size = fs11.fstatSync(fd).size;
+      if (process.platform !== "win32")
+        tighten(fd);
+      const size = fs12.fstatSync(fd).size;
       let fence = "";
       if (size > 0) {
         const last = Buffer.alloc(1);
-        fs11.readSync(fd, last, 0, 1, size - 1);
+        fs12.readSync(fd, last, 0, 1, size - 1);
         if (last[0] !== 10)
           fence = `
 `;
@@ -23209,17 +23307,17 @@ function appendLine(file, build, options) {
       if (!line.ok)
         return line;
       const bytes = Buffer.from(fence + line.value);
-      const written = fs11.writeSync(fd, bytes);
+      const written = fs12.writeSync(fd, bytes);
       if (written !== bytes.length)
         return err("unavailable", `short write to ${file}: ${written} of ${bytes.length} bytes; the row is torn and will be skipped`);
       return { ok: true, value: undefined };
     } finally {
-      fs11.closeSync(fd);
+      fs12.closeSync(fd);
     }
   };
   try {
-    fs11.mkdirSync(path13.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path13.dirname(file)))
+    fs12.mkdirSync(path14.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path14.dirname(file)))
       return write();
     const locked = withLedgerLock(file, write);
     return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
@@ -23287,8 +23385,10 @@ function readLedger(cwd, options = {}) {
   if (!file.ok)
     return file;
   let text = "";
+  let stat = null;
   try {
-    text = fs11.readFileSync(file.value, "utf8");
+    stat = fs12.statSync(file.value);
+    text = fs12.readFileSync(file.value, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return {
@@ -23307,6 +23407,7 @@ function readLedger(cwd, options = {}) {
   const integrity = { chained: 0, legacy: 0, unverified: [] };
   const earlier = new Set([null]);
   let chainStarted = false;
+  const ids = new Set;
   for (const raw of text.split(`
 `)) {
     const trimmed = raw.trim();
@@ -23340,6 +23441,10 @@ function readLedger(cwd, options = {}) {
       reason = "unsigned";
     else
       rowIntegrity = "legacy";
+    if (options.integrity && !reason && ids.has(parsed.id))
+      reason = "duplicate_id";
+    if (options.integrity)
+      ids.add(parsed.id);
     if (reason)
       rowIntegrity = "unverified";
     const pr = typeof parsed.pr === "number" && Number.isInteger(parsed.pr) ? parsed.pr : undefined;
@@ -23363,7 +23468,8 @@ function readLedger(cwd, options = {}) {
       seq: rows.length + 1,
       superseded: false,
       supersedeIgnored: false,
-      ...rowIntegrity ? { integrity: rowIntegrity } : {}
+      ...rowIntegrity ? { integrity: rowIntegrity } : {},
+      ...reason ? { integrityReason: reason } : {}
     };
     rows.push(row);
     if (!options.integrity)
@@ -23391,18 +23497,48 @@ function readLedger(cwd, options = {}) {
   const byId = new Map;
   for (const row of rows) {
     const target = row.supersedes ? byId.get(row.supersedes) : undefined;
-    if (target && supersedeAllowed(row, target, renameAwareBranch(scopeOf, row.branch)) === null)
+    if (target && row.integrity !== "unverified" && supersedeAllowed(row, target, renameAwareBranch(scopeOf, row.branch)) === null)
       target.superseded = true;
     else if (row.supersedes)
       row.supersedeIgnored = true;
     if (!byId.has(row.id))
       byId.set(row.id, row);
   }
+  if (options.integrity && stat && Buffer.byteLength(text) === stat.size)
+    tamperCache.set(file.value, {
+      size: stat.size,
+      stamp: fileStamp(stat),
+      breaks: integrity.unverified.filter((row) => TAMPER_REASONS.has(row.reason))
+    });
   return {
     ok: true,
     value: { path: file.value, rows, skipped, integrity: options.integrity ? integrity : null }
   };
 }
+var TAMPER_REASONS = new Set(["hash_mismatch", "broken_link"]);
+var tamperCache = new Map;
+var fileStamp = (stat) => `${stat.ino}:${stat.mtimeMs}:${stat.ctimeMs}`;
+function ledgerTampering(cwd) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return [];
+  try {
+    const stat = fs12.statSync(file.value);
+    const cached = tamperCache.get(file.value);
+    if (cached && cached.size === stat.size && cached.stamp === fileStamp(stat))
+      return cached.breaks;
+  } catch {
+    return [];
+  }
+  const read = readLedger(cwd, { integrity: true });
+  return read.ok ? (read.value.integrity?.unverified ?? []).filter((row) => TAMPER_REASONS.has(row.reason)) : [];
+}
+function tamperedUnblock(cwd) {
+  const file = ledgerPath(cwd);
+  const where = file.ok ? file.value : "the ledger file";
+  return `workit ledger verify-integrity  # lists the edited or missing rows; if the edit is understood, move ${where} aside (mv ${where} ${where}.tampered-<date>) and record the verdicts again`;
+}
+var tamperedWarning = (cwd, breaks) => `the ledger was edited, or a row was removed or moved (${breaks.slice(0, 3).map((row) => `${row.reason} at row ${row.seq}`).join(", ")}${breaks.length > 3 ? ", …" : ""}): no verdict is accepted until it is repaired. ${tamperedUnblock(cwd)}`;
 function verdictBasis(verdict, current) {
   if (verdict.head && verdict.head === current.head)
     return "fresh";
@@ -23410,7 +23546,7 @@ function verdictBasis(verdict, current) {
     return "carried";
   return "stale";
 }
-var isLiveVerdict = (row) => row.type === "verdict" && typeof row.result === "string" && !row.superseded;
+var isLiveVerdict = (row, retired) => row.type === "verdict" && typeof row.result === "string" && !retired.has(row.id);
 function trailerSessions(cwd, base, head) {
   if (!base || !head || !safeRef(base) || !safeRef(head))
     return [];
@@ -23491,6 +23627,56 @@ var authoredBy = (authors, session) => {
       return true;
   return false;
 };
+var TRUST_REASONS = new Set([
+  "unsigned",
+  "hash_mismatch",
+  "broken_link",
+  "duplicate_id",
+  "unissued_session",
+  "unbound_session"
+]);
+var SHELL_VOUCHED_HOSTS = new Set([
+  "cli",
+  "opencode",
+  "pi",
+  "codex_cli",
+  "codex_desktop"
+]);
+function sessionTrust(cwd, row) {
+  const session = row.actor.session;
+  if (!session || row.self === true)
+    return null;
+  const source = typeof row.sessionSource === "string" ? row.sessionSource : "env";
+  const host = row.actor.host;
+  const issuedOnly = source === "flag" ? host !== "cli" : source === "env" && session.includes(":") && !SHELL_VOUCHED_HOSTS.has(host);
+  if (!issuedOnly)
+    return null;
+  const binding = issuedBinding(cwd, session);
+  if (binding === null)
+    return "unissued_session";
+  return binding === "token" && row.sessionBound !== true ? "unbound_session" : null;
+}
+function trustReasons(cwd, row) {
+  if (row.integrity === "unverified")
+    return [row.integrityReason ?? "unsigned"];
+  if (row.integrity !== "verified")
+    return ["unsigned"];
+  const session = sessionTrust(cwd, row);
+  return session ? [session] : [];
+}
+function withIntegrity(cwd, rows) {
+  if (rows.every((row) => row.integrity !== undefined))
+    return rows;
+  const read = readLedger(cwd, { integrity: true });
+  const bySeq = new Map(read.ok ? read.value.rows.map((row) => [row.seq, row]) : []);
+  return rows.map((row) => {
+    if (row.integrity !== undefined)
+      return row;
+    const fresh = bySeq.get(row.seq);
+    return fresh && fresh.id === row.id && fresh.at === row.at ? fresh : row;
+  });
+}
+var untrusted = (reasons) => reasons.some((reason) => TRUST_REASONS.has(reason));
 var independenceReasons = (row, authors) => {
   const reasons = [];
   if (!row.actor.session)
@@ -23501,15 +23687,17 @@ var independenceReasons = (row, authors) => {
     reasons.push("self");
   return reasons;
 };
-function effectiveOf(rows, authors, sameCode, isCurrent) {
+function effectiveOf(rows, reasonsOf, sameCode, isCurrent) {
   let effective = null;
   for (const row of rows) {
     if (!effective) {
       effective = row;
       continue;
     }
-    const rowIndependent = independenceReasons(row, authors).length === 0;
-    const effIndependent = independenceReasons(effective, authors).length === 0;
+    if (untrusted(reasonsOf(row)) && !untrusted(reasonsOf(effective)))
+      continue;
+    const rowIndependent = reasonsOf(row).length === 0;
+    const effIndependent = reasonsOf(effective).length === 0;
     if (effIndependent && !rowIndependent && isCurrent(effective))
       continue;
     if (effIndependent && FAILING.has(String(effective.result)) && row.actor.session === effective.actor.session && sameCode(effective, row))
@@ -23523,7 +23711,7 @@ function restackCarries(rows, branch, from, to) {
     return false;
   const edges = new Map;
   for (const row of rows)
-    if (row.type === "stack.restacked" && row.observer === "workit_cli" && row.branch === branch && row.patchEqual === true && typeof row.fromHead === "string" && row.head)
+    if (row.type === "stack.restacked" && row.observer === "workit_cli" && row.integrity === "verified" && row.branch === branch && row.patchEqual === true && typeof row.fromHead === "string" && row.head)
       edges.set(row.fromHead, [...edges.get(row.fromHead) ?? [], row.head]);
   const seen = new Set([from]);
   const queue = [from];
@@ -23539,7 +23727,8 @@ function restackCarries(rows, branch, from, to) {
   }
   return false;
 }
-function checkVerdicts(cwd, branch, rows) {
+function checkVerdicts(cwd, branch, ledgerRows) {
+  const rows = withIntegrity(cwd, ledgerRows);
   const head = branchHead(cwd, branch);
   const fallbackBase = defaultBase(cwd);
   const scope = branchScope(cwd, branch);
@@ -23569,21 +23758,47 @@ function checkVerdicts(cwd, branch, rows) {
     return verdictBasis(failed, { head: row.head, ...keys }) !== "stale" || restackCarries(rows, branch, failed.head, row.head);
   };
   const authors = authorSessions(cwd, rows, branch, { base: fallbackBase, head }, scope);
+  const failureAuthorCache = new Map;
+  const failureAuthors = (row) => {
+    let set = failureAuthorCache.get(row.seq);
+    if (!set) {
+      set = authorSessions(cwd, rows.filter((other) => other.integrity === "verified" && other.seq < row.seq), branch, { base: null, head: null }, scope);
+      failureAuthorCache.set(row.seq, set);
+    }
+    return set;
+  };
+  const reasonCache = new Map;
+  const reasonsOf = (row) => {
+    let reasons = reasonCache.get(row);
+    if (!reasons) {
+      const failing = FAILING.has(String(row.result));
+      reasons = [
+        ...trustReasons(cwd, row),
+        ...independenceReasons(row, failing ? failureAuthors(row) : authors)
+      ];
+      reasonCache.set(row, reasons);
+    }
+    return reasons;
+  };
+  const retired = new Set;
+  for (const row of rows)
+    if (row.type === "verdict" && row.supersedes && !row.supersedeIgnored && trustReasons(cwd, row).length === 0)
+      retired.add(row.supersedes);
   const byKind = new Map;
   for (const row of rows)
-    if (isLiveVerdict(row) && scope(row)) {
+    if (isLiveVerdict(row, retired) && scope(row)) {
       const kind = typeof row.kind === "string" ? row.kind : "review";
       byKind.set(kind, [...byKind.get(kind) ?? [], row]);
     }
   const verdicts = [];
   const warnings = [];
   for (const [kind, list] of byKind) {
-    const row = effectiveOf(list, authors, sameCode, (candidate) => basisOf(candidate) !== "stale");
+    const row = effectiveOf(list, reasonsOf, sameCode, (candidate) => basisOf(candidate) !== "stale");
     if (!row)
       continue;
     const basis = basisOf(row);
     const current = basis !== "stale";
-    const independence = independenceReasons(row, authors);
+    const independence = reasonsOf(row);
     const reasons = [
       ...current ? [] : ["stale"],
       ...PASSING.has(String(row.result)) ? [] : ["not_passing"],
@@ -23600,23 +23815,31 @@ function checkVerdicts(cwd, branch, rows) {
     });
     if (reasons.length === 0) {
       for (const later of list)
-        if (later.seq > row.seq && independenceReasons(later, authors).length > 0 && FAILING.has(String(later.result)) && basisOf(later) !== "stale")
+        if (later.seq > row.seq && reasonsOf(later).length > 0 && !untrusted(reasonsOf(later)) && FAILING.has(String(later.result)) && basisOf(later) !== "stale")
           warnings.push(`the author's own (self) ${String(later.result)} ${kind} verdict ${later.id} by ${later.actor.session ?? "no session"} on the current code is newer than the accepted pass ${row.id}: read it before merging`);
     }
   }
   for (const row of rows)
     if (row.integrity === "unverified" && scope(row))
       warnings.push(`ledger row ${row.id} (${row.type}) on ${row.branch ?? branch} is unverified: the workit CLI did not write it or it changed afterwards (workit ledger verify-integrity)`);
+  const tampered = ledgerTampering(cwd);
+  if (tampered.length) {
+    warnings.push(tamperedWarning(cwd, tampered));
+    for (const entry of verdicts) {
+      entry.accepted = false;
+      entry.reasons = [...entry.reasons, "ledger_tampered"];
+    }
+  }
   verdicts.sort((a, b) => a.verdict.seq - b.verdict.seq);
   const newestCurrent = verdicts.findLast((entry) => entry.current) ?? verdicts.at(-1) ?? null;
   const failing = verdicts.find((entry) => entry.current && entry.independent && FAILING.has(String(entry.verdict.result)));
   const newestAccepted = verdicts.findLast((entry) => entry.accepted && STRONG_RESULTS.has(String(entry.verdict.result))) ?? null;
-  const accepted = newestAccepted && !failing ? { accepted: true, verdict: newestAccepted.verdict, reasons: [] } : {
+  const accepted = tampered.length ? { accepted: false, verdict: null, reasons: ["ledger_tampered"] } : newestAccepted && !failing ? { accepted: true, verdict: newestAccepted.verdict, reasons: [] } : {
     accepted: false,
     verdict: failing?.verdict ?? null,
     reasons: failing ? ["failing_verdict"] : !newestCurrent ? ["no_verdict"] : newestCurrent.reasons.length ? newestCurrent.reasons : ["type_check_only"]
   };
-  const selfEntry = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && STRONG_RESULTS.has(String(entry.verdict.result)));
+  const selfEntry = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && !untrusted(entry.reasons) && STRONG_RESULTS.has(String(entry.verdict.result)));
   return {
     branch,
     head,
@@ -23779,7 +24002,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path14.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path15.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -23827,15 +24050,15 @@ function derivedRuleStatus(task, requirement, root, ledger) {
 }
 
 // packages/workit-core/src/core/task-evaluation.ts
-var digestBytes = (value) => createHash9("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path15.sep}`);
-var relative = (root, candidate) => path15.relative(root, candidate).split(path15.sep).join("/") || ".";
+var digestBytes = (value) => createHash10("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path16.sep}`);
+var relative = (root, candidate) => path16.relative(root, candidate).split(path16.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path15.posix.normalize(value);
+  const normalized = path16.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -23883,21 +24106,21 @@ var gitPaths = (root) => {
       git: !/not a git repository/i.test(stderr)
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path16.sep).join("/")) : [];
   const stagedDeleted = spawnSync10("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))
       return { paths, uncertain: true, git: true };
   } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path16.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs12.readdirSync(directory);
+    names = fs13.readdirSync(directory);
   } catch {
     return true;
   }
@@ -23905,10 +24128,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path15.join(directory, name);
+    const target = path16.join(directory, name);
     let stat;
     try {
-      stat = fs12.lstatSync(target);
+      stat = fs13.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -23923,14 +24146,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path15.resolve(root, item);
+    const target = path16.resolve(root, item);
     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 (!fs12.existsSync(ancestor) && ancestor !== root)
-      ancestor = path15.dirname(ancestor);
+    while (!fs13.existsSync(ancestor) && ancestor !== root)
+      ancestor = path16.dirname(ancestor);
     try {
-      if (!inside(root, fs12.realpathSync(ancestor)))
+      if (!inside(root, fs13.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}`);
@@ -23942,7 +24165,7 @@ var scopeRoots = (root, scope) => {
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs12.realpathSync(root);
+    checkout = fs13.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -23960,11 +24183,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs12.existsSync(target))
+    if (!fs13.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs12.lstatSync(target);
+      stat = fs13.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -23980,17 +24203,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path15.join(checkout, item);
+    const target = path16.join(checkout, item);
     try {
-      const stat = fs12.lstatSync(target);
+      const stat = fs13.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs12.readlinkSync(target);
+        const link = fs13.readlinkSync(target);
         files.push({ path: item, kind: "symlink", digest: digestBytes(link), executable: null });
       } else if (stat.isFile()) {
         files.push({
           path: item,
           kind: "file",
-          digest: digestBytes(fs12.readFileSync(target)),
+          digest: digestBytes(fs13.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -24155,7 +24378,7 @@ var findingVerificationPasses = (findingCandidateId, evidence) => evidence.statu
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs12.realpathSync(checkoutRoot);
+    root = fs13.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -24164,23 +24387,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path15.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path15.sep}`))
+    const target = path16.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path16.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const below = path15.relative(root, target);
+      const below = path16.relative(root, target);
       let current = root;
-      for (const segment of below.split(path15.sep)) {
+      for (const segment of below.split(path16.sep)) {
         if (!segment)
           continue;
-        current = path15.join(current, segment);
-        const stat = fs12.lstatSync(current);
-        const real = fs12.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path15.sep}`))
+        current = path16.join(current, segment);
+        const stat = fs13.lstatSync(current);
+        const real = fs13.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path16.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -24196,7 +24419,7 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         if (current !== target && !stat.isDirectory())
           return failure2("invalid_input", "document reference ancestor is not a directory");
       }
-      if (digestBytes(fs12.readFileSync(target)) !== reference.digest)
+      if (digestBytes(fs13.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "decision document bytes have changed");
     } catch {
       return failure2("invalid_input", "decision document is unavailable");
@@ -25054,7 +25277,7 @@ var judgeInputSummary = (raw) => {
 
 // packages/workit-core/src/autonomy.ts
 import os4 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 var accountHome = () => {
   try {
     return os4.userInfo().homedir;
@@ -25063,10 +25286,10 @@ var accountHome = () => {
   }
 };
 var grantsHome = { resolve: accountHome };
-var grantsDir = () => path16.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path17.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path16.resolve(resolveConfigDir());
-  return configured === path16.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path16.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  const configured = path17.resolve(resolveConfigDir());
+  return configured === path17.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path17.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -26838,7 +27061,7 @@ class WorkitCore {
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -26972,7 +27195,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path17.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path18.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -27003,7 +27226,7 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path17.join(cwd, "package.json");
+  const pkgPath = path18.join(cwd, "package.json");
   if (!existsSync6(pkgPath))
     return [];
   try {
@@ -27029,9 +27252,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path17.join(dir, entry.name), depth + 1);
+        walk(path18.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path17.relative(cwd, path17.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path18.relative(cwd, path18.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -27047,7 +27270,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path17.resolve(repoRoot(root));
+  const cwd = path18.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -27105,7 +27328,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed2(path17.join(cwd, template), 220);
+    stdout += readTrimmed2(path18.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -27115,7 +27338,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync6(path17.join(cwd, "package.json"))) {
+  if (existsSync6(path18.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -27124,7 +27347,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync6(path17.join(cwd, "Cargo.toml")) || existsSync6(path17.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync6(path18.join(cwd, "Cargo.toml")) || existsSync6(path18.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -27157,7 +27380,7 @@ var CHANGELOG_RULES = `- Use an [Unreleased] section.
 - Apply with the host-native editor, preserving the repository changelog conventions.
 - If Unreleased already has duplicate category headings, normalize_only first.`;
 function changelogContext(root, range) {
-  const cwd = path17.resolve(repoRoot(root));
+  const cwd = path18.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -27175,7 +27398,7 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path17.join(cwd, "CHANGELOG.md");
+  const changelogPath = path18.join(cwd, "CHANGELOG.md");
   if (existsSync6(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
@@ -27195,7 +27418,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path17.resolve(repoRoot(root));
+  const cwd = path18.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -27217,7 +27440,7 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path17.join(cwd, "README.md");
+  const readme = path18.join(cwd, "README.md");
   if (existsSync6(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
@@ -27226,7 +27449,7 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path17.join(cwd, "package.json");
+  const pkgPath = path18.join(cwd, "package.json");
   if (existsSync6(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
@@ -27240,7 +27463,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path17.resolve(repoRoot(root));
+  const cwd = path18.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -27278,7 +27501,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync6(path17.join(cwd, rel)))
+    if (existsSync6(path18.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -27309,8 +27532,8 @@ function releaseNotesContext(root, rangeOrTag) {
 import { spawnSync as spawnSync13 } from "node:child_process";
 
 // packages/workit-core/src/core/pr-create.ts
-import fs13 from "node:fs";
-import path18 from "node:path";
+import fs14 from "node:fs";
+import path19 from "node:path";
 import { spawnSync as spawnSync12 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
@@ -27321,13 +27544,13 @@ function parseGhIssue(value) {
 // packages/workit-core/src/core/pr-create.ts
 function whichOnPath(tool) {
   const names = process.platform === "win32" ? [tool, `${tool}.exe`, `${tool}.cmd`] : [tool];
-  for (const dir of (process.env.PATH ?? "").split(path18.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path19.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path18.join(dir, name);
+      const candidate = path19.join(dir, name);
       try {
-        fs13.accessSync(candidate, fs13.constants.X_OK);
+        fs14.accessSync(candidate, fs14.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -27445,8 +27668,8 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 
 // packages/workit-core/src/core/youtrack.ts
-import fs14 from "node:fs";
-import path19 from "node:path";
+import fs15 from "node:fs";
+import path20 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -27459,22 +27682,22 @@ var resolveWorkspaceRoot = (explicit) => explicit || process.cwd();
 // packages/workit-core/src/core/youtrack.ts
 var ISSUE_RE = /^[A-Z]+-\d+$/;
 var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path19.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path19.join(resolveConfigDir(), "youtrack.json");
+var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path20.join(configDir(), "youtrack.json");
+var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path20.join(resolveConfigDir(), "youtrack.json");
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs14.statSync(p).mode & 511;
+  const mode = fs15.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs14.existsSync(cfgPath)) {
+  if (!fs15.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -27485,11 +27708,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs14.existsSync(cfgPath))
+  if (!fs15.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -27528,12 +27751,12 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path19.isAbsolute(tokenFile) ? path19.resolve(tokenFile) : path19.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs14.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path20.isAbsolute(tokenFile) ? path20.resolve(tokenFile) : path20.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs15.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs14.readFileSync(tokenPath, "utf8").trim();
+  const token = fs15.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -27598,9 +27821,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs14.existsSync(full))
+    if (!fs15.existsSync(full))
       continue;
-    const text = fs14.readFileSync(full, "utf8");
+    const text = fs15.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -27870,15 +28093,15 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path20.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path20.sep)) {
+  const target = path21.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path21.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync7(ancestor))
-    ancestor = path20.dirname(ancestor);
+    ancestor = path21.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path20.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path21.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -27936,13 +28159,13 @@ var rootVariants = (workspaceRoot) => {
   if (!workspaceRoot)
     return [];
   const roots = new Set;
-  for (const candidate of [workspaceRoot, path21.resolve(workspaceRoot)]) {
-    if (path21.isAbsolute(candidate) && candidate !== path21.parse(candidate).root)
+  for (const candidate of [workspaceRoot, path22.resolve(workspaceRoot)]) {
+    if (path22.isAbsolute(candidate) && candidate !== path22.parse(candidate).root)
       roots.add(candidate);
   }
   try {
     const canonical = realpathSync6(workspaceRoot);
-    if (canonical !== path21.parse(canonical).root)
+    if (canonical !== path22.parse(canonical).root)
       roots.add(canonical);
   } catch {}
   return [...roots].toSorted((left, right) => right.length - left.length);
@@ -28024,11 +28247,11 @@ var thrownResult = (tool, error, workspaceRoot) => {
 };
 function createMcpServer(host, contextProvider) {
   assertMcpHost(host);
-  const here = path21.dirname(fileURLToPath2(import.meta.url));
+  const here = path22.dirname(fileURLToPath2(import.meta.url));
   const sourceMarker = markSourcesLoaded([
-    path21.join(here, "server.ts"),
-    path21.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
-    path21.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
+    path22.join(here, "server.ts"),
+    path22.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
+    path22.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
   ].filter((file) => existsSync8(file)));
   let staleWarned = false;
   const server = new Server({ name: "workit", version: VERSION }, { capabilities: { tools: {}, resources: {} } });
@@ -28208,8 +28431,8 @@ var main = async () => {
     process.exitCode = 2;
   }
 };
-var entryPath = process.argv[1] ? path22.resolve(process.argv[1]) : "";
-if (entryPath === path22.resolve(fileURLToPath3(import.meta.url)))
+var entryPath = process.argv[1] ? path23.resolve(process.argv[1]) : "";
+if (entryPath === path23.resolve(fileURLToPath3(import.meta.url)))
   await main();
 // packages/workit-core/src/hooks/descriptor.ts
 var support = (descriptor, axis) => {
@@ -28437,7 +28660,7 @@ var cursorContextProvider = (workspaceRoot = process.env.WORKFLOW_WORKSPACE_ROOT
 var stampCursorSessionStart = (stateDir = resolveStateDir()) => {
   try {
     mkdirSync3(stateDir, { recursive: true });
-    writeFileSync3(path23.join(stateDir, "cursor-session-last-start"), `${JSON.stringify({ at: new Date().toISOString() })}
+    writeFileSync3(path24.join(stateDir, "cursor-session-last-start"), `${JSON.stringify({ at: new Date().toISOString() })}
 `);
   } catch {}
 };