@brainervirus/workit-codex 8.9.1 → 8.11.0

package/dist/{workit-hook-vjkepg0b.js → workit-hook-gtdf2ra8.js}

@@ -24,9 +24,9 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
-import { createHash as createHash10 } from "node:crypto";
-import fs13 from "node:fs";
-import path16 from "node:path";
+import { createHash as createHash11 } from "node:crypto";
+import fs14 from "node:fs";
+import path17 from "node:path";
 
 // packages/workit-core/src/core/methods.ts
 var METHODS = {
@@ -101,7 +101,8 @@ Autonomy contract:
   satisfies a gate; an ad-hoc \`workit check -- <cmd>\` never does.
 - Author is not verifier: your own verdict is \`--self\`, shown as
   self-reviewed, never verified. High risk, \`verification: independent\` and
-  merge need a verifier with its own session (\`WORKIT_SESSION_ID=<lead>-v<n>\`).
+  merge need a verifier with its own host-derived session (a subagent's
+  \`<lead>:<child>\`, set by the host); never hand-mint one such as \`<lead>-v1\`.
 - A local-commit endpoint does not imply PR readiness, and a local commit alone
   is not evidence of a requested remote push. Before reporting delivery,
   reconcile every requested item and observe it (\`workit verify-delivery\`).
@@ -8787,10 +8788,10 @@ function requirementId(input) {
 }
 
 // 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 path14 from "node:path";
+import path15 from "node:path";
 
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -9179,9 +9180,9 @@ function pushRemoteName(cwd, branch) {
 }
 
 // packages/workit-core/src/core/task-store.ts
-import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
-import * as fs9 from "node:fs";
-import path8 from "node:path";
+import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
+import * as fs10 from "node:fs";
+import path9 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -9785,6 +9786,9 @@ function acquireFileLockSync(targetPath, options) {
   }
 }
 // packages/workit-core/src/host-session.ts
+import { createHash as createHash4 } from "node:crypto";
+import fs7 from "node:fs";
+import path6 from "node:path";
 var HOST_SESSION_VARS = [
   ["OPENCODE_SESSION_ID", () => "opencode"],
   ["PI_SESSION_ID", () => "pi"],
@@ -9812,16 +9816,44 @@ function hostSessionFromEnv(env) {
   }
   return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
 }
+var ISSUED_PER_LEAD = 64;
+var ISSUED_SESSIONS_MARKER = "workit-issued-sessions/1";
+var hash = (value) => createHash4("sha256").update(value).digest("hex").slice(0, 32);
+var issuedRoot = (cwd) => {
+  const location = resolveStore(cwd);
+  return location instanceof Error ? null : path6.join(location.dir, "hooks", "issued");
+};
+var issuedDir = (cwd, lead) => {
+  const root = issuedRoot(cwd);
+  return root === null ? null : path6.join(root, hash(lead));
+};
+function recordIssuedSession(cwd, lead, issued) {
+  try {
+    const dir = issuedDir(cwd, lead);
+    if (!dir)
+      return;
+    fs7.mkdirSync(dir, { recursive: true });
+    const own = hash(issued);
+    fs7.writeFileSync(path6.join(dir, own), ISSUED_SESSIONS_MARKER);
+    const entries = fs7.readdirSync(dir);
+    if (entries.length <= ISSUED_PER_LEAD)
+      return;
+    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs7.statSync(path6.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
+    for (const { name } of byAge.slice(0, entries.length - ISSUED_PER_LEAD))
+      fs7.rmSync(path6.join(dir, name), { force: true });
+  } catch {}
+}
+var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
 
 // packages/workit-core/src/core/package-root.ts
 import { existsSync } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  let dir = path7.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path6.dirname(dir);
-    if (existsSync(path6.join(dir, "package.json")) || parent === dir)
+    const parent = path7.dirname(dir);
+    if (existsSync(path7.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
@@ -9829,7 +9861,7 @@ var packageRoot = () => {
 
 // packages/workit-core/src/core/store-lock.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import { hostname } from "node:os";
 var metadataLockSchema = object({
   pid: number2().int().nonnegative().safe(),
@@ -9871,7 +9903,7 @@ var parseProcStatStart = (stat) => {
 var processStartOf = (pid) => {
   if (process.platform === "linux") {
     try {
-      return parseProcStatStart(fs7.readFileSync(`/proc/${pid}/stat`, "utf8"));
+      return parseProcStatStart(fs8.readFileSync(`/proc/${pid}/stat`, "utf8"));
     } catch {
       return null;
     }
@@ -9892,7 +9924,7 @@ var processStartOf = (pid) => {
 };
 var readTrimmed = (file) => {
   try {
-    return fs7.readFileSync(file, "utf8").trim() || null;
+    return fs8.readFileSync(file, "utf8").trim() || null;
   } catch {
     return null;
   }
@@ -9903,7 +9935,7 @@ var localLockHost = () => {
     return cachedLockHost;
   let pidns = null;
   try {
-    pidns = /\[(\d+)\]/.exec(fs7.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
+    pidns = /\[(\d+)\]/.exec(fs8.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
   } catch {}
   const boot = readTrimmed("/proc/sys/kernel/random/boot_id");
   cachedLockHost = pidns || boot ? `${hostname()}#${pidns ?? "?"}:${boot ?? "?"}` : hostname();
@@ -9949,7 +9981,7 @@ var classifyLockOwner = (payload, ageMs, localHost = localLockHost(), options =
 };
 var ageOf = (file, nowMs) => {
   try {
-    return nowMs - fs7.lstatSync(file).mtimeMs;
+    return nowMs - fs8.lstatSync(file).mtimeMs;
   } catch {
     return null;
   }
@@ -9960,7 +9992,7 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
   if (age === null || age <= RECLAIM_GUARD_TTL_MS)
     return false;
   try {
-    fs7.rmdirSync(guard);
+    fs8.rmdirSync(guard);
     return true;
   } catch {
     return false;
@@ -9969,8 +10001,8 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
 
 // packages/workit-core/src/store/event-log.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import fs8 from "node:fs";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import path8 from "node:path";
 var EVENT_VERSION = 1;
 
 class LogDamage extends Error {
@@ -9999,7 +10031,7 @@ var parseEvent = (line, file, offset) => {
 function readLog(file, from = 0, expectSeq = null) {
   let fd;
   try {
-    fd = fs8.openSync(file, "r");
+    fd = fs9.openSync(file, "r");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -10008,13 +10040,13 @@ function readLog(file, from = 0, expectSeq = null) {
   let bytes;
   let size;
   try {
-    size = fs8.fstatSync(fd).size;
+    size = fs9.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 = fs8.readSync(fd, bytes, read, bytes.length - read, from + read);
+      const got = fs9.readSync(fd, bytes, read, bytes.length - read, from + read);
       if (got === 0)
         break;
       read += got;
@@ -10022,7 +10054,7 @@ function readLog(file, from = 0, expectSeq = null) {
     bytes = bytes.subarray(0, read);
     size = from + read;
   } finally {
-    fs8.closeSync(fd);
+    fs9.closeSync(fd);
   }
   const events = [];
   let start = 0;
@@ -10047,11 +10079,11 @@ function readLog(file, from = 0, expectSeq = null) {
 }
 var fsyncDirectory = (dir) => {
   try {
-    const fd = fs8.openSync(dir, "r");
+    const fd = fs9.openSync(dir, "r");
     try {
-      fs8.fsyncSync(fd);
+      fs9.fsyncSync(fd);
     } finally {
-      fs8.closeSync(fd);
+      fs9.closeSync(fd);
     }
   } catch (error) {
     if (process.platform !== "win32")
@@ -10061,46 +10093,46 @@ var fsyncDirectory = (dir) => {
 function appendEvent(file, event, validEnd) {
   const line = Buffer.from(`${JSON.stringify(event)}
 `, "utf8");
-  const created = !fs8.existsSync(file);
-  if (!created && fs8.statSync(file).size !== validEnd) {
-    const cut = fs8.openSync(file, "r+");
+  const created = !fs9.existsSync(file);
+  if (!created && fs9.statSync(file).size !== validEnd) {
+    const cut = fs9.openSync(file, "r+");
     try {
-      fs8.ftruncateSync(cut, validEnd);
-      fs8.fsyncSync(cut);
+      fs9.ftruncateSync(cut, validEnd);
+      fs9.fsyncSync(cut);
     } finally {
-      fs8.closeSync(cut);
+      fs9.closeSync(cut);
     }
   }
-  const fd = fs8.openSync(file, "a", 384);
+  const fd = fs9.openSync(file, "a", 384);
   try {
     let written = 0;
     while (written < line.length)
-      written += fs8.writeSync(fd, line, written, line.length - written);
-    fs8.fsyncSync(fd);
+      written += fs9.writeSync(fd, line, written, line.length - written);
+    fs9.fsyncSync(fd);
   } finally {
-    fs8.closeSync(fd);
+    fs9.closeSync(fd);
   }
   if (created)
-    fsyncDirectory(path7.dirname(file));
+    fsyncDirectory(path8.dirname(file));
   return validEnd;
 }
 function replaceFile(file, bytes, durable) {
   const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
   try {
-    const fd = fs8.openSync(temporary, "wx", 384);
+    const fd = fs9.openSync(temporary, "wx", 384);
     try {
-      fs8.writeSync(fd, bytes);
+      fs9.writeSync(fd, bytes);
       if (durable)
-        fs8.fsyncSync(fd);
+        fs9.fsyncSync(fd);
     } finally {
-      fs8.closeSync(fd);
+      fs9.closeSync(fd);
     }
     renameWithRetry(temporary, file);
     if (durable)
-      fsyncDirectory(path7.dirname(file));
+      fsyncDirectory(path8.dirname(file));
   } catch (error) {
     try {
-      fs8.unlinkSync(temporary);
+      fs9.unlinkSync(temporary);
     } catch {}
     throw error;
   }
@@ -10125,7 +10157,7 @@ var retryTransient = (run) => {
     }
   }
 };
-var renameWithRetry = (from, to) => retryTransient(() => fs8.renameSync(from, to));
+var renameWithRetry = (from, to) => retryTransient(() => fs9.renameSync(from, to));
 
 // packages/workit-core/src/store/patch.ts
 var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -10238,7 +10270,7 @@ var isPatch = (value) => Array.isArray(value) && value.every((op) => {
 });
 
 // packages/workit-core/src/store/reduce.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 var OPENING_TYPES = new Set([
   "task.opened",
   "task.imported",
@@ -10267,7 +10299,7 @@ var isObject3 = (value) => typeof value === "object" && value !== null && !Array
 var isKey = (value) => isObject3(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) => isObject3(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) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
+var blobDigest = (value) => createHash5("sha256").update(JSON.stringify(value)).digest("hex");
 var toBlob = (value, blobs) => {
   if (!isObject3(value))
     return value;
@@ -10422,7 +10454,7 @@ var indexEntry = (task, key, legacy, file) => {
 };
 var fileSignature = (file) => {
   try {
-    const stat = fs9.statSync(file, { bigint: true });
+    const stat = fs10.statSync(file, { bigint: true });
     return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
   } catch {
     return null;
@@ -10440,7 +10472,7 @@ var cachedRuntimeVersion = null;
 var runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs9.readFileSync(path8.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs10.readFileSync(path9.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -10466,14 +10498,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 fs9.readFileSync(file, "utf8");
+    return fs10.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(path8.join(path8.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+  const first = readText(path9.join(path9.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];
@@ -10483,7 +10515,7 @@ var branchStart = (location, branch, aliases) => {
     return start;
   if (!location.git)
     return null;
-  for (const line of readText(path8.join(location.git.gitDir, "logs", "HEAD")).split(`
+  for (const line of readText(path9.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]);
@@ -10493,23 +10525,23 @@ var branchStart = (location, branch, aliases) => {
   }
   return null;
 };
-var refExists = (common, ref) => fs9.existsSync(path8.join(common, ref)) || readText(path8.join(common, "packed-refs")).includes(` ${ref}
+var refExists = (common, ref) => fs10.existsSync(path9.join(common, ref)) || readText(path9.join(common, "packed-refs")).includes(` ${ref}
 `);
 var origins = new Map;
 var sameDirectoryIdentity = (left, right) => {
-  if (!path8.isAbsolute(left) || !path8.isAbsolute(right))
+  if (!path9.isAbsolute(left) || !path9.isAbsolute(right))
     return false;
-  const normalizedLeft = path8.resolve(left);
-  const normalizedRight = path8.resolve(right);
+  const normalizedLeft = path9.resolve(left);
+  const normalizedRight = path9.resolve(right);
   try {
-    const a = fs9.statSync(normalizedLeft, { bigint: true });
-    const b = fs9.statSync(normalizedRight, { bigint: true });
+    const a = fs10.statSync(normalizedLeft, { bigint: true });
+    const b = fs10.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 = fs9.realpathSync(normalizedLeft);
-    const canonicalRight = fs9.realpathSync(normalizedRight);
+    const canonicalLeft = fs10.realpathSync(normalizedLeft);
+    const canonicalRight = fs10.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;
@@ -10546,8 +10578,8 @@ class TaskStore {
   migrationChecked = false;
   compactDue = new Set;
   constructor(root, options = {}) {
-    const resolved = path8.resolve(root);
-    this.origin = fs9.existsSync(resolved) ? fs9.realpathSync(resolved) : resolved;
+    const resolved = path9.resolve(root);
+    this.origin = fs10.existsSync(resolved) ? fs10.realpathSync(resolved) : resolved;
     this.located = resolveStore(this.origin);
     this.root = checkoutRootOf(this.origin, this.located);
     this.lockTimeoutMs = options.lockTimeoutMs ?? defaultLockTimeout();
@@ -10555,7 +10587,7 @@ class TaskStore {
     this.migrateOnRead = options.migrateOnRead;
   }
   location() {
-    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs9.existsSync(path8.join(this.root, ".git"))) {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs10.existsSync(path9.join(this.root, ".git"))) {
       this.located = undefined;
       this.migrationChecked = false;
     }
@@ -10619,7 +10651,7 @@ class TaskStore {
     const tasksDir = this.paths().tasks;
     let names;
     try {
-      names = fs9.existsSync(tasksDir) ? fs9.readdirSync(tasksDir).filter((name) => validId(name)) : [];
+      names = fs10.existsSync(tasksDir) ? fs10.readdirSync(tasksDir).filter((name) => validId(name)) : [];
     } catch (error) {
       return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
         path: tasksDir
@@ -10660,7 +10692,7 @@ class TaskStore {
     const file = this.paths().workspace;
     let bytes;
     try {
-      bytes = retryTransient(() => fs9.readFileSync(file, "utf8"));
+      bytes = retryTransient(() => fs10.readFileSync(file, "utf8"));
     } catch (error) {
       if (error.code === "ENOENT")
         return success(null, null, null);
@@ -10711,7 +10743,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" : path8.basename(this.root) || this.root;
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path9.basename(this.root) || this.root;
       const intent = {
         objective: input.objective?.trim() || `Work on ${label}`,
         scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
@@ -10771,14 +10803,14 @@ class TaskStore {
     const branch = key.ok ? key.data.branch : null;
     if (!branch || !location.ok)
       return success(null, null, null);
-    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 common = path9.dirname(location.data.dir);
+    const heads = path9.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path9.join(location.data.git.gitDir, "logs", "HEAD") : "";
     const signatures = [
-      path8.join(heads, branch),
+      path9.join(heads, branch),
       headLog,
       heads,
-      path8.join(common, "packed-refs")
+      path9.join(common, "packed-refs")
     ].map((file) => fileSignature(file) ?? "-");
     const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
     let resolved = origins.get(slot);
@@ -10790,7 +10822,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(path8.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path9.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
       const name = start && (remote ? start.slice(slash + 1) : start);
       resolved = {
         signature: signatures.join("|"),
@@ -11028,13 +11060,13 @@ class TaskStore {
     if (!ready.ok)
       return ready;
     const dirs = this.paths();
-    const recovery = path8.join(this.root, ".workit", "recovery");
-    if (fs9.existsSync(recovery)) {
+    const recovery = path9.join(this.root, ".workit", "recovery");
+    if (fs10.existsSync(recovery)) {
       let files = 0;
       let bytes = 0;
       try {
-        for (const name of fs9.readdirSync(recovery)) {
-          const stat = fs9.lstatSync(path8.join(recovery, name));
+        for (const name of fs10.readdirSync(recovery)) {
+          const stat = fs10.lstatSync(path9.join(recovery, name));
           if (!stat.isFile())
             continue;
           files += 1;
@@ -11043,17 +11075,17 @@ class TaskStore {
       } catch {}
       const remove = options.pruneRecovery === true && !dryRun;
       if (remove)
-        fs9.rmSync(recovery, { recursive: true, force: true });
+        fs10.rmSync(recovery, { recursive: true, force: true });
       report.legacyRecovery = { path: recovery, files, bytes, removed: remove };
     }
-    if (!fs9.existsSync(dirs.tasks))
+    if (!fs10.existsSync(dirs.tasks))
       return success(null, null, report);
-    const names = fs9.readdirSync(dirs.tasks).filter((name) => validId(name));
+    const names = fs10.readdirSync(dirs.tasks).filter((name) => validId(name));
     for (const name of names) {
       const file = this.eventsPath(name);
       let size = 0;
       try {
-        size = fs9.statSync(file).size;
+        size = fs10.statSync(file).size;
       } catch {
         continue;
       }
@@ -11081,16 +11113,16 @@ class TaskStore {
       const references = new Set;
       for (const name of names)
         try {
-          for (const match of fs9.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
+          for (const match of fs10.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
             references.add(match[1]);
         } catch {}
-      if (fs9.existsSync(dirs.blobs))
-        for (const name of fs9.readdirSync(dirs.blobs)) {
+      if (fs10.existsSync(dirs.blobs))
+        for (const name of fs10.readdirSync(dirs.blobs)) {
           const digest = name.replace(/\.json$/, "");
-          const file = path8.join(dirs.blobs, name);
+          const file = path9.join(dirs.blobs, name);
           let stat;
           try {
-            stat = fs9.lstatSync(file);
+            stat = fs10.lstatSync(file);
           } catch {
             continue;
           }
@@ -11101,11 +11133,11 @@ class TaskStore {
           report.blobs.removed += 1;
           report.blobs.removedBytes += stat.size;
           if (!dryRun)
-            fs9.rmSync(file, { force: true });
+            fs10.rmSync(file, { force: true });
         }
       return success(null, null, null);
     };
-    const swept = dryRun ? sweep() : this.withLock(path8.join(dirs.dir, "gc.lock"), sweep);
+    const swept = dryRun ? sweep() : this.withLock(path9.join(dirs.dir, "gc.lock"), sweep);
     if (!swept.ok)
       return swept;
     const temporaryDirs = [
@@ -11113,17 +11145,17 @@ class TaskStore {
       dirs.tasks,
       dirs.blobs,
       dirs.checkout,
-      ...names.map((name) => path8.join(dirs.tasks, name))
+      ...names.map((name) => path9.join(dirs.tasks, name))
     ];
     for (const directory of temporaryDirs) {
-      if (!fs9.existsSync(directory))
+      if (!fs10.existsSync(directory))
         continue;
-      for (const name of fs9.readdirSync(directory)) {
+      for (const name of fs10.readdirSync(directory)) {
         if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
           continue;
-        const file = path8.join(directory, name);
+        const file = path9.join(directory, name);
         try {
-          const stat = fs9.lstatSync(file);
+          const stat = fs10.lstatSync(file);
           if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
             continue;
         } catch {
@@ -11131,37 +11163,37 @@ class TaskStore {
         }
         report.temporary.removed += 1;
         if (!dryRun)
-          fs9.rmSync(file, { force: true });
+          fs10.rmSync(file, { force: true });
       }
     }
     return success(null, null, report);
   }
   paths() {
     const location = this.location();
-    const dir = location.ok ? location.data.dir : path8.join(this.root, ".workit");
-    const checkout = path8.join(dir, "checkouts", checkoutSlug(this.root));
+    const dir = location.ok ? location.data.dir : path9.join(this.root, ".workit");
+    const checkout = path9.join(dir, "checkouts", checkoutSlug(this.root));
     return {
       dir,
       shared: location.ok ? location.data.shared : false,
-      marker: path8.join(dir, "store.json"),
+      marker: path9.join(dir, "store.json"),
       checkout,
-      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")
+      workspace: path9.join(checkout, "workspace.json"),
+      checkoutLock: path9.join(checkout, "metadata.lock"),
+      tasks: path9.join(dir, "tasks"),
+      index: path9.join(dir, "task-index.json"),
+      blobs: path9.join(dir, "blobs", "candidates"),
+      legacy: path9.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path9.join(this.root, ".workit")
     };
   }
   eventsPath(taskId) {
-    return path8.join(this.paths().tasks, taskId, "events.jsonl");
+    return path9.join(this.paths().tasks, taskId, "events.jsonl");
   }
   snapshotPath(taskId) {
-    return path8.join(this.paths().tasks, taskId, "snapshot.json");
+    return path9.join(this.paths().tasks, taskId, "snapshot.json");
   }
   taskLockPath(taskId) {
-    return path8.join(this.paths().tasks, taskId, "lock");
+    return path9.join(this.paths().tasks, taskId, "lock");
   }
   ready(write = false) {
     const location = this.location();
@@ -11171,7 +11203,7 @@ class TaskStore {
       return success(null, null, null);
     const dirs = this.paths();
     try {
-      const marker = JSON.parse(fs9.readFileSync(dirs.marker, "utf8"));
+      const marker = JSON.parse(fs10.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 {}
@@ -11200,21 +11232,21 @@ class TaskStore {
     return {
       read: (digest) => {
         try {
-          return JSON.parse(fs9.readFileSync(path8.join(dir, `${digest}.json`), "utf8"));
+          return JSON.parse(fs10.readFileSync(path9.join(dir, `${digest}.json`), "utf8"));
         } catch (error) {
           throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
         }
       },
       write: (digest, value) => {
-        const file = path8.join(dir, `${digest}.json`);
-        if (fs9.existsSync(file)) {
+        const file = path9.join(dir, `${digest}.json`);
+        if (fs10.existsSync(file)) {
           const stamp = new Date;
           try {
-            fs9.utimesSync(file, stamp, stamp);
+            fs10.utimesSync(file, stamp, stamp);
             return;
           } catch {}
         }
-        fs9.mkdirSync(dir, { recursive: true });
+        fs10.mkdirSync(dir, { recursive: true });
         replaceFile(file, JSON.stringify(value), true);
       }
     };
@@ -11296,7 +11328,7 @@ class TaskStore {
   }
   readSnapshot(taskId) {
     try {
-      const value = JSON.parse(fs9.readFileSync(this.snapshotPath(taskId), "utf8"));
+      const value = JSON.parse(fs10.readFileSync(this.snapshotPath(taskId), "utf8"));
       if (!isObject4(value) || value.v !== 1 || value.task !== taskId || typeof value.seq !== "number" || typeof value.lastId !== "string" || typeof value.lastStart !== "number" || typeof value.end !== "number" || !isObject4(value.record))
         return null;
       return value;
@@ -11398,8 +11430,8 @@ class TaskStore {
     }
   }
   openTask(record, type, key, legacy = null) {
-    const dir = path8.join(this.paths().tasks, record.id);
-    fs9.mkdirSync(dir, { recursive: true });
+    const dir = path9.join(this.paths().tasks, record.id);
+    fs10.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, {
@@ -11451,11 +11483,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 = fs9.readFileSync(file).subarray(log.end, latest.end);
+        const appended = fs10.readFileSync(file).subarray(log.end, latest.end);
         const bytes = Buffer.concat([Buffer.from(prefix, "utf8"), appended]);
         replaceFile(file, bytes.toString("utf8"), true);
         try {
-          fs9.rmSync(this.snapshotPath(taskId), { force: true });
+          fs10.rmSync(this.snapshotPath(taskId), { force: true });
         } catch {}
         const reloaded = this.load(taskId);
         if (reloaded.ok && reloaded.data)
@@ -11468,7 +11500,7 @@ class TaskStore {
   }
   countEvents(file) {
     try {
-      const bytes = fs9.readFileSync(file);
+      const bytes = fs10.readFileSync(file);
       let count = 0;
       for (let index = bytes.indexOf(10);index >= 0; index = bytes.indexOf(10, index + 1))
         count += 1;
@@ -11490,8 +11522,8 @@ class TaskStore {
     return bound.ok ? success(null, null, bound.data[0] ?? null) : bound;
   }
   withKeyLock(key, operation) {
-    const digest = createHash5("sha256").update(key).digest("hex").slice(0, 32);
-    return this.withLock(path8.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+    const digest = createHash6("sha256").update(key).digest("hex").slice(0, 32);
+    return this.withLock(path9.join(this.paths().dir, "keys", `${digest}.lock`), operation);
   }
   bindLocked(taskId, key, timestamp) {
     const current = this.readWorkspace();
@@ -11632,7 +11664,7 @@ class TaskStore {
   writeWorkspace(record) {
     const file = this.paths().workspace;
     try {
-      fs9.mkdirSync(path8.dirname(file), { recursive: true });
+      fs10.mkdirSync(path9.dirname(file), { recursive: true });
       replaceFile(file, `${canonicalJson(record)}
 `, true);
       return success(null, null, null);
@@ -11642,7 +11674,7 @@ class TaskStore {
   }
   readIndex() {
     try {
-      const value = JSON.parse(fs9.readFileSync(this.paths().index, "utf8"));
+      const value = JSON.parse(fs10.readFileSync(this.paths().index, "utf8"));
       if (!isObject4(value) || value.version !== INDEX_VERSION || !isObject4(value.tasks))
         return {};
       const tasks = {};
@@ -11656,7 +11688,7 @@ class TaskStore {
   }
   writeIndex(entries) {
     try {
-      fs9.mkdirSync(this.paths().tasks, { recursive: true });
+      fs10.mkdirSync(this.paths().tasks, { recursive: true });
       replaceFile(this.paths().index, JSON.stringify({
         version: INDEX_VERSION,
         tasks: Object.fromEntries(entries.map((entry) => [entry.id, entry]))
@@ -11710,23 +11742,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) => path8.join(dir, ".workit"));
+    return [...new Set([this.root, this.origin])].map((dir) => path9.join(dir, ".workit"));
   }
   pendingMigrations() {
     return this.v2Dirs().filter((dir) => {
-      const raw = this.readV2Workspace(path8.join(dir, "workspace.json"));
+      const raw = this.readV2Workspace(path9.join(dir, "workspace.json"));
       return raw !== null && raw !== TOMBSTONE;
     });
   }
   migrateV2(v2) {
     const dirs = this.paths();
-    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 v2Workspace = path9.join(v2, "workspace.json");
+    const v2Tasks = path9.join(v2, "tasks");
+    const legacy = path9.join(dirs.dir, "legacy", checkoutSlug(path9.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(path8.join(v2, "metadata.lock"), () => {
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path9.join(v2, "metadata.lock"), () => {
       const workspace = this.readV2Workspace(v2Workspace);
       if (workspace === null || workspace === TOMBSTONE)
         return success(null, null, null);
@@ -11735,7 +11767,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 = fs9.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path8.join(v2Tasks, name)));
+        files = fs10.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path9.join(v2Tasks, name)));
       } catch {}
       const current = this.readWorkspace();
       if (!current.ok)
@@ -11753,22 +11785,22 @@ class TaskStore {
       let skipped = 0;
       const done = new Map;
       try {
-        fs9.mkdirSync(path8.join(legacy, "tasks"), { recursive: true });
+        fs10.mkdirSync(path9.join(legacy, "tasks"), { recursive: true });
         for (const name of ["workspace.json", "index.json"])
-          if (fs9.existsSync(path8.join(v2, name)))
-            fs9.copyFileSync(path8.join(v2, name), path8.join(legacy, name));
+          if (fs10.existsSync(path9.join(v2, name)))
+            fs10.copyFileSync(path9.join(v2, name), path9.join(legacy, name));
         for (const name of files) {
           const id = name.slice(0, -5);
-          const file = path8.join(v2Tasks, name);
-          const bytes = fs9.readFileSync(file, "utf8");
+          const file = path9.join(v2Tasks, name);
+          const bytes = fs10.readFileSync(file, "utf8");
           const digest = sha256(bytes);
-          fs9.writeFileSync(path8.join(legacy, "tasks", name), bytes);
+          fs10.writeFileSync(path9.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: path8.join(legacy, "tasks", name), digest };
-          if (!fs9.existsSync(this.eventsPath(id))) {
+          const origin = { path: path9.join(legacy, "tasks", name), digest };
+          if (!fs10.existsSync(this.eventsPath(id))) {
             this.openTask(record, "migrated.from_v2", null, origin);
             migrated += 1;
           } else {
@@ -11803,8 +11835,8 @@ class TaskStore {
       try {
         let complete = true;
         for (const [name, digest] of done) {
-          const file = path8.join(v2Tasks, name);
-          if (sha256(fs9.readFileSync(file, "utf8")) !== digest) {
+          const file = path9.join(v2Tasks, name);
+          if (sha256(fs10.readFileSync(file, "utf8")) !== digest) {
             complete = false;
             continue;
           }
@@ -11814,7 +11846,7 @@ class TaskStore {
           return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
             path: v2
           });
-        fs9.rmSync(path8.join(v2, "index.json"), { force: true });
+        fs10.rmSync(path9.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)}`, {
@@ -11834,45 +11866,45 @@ class TaskStore {
   }
   adoptLocalStore() {
     const dirs = this.paths();
-    const marker = path8.join(dirs.v2, "store.json");
-    if (!dirs.shared || !fs9.existsSync(marker))
+    const marker = path9.join(dirs.v2, "store.json");
+    if (!dirs.shared || !fs10.existsSync(marker))
       return success(null, null, null);
     return this.withLock(dirs.checkoutLock, () => {
-      if (!fs9.existsSync(marker))
+      if (!fs10.existsSync(marker))
         return success(null, null, null);
       let tasks = 0;
       try {
         const merge = (from, to) => {
-          if (!fs9.existsSync(to)) {
-            fs9.mkdirSync(path8.dirname(to), { recursive: true });
+          if (!fs10.existsSync(to)) {
+            fs10.mkdirSync(path9.dirname(to), { recursive: true });
             try {
-              fs9.renameSync(from, to);
+              fs10.renameSync(from, to);
             } catch {
-              fs9.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
-              fs9.rmSync(from, { recursive: true, force: true });
+              fs10.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
+              fs10.rmSync(from, { recursive: true, force: true });
             }
             return;
           }
-          if (fs9.lstatSync(from).isDirectory() && fs9.lstatSync(to).isDirectory())
-            for (const name of fs9.readdirSync(from))
-              merge(path8.join(from, name), path8.join(to, name));
+          if (fs10.lstatSync(from).isDirectory() && fs10.lstatSync(to).isDirectory())
+            for (const name of fs10.readdirSync(from))
+              merge(path9.join(from, name), path9.join(to, name));
         };
         for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
-          const from = path8.join(dirs.v2, sub);
-          if (!fs9.existsSync(from))
+          const from = path9.join(dirs.v2, sub);
+          if (!fs10.existsSync(from))
             continue;
           if (sub === "tasks") {
-            for (const name of fs9.readdirSync(from))
-              if (validId(name) && !fs9.existsSync(path8.join(dirs.dir, sub, name)))
+            for (const name of fs10.readdirSync(from))
+              if (validId(name) && !fs10.existsSync(path9.join(dirs.dir, sub, name)))
                 tasks += 1;
           }
-          merge(from, path8.join(dirs.dir, sub));
+          merge(from, path9.join(dirs.dir, sub));
         }
-        const ledger = path8.join(dirs.v2, "ledger");
-        if (fs9.existsSync(ledger) && !fs9.existsSync(path8.join(dirs.dir, "ledger")))
-          merge(ledger, path8.join(dirs.dir, "ledger"));
-        fs9.rmSync(path8.join(dirs.v2, "task-index.json"), { force: true });
-        fs9.renameSync(marker, path8.join(dirs.v2, "store.moved.json"));
+        const ledger = path9.join(dirs.v2, "ledger");
+        if (fs10.existsSync(ledger) && !fs10.existsSync(path9.join(dirs.dir, "ledger")))
+          merge(ledger, path9.join(dirs.dir, "ledger"));
+        fs10.rmSync(path9.join(dirs.v2, "task-index.json"), { force: true });
+        fs10.renameSync(marker, path9.join(dirs.v2, "store.moved.json"));
       } catch (error) {
         return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
           path: dirs.v2
@@ -11892,7 +11924,7 @@ class TaskStore {
   readV2Workspace(file) {
     let bytes;
     try {
-      bytes = fs9.readFileSync(file, "utf8");
+      bytes = fs10.readFileSync(file, "utf8");
     } catch {
       return null;
     }
@@ -11910,7 +11942,7 @@ class TaskStore {
       schemaVersion: SCHEMA_VERSION,
       id: workspaceId ?? newId(),
       revision: newRevision(),
-      root: path8.dirname(v2),
+      root: path9.dirname(v2),
       runtime: { createdWith: version, updatedWith: version },
       writer: null,
       store: {
@@ -11921,12 +11953,12 @@ class TaskStore {
       },
       critical: ["store"]
     };
-    fs9.mkdirSync(v2, { recursive: true });
-    const ignore = path8.join(v2, ".gitignore");
-    if (!fs9.existsSync(ignore))
-      fs9.writeFileSync(ignore, `*
+    fs10.mkdirSync(v2, { recursive: true });
+    const ignore = path9.join(v2, ".gitignore");
+    if (!fs10.existsSync(ignore))
+      fs10.writeFileSync(ignore, `*
 `);
-    replaceFile(path8.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+    replaceFile(path9.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
 `, true);
   }
   stubFor(taskId) {
@@ -11942,7 +11974,7 @@ class TaskStore {
   }
   isStub(file) {
     try {
-      const value = JSON.parse(fs9.readFileSync(file, "utf8"));
+      const value = JSON.parse(fs10.readFileSync(file, "utf8"));
       return isObject4(value) && isObject4(value.store) && value.store.format === "workit-store";
     } catch {
       return false;
@@ -11950,32 +11982,32 @@ class TaskStore {
   }
   writeTombstoneIfMissing() {
     try {
-      const v2 = path8.join(this.root, ".workit");
-      if (fs9.existsSync(path8.join(v2, "workspace.json")))
+      const v2 = path9.join(this.root, ".workit");
+      if (fs10.existsSync(path9.join(v2, "workspace.json")))
         return;
       let id = null;
       try {
-        id = JSON.parse(fs9.readFileSync(this.paths().workspace, "utf8")).id ?? null;
+        id = JSON.parse(fs10.readFileSync(this.paths().workspace, "utf8")).id ?? null;
       } catch {}
       this.writeTombstone(v2, id);
     } catch {}
   }
   initializeStorage() {
     const dirs = this.paths();
-    retryTransient(() => fs9.mkdirSync(dirs.checkout, { recursive: true }));
-    retryTransient(() => fs9.mkdirSync(dirs.tasks, { recursive: true }));
-    if (!fs9.existsSync(dirs.marker))
+    retryTransient(() => fs10.mkdirSync(dirs.checkout, { recursive: true }));
+    retryTransient(() => fs10.mkdirSync(dirs.tasks, { recursive: true }));
+    if (!fs10.existsSync(dirs.marker))
       replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
 `, false);
     if (!dirs.shared) {
-      const ignore = path8.join(dirs.dir, ".gitignore");
+      const ignore = path9.join(dirs.dir, ".gitignore");
       let current = null;
       try {
-        current = fs9.readFileSync(ignore, "utf8");
+        current = fs10.readFileSync(ignore, "utf8");
       } catch {}
       if (current !== `*
 `)
-        retryTransient(() => fs9.writeFileSync(ignore, `*
+        retryTransient(() => fs10.writeFileSync(ignore, `*
 `));
     }
     this.writeTombstoneIfMissing();
@@ -11991,7 +12023,7 @@ class TaskStore {
       shouldReclaim: ({ payload, nowMs }) => {
         let ageMs = null;
         try {
-          ageMs = nowMs - fs9.lstatSync(lockPath).mtimeMs;
+          ageMs = nowMs - fs10.lstatSync(lockPath).mtimeMs;
         } catch {}
         return classifyLockOwner(payload, ageMs, localLockHost(), TASK_STORE_LOCK).state === "stale";
       },
@@ -12028,7 +12060,7 @@ class TaskStore {
   withLock(lockPath, operation) {
     try {
       this.initializeStorage();
-      fs9.mkdirSync(path8.dirname(lockPath), { recursive: true });
+      fs10.mkdirSync(path9.dirname(lockPath), { recursive: true });
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
         path: this.paths().dir
@@ -12068,18 +12100,18 @@ class TaskStore {
   lockDirWritable(lockPath) {
     const probe = `${lockPath}.${process.pid}.${randomUUID3()}.probe`;
     try {
-      fs9.closeSync(fs9.openSync(probe, "wx", 384));
+      fs10.closeSync(fs10.openSync(probe, "wx", 384));
     } catch {
       return false;
     }
     try {
-      fs9.rmSync(probe, { force: true });
+      fs10.rmSync(probe, { force: true });
     } catch {}
     return true;
   }
   lockHolderPresent(lockPath) {
     try {
-      fs9.lstatSync(lockPath);
+      fs10.lstatSync(lockPath);
       return true;
     } catch (error) {
       return error?.code !== "ENOENT";
@@ -12091,12 +12123,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 ${path8.dirname(lockPath)}.`
+        guidance: `Check permissions and the read-only attribute on ${path9.dirname(lockPath)}.`
       });
     if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
       let lock = null;
       try {
-        lock = parseMetadataLockOrNull(fs9.readFileSync(lockPath, "utf8"));
+        lock = parseMetadataLockOrNull(fs10.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",
@@ -12111,17 +12143,17 @@ class TaskStore {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path13 from "node:path";
+import path14 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 path12 from "node:path";
+import { createHash as createHash9, randomBytes as randomBytes2 } from "node:crypto";
+import fs12 from "node:fs";
+import path13 from "node:path";
 
 // packages/workit-core/src/core/vcs-config.ts
-import fs10 from "node:fs";
-import path11 from "node:path";
+import fs11 from "node:fs";
+import path12 from "node:path";
 import { spawnSync as spawnSync8 } from "node:child_process";
 
 // packages/workit-core/src/core/config.ts
@@ -12135,7 +12167,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import os2 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 var EVENT = {
@@ -12179,7 +12211,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 ?? path9.join(process.env.XDG_CONFIG_HOME || path9.join(os2.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -12189,7 +12221,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path9.join(process.env.XDG_CONFIG_HOME || path9.join(os2.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workflow-toolkit");
   if (!existsSync3(legacy)) {
     migratedDir = dir;
     return dir;
@@ -12202,8 +12234,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 = path9.join(legacy, entry.name);
-    const dest = path9.join(dir, entry.name);
+    const src = path10.join(legacy, entry.name);
+    const dest = path10.join(dir, entry.name);
     if (existsSync3(dest))
       continue;
     try {
@@ -12275,7 +12307,7 @@ var parseConfigResult = (raw, file) => {
   return { status: "valid", path: file, config };
 };
 var readConfigTyped = (dir) => {
-  const file = path9.join(dir ?? configDir(), "config.json");
+  const file = path10.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -12284,7 +12316,7 @@ var readConfig = () => {
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
 };
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path9.join(configDir(), "vcs.json");
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.join(configDir(), "vcs.json");
 var branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
 var resolveBranchPolicy = (config, workspace, repoPreset) => {
   const wp = workspace?.branchPolicy ?? {};
@@ -12326,9 +12358,9 @@ var resolveCommitPolicy = (config, workspace) => {
 
 // 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 path10 from "node:path";
+import path11 from "node:path";
 
 // packages/workit-core/src/core/branch-policy.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -12345,6 +12377,7 @@ var branchNames = (workspaceRoot) => {
   return new Set((r.stdout ?? "").split(`
 `).filter(Boolean).map((ref) => ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref.slice("refs/remotes/origin/".length)));
 };
+var productionBranchOf = (names) => names.has("main") ? "main" : names.has("master") ? "master" : "main";
 var detectBranchPolicy = (workspaceRoot) => {
   const names = branchNames(workspaceRoot);
   const develop = names.has("develop");
@@ -12453,7 +12486,7 @@ var releaseTrackSchema = object({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource?.kind === "package-json" && (path10.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" && (path11.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"],
@@ -12513,7 +12546,7 @@ var workspacesFileSchema = object({ workspaces: array(workspaceConfigSchema).opt
     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` };
@@ -12551,7 +12584,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path10.join(dir, "workspaces.json");
+  const file = path11.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -12662,9 +12695,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 && path10.resolve(gitDir) !== path10.resolve(common)) {
+  if (gitDir && common && path11.resolve(gitDir) !== path11.resolve(common)) {
     const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
-    main = listed?.trim() || (path10.basename(common) === ".git" ? path10.dirname(common) : common);
+    main = listed?.trim() || (path11.basename(common) === ".git" ? path11.dirname(common) : common);
   }
   mainCheckouts.set(cwd, main);
   return main;
@@ -12755,7 +12788,7 @@ var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
 var matchRuntimeWorkspace = (cwd) => {
-  const file = path10.join(configDir(), "workspaces.json");
+  const file = path11.join(configDir(), "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -12830,7 +12863,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";
 class ReleaseTrackError extends Error {
 }
@@ -13213,7 +13246,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;
@@ -13228,7 +13261,7 @@ function resolveTrackFor(cwd, options) {
 }
 
 // packages/workit-core/src/core/vcs-config.ts
-var workspacesPath = () => path11.join(configDir(), "workspaces.json");
+var workspacesPath = () => path12.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" });
@@ -13245,7 +13278,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: {} };
   }
@@ -13330,7 +13363,7 @@ function vcsConfig(mode, cwd, options = {}) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path11.resolve(cfgPath),
+    configPath: path12.resolve(cfgPath),
     provider,
     defaultTargetBranch: workspaceDefault,
     pr: cfg.pr ?? {},
@@ -13456,7 +13489,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 "))
@@ -13468,14 +13501,14 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path12.resolve(cwd));
+  const location = resolveStore(path13.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: path12.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path13.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
@@ -13495,7 +13528,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;
   }
@@ -13505,15 +13538,15 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs11.readFileSync(path12.join(lock, LOCK_OWNER), "utf8");
+    return fs12.readFileSync(path13.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path12.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path13.join(lock, LOCK_OWNER), lock]) {
     try {
-      return Date.now() - fs11.statSync(target).mtimeMs;
+      return Date.now() - fs12.statSync(target).mtimeMs;
     } catch {}
   }
   return null;
@@ -13521,14 +13554,14 @@ 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(path12.join(lock, LOCK_OWNER), token);
+    fs12.writeFileSync(path13.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
@@ -13536,35 +13569,35 @@ var ledgerLock = {
       return false;
     const tomb = `${lock}.release-${randomBytes2(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")}`;
     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;
   }
@@ -13591,14 +13624,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)
@@ -13629,13 +13662,13 @@ var lastLine = (fd, size) => {
 };
 function appendLine(file, build, options) {
   const write = () => {
-    const fd = fs11.openSync(file, "a+");
+    const fd = fs12.openSync(file, "a+");
     try {
-      const size = fs11.fstatSync(fd).size;
+      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 = `
 `;
@@ -13644,17 +13677,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(path12.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path12.dirname(file)))
+    fs12.mkdirSync(path13.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path13.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");
@@ -13726,7 +13759,7 @@ function readLedger(cwd, options = {}) {
     return file;
   let text = "";
   try {
-    text = fs11.readFileSync(file.value, "utf8");
+    text = fs12.readFileSync(file.value, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return {
@@ -13920,11 +13953,20 @@ function authorSessions(cwd, rows, branch, range = { base: null, head: null }, s
     sessions.add(session);
   return sessions;
 }
+var derivesFrom = (derived, bare) => !bare.includes(":") && derived.endsWith(`:${bare}`);
+var authoredBy = (authors, session) => {
+  if (authors.has(session))
+    return true;
+  for (const author of authors)
+    if (derivesFrom(author, session) || derivesFrom(session, author))
+      return true;
+  return false;
+};
 var independenceReasons = (row, authors) => {
   const reasons = [];
   if (!row.actor.session)
     reasons.push("no_session");
-  else if (authors.has(row.actor.session))
+  else if (authoredBy(authors, row.actor.session))
     reasons.push("author_session");
   if (row.self === true && !reasons.includes("no_session"))
     reasons.push("self");
@@ -14208,7 +14250,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path13.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path14.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -14267,15 +14309,15 @@ function writeBlockers(task, root) {
 }
 
 // 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}${path14.sep}`);
-var relative = (root, candidate) => path14.relative(root, candidate).split(path14.sep).join("/") || ".";
+var digestBytes = (value) => createHash10("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 canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path14.posix.normalize(value);
+  const normalized = path15.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -14323,21 +14365,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(path14.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.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(path14.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.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;
   }
@@ -14345,10 +14387,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path14.join(directory, name);
+    const target = path15.join(directory, name);
     let stat;
     try {
-      stat = fs12.lstatSync(target);
+      stat = fs13.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -14363,14 +14405,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path14.resolve(root, item);
+    const target = path15.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 = path14.dirname(ancestor);
+    while (!fs13.existsSync(ancestor) && ancestor !== root)
+      ancestor = path15.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}`);
@@ -14382,7 +14424,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");
   }
@@ -14400,11 +14442,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;
@@ -14420,17 +14462,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path14.join(checkout, item);
+    const target = path15.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()) {
@@ -14595,7 +14637,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");
   }
@@ -14604,23 +14646,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path14.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path14.sep}`))
+    const target = path15.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path15.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 = path14.relative(root, target);
+      const below = path15.relative(root, target);
       let current = root;
-      for (const segment of below.split(path14.sep)) {
+      for (const segment of below.split(path15.sep)) {
         if (!segment)
           continue;
-        current = path14.join(current, segment);
-        const stat = fs12.lstatSync(current);
-        const real = fs12.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path14.sep}`))
+        current = path15.join(current, segment);
+        const stat = fs13.lstatSync(current);
+        const real = fs13.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path15.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -14636,7 +14678,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");
@@ -15493,7 +15535,7 @@ var judgeInputSummary = (raw) => {
 
 // packages/workit-core/src/autonomy.ts
 import os3 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 var accountHome = () => {
   try {
     return os3.userInfo().homedir;
@@ -15502,10 +15544,10 @@ var accountHome = () => {
   }
 };
 var grantsHome = { resolve: accountHome };
-var grantsDir = () => path15.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path16.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path15.resolve(resolveConfigDir());
-  return configured === path15.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 ${path15.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  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`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -17487,7 +17529,7 @@ function entryCompactContext(store, entry, session, context) {
     return null;
   const freshness = { mode: "signal", current: () => recentSignal(store.root) };
   const observed = task?.data.evidence.some(isObservedCheck) ?? false;
-  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path16.resolve(store.root, ref.path)] : []));
+  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path17.resolve(store.root, ref.path)] : []));
   const observedFiles = filesKey(files);
   const compact = new WorkitCore(store, context).compactContext(entry?.id ?? null, freshness, origin && { origin: origin.origin, taskId: origin.entry.id });
   if (!compact.ok || !compact.data)
@@ -17556,7 +17598,7 @@ var turnContextText = (input, descriptor) => {
   }
 };
 var TURN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-var digestOf = (text) => createHash10("sha256").update(text).digest("hex");
+var digestOf = (text) => createHash11("sha256").update(text).digest("hex");
 var turnMarker = (input) => {
   if (!input.session.id)
     return null;
@@ -17565,32 +17607,32 @@ var turnMarker = (input) => {
     if (location instanceof Error)
       return null;
     const session = [input.host, input.session.id, input.session.agentId ?? ""].join("\x00");
-    return path16.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
+    return path17.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
   } catch {
     return null;
   }
 };
 var writeTurnDigest = (file, digest) => {
   try {
-    fs13.mkdirSync(path16.dirname(file), { recursive: true });
-    fs13.writeFileSync(file, `${JSON.stringify({ digest })}
+    fs14.mkdirSync(path17.dirname(file), { recursive: true });
+    fs14.writeFileSync(file, `${JSON.stringify({ digest })}
 `);
   } catch {}
 };
 var clearTurnDigest = (file) => {
   try {
-    fs13.rmSync(file, { force: true });
+    fs14.rmSync(file, { force: true });
   } catch {}
 };
 var pruneTurnDigests = (dir, now) => {
   try {
-    for (const name of fs13.readdirSync(dir)) {
+    for (const name of fs14.readdirSync(dir)) {
       if (!name.startsWith("turn-"))
         continue;
-      const file = path16.join(dir, name);
+      const file = path17.join(dir, name);
       try {
-        if (now - fs13.statSync(file).mtimeMs > TURN_TTL_MS)
-          fs13.rmSync(file, { force: true });
+        if (now - fs14.statSync(file).mtimeMs > TURN_TTL_MS)
+          fs14.rmSync(file, { force: true });
       } catch {}
     }
   } catch {}
@@ -17606,7 +17648,7 @@ var changedTurnContext = (input, text) => {
     return text;
   const digest = digestOf(text);
   try {
-    const previous = JSON.parse(fs13.readFileSync(file, "utf8"));
+    const previous = JSON.parse(fs14.readFileSync(file, "utf8"));
     if (previous.digest === digest)
       return null;
   } catch {}
@@ -17617,14 +17659,26 @@ var seedTurnContext = (input, descriptor, text = turnContextText(input, descript
   const file = turnMarker(input);
   if (!file)
     return;
-  pruneTurnDigests(path16.dirname(file), Date.now());
+  pruneTurnDigests(path17.dirname(file), Date.now());
   if (text)
     writeTurnDigest(file, digestOf(text));
   else
     clearTurnDigest(file);
 };
+// packages/workit-core/src/core/route-intent.ts
+import { spawnSync as spawnSync12 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import path20 from "node:path";
+
+// packages/workit-core/src/hooks/raw-git.ts
+import { spawnSync as spawnSync11 } from "node:child_process";
+import { createHash as createHash14 } from "node:crypto";
+import fs16 from "node:fs";
+import os4 from "node:os";
+import path19 from "node:path";
+
 // packages/workit-core/src/core/branch.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 var withReleaseTracks = (workspaceRoot, policy) => {
   const read = workspaceReleaseTracks(workspaceRoot);
   if (read.error)
@@ -17660,10 +17714,72 @@ function effectiveWorkspacePolicy(workspaceRoot, kind, profileName) {
     provenance: { commitPolicy: selected.source }
   };
 }
+var KIND_SYNONYMS = {
+  fix: "bugfix",
+  fixes: "bugfix",
+  bug: "bugfix",
+  bugs: "bugfix",
+  bugfixes: "bugfix",
+  feat: "feature",
+  features: "feature",
+  chore: "feature",
+  docs: "feature",
+  doc: "feature",
+  refactor: "feature",
+  test: "feature",
+  tests: "feature",
+  ci: "feature",
+  build: "feature",
+  perf: "feature",
+  style: "feature",
+  deps: "feature",
+  task: "feature",
+  enhancement: "feature",
+  hot: "hotfix",
+  hotfixes: "hotfix",
+  releases: "release",
+  rel: "release"
+};
+var allowedKinds = (allowed) => [
+  ...new Set(allowed.map((pattern) => /^\^([\w.-]+)\\?\/\.\*\$$/u.exec(pattern.source)?.[1]?.toLowerCase()).filter((kind) => Boolean(kind)))
+];
+var editDistance = (a, b) => {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1;i <= a.length; i++) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1;j <= b.length; j++) {
+      const saved = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = saved;
+    }
+  }
+  return row[b.length];
+};
+var suggestBranchName = (name, kinds) => {
+  if (!kinds.length)
+    return null;
+  const slash = name.indexOf("/");
+  const prefix = slash > 0 ? name.slice(0, slash).toLowerCase() : "";
+  const rest = (slash > 0 ? name.slice(slash + 1) : name) || "name";
+  const synonym = KIND_SYNONYMS[prefix];
+  const near = kinds.map((kind) => ({ kind, distance: editDistance(prefix, kind) })).filter((entry) => prefix && entry.distance <= 2).toSorted((a, b) => a.distance - b.distance)[0]?.kind;
+  const kind = (synonym && kinds.includes(synonym) ? synonym : null) ?? near ?? (kinds.includes("feature") ? "feature" : kinds[0]);
+  return `${kind}/${rest}`;
+};
+var kindList = (kinds) => kinds.map((kind) => `${kind}/`).join(", ");
+var aliasNote = (kinds) => {
+  const notes = [
+    ["fix", "bugfix"],
+    ["chore", "feature"]
+  ].filter(([, kind]) => kinds.includes(kind)).map(([alias, kind]) => `${alias}/ is ${kind}/`);
+  return notes.length ? ` (${notes.join(", ")})` : "";
+};
 var validateBranchNamePolicy = (name, policy, source) => {
   const allowed = policy.allowed.map((pattern) => `/${pattern.source}/${pattern.flags}`);
+  const kinds = allowedKinds(policy.allowed);
   if (policy.protected.has(name.toLowerCase())) {
-    const correction = `choose a non-protected branch matching one of: ${allowed.join(", ")}`;
+    const correction = kinds.length ? `choose a non-protected branch of an allowed kind (${kindList(kinds)}), e.g. ${kinds[0]}/<slug>: workit git branch --kind ${kinds[0]} --slug <slug>` : `choose a non-protected branch matching one of: ${allowed.join(", ")}`;
     return {
       ok: false,
       rule: "protected_ref",
@@ -17674,7 +17790,8 @@ var validateBranchNamePolicy = (name, policy, source) => {
     };
   }
   if (!policy.allowed.some((pattern) => pattern.test(name))) {
-    const correction = `choose a branch matching one of: ${allowed.join(", ")}`;
+    const suggestion = suggestBranchName(name, kinds);
+    const correction = suggestion && policy.allowed.some((pattern) => pattern.test(suggestion)) ? `use ${JSON.stringify(suggestion)}; the allowed kinds are ${kindList(kinds)} (workit git branch ${suggestion})` : `choose a branch matching one of: ${allowed.join(", ")}`;
     return {
       ok: false,
       rule: "allowed_pattern",
@@ -17692,7 +17809,7 @@ var branchPolicySnapshotFor = (workspaceRoot) => {
   const source = resolved.provenance.branchPolicy;
   const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
   const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
-  const fingerprint = createHash11("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
+  const fingerprint = createHash12("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
   return {
     branchPolicy,
     namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
@@ -17717,31 +17834,87 @@ var validateBranchNameFor = (workspaceRoot, name) => {
   }
 };
 var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
-
-// packages/workit-core/src/core/route-intent.ts
-var shellBranchTarget = (command) => {
-  if (!command.trim() || /[\r\n;&|<>`'"$()\\*?{}~!#]/u.test(command) || command.includes("[") || command.includes("]"))
-    return null;
-  const args = command.trim().split(/\s+/u);
-  if (args[0] !== "git")
+var gitFlowOf = (root, integration) => {
+  try {
+    if (resolveBranchPolicyFor(root).preset !== "gitflow")
+      return null;
+    const selected = resolveRuntimeWorkspacePolicy(root, "branch", process.env.WORKFLOW_PROFILE?.trim() || undefined).policy;
+    const names = branchNames(root);
+    const production = productionBranchOf(names);
+    const develop = selected?.developBranch?.trim() || (integration && integration.toLowerCase() !== production ? integration : "develop");
+    return { develop, production, developExists: names.has(develop) };
+  } catch {
     return null;
-  const option = args[2];
-  const target = args[1] === "switch" && ["-c", "--create", "-C", "--force-create"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "checkout" && ["-b", "-B"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "branch" && (args.length === 3 || args.length === 4) ? args[2] : null;
-  return target && !target.startsWith("-") ? target : null;
+  }
+};
+var releaseBranchesOf = (cwd) => {
+  try {
+    const resolved = resolveBranchPolicyFor(cwd);
+    const flow = resolved.preset === "gitflow" ? gitFlowOf(cwd) : null;
+    return {
+      preset: resolved.preset,
+      branches: flow ? [flow.production, flow.develop] : [],
+      production: flow ? flow.production : resolved.defaultTargetBranch
+    };
+  } catch {
+    return { preset: "unknown", branches: [], production: null };
+  }
 };
-var shellBranchPolicyViolation = (root, command) => {
-  const target = shellBranchTarget(command);
-  return target === null ? null : validateBranchNameFor(root, target);
+var releaseBranch = (cwd, branch) => releaseBranchesOf(cwd).branches.some((name) => name.toLowerCase() === branch.toLowerCase());
+var branchGuidance = (cwd) => {
+  try {
+    const patterns = branchPolicySnapshotFor(cwd).namePolicy.allowed;
+    const kinds = allowedKinds(patterns);
+    const kindShaped = new Set(kinds.map((kind) => branchGlobPattern(`${kind}/*`).source));
+    const anyName = patterns.some((pattern) => pattern.source === "^.*$");
+    const others = patterns.filter((pattern) => !kindShaped.has(pattern.source)).map((pattern) => globOf(pattern));
+    const allowed = anyName ? "Any non-protected branch name is allowed here." : `${kinds.length ? `Allowed branch kinds here: ${kindList(kinds)}${aliasNote(kinds)}` : "Allowed branch names here:"}${others.length ? `${kinds.length ? "; also" : ""} names matching ${others.join(", ")}` : ""}; anything else is denied.`;
+    const resolved = vcsConfig("resolve", cwd);
+    const integration = resolved.ok === false ? null : String(resolved.defaultTargetBranch ?? "") || null;
+    const flow = resolved.releaseTrack?.track ? null : gitFlowOf(cwd, integration);
+    if (flow?.developExists)
+      return `${allowed} git-flow: feature/, bugfix/ and release/ start from origin/${flow.develop}, hotfix/ from origin/${flow.production}; feature/ and bugfix/ land on ${flow.develop}, release/ and hotfix/ on ${flow.production}.`;
+    const names = branchNames(cwd);
+    const configured = String(resolved.baseBranch ?? integration ?? "") || null;
+    const trunk = productionBranchOf(names);
+    const base = configured && names.has(configured) ? `Branch from origin/${configured}.` : names.has(trunk) ? `Branch from origin/${trunk}${configured ? ` (the default target ${configured} does not exist here)` : ""}.` : "No base branch exists here yet; pass the base explicitly.";
+    return `${allowed} ${base}`;
+  } catch {
+    return null;
+  }
 };
+var globOf = (pattern) => pattern.source.replace(/^\^|\$$/gu, "").replaceAll(".*", "*").replace(/\\(.)/gu, "$1");
 
-// packages/workit-core/src/hooks/policy.ts
-var shellPolicy = (cwd, command) => {
-  const policy = shellBranchPolicyViolation(cwd, command);
-  return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
+// packages/workit-core/src/hooks/session-marker.ts
+import { createHash as createHash13 } from "node:crypto";
+import fs15 from "node:fs";
+import path18 from "node:path";
+var sessionMarkerFile = (input, session, store) => {
+  let dir = store;
+  if (dir === undefined) {
+    const location = resolveStore(input.cwd);
+    if (location instanceof Error || !location.shared)
+      return null;
+    dir = location.dir;
+  }
+  const name = createHash13("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
+  return path18.join(dir, "hooks", `skills-${name}.json`);
+};
+var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+var readSessionMarker = (file) => {
+  try {
+    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
+    return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
+  } catch {
+    return { nudged: [], loaded: [], raw: [] };
+  }
+};
+var writeSessionMarker = (file, marker) => {
+  try {
+    fs15.mkdirSync(path18.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, JSON.stringify(marker));
+  } catch {}
 };
-// packages/workit-core/src/hooks/write-gate.ts
-import { realpathSync as realpathSync5 } from "node:fs";
-import path17 from "node:path";
 
 // packages/workit-core/src/hooks/shell-words.ts
 var closingQuote = (command, start, dialect) => {
@@ -17866,295 +18039,81 @@ var segmentsOf = (command, dialect = "posix") => {
   return segments;
 };
 
-// packages/workit-core/src/hooks/write-gate.ts
+// packages/workit-core/src/hooks/raw-git.ts
 var NONE2 = { kind: "none" };
-var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
-var canonical2 = (file) => {
-  let rest = "";
-  for (let dir = path17.resolve(file);; dir = path17.dirname(dir)) {
-    try {
-      return path17.join(realpathSync5(dir), rest);
-    } catch {
-      if (path17.dirname(dir) === dir)
-        return path17.resolve(file);
-      rest = rest ? path17.join(path17.basename(dir), rest) : path17.basename(dir);
-    }
-  }
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
+var SCRIPT_FLAG = /^-[a-zA-Z]*c[a-zA-Z]*$/;
+var CD = new Set(["cd", "chdir", "set-location", "sl"]);
+var PUSHD = new Set(["pushd", "push-location"]);
+var POPD = new Set(["popd", "pop-location"]);
+var GIT_VALUE_OPTIONS = new Set([
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--config-env",
+  "--super-prefix"
+]);
+var isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var joinDir = (base, next) => {
+  if (base === undefined || /[$`*?]/.test(next) || next === "-")
+    return;
+  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
 };
-var exempt = (cwd, root, file, plans) => {
-  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path17.relative(fold(canonical2(root)), fold(canonical2(path17.resolve(cwd, file))));
-  if (relative.startsWith("..") || path17.isAbsolute(relative))
-    return true;
-  const posix = relative.split(path17.sep).join("/");
-  const segments = posix.split("/");
-  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+var cdTarget = (words) => {
+  const args = words.slice(1);
+  const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
+  if (flag >= 0)
+    return args[flag + 1] ?? null;
+  return args.find((word) => word === "-" || !word.startsWith("-")) ?? null;
 };
-var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
-var operands = (words) => words.filter((item) => !item.startsWith("-"));
-var editsOf = (input) => {
+var stripPrefixes = (input) => {
   let words = input;
-  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
-    words = words.slice(1);
-  const [verb, ...args] = words;
-  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
-  if (!name || name === "workit" || name === "npx" && args.some((item) => /workit/.test(item)))
-    return [];
-  switch (name) {
-    case "touch":
-    case "mkdir":
-    case "rm":
-    case "rmdir":
-    case "tee":
-    case "mv":
-    case "truncate":
-      return operands(args);
-    case "cp":
-    case "ln":
-    case "install": {
-      const target = args.indexOf("-t");
-      if (target >= 0)
-        return args[target + 1] ? [args[target + 1]] : null;
-      const last = operands(args).at(-1);
-      return last ? [last] : null;
+  for (;; ) {
+    const first = words[0];
+    if (first === undefined)
+      return words;
+    if (/^\w+=/.test(first))
+      words = words.slice(1);
+    else if (PREFIXES2.has(first)) {
+      words = words.slice(1);
+      while (words[0]?.startsWith("-"))
+        words = words.slice(words[0] === "-u" ? 2 : 1);
+    } else if (first === "timeout") {
+      words = words.slice(1);
+      while (words[0]?.startsWith("-"))
+        words = words.slice(1);
+      words = words.slice(1);
+    } else
+      return words;
+  }
+};
+var commandName = (word) => (word?.split(/[\\/]/).at(-1) ?? "").toLowerCase().replace(/\.exe$/, "");
+function rawInvocations(command, dialect = "posix", depth = 0) {
+  const found = [];
+  let dir = null;
+  const groups = [];
+  let stack = [];
+  for (const segment of segmentsOf(command, dialect)) {
+    if (segment.group === "open") {
+      groups.push({ dir, stack: [...stack] });
+      continue;
     }
-    case "dd":
-      return args.filter((item) => item.startsWith("of=")).map((item) => item.slice(3));
-    case "sed":
-    case "perl": {
-      if (!args.some((item) => /^-[a-zA-Z]*i|^--in-place/.test(item)))
-        return [];
-      const scripted = args.some((item) => item === "-e" || item === "-f");
-      const files = [];
-      for (let index = 0;index < args.length; index++) {
-        if (args[index] === "-e" || args[index] === "-f")
-          index++;
-        else if (!args[index].startsWith("-"))
-          files.push(args[index]);
-      }
-      return scripted ? files : files.slice(1);
+    if (segment.group === "close") {
+      const saved = groups.pop();
+      if (saved)
+        ({ dir, stack } = saved);
+      continue;
     }
-    case "patch":
-      return null;
-    case "set-content":
-    case "add-content":
-    case "out-file":
-    case "new-item":
-    case "ni":
-    case "remove-item":
-    case "del":
-    case "copy-item":
-    case "move-item": {
-      const flag = args.findIndex((item) => /^-(?:path|filepath|literalpath|destination)$/i.test(item));
-      if (flag >= 0)
-        return args[flag + 1] ? [args[flag + 1]] : null;
-      const files = operands(args);
-      if (name === "move-item")
-        return files.length ? files : null;
-      const file = name === "copy-item" ? files.at(-1) : files[0];
-      return file ? [file] : null;
-    }
-    case "git": {
-      const sub = operands(args)[0];
-      if (sub === "apply")
-        return null;
-      if (sub === "restore" || sub === "mv" || sub === "rm")
-        return operands(args).slice(1);
-      if (sub === "checkout" && args.includes("--"))
-        return args.slice(args.indexOf("--") + 1);
-      return [];
-    }
-    default:
-      return [];
-  }
-};
-var shellWrites = (command) => {
-  const targets = [];
-  let unknown = false;
-  for (const segment of segmentsOf(command)) {
-    targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
-    const edits = editsOf(segment.words);
-    if (edits === null)
-      unknown = true;
-    else
-      targets.push(...edits);
-  }
-  if (!unknown && targets.length === 0)
-    return { writes: false, targets: null };
-  return { writes: true, targets: unknown ? null : targets };
-};
-var cache2 = new Map;
-var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path17.resolve(root, file)) ?? "-").join("\x00");
-var gateFor = (cwd) => {
-  const store = new TaskStore(cwd);
-  const listed = store.listTaskIndex();
-  if (!listed.ok)
-    return null;
-  const key = store.currentKey();
-  if (!key.ok)
-    return null;
-  const entry = listed.data.filter((item) => item.key === key.data.key && item.status !== "closed").toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
-  if (!entry)
-    return { blockers: [], root: store.root, plans: new Set };
-  const ledger = ledgerPath(store.root);
-  const cacheKey = `${entry.id}\x00${entry.revision}\x00${ledger.ok && fileSignature(ledger.value) || "-"}`;
-  const hit = cache2.get(store.root);
-  if (hit && hit.key === cacheKey && hit.planKey === planKeyOf(store.root, hit.plans))
-    return hit;
-  const task = store.readTask(entry.id);
-  if (!task.ok)
-    return null;
-  const workspace = store.readWorkspace();
-  const plans = new Set((latestJudgment(task.data)?.refs ?? []).flatMap((ref) => ref.kind === "file" ? [ref.path] : []));
-  const blockers = writeBlockers(task.data, store.root).filter((blocker) => {
-    const requirement = task.data.policy?.requirements.find((item) => item.ruleId === blocker.ruleId && item.before === "write");
-    return !(requirement?.acceptanceAllowed && workspace.ok && workspace.data && applicableDecision(task.data, workspace.data, requirement, store.root).length > 0);
-  });
-  const gate = {
-    blockers,
-    root: store.root,
-    plans,
-    key: cacheKey,
-    planKey: planKeyOf(store.root, plans)
-  };
-  cache2.set(store.root, gate);
-  if (cache2.size > 32)
-    cache2.delete(cache2.keys().next().value);
-  return gate;
-};
-function writeGate(cwd, paths) {
-  try {
-    const gate = gateFor(cwd);
-    if (!gate || gate.blockers.length === 0)
-      return NONE2;
-    if (paths?.length && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
-      return NONE2;
-    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
-    return {
-      kind: "deny",
-      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
-      unblock: gate.blockers[0].reason
-    };
-  } catch {
-    return NONE2;
-  }
-}
-// packages/workit-core/src/hooks/stop.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
-
-// packages/workit-core/src/hooks/raw-git.ts
-import { spawnSync as spawnSync11 } from "node:child_process";
-import { createHash as createHash13 } from "node:crypto";
-import fs15 from "node:fs";
-import os4 from "node:os";
-import path19 from "node:path";
-
-// packages/workit-core/src/hooks/session-marker.ts
-import { createHash as createHash12 } from "node:crypto";
-import fs14 from "node:fs";
-import path18 from "node:path";
-var sessionMarkerFile = (input, session, store) => {
-  let dir = store;
-  if (dir === undefined) {
-    const location = resolveStore(input.cwd);
-    if (location instanceof Error || !location.shared)
-      return null;
-    dir = location.dir;
-  }
-  const name = createHash12("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path18.join(dir, "hooks", `skills-${name}.json`);
-};
-var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-var readSessionMarker = (file) => {
-  try {
-    const value = JSON.parse(fs14.readFileSync(file, "utf8"));
-    return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
-  } catch {
-    return { nudged: [], loaded: [], raw: [] };
-  }
-};
-var writeSessionMarker = (file, marker) => {
-  try {
-    fs14.mkdirSync(path18.dirname(file), { recursive: true });
-    fs14.writeFileSync(file, JSON.stringify(marker));
-  } catch {}
-};
-
-// packages/workit-core/src/hooks/raw-git.ts
-var NONE3 = { kind: "none" };
-var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-var PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
-var SCRIPT_FLAG = /^-[a-zA-Z]*c[a-zA-Z]*$/;
-var CD = new Set(["cd", "chdir", "set-location", "sl"]);
-var PUSHD = new Set(["pushd", "push-location"]);
-var POPD = new Set(["popd", "pop-location"]);
-var GIT_VALUE_OPTIONS = new Set([
-  "-c",
-  "--git-dir",
-  "--work-tree",
-  "--namespace",
-  "--exec-path",
-  "--config-env",
-  "--super-prefix"
-]);
-var isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
-var joinDir = (base, next) => {
-  if (base === undefined || /[$`*?]/.test(next) || next === "-")
-    return;
-  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
-};
-var cdTarget = (words) => {
-  const args = words.slice(1);
-  const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
-  if (flag >= 0)
-    return args[flag + 1] ?? null;
-  return args.find((word) => word === "-" || !word.startsWith("-")) ?? null;
-};
-var stripPrefixes = (input) => {
-  let words = input;
-  for (;; ) {
-    const first = words[0];
-    if (first === undefined)
-      return words;
-    if (/^\w+=/.test(first))
-      words = words.slice(1);
-    else if (PREFIXES3.has(first)) {
-      words = words.slice(1);
-      while (words[0]?.startsWith("-"))
-        words = words.slice(words[0] === "-u" ? 2 : 1);
-    } else if (first === "timeout") {
-      words = words.slice(1);
-      while (words[0]?.startsWith("-"))
-        words = words.slice(1);
-      words = words.slice(1);
-    } else
-      return words;
-  }
-};
-var commandName = (word) => (word?.split(/[\\/]/).at(-1) ?? "").toLowerCase().replace(/\.exe$/, "");
-function rawInvocations(command, dialect = "posix", depth = 0) {
-  const found = [];
-  let dir = null;
-  const groups = [];
-  let stack = [];
-  for (const segment of segmentsOf(command, dialect)) {
-    if (segment.group === "open") {
-      groups.push({ dir, stack: [...stack] });
-      continue;
-    }
-    if (segment.group === "close") {
-      const saved = groups.pop();
-      if (saved)
-        ({ dir, stack } = saved);
-      continue;
-    }
-    const words = stripPrefixes(segment.words);
-    const name = commandName(words[0]);
-    if (CD.has(name)) {
-      const target = cdTarget(words);
-      dir = target === null ? os4.homedir() : joinDir(dir, target);
-      continue;
+    const words = stripPrefixes(segment.words);
+    const name = commandName(words[0]);
+    if (CD.has(name)) {
+      const target = cdTarget(words);
+      dir = target === null ? os4.homedir() : joinDir(dir, target);
+      continue;
     }
     if (PUSHD.has(name)) {
       const target = cdTarget(words);
@@ -18234,6 +18193,10 @@ var pushAction = (args) => {
   let force = false;
   let lease = false;
   let wholesale = false;
+  let allTags = false;
+  let deletes = false;
+  let allBranches = false;
+  let mirror = false;
   let remote = null;
   const positionals = [];
   for (let index = 1;index < args.length; index++) {
@@ -18254,14 +18217,22 @@ var pushAction = (args) => {
       force = true;
     else if (arg.startsWith("--force-with-lease") || arg === "--force-if-includes")
       lease = true;
-    else if (["--all", "--mirror", "--branches", "--tags"].includes(arg))
-      wholesale = true;
+    else if (arg === "--delete" || arg === "-d")
+      deletes = true;
+    else if (arg === "--tags")
+      allTags = wholesale = true;
+    else if (arg === "--all" || arg === "--branches")
+      allBranches = wholesale = true;
+    else if (arg === "--mirror")
+      mirror = wholesale = true;
     else if (!arg.startsWith("-"))
       positionals.push(arg);
   }
   const specs = remote === null ? positionals.slice(1) : positionals;
   remote ??= positionals[0] ?? null;
   const targets = [];
+  const tags = [];
+  const deleted = [];
   for (const raw of specs) {
     if (raw.startsWith("+"))
       force = true;
@@ -18270,16 +18241,29 @@ var pushAction = (args) => {
     const destination = colon >= 0 ? spec.slice(colon + 1) : spec;
     if (!destination)
       continue;
-    if (destination === "HEAD")
-      targets.push(null);
-    else if (destination.startsWith("refs/heads/"))
-      targets.push(destination.slice(11));
-    else if (!destination.startsWith("refs/"))
-      targets.push(destination);
+    const name = destination === "HEAD" ? null : destination.startsWith("refs/heads/") ? destination.slice(11) : destination.startsWith("refs/") ? undefined : destination;
+    if (destination.startsWith("refs/tags/"))
+      tags.push(destination.slice(10));
+    if (name === undefined)
+      continue;
+    targets.push(name);
+    if (colon === 0 && name !== null)
+      deleted.push(name);
   }
   if (specs.length === 0 && !wholesale)
     targets.push(null);
-  return { kind: "push", targets, blindForce: force && !lease, remote };
+  return {
+    kind: "push",
+    targets,
+    blindForce: force && !lease,
+    remote,
+    ...tags.length ? { tags } : {},
+    ...allTags ? { allTags: true } : {},
+    ...deletes ? { deletes: true } : {},
+    ...deleted.length ? { deleted } : {},
+    ...allBranches ? { allBranches: true } : {},
+    ...mirror ? { mirror: true } : {}
+  };
 };
 var VALUE_OPTIONS = {
   git: new Set([
@@ -18355,7 +18339,7 @@ var repoAt = (dir) => {
   return { location, dir, branch: resolveTaskKey(dir, location).branch };
 };
 var isWorkitWorkspace = (repo) => {
-  if (fs15.existsSync(repo.location.dir))
+  if (fs16.existsSync(repo.location.dir))
     return true;
   try {
     return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
@@ -18386,7 +18370,7 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs15.readFileSync(path19.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs16.readFileSync(path19.join(git.gitDir, "HEAD"), "utf8").trim();
     if (/^[0-9a-f]{40,64}$/.test(head))
       return head;
     const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
@@ -18394,20 +18378,72 @@ var headSha2 = (repo) => {
       return null;
     const common = path19.dirname(repo.location.dir);
     try {
-      return fs15.readFileSync(path19.join(common, ref), "utf8").trim() || null;
+      return fs16.readFileSync(path19.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs15.readFileSync(path19.join(common, "packed-refs"), "utf8");
+    const packed = fs16.readFileSync(path19.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
   }
 };
 var quote = (text) => `\`${text}\``;
-var refusal = (action, branch) => {
+var refusal = (action, branch, dir) => {
   if (action.kind === "merge")
     return `workit: raw ${quote(action.forge === "gh" ? "gh pr merge" : "glab mr merge")} bypasses the merge grant and the verdict gate. Run ${quote("workit pr merge")} instead (it checks both; ${quote("workit help pr")}).`;
+  const plainPush = action.kind === "push" && !action.blindForce && !action.deletes;
+  if (dir && branch && plainPush && releaseBranch(dir, branch))
+    return `workit: raw ${quote("git push")} onto ${branch}, a protected release branch, bypasses workit's protected-branch check. To finish a release or hotfix, push it with ${quote(`workit git push --release ${branch} [--release v<version>]`)}: it pushes ${branch} (fast-forward only) and the release tag, verifies the remote and records it, under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}). Feature work goes through ${quote("workit git push")} and ${quote("workit pr merge")}.`;
   return `workit: raw ${quote("git push")}${action.kind === "push" && action.blindForce ? " --force" : ""} onto ${branch}, a protected branch or the default target, bypasses workit's protected-branch check. Push your feature branch with ${quote("workit git push")} (${quote("workit git push --force-with-lease")} to rewrite it) and land it with ${quote("workit pr merge")}.`;
 };
+var refFacts = (repo, remote) => {
+  const facts = { heads: new Set, tags: new Set, remoteHeads: new Set };
+  const listed = spawnSync11("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/tags", `refs/remotes/${remote}`], { cwd: repo.dir, encoding: "utf8", timeout: 5000 });
+  const remotePrefix = `refs/remotes/${remote}/`;
+  for (const ref of (listed.stdout ?? "").split(`
+`)) {
+    if (ref.startsWith("refs/heads/"))
+      facts.heads.add(ref.slice(11));
+    else if (ref.startsWith("refs/tags/"))
+      facts.tags.add(ref.slice(10));
+    else if (ref.startsWith(remotePrefix))
+      facts.remoteHeads.add(ref.slice(remotePrefix.length));
+  }
+  return facts;
+};
+var isTag = (facts, name) => facts.tags.has(name) && !facts.heads.has(name);
+var tagRefusal = (action, facts) => {
+  const tags = [
+    ...action.tags ?? [],
+    ...action.targets.filter((name) => name !== null && isTag(facts, name))
+  ];
+  if (!tags.length && !action.allTags)
+    return null;
+  const named = tags.length ? tags.join(" --release ") : "v<version>";
+  return `workit: raw ${quote(`git push${action.allTags ? " --tags" : ""}`)} of ${tags.length ? `tag ${tags.join(", ")}` : "tags"} bypasses the release grant. Push a release tag with ${quote(`workit git push --release ${named}`)} (v<version> tags whose commit the production branch already has; a tag never moves), under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}).`;
+};
+var remoteHas = (repo, remote, branch) => {
+  const listed = spawnSync11("git", ["ls-remote", "--heads", remote, `refs/heads/${branch}`], {
+    cwd: repo.dir,
+    encoding: "utf8",
+    timeout: 3000,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  return listed.status !== 0 || (listed.stdout ?? "").trim() !== "";
+};
+var offPolicyPush = (action, repo, facts, remote) => {
+  const names = action.allBranches ? [...facts.heads] : action.targets.map((target) => target ?? repo.branch);
+  for (const branch of names) {
+    if (!branch || action.deleted?.includes(branch) || isTag(facts, branch))
+      continue;
+    if (facts.remoteHeads.has(branch))
+      continue;
+    const check = validateBranchNameFor(repo.dir, branch);
+    if (check.ok || check.rule !== "allowed_pattern" || remoteHas(repo, remote, branch))
+      continue;
+    return `workit: raw ${quote("git push")} onto ${branch}: ${check.error}`;
+  }
+  return null;
+};
 var nudgeFor = (action, host, session) => {
   switch (action.kind) {
     case "commit": {
@@ -18470,7 +18506,7 @@ var unseenNudges = (input, nudges, store) => {
 function rawGitPre(input, command, options = {}) {
   try {
     if (!mentionsRawTool(command))
-      return NONE3;
+      return NONE2;
     const dialect = dialectOf(input);
     const nudges = new Map;
     let store = null;
@@ -18478,32 +18514,43 @@ function rawGitPre(input, command, options = {}) {
       store ??= repo.location.dir;
       if (action.kind === "merge")
         return deny(refusal(action, null));
-      if (action.kind === "push")
+      if (action.kind === "push" && toPushRemote(repo, action.remote)) {
+        if (action.mirror)
+          return deny(`workit: raw ${quote("git push --mirror")} rewrites and deletes every remote ref, protected branches and tags included. Push one branch with ${quote("workit git push")}.`);
         for (const target of action.targets) {
           const branch = target ?? repo.branch;
-          if (branch && guardedBranch(repo.dir, branch) && toPushRemote(repo, action.remote))
-            return deny(refusal(action, branch));
+          if (branch && guardedBranch(repo.dir, branch))
+            return deny(refusal(action, branch, repo.dir));
         }
+        const remote = action.remote ?? pushRemoteName(repo.dir, repo.branch) ?? "origin";
+        const facts = refFacts(repo, remote);
+        const tagDeny = tagRefusal(action, facts);
+        if (tagDeny)
+          return deny(tagDeny);
+        const nameDeny = action.deletes ? null : offPolicyPush(action, repo, facts, remote);
+        if (nameDeny)
+          return deny(nameDeny);
+      }
       const nudge = nudgeFor(action, input.host, input.session.id);
       if (nudge && !nudges.has(nudgeKind(action)))
         nudges.set(nudgeKind(action), nudge);
     }
     if (options.nudge === false || !store || nudges.size === 0)
-      return NONE3;
+      return NONE2;
     if (workitInvocations(command, dialect).length > 0)
-      return NONE3;
+      return NONE2;
     const shown = unseenNudges(input, nudges, store);
     return shown.length ? { kind: "context", text: shown.join(`
-`) } : NONE3;
+`) } : NONE2;
   } catch {
-    return NONE3;
+    return NONE2;
   }
 }
 var deny = (reason) => ({ kind: "deny", reason, unblock: null });
 var NEXT_COMMAND = "next";
 var MARKER_TTL_SECONDS = 3600;
-var markerFile = (repo, session, key) => path19.join(repo.location.dir, "hooks", `commit-${createHash13("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
-var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash13("sha256").update(command).digest("hex")}`;
+var markerFile = (repo, session, key) => path19.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
+var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash14("sha256").update(command).digest("hex")}`;
 function noteRawCommit(input, command, key) {
   try {
     if (!input.session.id || !/\bcommit\b/.test(command))
@@ -18513,8 +18560,8 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs15.mkdirSync(path19.dirname(file), { recursive: true });
-      fs15.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+      fs16.mkdirSync(path19.dirname(file), { recursive: true });
+      fs16.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
   } catch {}
@@ -18537,11 +18584,11 @@ var headCommit = (dir) => {
 var settle2 = (input, repo, file) => {
   let marker;
   try {
-    marker = JSON.parse(fs15.readFileSync(file, "utf8"));
+    marker = JSON.parse(fs16.readFileSync(file, "utf8"));
   } catch {
     return;
   }
-  fs15.rmSync(file, { force: true });
+  fs16.rmSync(file, { force: true });
   const session = input.session.id;
   const now = Date.now() / 1000;
   if (typeof marker.at !== "number" || now - marker.at > MARKER_TTL_SECONDS)
@@ -18590,12 +18637,297 @@ function settlePendingCommit(input) {
     if (!repo)
       return;
     const file = markerFile(repo, input.session.id, NEXT_COMMAND);
-    if (fs15.existsSync(file))
+    if (fs16.existsSync(file))
       settle2(input, repo, file);
   } catch {}
 }
 
+// packages/workit-core/src/core/route-intent.ts
+var UNKNOWABLE = /[$`*?[\]{}~]/u;
+var SWITCH_CREATE = new Set(["-c", "--create", "-C", "--force-create", "--orphan"]);
+var CHECKOUT_CREATE = new Set(["-b", "-B", "--orphan"]);
+var WORKTREE_CREATE = new Set(["-b", "-B"]);
+var BRANCH_NO_CREATE = new Set(["-d", "-D", "--delete", "-l", "--list", "-a", "--all", "-r", "--remotes", "--show-current"].concat(["-v", "-vv", "--verbose", "--contains", "--no-contains", "--merged", "--no-merged"]).concat(["--points-at", "--sort", "--format", "--column", "--no-column", "-u"]).concat(["--set-upstream-to", "--unset-upstream", "--edit-description", "-i", "--ignore-case"]));
+var BRANCH_RENAME = new Set(["-m", "-M", "--move", "-c", "-C", "--copy"]);
+var flagValue = (args, flags) => {
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--")
+      return null;
+    if (flags.has(arg))
+      return args[index + 1] ?? null;
+    const eq = arg.indexOf("=");
+    if (arg.startsWith("--") && eq > 0 && flags.has(arg.slice(0, eq)))
+      return arg.slice(eq + 1);
+    if (!arg.startsWith("--") && arg.length > 2 && flags.has(arg.slice(0, 2)))
+      return arg.slice(2);
+  }
+  return null;
+};
+var WORKTREE_VALUES = new Set(["--reason"]);
+var worktreeTarget = (args) => {
+  const named = flagValue(args, WORKTREE_CREATE);
+  if (named !== null)
+    return named;
+  const positionals = [];
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--detach" || arg === "-d")
+      return null;
+    if (WORKTREE_VALUES.has(arg))
+      index++;
+    else if (!arg.startsWith("-"))
+      positionals.push(arg);
+  }
+  if (positionals.length !== 1)
+    return null;
+  const base = positionals[0].split(/[\\/]/u).findLast(Boolean) ?? "";
+  return base && base !== "." && base !== ".." ? base : null;
+};
+var branchCommandTarget = (args) => {
+  let rename = false;
+  const positionals = [];
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      positionals.push(...args.slice(index + 1));
+      break;
+    }
+    const flag = arg.split("=", 1)[0];
+    if (BRANCH_NO_CREATE.has(flag))
+      return null;
+    if (BRANCH_RENAME.has(flag))
+      rename = true;
+    else if (!arg.startsWith("-"))
+      positionals.push(arg);
+  }
+  if (positionals.length < 1 || positionals.length > 2)
+    return null;
+  return rename ? positionals.at(-1) ?? null : positionals[0];
+};
+var gitBranchCreation = (args) => {
+  const [sub, second] = args;
+  const target = sub === "switch" ? flagValue(args, SWITCH_CREATE) : sub === "checkout" ? flagValue(args, CHECKOUT_CREATE) : sub === "branch" ? branchCommandTarget(args) : sub === "worktree" && second === "add" ? worktreeTarget(args.slice(1)) : null;
+  return target && !target.startsWith("-") && !UNKNOWABLE.test(target) ? target : null;
+};
+var shellBranchTargets = (command, dialect = "posix") => {
+  if (!/\bgit\b/u.test(command))
+    return [];
+  const found = [];
+  for (const invocation of rawInvocations(command, dialect)) {
+    if (invocation.tool !== "git")
+      continue;
+    const branch = gitBranchCreation(invocation.args);
+    if (branch)
+      found.push({ branch, dir: invocation.dir });
+  }
+  return found;
+};
+var localBranchExists = (dir, branch) => spawnSync12("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+  cwd: dir,
+  stdio: "ignore",
+  timeout: 5000
+}).status === 0;
+var shellBranchPolicyViolation = (root, command, dialect = "posix") => {
+  let judged = false;
+  for (const target of shellBranchTargets(command, dialect)) {
+    if (target.dir === undefined)
+      continue;
+    const dir = target.dir === null ? root : path20.resolve(root, target.dir);
+    if (target.dir !== null && (!existsSync6(dir) || !inWorkitWorkspace(dir)))
+      continue;
+    if (localBranchExists(dir, target.branch))
+      continue;
+    judged = true;
+    const check = validateBranchNameFor(dir, target.branch);
+    if (!check.ok)
+      return check;
+  }
+  return judged ? { ok: true } : null;
+};
+
+// packages/workit-core/src/hooks/policy.ts
+var shellPolicy = (cwd, command, dialect = "posix") => {
+  const policy = shellBranchPolicyViolation(cwd, command, dialect);
+  return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
+};
+// packages/workit-core/src/hooks/write-gate.ts
+import { realpathSync as realpathSync5 } from "node:fs";
+import path21 from "node:path";
+var NONE3 = { kind: "none" };
+var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
+var canonical2 = (file) => {
+  let rest = "";
+  for (let dir = path21.resolve(file);; dir = path21.dirname(dir)) {
+    try {
+      return path21.join(realpathSync5(dir), rest);
+    } catch {
+      if (path21.dirname(dir) === dir)
+        return path21.resolve(file);
+      rest = rest ? path21.join(path21.basename(dir), rest) : path21.basename(dir);
+    }
+  }
+};
+var exempt = (cwd, root, file, plans) => {
+  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
+  const relative = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
+  if (relative.startsWith("..") || path21.isAbsolute(relative))
+    return true;
+  const posix = relative.split(path21.sep).join("/");
+  const segments = posix.split("/");
+  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+};
+var PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+var operands = (words) => words.filter((item) => !item.startsWith("-"));
+var editsOf = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES3.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const [verb, ...args] = words;
+  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
+  if (!name || name === "workit" || name === "npx" && args.some((item) => /workit/.test(item)))
+    return [];
+  switch (name) {
+    case "touch":
+    case "mkdir":
+    case "rm":
+    case "rmdir":
+    case "tee":
+    case "mv":
+    case "truncate":
+      return operands(args);
+    case "cp":
+    case "ln":
+    case "install": {
+      const target = args.indexOf("-t");
+      if (target >= 0)
+        return args[target + 1] ? [args[target + 1]] : null;
+      const last = operands(args).at(-1);
+      return last ? [last] : null;
+    }
+    case "dd":
+      return args.filter((item) => item.startsWith("of=")).map((item) => item.slice(3));
+    case "sed":
+    case "perl": {
+      if (!args.some((item) => /^-[a-zA-Z]*i|^--in-place/.test(item)))
+        return [];
+      const scripted = args.some((item) => item === "-e" || item === "-f");
+      const files = [];
+      for (let index = 0;index < args.length; index++) {
+        if (args[index] === "-e" || args[index] === "-f")
+          index++;
+        else if (!args[index].startsWith("-"))
+          files.push(args[index]);
+      }
+      return scripted ? files : files.slice(1);
+    }
+    case "patch":
+      return null;
+    case "set-content":
+    case "add-content":
+    case "out-file":
+    case "new-item":
+    case "ni":
+    case "remove-item":
+    case "del":
+    case "copy-item":
+    case "move-item": {
+      const flag = args.findIndex((item) => /^-(?:path|filepath|literalpath|destination)$/i.test(item));
+      if (flag >= 0)
+        return args[flag + 1] ? [args[flag + 1]] : null;
+      const files = operands(args);
+      if (name === "move-item")
+        return files.length ? files : null;
+      const file = name === "copy-item" ? files.at(-1) : files[0];
+      return file ? [file] : null;
+    }
+    case "git": {
+      const sub = operands(args)[0];
+      if (sub === "apply")
+        return null;
+      if (sub === "restore" || sub === "mv" || sub === "rm")
+        return operands(args).slice(1);
+      if (sub === "checkout" && args.includes("--"))
+        return args.slice(args.indexOf("--") + 1);
+      return [];
+    }
+    default:
+      return [];
+  }
+};
+var shellWrites = (command) => {
+  const targets = [];
+  let unknown = false;
+  for (const segment of segmentsOf(command)) {
+    targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
+    const edits = editsOf(segment.words);
+    if (edits === null)
+      unknown = true;
+    else
+      targets.push(...edits);
+  }
+  if (!unknown && targets.length === 0)
+    return { writes: false, targets: null };
+  return { writes: true, targets: unknown ? null : targets };
+};
+var cache2 = new Map;
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path21.resolve(root, file)) ?? "-").join("\x00");
+var gateFor = (cwd) => {
+  const store = new TaskStore(cwd);
+  const listed = store.listTaskIndex();
+  if (!listed.ok)
+    return null;
+  const key = store.currentKey();
+  if (!key.ok)
+    return null;
+  const entry = listed.data.filter((item) => item.key === key.data.key && item.status !== "closed").toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
+  if (!entry)
+    return { blockers: [], root: store.root, plans: new Set };
+  const ledger = ledgerPath(store.root);
+  const cacheKey = `${entry.id}\x00${entry.revision}\x00${ledger.ok && fileSignature(ledger.value) || "-"}`;
+  const hit = cache2.get(store.root);
+  if (hit && hit.key === cacheKey && hit.planKey === planKeyOf(store.root, hit.plans))
+    return hit;
+  const task = store.readTask(entry.id);
+  if (!task.ok)
+    return null;
+  const workspace = store.readWorkspace();
+  const plans = new Set((latestJudgment(task.data)?.refs ?? []).flatMap((ref) => ref.kind === "file" ? [ref.path] : []));
+  const blockers = writeBlockers(task.data, store.root).filter((blocker) => {
+    const requirement = task.data.policy?.requirements.find((item) => item.ruleId === blocker.ruleId && item.before === "write");
+    return !(requirement?.acceptanceAllowed && workspace.ok && workspace.data && applicableDecision(task.data, workspace.data, requirement, store.root).length > 0);
+  });
+  const gate = {
+    blockers,
+    root: store.root,
+    plans,
+    key: cacheKey,
+    planKey: planKeyOf(store.root, plans)
+  };
+  cache2.set(store.root, gate);
+  if (cache2.size > 32)
+    cache2.delete(cache2.keys().next().value);
+  return gate;
+};
+function writeGate(cwd, paths) {
+  try {
+    const gate = gateFor(cwd);
+    if (!gate || gate.blockers.length === 0)
+      return NONE3;
+    if (paths?.length && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
+      return NONE3;
+    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
+    return {
+      kind: "deny",
+      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
+      unblock: gate.blockers[0].reason
+    };
+  } catch {
+    return NONE3;
+  }
+}
 // packages/workit-core/src/hooks/stop.ts
+import { spawnSync as spawnSync13 } from "node:child_process";
 var NONE4 = { kind: "none" };
 var QUESTION = /[?？؟](?=[\s*_`"')\]>]*(?:\s|$))|¿/;
 var OFFER = /\b(?:let me know|want me to|should I|shall I|would you like|do you want|if you(?:'d| would) like|may I|can I go ahead)\b/i;
@@ -18616,7 +18948,7 @@ var asksUser = (message) => {
 };
 var short = (sha) => (sha ?? "?").slice(0, 12);
 var gitList = (cwd, args) => {
-  const run = spawnSync12("git", args, {
+  const run = spawnSync13("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 3000,
@@ -18979,13 +19311,13 @@ ${line}` };
   return decision;
 };
 // packages/workit-core/src/hooks/hosts/fields.ts
-import { existsSync as existsSync6, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path20 from "node:path";
+import { existsSync as existsSync7, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
+import path22 from "node:path";
 var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
 var optionalText = (value) => typeof value === "string" ? value : null;
 var existingDirectory = (value) => {
-  if (!nonEmpty2(value) || !path20.isAbsolute(value) || !existsSync6(value))
+  if (!nonEmpty2(value) || !path22.isAbsolute(value) || !existsSync7(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -19074,17 +19406,20 @@ var subagentStartText = (input, descriptor, event) => {
   const role = workitRole(descriptor, event.agentType);
   const who = `${descriptor.label} subagent ${event.agentId} (${event.agentType})`;
   const isolated = descriptor.subagents.worktreeIsolation === "native" && (role === "implementer" || CLAUDE_WORKTREE.test(input.cwd));
+  const guide = role === "implementer" ? branchGuidance(input.cwd) : null;
   if (role === "implementer" && isolated)
-    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${ISOLATED_GIT} Use a policy-compliant branch (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${ISOLATED_GIT} Plain git is expected here, and the branch name is still policy-checked: a raw \`git switch -c\`, \`git checkout -b\`, \`git branch\` or \`git worktree add -b\` onto a protected or non-compliant name is denied, so use a policy-compliant branch.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   if (isolated)
     return `${ISOLATED_GIT}
 ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
   if (role === "implementer")
-    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (or \`--kind <kind> --slug <slug>\`, which picks the base); branch policy hooks still deny protected or non-compliant branches, raw git included.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   const readOnly = `Workit observed ${who} as read-only/agent-guided.`;
   if (role !== "judge" || !event.agentId)
     return readOnly;
   const own = subagentSession(session, event.agentId);
+  if (session)
+    recordIssuedSession(input.cwd || process.cwd(), session, own);
   return `${readOnly} Its own Workit session is ${own}: record verdicts with \`workit ledger verdict <result> --session ${own} ...\` so the ledger tells it apart from the author.`;
 };
 function handleHook(input, deps) {
@@ -19118,7 +19453,7 @@ function handleHook(input, deps) {
       if (skillRead)
         recordSkillLoad(input, skillRead, "read");
       const canDeny = usable2(descriptor.shellPolicy.deny);
-      const policy = canDeny ? shellPolicy(input.cwd, event.command) : NONE5;
+      const policy = canDeny ? shellPolicy(input.cwd, event.command, event.dialect) : NONE5;
       if (policy.kind !== "none")
         return policy;
       const postTool = usable2(descriptor.events["shell.post"].support);
@@ -19716,12 +20051,12 @@ var codexAdapter = {
     };
   },
   render: render2,
-  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under its own session, never the author's: a workit-verifier or workit-reviewer agent uses the --session its SubagentStart context names; any other uses one the lead assigns (WORKIT_HOST=codex_cli WORKIT_SESSION_ID=<lead>-v<n>). Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
+  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under its own session, never the author's: a workit-verifier or workit-reviewer agent uses the --session its SubagentStart context names; any other passes --as verifier (an id derived from its own thread). A hand-minted id such as <lead>-v1 is refused as forged_session. Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
 };
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import fs16 from "node:fs";
-import path21 from "node:path";
+import fs17 from "node:fs";
+import path23 from "node:path";
 var undocumented = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
 var CURSOR_DESCRIPTOR = {
@@ -19918,17 +20253,17 @@ var protocolEvent2 = (input) => {
 };
 var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 var lastAssistantText = (file) => {
-  if (!file || !path21.isAbsolute(file))
+  if (!file || !path23.isAbsolute(file))
     return null;
   try {
-    const size = fs16.statSync(file).size;
+    const size = fs17.statSync(file).size;
     const start = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
     const buffer = Buffer.alloc(size - start);
-    const fd = fs16.openSync(file, "r");
+    const fd = fs17.openSync(file, "r");
     try {
-      fs16.readSync(fd, buffer, 0, buffer.length, start);
+      fs17.readSync(fd, buffer, 0, buffer.length, start);
     } finally {
-      fs16.closeSync(fd);
+      fs17.closeSync(fd);
     }
     const lines = buffer.toString("utf8").split(`
 `);
@@ -19955,7 +20290,7 @@ var lastAssistantText = (file) => {
     return null;
   }
 };
-var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path21.sep) ? root : `${root}${path21.sep}`);
+var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path23.sep) ? root : `${root}${path23.sep}`);
 var hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")