npm - @brainervirus/workit-opencode - Versions diffs - 8.20.0 → 8.21.0 - Mend

@brainervirus/workit-opencode 8.20.0 → 8.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/plugin.js +506 -314
package/package.json +2 -2

package/dist/plugin.js CHANGED Viewed

@@ -6,7 +6,7 @@ function define(plugin) {
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync16 } from "node:child_process";
 import { existsSync as existsSync8, realpathSync as realpathSync5 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -14414,10 +14414,10 @@ var workerBlocksTransition = (transition, state) => transition === "pause" ? fal
 var holdsLiveState = (state, dirty) => state === "running" || dirty === true;
 // packages/workit-core/src/core/task-evaluation.ts
-import { createHash as createHash11 } from "node:crypto";
-import * as fs13 from "node:fs";
+import { createHash as createHash12 } from "node:crypto";
+import * as fs14 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path16 from "node:path";
+import path17 from "node:path";
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
@@ -14648,13 +14648,70 @@ function checkCommand(args, version, onPath = workitAvailable()) {
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { createHash as createHash10, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash11, randomBytes as randomBytes3 } from "node:crypto";
+import fs13 from "node:fs";
+import path15 from "node:path";
+// packages/workit-core/src/hooks/standing-signal.ts
+import { createHash as createHash10 } from "node:crypto";
 import fs12 from "node:fs";
 import path14 from "node:path";
+var gitStoreDir = (cwd) => {
+  try {
+    for (let dir = path14.resolve(cwd);; dir = path14.dirname(dir)) {
+      const dotGit = path14.join(dir, ".git");
+      if (fs12.existsSync(dotGit)) {
+        let gitDir = dotGit;
+        if (fs12.statSync(dotGit).isFile()) {
+          const target = /^gitdir:\s*(.+)$/mu.exec(fs12.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+          if (!target)
+            return null;
+          gitDir = path14.resolve(dir, target);
+          const common = path14.join(gitDir, "commondir");
+          if (fs12.existsSync(common))
+            gitDir = path14.resolve(gitDir, fs12.readFileSync(common, "utf8").trim());
+        }
+        return path14.join(gitDir, "workit");
+      }
+      if (path14.dirname(dir) === dir)
+        return null;
+    }
+  } catch {
+    return null;
+  }
+};
+var standingRevFile = (store) => path14.join(store, "standing", "rev");
+var standingSeenFile = (store, session, agentId) => path14.join(store, "standing", "seen", `${createHash10("sha256").update(`${session}\x00${agentId ?? ""}`).digest("hex").slice(0, 32)}.json`);
+var readStandingRev = (store) => {
+  try {
+    return fs12.readFileSync(standingRevFile(store), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+};
+var readStandingSeen = (file) => {
+  try {
+    const value = JSON.parse(fs12.readFileSync(file, "utf8"));
+    return {
+      rev: typeof value.rev === "string" ? value.rev : null,
+      ids: Array.isArray(value.ids) ? value.ids.filter((id) => typeof id === "string") : []
+    };
+  } catch {
+    return { rev: null, ids: [] };
+  }
+};
+var writeStandingSeen = (file, seen) => {
+  try {
+    fs12.mkdirSync(path14.dirname(file), { recursive: true });
+    fs12.writeFileSync(file, JSON.stringify(seen));
+  } catch {}
+};
+// packages/workit-core/src/ledger.ts
 var LEDGER_VERSION = 1;
 var MAX_LINE_BYTES = 4096;
 var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
@@ -14764,7 +14821,7 @@ function diffHash(cwd, base, head) {
   ], GIT_TIMEOUTS.worktree);
   if (!diff.ok || !diff.stdout)
     return null;
-  const hash = createHash10("sha256");
+  const hash = createHash11("sha256");
   for (const line of diff.stdout.split(`
 `)) {
     if (line.startsWith("index "))
@@ -14776,14 +14833,14 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path14.resolve(cwd));
+  const location = resolveStore(path15.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: path14.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path15.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 var newId2 = () => `${Date.now().toString(36)}-${randomBytes3(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
@@ -14803,7 +14860,7 @@ var onNetworkFs = (dir) => {
   if (process.platform !== "linux")
     return false;
   try {
-    return isNetworkFsType(fs12.statfsSync(dir).type);
+    return isNetworkFsType(fs13.statfsSync(dir).type);
   } catch {
     return false;
   }
@@ -14813,15 +14870,15 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs12.readFileSync(path14.join(lock, LOCK_OWNER), "utf8");
+    return fs13.readFileSync(path15.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path14.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path15.join(lock, LOCK_OWNER), lock]) {
     try {
-      return Date.now() - fs12.statSync(target).mtimeMs;
+      return Date.now() - fs13.statSync(target).mtimeMs;
     } catch {}
   }
   return null;
@@ -14829,14 +14886,14 @@ var lockAgeMs = (lock) => {
 var ledgerLock = {
   acquire(lock) {
     try {
-      fs12.mkdirSync(lock);
+      fs13.mkdirSync(lock);
     } catch (error) {
       if (error.code === "EEXIST")
         return null;
       throw error;
     }
     const token = `${process.pid}-${randomBytes3(8).toString("hex")}`;
-    fs12.writeFileSync(path14.join(lock, LOCK_OWNER), token);
+    fs13.writeFileSync(path15.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
@@ -14844,35 +14901,35 @@ var ledgerLock = {
       return false;
     const tomb = `${lock}.release-${randomBytes3(6).toString("hex")}`;
     try {
-      fs12.renameSync(lock, tomb);
+      fs13.renameSync(lock, tomb);
     } catch {
       return false;
     }
     if (lockToken(tomb) !== token) {
       try {
-        fs12.renameSync(tomb, lock);
+        fs13.renameSync(tomb, lock);
       } catch {}
       return false;
     }
-    fs12.rmSync(tomb, { recursive: true, force: true });
+    fs13.rmSync(tomb, { recursive: true, force: true });
     return true;
   },
   token: lockToken,
   reap(lock, observed) {
     const tomb = `${lock}.reap-${randomBytes3(6).toString("hex")}`;
     try {
-      fs12.renameSync(lock, tomb);
+      fs13.renameSync(lock, tomb);
     } catch {
       return false;
     }
     if (lockToken(tomb) === observed) {
-      fs12.rmSync(tomb, { recursive: true, force: true });
+      fs13.rmSync(tomb, { recursive: true, force: true });
       return true;
     }
     try {
-      fs12.renameSync(tomb, lock);
+      fs13.renameSync(tomb, lock);
     } catch {
-      fs12.rmSync(tomb, { recursive: true, force: true });
+      fs13.rmSync(tomb, { recursive: true, force: true });
     }
     return false;
   }
@@ -14899,14 +14956,14 @@ function withLedgerLock(file, fn, waitMs = hostAwareLockTimeout(LOCK_WAIT_MS)) {
     ledgerLock.release(lock, token);
   }
 }
-var sha2562 = (text) => createHash10("sha256").update(text).digest("hex");
+var sha2562 = (text) => createHash11("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);
-    fs12.readSync(fd, buffer, 0, span, size - span);
+    fs13.readSync(fd, buffer, 0, span, size - span);
     const end = buffer.lastIndexOf(10);
     if (end < 0) {
       if (span === size)
@@ -14937,21 +14994,21 @@ var lastLine = (fd, size) => {
 };
 var tighten = (fd) => {
   try {
-    if ((fs12.fstatSync(fd).mode & 63) !== 0)
-      fs12.fchmodSync(fd, 384);
+    if ((fs13.fstatSync(fd).mode & 63) !== 0)
+      fs13.fchmodSync(fd, 384);
   } catch {}
 };
 function appendLine(file, build, options) {
   const write = () => {
-    const fd = fs12.openSync(file, "a+", 384);
+    const fd = fs13.openSync(file, "a+", 384);
     try {
       if (process.platform !== "win32")
         tighten(fd);
-      const size = fs12.fstatSync(fd).size;
+      const size = fs13.fstatSync(fd).size;
       let fence = "";
       if (size > 0) {
         const last = Buffer.alloc(1);
-        fs12.readSync(fd, last, 0, 1, size - 1);
+        fs13.readSync(fd, last, 0, 1, size - 1);
         if (last[0] !== 10)
           fence = `
 `;
@@ -14960,17 +15017,17 @@ function appendLine(file, build, options) {
       if (!line.ok)
         return line;
       const bytes = Buffer.from(fence + line.value);
-      const written = fs12.writeSync(fd, bytes);
+      const written = fs13.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 {
-      fs12.closeSync(fd);
+      fs13.closeSync(fd);
     }
   };
   try {
-    fs12.mkdirSync(path14.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path14.dirname(file)))
+    fs13.mkdirSync(path15.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path15.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");
@@ -15043,8 +15100,8 @@ function readLedger(cwd, options = {}) {
   let text = "";
   let stat = null;
   try {
-    stat = fs12.statSync(file.value);
-    text = fs12.readFileSync(file.value, "utf8");
+    stat = fs13.statSync(file.value);
+    text = fs13.readFileSync(file.value, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return {
@@ -15179,7 +15236,7 @@ function ledgerTampering(cwd) {
   if (!file.ok)
     return [];
   try {
-    const stat = fs12.statSync(file.value);
+    const stat = fs13.statSync(file.value);
     const cached = tamperCache.get(file.value);
     if (cached && cached.size === stat.size && cached.stamp === fileStamp(stat))
       return cached.breaks;
@@ -15510,6 +15567,28 @@ function checkVerdicts(cwd, branch, ledgerRows) {
     warnings
   };
 }
+var fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session);
+function activeStanding(rows, fanout, leads = null) {
+  const active = [];
+  for (const row of rows) {
+    if (row.fanout !== fanout || !fromLead(row, leads))
+      continue;
+    if (row.type === "standing" && typeof row.what === "string" && row.what.trim()) {
+      if (!row.superseded)
+        active.push(row);
+    } else if (row.type === "standing.cleared") {
+      const target = str2(row.target);
+      if (target === null)
+        active.length = 0;
+      else {
+        const index = active.findIndex((order) => order.id === target);
+        if (index >= 0)
+          active.splice(index, 1);
+      }
+    }
+  }
+  return active;
+}
 var OBSERVED_ONLY = new Set([
   "check",
   "merge.unverified",
@@ -15658,7 +15737,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path15.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path16.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -15717,15 +15796,15 @@ function writeBlockers(task, root) {
 }
 // packages/workit-core/src/core/task-evaluation.ts
-var digestBytes = (value) => createHash11("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path16.sep}`);
-var relative = (root, candidate) => path16.relative(root, candidate).split(path16.sep).join("/") || ".";
+var digestBytes = (value) => createHash12("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path17.sep}`);
+var relative = (root, candidate) => path17.relative(root, candidate).split(path17.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path16.posix.normalize(value);
+  const normalized = path17.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -15773,21 +15852,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(path16.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path17.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(path16.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path17.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs13.readdirSync(directory);
+    names = fs14.readdirSync(directory);
   } catch {
     return true;
   }
@@ -15795,10 +15874,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path16.join(directory, name);
+    const target = path17.join(directory, name);
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs14.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -15813,14 +15892,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path16.resolve(root, item);
+    const target = path17.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 (!fs13.existsSync(ancestor) && ancestor !== root)
-      ancestor = path16.dirname(ancestor);
+    while (!fs14.existsSync(ancestor) && ancestor !== root)
+      ancestor = path17.dirname(ancestor);
     try {
-      if (!inside(root, fs13.realpathSync(ancestor)))
+      if (!inside(root, fs14.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}`);
@@ -15832,7 +15911,7 @@ var scopeRoots = (root, scope) => {
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs13.realpathSync(root);
+    checkout = fs14.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -15850,11 +15929,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs13.existsSync(target))
+    if (!fs14.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs14.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -15870,17 +15949,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path16.join(checkout, item);
+    const target = path17.join(checkout, item);
     try {
-      const stat = fs13.lstatSync(target);
+      const stat = fs14.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs13.readlinkSync(target);
+        const link = fs14.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(fs13.readFileSync(target)),
+          digest: digestBytes(fs14.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -16045,7 +16124,7 @@ var findingVerificationPasses = (findingCandidateId, evidence) => evidence.statu
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs13.realpathSync(checkoutRoot);
+    root = fs14.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -16054,23 +16133,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path16.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path16.sep}`))
+    const target = path17.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path17.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 = path16.relative(root, target);
+      const below = path17.relative(root, target);
       let current = root;
-      for (const segment of below.split(path16.sep)) {
+      for (const segment of below.split(path17.sep)) {
         if (!segment)
           continue;
-        current = path16.join(current, segment);
-        const stat = fs13.lstatSync(current);
-        const real = fs13.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path16.sep}`))
+        current = path17.join(current, segment);
+        const stat = fs14.lstatSync(current);
+        const real = fs14.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path17.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -16086,7 +16165,7 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         if (current !== target && !stat.isDirectory())
           return failure2("invalid_input", "document reference ancestor is not a directory");
       }
-      if (digestBytes(fs13.readFileSync(target)) !== reference.digest)
+      if (digestBytes(fs14.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "decision document bytes have changed");
     } catch {
       return failure2("invalid_input", "decision document is unavailable");
@@ -16666,19 +16745,19 @@ var exportDigest = (bundle) => sha256({
 // packages/workit-core/src/core/route-intent.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 // 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 { createHash as createHash14 } from "node:crypto";
+import fs16 from "node:fs";
 import os4 from "node:os";
-import path18 from "node:path";
+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 path17 from "node:path";
+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) {
@@ -16687,13 +16766,13 @@ var sessionMarkerFile = (input, session, store) => {
       return null;
     dir = location.dir;
   }
-  const name = createHash12("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path17.join(dir, "hooks", `skills-${name}.json`);
+  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(fs14.readFileSync(file, "utf8"));
+    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: [] };
@@ -16701,8 +16780,8 @@ var readSessionMarker = (file) => {
 };
 var writeSessionMarker = (file, marker) => {
   try {
-    fs14.mkdirSync(path17.dirname(file), { recursive: true });
-    fs14.writeFileSync(file, JSON.stringify(marker));
+    fs15.mkdirSync(path18.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, JSON.stringify(marker));
   } catch {}
 };
@@ -17199,14 +17278,14 @@ var GIT_CONFIG_ENV = /^GIT_(?:CONFIG\w*|DIR|COMMON_DIR|WORK_TREE)$/;
 var ASSIGNMENT = /^([A-Za-z_]\w*)=([\s\S]*)$/;
 var MAX_DEPTH = 4;
 var MAX_EXPANSIONS = 16;
-var isAbsolute = (value) => path18.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 var HERE = /^(?:\$PWD|\$\{PWD\}|\$\(\s*pwd\s*\)|`pwd`|\$\(\s*git\s+rev-parse\s+--show-toplevel\s*\))(?=$|[\\/])/;
 var joinDir = (base, raw) => {
   const next = raw.replace(HERE, ".");
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path18.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path18.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
 };
 var rebase = (base, inner) => inner === null ? base : inner === undefined ? undefined : joinDir(base, inner);
 var cdTarget = (words) => {
@@ -18018,7 +18097,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;
@@ -18039,17 +18118,17 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs15.readFileSync(path18.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];
     if (!ref)
       return null;
-    const common = path18.dirname(repo.location.dir);
+    const common = path19.dirname(repo.location.dir);
     try {
-      return fs15.readFileSync(path18.join(common, ref), "utf8").trim() || null;
+      return fs16.readFileSync(path19.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs15.readFileSync(path18.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;
@@ -18137,8 +18216,8 @@ var expandGitAliases = (root, invocation, cache = new Map, depth = 0) => {
   const sub = invocation.args[0];
   if (invocation.tool !== "git" || invocation.dir === undefined || !sub || sub.startsWith("-") || GIT_COMMANDS.has(sub) || depth >= MAX_DEPTH)
     return [invocation];
-  const dir = path18.resolve(root, invocation.dir ?? ".");
-  if (!fs15.existsSync(dir))
+  const dir = path19.resolve(root, invocation.dir ?? ".");
+  if (!fs16.existsSync(dir))
     return [invocation];
   const config = gitConfig(dir, invocation, cache);
   const alias = configValue(config, `alias.${sub.toLowerCase()}`);
@@ -18160,11 +18239,11 @@ var expandGitAliases = (root, invocation, cache = new Map, depth = 0) => {
 var normalizedUrl = (url, dir) => {
   const trimmed = url.trim();
   if (/^file:\/\//i.test(trimmed))
-    return path18.resolve(dir, trimmed.slice(7)).replace(/\/+$/, "").replace(/\.git$/, "");
+    return path19.resolve(dir, trimmed.slice(7)).replace(/\/+$/, "").replace(/\.git$/, "");
   const scheme = /^[a-z][a-z0-9+.-]*:\/\//i.exec(trimmed);
   const scp = !scheme && /^(?:[^@/\\]+@)?[^/\\:]{2,}:/.test(trimmed);
   if (!scheme && !scp)
-    return path18.resolve(dir, trimmed).replace(/\/+$/, "").replace(/\.git$/, "");
+    return path19.resolve(dir, trimmed).replace(/\/+$/, "").replace(/\.git$/, "");
   const value = scheme ? trimmed.slice(scheme[0].length).replace(/^[^@/]*@/, "").replace(/^([^/:]+):\d+(?=\/)/, "$1") : trimmed.replace(/^[^@/]*@/, "").replace(":", "/");
   return value.toLowerCase().replace(/\/{2,}/g, "/").replace(/^www\./, "").replace(/\/+$/, "").replace(/\.git$/, "");
 };
@@ -18388,7 +18467,7 @@ var actionsIn = (cwd, command, dialect, cache = new Map) => {
   const out = [];
   const repos = new Map;
   const repoFor = (relative) => {
-    const dir = path18.resolve(cwd, relative ?? ".");
+    const dir = path19.resolve(cwd, relative ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -18473,8 +18552,8 @@ var analysisDenial = (error) => ({
   unblock: SPLIT_IT
 });
 var MARKER_TTL_SECONDS = 3600;
-var markerFile = (repo, session, key) => path18.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))
@@ -18484,8 +18563,8 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs15.mkdirSync(path18.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 {}
@@ -18508,11 +18587,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)
@@ -18703,7 +18782,7 @@ var judgedDir = (root, dir) => {
     return null;
   if (dir === null)
     return root;
-  const resolved = path19.resolve(root, dir);
+  const resolved = path20.resolve(root, dir);
   return existsSync6(resolved) && inWorkitWorkspace(resolved) ? resolved : null;
 };
 var shellBranchPolicyViolation = (root, command, dialect = "posix") => {
@@ -18939,7 +19018,7 @@ var judgeInputSummary = (raw) => {
 // packages/workit-core/src/autonomy.ts
 import os5 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 // packages/workit-core/src/core/safe-write.ts
 import {
@@ -18973,10 +19052,10 @@ var accountHome = () => {
   }
 };
 var grantsHome = { resolve: accountHome };
-var grantsDir = () => path20.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path21.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path20.resolve(resolveConfigDir());
-  return configured === path20.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 ${path20.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  const configured = path21.resolve(resolveConfigDir());
+  return configured === path21.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 ${path21.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -20779,7 +20858,7 @@ class WorkitCore {
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync13 } from "node:child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -20913,7 +20992,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path21.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path22.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -20944,7 +21023,7 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path21.join(cwd, "package.json");
+  const pkgPath = path22.join(cwd, "package.json");
   if (!existsSync7(pkgPath))
     return [];
   try {
@@ -20970,9 +21049,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path21.join(dir, entry.name), depth + 1);
+        walk(path22.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path21.relative(cwd, path21.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path22.relative(cwd, path22.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -20988,7 +21067,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path21.resolve(repoRoot(root));
+  const cwd = path22.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -21046,7 +21125,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 `;
-    stdout += readTrimmed2(path21.join(cwd, template), 220);
+    stdout += readTrimmed2(path22.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
@@ -21056,7 +21135,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync7(path21.join(cwd, "package.json"))) {
+  if (existsSync7(path22.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -21065,7 +21144,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync7(path21.join(cwd, "Cargo.toml")) || existsSync7(path21.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync7(path22.join(cwd, "Cargo.toml")) || existsSync7(path22.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -21098,7 +21177,7 @@ var CHANGELOG_RULES = `- Use an [Unreleased] section.
 - Apply with the host-native editor, preserving the repository changelog conventions.
 - If Unreleased already has duplicate category headings, normalize_only first.`;
 function changelogContext(root, range) {
-  const cwd = path21.resolve(repoRoot(root));
+  const cwd = path22.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -21116,7 +21195,7 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path21.join(cwd, "CHANGELOG.md");
+  const changelogPath = path22.join(cwd, "CHANGELOG.md");
   if (existsSync7(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
@@ -21136,7 +21215,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path21.resolve(repoRoot(root));
+  const cwd = path22.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -21158,7 +21237,7 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path21.join(cwd, "README.md");
+  const readme = path22.join(cwd, "README.md");
   if (existsSync7(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
@@ -21167,7 +21246,7 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path21.join(cwd, "package.json");
+  const pkgPath = path22.join(cwd, "package.json");
   if (existsSync7(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
@@ -21181,7 +21260,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path21.resolve(repoRoot(root));
+  const cwd = path22.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -21219,7 +21298,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync7(path21.join(cwd, rel)))
+    if (existsSync7(path22.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -21250,8 +21329,8 @@ function releaseNotesContext(root, rangeOrTag) {
 import { spawnSync as spawnSync15 } from "node:child_process";
 // packages/workit-core/src/core/pr-create.ts
-import fs16 from "node:fs";
-import path22 from "node:path";
+import fs17 from "node:fs";
+import path23 from "node:path";
 import { spawnSync as spawnSync14 } from "node:child_process";
 import { pathToFileURL } from "node:url";
 // packages/workit-core/src/forge/pr-body.ts
@@ -21263,13 +21342,13 @@ function parseGhIssue(value) {
 // packages/workit-core/src/core/pr-create.ts
 function whichOnPath(tool) {
   const names = process.platform === "win32" ? [tool, `${tool}.exe`, `${tool}.cmd`] : [tool];
-  for (const dir of (process.env.PATH ?? "").split(path22.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path23.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path22.join(dir, name);
+      const candidate = path23.join(dir, name);
       try {
-        fs16.accessSync(candidate, fs16.constants.X_OK);
+        fs17.accessSync(candidate, fs17.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -21289,7 +21368,7 @@ var pushRemote = (cwd) => {
 };
 var safePushUrl = (remote) => {
   const raw = remote.trim();
-  if (path22.isAbsolute(raw))
+  if (path23.isAbsolute(raw))
     return pathToFileURL(raw).href;
   if (!raw.includes("://")) {
     const scp = /^(?:([^@\s]+)@)?([^:]+):(.+)$/u.exec(raw);
@@ -21420,8 +21499,8 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 // packages/workit-core/src/core/youtrack.ts
-import fs17 from "node:fs";
-import path23 from "node:path";
+import fs18 from "node:fs";
+import path24 from "node:path";
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -21434,22 +21513,22 @@ var resolveWorkspaceRoot = (explicit) => explicit || process.cwd();
 // packages/workit-core/src/core/youtrack.ts
 var ISSUE_RE = /^[A-Z]+-\d+$/;
 var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path23.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path23.join(resolveConfigDir(), "youtrack.json");
+var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path24.join(configDir(), "youtrack.json");
+var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path24.join(resolveConfigDir(), "youtrack.json");
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs17.statSync(p).mode & 511;
+  const mode = fs18.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs17.existsSync(cfgPath)) {
+  if (!fs18.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs17.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs18.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -21460,11 +21539,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs17.existsSync(cfgPath))
+  if (!fs18.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs17.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs18.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -21503,12 +21582,12 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path23.isAbsolute(tokenFile) ? path23.resolve(tokenFile) : path23.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs17.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path24.isAbsolute(tokenFile) ? path24.resolve(tokenFile) : path24.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs18.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs17.readFileSync(tokenPath, "utf8").trim();
+  const token = fs18.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -21554,7 +21633,7 @@ function youTrackTokenCreateUrl() {
   const desc = String(defaults.description ?? "OpenCode workit — /wk-issue-update and /wk-meetings");
   const scopes = Array.isArray(defaults.scopes) ? defaults.scopes : ["YouTrack"];
   const base = String(config.baseUrl ?? "").replace(/\/+$/, "");
-  const tokenFile = String(config.tokenFile ?? path23.join(path23.dirname(loaded.path), "youtrack.token"));
+  const tokenFile = String(config.tokenFile ?? path24.join(path24.dirname(loaded.path), "youtrack.token"));
   const tab = String(defaults.profileTab ?? "account-security");
   const createUrl = base ? `${base}/users/me?${new URLSearchParams({ tab })}` : null;
   const docsUrl = "https://www.jetbrains.com/help/youtrack/cloud/manage-permanent-token.html";
@@ -21563,7 +21642,7 @@ function youTrackTokenCreateUrl() {
       tokenName: name,
       tokenDescription: desc,
       scopes,
-      tokenFile: path23.resolve(tokenFile),
+      tokenFile: path24.resolve(tokenFile),
       createUrl,
       docsUrl,
       prefillSupported: false,
@@ -21609,9 +21688,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs17.existsSync(full))
+    if (!fs18.existsSync(full))
       continue;
-    const text = fs17.readFileSync(full, "utf8");
+    const text = fs18.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -21903,15 +21982,15 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path24.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path24.sep)) {
+  const target = path25.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path25.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync8(ancestor))
-    ancestor = path24.dirname(ancestor);
+    ancestor = path25.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path24.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path25.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -21955,7 +22034,7 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
-import path25 from "node:path";
+import path26 from "node:path";
 var MIGRATION_PENDING_NOTE = "workit migration pending — run `workit task status`";
 var migrationPending = (result) => !result.ok && result.code === "needs_input" && (result.error ?? "").startsWith(MIGRATION_PENDING);
 var boundTo = (entry, session) => entry.sessions.some((item) => item.host === session.host && item.handle === session.handle);
@@ -22040,7 +22119,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" ? [path25.resolve(store.root, ref.path)] : []));
+  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path26.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)
@@ -22071,13 +22150,13 @@ var shellPolicy = (cwd, command, dialect = "posix") => {
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
 // packages/workit-core/src/core/heavy-rules.ts
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import os6 from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 var EMPTY = () => ({ deny: [], allow: [] });
 var readText2 = (file) => {
   try {
-    return fs18.readFileSync(file, "utf8");
+    return fs19.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -22114,19 +22193,19 @@ function parseJsonc(text) {
   return JSON.parse(out.replace(/,(\s*[}\]])/gu, "$1"));
 }
 function gitTop(cwd) {
-  for (let dir = path26.resolve(cwd);; dir = path26.dirname(dir)) {
-    if (fs18.existsSync(path26.join(dir, ".git")))
+  for (let dir = path27.resolve(cwd);; dir = path27.dirname(dir)) {
+    if (fs19.existsSync(path27.join(dir, ".git")))
       return dir;
-    if (path26.dirname(dir) === dir)
+    if (path27.dirname(dir) === dir)
       return null;
   }
 }
 var projectDirs = (cwd) => {
   const top = gitTop(cwd);
   const dirs = [];
-  for (let dir = path26.resolve(cwd);; dir = path26.dirname(dir)) {
+  for (let dir = path27.resolve(cwd);; dir = path27.dirname(dir)) {
     dirs.push(dir);
-    if (!top || dir === top || path26.dirname(dir) === dir)
+    if (!top || dir === top || path27.dirname(dir) === dir)
       return dirs;
   }
 };
@@ -22138,12 +22217,12 @@ var CLAUDE_MANAGED = {
 };
 function claudeSettingsFiles(cwd, env, platform = process.platform) {
   const project = env.CLAUDE_PROJECT_DIR || gitTop(cwd) || cwd;
-  const user = env.CLAUDE_CONFIG_DIR || path26.join(homeOf(env), ".claude");
+  const user = env.CLAUDE_CONFIG_DIR || path27.join(homeOf(env), ".claude");
   return [
     ...CLAUDE_MANAGED[platform] ? [CLAUDE_MANAGED[platform]] : [],
-    path26.join(user, "settings.json"),
-    path26.join(project, ".claude", "settings.json"),
-    path26.join(project, ".claude", "settings.local.json")
+    path27.join(user, "settings.json"),
+    path27.join(project, ".claude", "settings.json"),
+    path27.join(project, ".claude", "settings.local.json")
   ];
 }
 var bashPattern = (entry) => {
@@ -22233,10 +22312,10 @@ var opencodeConfig = (value, rules) => {
 function opencodeRules(cwd, env = process.env) {
   const rules = EMPTY();
   try {
-    const config = env.XDG_CONFIG_HOME || path26.join(homeOf(env), ".config");
+    const config = env.XDG_CONFIG_HOME || path27.join(homeOf(env), ".config");
     const files = [
-      ...OPENCODE_NAMES.map((name) => path26.join(config, "opencode", name)),
-      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path26.join(dir, name), path26.join(dir, ".opencode", name)])),
+      ...OPENCODE_NAMES.map((name) => path27.join(config, "opencode", name)),
+      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path27.join(dir, name), path27.join(dir, ".opencode", name)])),
       ...env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []
     ];
     for (const file of files) {
@@ -22280,19 +22359,19 @@ var codexRule = (body) => {
 function codexRules(cwd, env = process.env) {
   const rules = EMPTY();
   try {
-    const home = env.CODEX_HOME || path26.join(homeOf(env), ".codex");
+    const home = env.CODEX_HOME || path27.join(homeOf(env), ".codex");
     const top = gitTop(cwd) ?? cwd;
-    for (const dir of [path26.join(home, "rules"), path26.join(top, ".codex", "rules")]) {
+    for (const dir of [path27.join(home, "rules"), path27.join(top, ".codex", "rules")]) {
       let files;
       try {
-        files = fs18.readdirSync(dir).filter((name) => name.endsWith(".rules"));
+        files = fs19.readdirSync(dir).filter((name) => name.endsWith(".rules"));
       } catch (error) {
         if (error.code === "ENOENT")
           continue;
         return "unreadable";
       }
       for (const name of files) {
-        const text = readText2(path26.join(dir, name)) ?? "";
+        const text = readText2(path27.join(dir, name)) ?? "";
         for (const part of text.split(/\bprefix_rule\s*\(/u).slice(1)) {
           const rule = codexRule(part);
           if (!rule)
@@ -22311,8 +22390,8 @@ function cursorRules(cwd, env = process.env) {
   try {
     const top = gitTop(cwd) ?? cwd;
     for (const file of [
-      path26.join(homeOf(env), ".cursor", "cli-config.json"),
-      path26.join(top, ".cursor", "cli.json")
+      path27.join(homeOf(env), ".cursor", "cli-config.json"),
+      path27.join(top, ".cursor", "cli.json")
     ]) {
       const text = readText2(file);
       if (text === null)
@@ -22386,23 +22465,23 @@ function wrapAllowed(read, words, command, options = {}) {
 }
 // packages/workit-core/src/core/heavy.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import os7 from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 function stateDir(env, platform = process.platform) {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
-    return path27.join(env.XDG_STATE_HOME, "workit");
+    return path28.join(env.XDG_STATE_HOME, "workit");
   const home = env.HOME || os7.homedir();
   if (platform === "darwin")
-    return path27.join(home, "Library", "Application Support", "workit");
+    return path28.join(home, "Library", "Application Support", "workit");
   if (platform === "win32")
-    return path27.join(env.LOCALAPPDATA ?? path27.join(home, "AppData", "Local"), "workit");
-  return path27.join(home, ".local", "state", "workit");
+    return path28.join(env.LOCALAPPDATA ?? path28.join(home, "AppData", "Local"), "workit");
+  return path28.join(home, ".local", "state", "workit");
 }
 var HEAVY_COMMANDS_FILE = "heavy-commands.json";
-var heavyCommandsFile = (env) => path27.join(stateDir(env), HEAVY_COMMANDS_FILE);
+var heavyCommandsFile = (env) => path28.join(stateDir(env), HEAVY_COMMANDS_FILE);
 var HEAVY_SCRIPT = /^(?:test|tests|t|tst|unit|integration|e2e|coverage|cov|lint|eslint|typecheck|type-check|types|tsc|check|verify|validate|build|compile|bundle|ci|sonar|cypress|playwright|jest|vitest|mocha|bench|benchmark|all)(?:$|[:_.-])/iu;
 var INFO_FLAGS = new Set(["--version", "-v", "-V", "--help", "-h", "help", "version"]);
 var WATCH_FLAG = /^(?:--watch(?:All)?(?:=.*)?|-w|--serve)$/u;
@@ -22665,7 +22744,7 @@ function parsePattern(pattern) {
 var matches = (matchers, words) => matchers.length <= words.length && matchers.every((matcher, index) => index === 0 ? matcher.test(words[0]) || matcher.test(baseName2(words[0])) : matcher.test(words[index]));
 var readJson = (file) => {
   try {
-    return JSON.parse(fs19.readFileSync(file, "utf8"));
+    return JSON.parse(fs20.readFileSync(file, "utf8"));
   } catch {
     return;
   }
@@ -22677,7 +22756,7 @@ function machinePatterns(env) {
   return isRecord5(value) ? stringList(value.patterns) : [];
 }
 function repoPatterns(cwd) {
-  return repoHeavyCommands(gitTop(cwd) ?? path27.resolve(cwd));
+  return repoHeavyCommands(gitTop(cwd) ?? path28.resolve(cwd));
 }
 function heavyLines(lines, options) {
   const found = [];
@@ -22755,12 +22834,12 @@ function heavyPlan(command, options) {
 }
 function workitOnPath2(env = process.env) {
   const names = process.platform === "win32" ? ["workit.exe", "workit.cmd", "workit"] : ["workit"];
-  for (const dir of (env.PATH ?? "").split(path27.delimiter))
+  for (const dir of (env.PATH ?? "").split(path28.delimiter))
     for (const name of names) {
       if (!dir)
         continue;
       try {
-        fs19.accessSync(path27.join(dir, name), fs19.constants.X_OK);
+        fs20.accessSync(path28.join(dir, name), fs20.constants.X_OK);
         return true;
       } catch {}
     }
@@ -22777,41 +22856,41 @@ function leaseRewrite(command) {
 }
 // packages/workit-core/src/core/heavy-words.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os8 from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 var HEAVY_WORDS = new Set(("npm npx pnpm pnpx yarn bun bunx deno corepack make gmake docker podman nerdctl " + "python python3 py uv poetry pdm pipenv hatch rye bundle rake nx " + "jest vitest mocha ava tap karma jasmine nyc c8 tsc vue-tsc svelte-check eslint stylelint " + "tslint webpack webpack-cli rollup parcel tsup vite next nuxt nuxi astro ng react-scripts " + "playwright cypress wdio testcafe turbo lerna sonar-scanner sonarless sonarless-mcp go " + "golangci-lint gotestsum staticcheck cargo mvn mvnw gradle gradlew ant sbt bazel bazelisk " + "buck2 dotnet msbuild pytest py.test tox nox mypy pyright pylint coverage maturin pip pip3 " + "rspec rails phpunit pest phpstan psalm composer mix swift xcodebuild flutter dart pod cmake " + "ninja meson ctest scons docker-compose buildah earthly").split(" "));
 var wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "")).filter(Boolean);
 var stateDir2 = (env) => {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
-    return path28.join(env.XDG_STATE_HOME, "workit");
+    return path29.join(env.XDG_STATE_HOME, "workit");
   const home = env.HOME || os8.homedir();
   if (process.platform === "darwin")
-    return path28.join(home, "Library", "Application Support", "workit");
+    return path29.join(home, "Library", "Application Support", "workit");
   if (process.platform === "win32")
-    return path28.join(env.LOCALAPPDATA ?? path28.join(home, "AppData", "Local"), "workit");
-  return path28.join(home, ".local", "state", "workit");
+    return path29.join(env.LOCALAPPDATA ?? path29.join(home, "AppData", "Local"), "workit");
+  return path29.join(home, ".local", "state", "workit");
 };
 var readJson2 = (file) => {
   try {
-    return JSON.parse(fs20.readFileSync(file, "utf8"));
+    return JSON.parse(fs21.readFileSync(file, "utf8"));
   } catch {
     return;
   }
 };
 var patternWords = (cwd, env) => {
   const patterns = [];
-  const machine = readJson2(path28.join(stateDir2(env), "heavy-commands.json"));
+  const machine = readJson2(path29.join(stateDir2(env), "heavy-commands.json"));
   if (Array.isArray(machine?.patterns))
     patterns.push(...machine.patterns);
-  for (let dir = path28.resolve(cwd);; dir = path28.dirname(dir)) {
-    if (fs20.existsSync(path28.join(dir, ".git"))) {
+  for (let dir = path29.resolve(cwd);; dir = path29.dirname(dir)) {
+    if (fs21.existsSync(path29.join(dir, ".git"))) {
       patterns.push(...repoHeavyCommands(dir));
       break;
     }
-    if (path28.dirname(dir) === dir)
+    if (path29.dirname(dir) === dir)
       break;
   }
   const words = new Set;
@@ -22872,14 +22951,14 @@ function heavyGate(cwd, command, options) {
 // packages/workit-core/src/hooks/write-gate.ts
 import { realpathSync as realpathSync6 } from "node:fs";
 import os10 from "node:os";
-import path30 from "node:path";
+import path31 from "node:path";
 // packages/workit-core/src/core/live-session.ts
 import { spawnSync as spawnSync17 } from "node:child_process";
-import { createHash as createHash14 } from "node:crypto";
-import fs21 from "node:fs";
+import { createHash as createHash15 } from "node:crypto";
+import fs22 from "node:fs";
 import os9 from "node:os";
-import path29 from "node:path";
+import path30 from "node:path";
 var LIVE_SESSION_TTL_MS = 15 * 60000;
 var HEARTBEAT_EVERY_MS = 30000;
 var liveProbe = {
@@ -22900,9 +22979,9 @@ var processAlive = (pid) => {
 var processInfo = (pid) => {
   try {
     if (liveProbe.platform === "linux") {
-      const stat = fs21.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const stat = fs22.readFileSync(`/proc/${pid}/stat`, "utf8");
       const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
-      const command = fs21.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
+      const command = fs22.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
       return Number.isInteger(ppid) ? { ppid, command: command.trim() } : null;
     }
     if (liveProbe.platform === "win32")
@@ -22953,35 +23032,35 @@ var liveOwner = (input, transport, env = process.env) => {
   };
 };
 var checkoutOf = (target) => {
-  let dir = path29.resolve(target);
-  while (!fs21.existsSync(dir) && path29.dirname(dir) !== dir)
-    dir = path29.dirname(dir);
-  if (fs21.existsSync(dir) && !fs21.statSync(dir).isDirectory())
-    dir = path29.dirname(dir);
-  const parts = dir.split(path29.sep);
+  let dir = path30.resolve(target);
+  while (!fs22.existsSync(dir) && path30.dirname(dir) !== dir)
+    dir = path30.dirname(dir);
+  if (fs22.existsSync(dir) && !fs22.statSync(dir).isDirectory())
+    dir = path30.dirname(dir);
+  const parts = dir.split(path30.sep);
   const dotGit = parts.lastIndexOf(".git");
   if (dotGit > 0)
-    dir = parts.slice(0, dotGit).join(path29.sep) || path29.sep;
+    dir = parts.slice(0, dotGit).join(path30.sep) || path30.sep;
   const location = resolveStore(dir);
   if (location instanceof Error || !location.shared || !location.top)
     return null;
   let top = location.top;
   try {
-    top = fs21.realpathSync.native(top);
+    top = fs22.realpathSync.native(top);
   } catch {}
   return top;
 };
-var markerFile2 = (top) => path29.join(resolveStateDir(), "live-sessions", `${createHash14("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`);
+var markerFile2 = (top) => path30.join(resolveStateDir(), "live-sessions", `${createHash15("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`);
 var checkoutKey = (top, platform = process.platform) => {
-  let key = path29.resolve(top);
+  let key = path30.resolve(top);
   try {
-    key = fs21.realpathSync.native(key);
+    key = fs22.realpathSync.native(key);
   } catch {}
   return platform === "win32" ? key.replaceAll("/", "\\").toLowerCase() : key;
 };
 var readMarker = (file) => {
   try {
-    const value = JSON.parse(fs21.readFileSync(file, "utf8"));
+    const value = JSON.parse(fs22.readFileSync(file, "utf8"));
     if (value?.version !== 1 || typeof value.session !== "string" || typeof value.host !== "string" || typeof value.heartbeatAt !== "string" || Number.isNaN(Date.parse(value.heartbeatAt)))
       return null;
     return {
@@ -23068,10 +23147,10 @@ var claimLiveSession = (target, owner, deps = {}) => {
       checkout,
       heartbeatAt: now.toISOString()
     };
-    fs21.mkdirSync(path29.dirname(file), { recursive: true });
+    fs22.mkdirSync(path30.dirname(file), { recursive: true });
     const temp = `${file}.${process.pid}.tmp`;
-    fs21.writeFileSync(temp, JSON.stringify(marker));
-    fs21.renameSync(temp, file);
+    fs22.writeFileSync(temp, JSON.stringify(marker));
+    fs22.renameSync(temp, file);
   } catch {}
 };
@@ -23080,22 +23159,22 @@ var NONE3 = { kind: "none" };
 var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
 var canonical2 = (file) => {
   let rest = "";
-  for (let dir = path30.resolve(file);; dir = path30.dirname(dir)) {
+  for (let dir = path31.resolve(file);; dir = path31.dirname(dir)) {
     try {
-      return path30.join(realpathSync6.native(dir), rest);
+      return path31.join(realpathSync6.native(dir), rest);
     } catch {
-      if (path30.dirname(dir) === dir)
-        return path30.resolve(file);
-      rest = rest ? path30.join(path30.basename(dir), rest) : path30.basename(dir);
+      if (path31.dirname(dir) === dir)
+        return path31.resolve(file);
+      rest = rest ? path31.join(path31.basename(dir), rest) : path31.basename(dir);
     }
   }
 };
 var exempt = (cwd, root, file, plans) => {
   const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path30.relative(fold(canonical2(root)), fold(canonical2(path30.resolve(cwd, file))));
-  if (relative.startsWith("..") || path30.isAbsolute(relative))
+  const relative = path31.relative(fold(canonical2(root)), fold(canonical2(path31.resolve(cwd, file))));
+  if (relative.startsWith("..") || path31.isAbsolute(relative))
     return true;
-  const posix = relative.split(path30.sep).join("/");
+  const posix = relative.split(path31.sep).join("/");
   const segments = posix.split("/");
   return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
 };
@@ -23216,7 +23295,7 @@ var shellWrites = (command, depth = 0) => {
   return { writes: true, targets: unknown ? null : targets };
 };
 var cache2 = new Map;
-var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path30.resolve(root, file)) ?? "-").join("\x00");
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path31.resolve(root, file)) ?? "-").join("\x00");
 var gateFor = (cwd) => {
   const store = new TaskStore(cwd);
   const listed = store.listTaskIndex();
@@ -23295,7 +23374,7 @@ var gitMutationDirs = (cwd, command, dialect) => {
       return [];
     if (sub === "stash" && ["list", "show"].includes(rest[0] ?? ""))
       return [];
-    return [path30.resolve(cwd, invocation.dir ?? ".")];
+    return [path31.resolve(cwd, invocation.dir ?? ".")];
   });
 };
 var CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
@@ -23306,7 +23385,7 @@ var cdInto = (dir, words) => {
   const target = named === undefined ? undefined : homeExpanded(named);
   if (dir === undefined || target === "-" || target && /^~|[$`*?]/.test(target))
     return;
-  return target === undefined ? os10.homedir() : path30.resolve(dir, target);
+  return target === undefined ? os10.homedir() : path31.resolve(dir, target);
 };
 var quoteWord2 = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
 var homeExpanded = (file) => {
@@ -23320,7 +23399,7 @@ var segmentTargets = (cwd, command, dialect, depth = 0) => {
   const groups = [];
   const at = (file) => {
     const home = homeExpanded(file);
-    return path30.isAbsolute(home) ? home : dir === undefined ? null : path30.resolve(dir, home);
+    return path31.isAbsolute(home) ? home : dir === undefined ? null : path31.resolve(dir, home);
   };
   for (const segment of segmentsOf(command, dialect)) {
     if (segment.group === "open") {
@@ -23361,7 +23440,7 @@ var segmentTargets = (cwd, command, dialect, depth = 0) => {
     const edits = editsOf(segment.words);
     if (edits === null) {
       if (dir !== undefined)
-        targets.push(path30.join(dir, DIR_TARGET));
+        targets.push(path31.join(dir, DIR_TARGET));
     } else
       for (const file of edits) {
         const resolved = at(file);
@@ -23369,7 +23448,7 @@ var segmentTargets = (cwd, command, dialect, depth = 0) => {
           targets.push(resolved);
       }
     if (dir !== undefined && workitInvocations(segment.words.map(quoteWord2).join(" "), "posix").some((args) => args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), "")))
-      targets.push(path30.join(dir, DIR_TARGET));
+      targets.push(path31.join(dir, DIR_TARGET));
   }
   return targets;
 };
@@ -23404,7 +23483,7 @@ var liveDeny = ({ marker, checkout, ageMs, file }) => {
 var guarded = (targets) => {
   const seen = new Set;
   return targets.filter((target) => {
-    const dir = path30.dirname(target);
+    const dir = path31.dirname(target);
     if (seen.has(dir))
       return false;
     seen.add(dir);
@@ -23425,7 +23504,7 @@ var claimAll = (owner, targets, deps) => {
   for (const target of guarded(targets))
     claimLiveSession(target, owner, deps);
 };
-var liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path30.resolve(cwd, file)) : [path30.join(cwd, DIR_TARGET)];
+var liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path31.resolve(cwd, file)) : [path31.join(cwd, DIR_TARGET)];
 var issuedTarget = (cwd, targets) => {
   const state = resolveStateDir();
   const found = targets.find((target) => underIssued(state, cwd, homeExpanded(target), process.platform, canonical2));
@@ -23433,7 +23512,7 @@ var issuedTarget = (cwd, targets) => {
 };
 var underIssued = (state, cwd, target, platform = process.platform, real = (file) => file) => {
   const win = platform === "win32";
-  const p = win ? path30.win32 : path30.posix;
+  const p = win ? path31.win32 : path31.posix;
   const fold = (value) => win || platform === "darwin" ? value.toLowerCase() : value;
   const named = win ? target.replace(/^\/([a-zA-Z])(?=\/|$)/, "$1:") : target;
   const relative = p.relative(fold(real(p.resolve(state))), fold(real(p.resolve(cwd, named))));
@@ -23482,7 +23561,7 @@ function shellGate(cwd, command, owner, dialect = "posix", deps) {
     try {
       targets = [
         ...segmentTargets(cwd, command, dialect),
-        ...gitMutationDirs(cwd, command, dialect).map((dir) => path30.join(dir, DIR_TARGET))
+        ...gitMutationDirs(cwd, command, dialect).map((dir) => path31.join(dir, DIR_TARGET))
       ];
     } catch {
       targets = [];
@@ -23922,8 +24001,110 @@ var WRITE_TOOLS = new Set([
   "editfile",
   "writefile"
 ]);
+// packages/workit-core/src/hooks/standing.ts
+import fs23 from "node:fs";
+import path32 from "node:path";
+var readPlans = (store) => {
+  const dir = path32.join(store, "fanouts");
+  let names;
+  try {
+    names = fs23.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const plans = [];
+  for (const name of names) {
+    try {
+      const raw = JSON.parse(fs23.readFileSync(path32.join(dir, name), "utf8"));
+      if (typeof raw.name !== "string" || !Array.isArray(raw.slices))
+        continue;
+      const texts = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "") : [];
+      plans.push({
+        name: raw.name,
+        leads: texts([raw.leadSession, ...texts(raw.formerLeads)]),
+        branches: texts(raw.slices.map((slice) => slice && typeof slice === "object" ? slice.branch : null))
+      });
+    } catch {}
+  }
+  return plans;
+};
+var leadOf2 = (input) => input.session.parentId ?? (input.session.agentId ? input.session.id : null) ?? (input.session.id.includes(":") ? input.session.id.split(":")[0] : null);
+var worksFor = (plan, input, branch) => {
+  const session = input.session.id;
+  if (plan.leads.includes(session) && !input.session.agentId)
+    return false;
+  const lead = leadOf2(input);
+  if (lead && plan.leads.includes(lead))
+    return true;
+  if (plan.leads.some((each) => session.startsWith(`${each}-w-`)))
+    return true;
+  const current = branch();
+  return current !== null && plan.branches.includes(current);
+};
+var standingFor = (input, store, rev) => {
+  const orders = new Map;
+  const ledger = readLedger(input.cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  let branch;
+  const lazyBranch = () => branch === undefined ? branch = currentBranch(input.cwd) : branch;
+  for (const plan of readPlans(store))
+    if (worksFor(plan, input, lazyBranch))
+      for (const row of activeStanding(rows, plan.name, plan.leads.length ? plan.leads : null))
+        orders.set(row.id, row);
+  return { rev, orders, rows };
+};
+var fanoutOf = (row) => typeof row.fanout === "string" ? row.fanout : "?";
+var changedSince = (now, ids) => {
+  const known = new Set(ids);
+  const added = [...now.orders.values()].filter((row) => !known.has(row.id));
+  const byId = new Map(now.rows.map((row) => [row.id, row]));
+  const dropped = ids.filter((id) => !now.orders.has(id)).map((id) => byId.get(id)).filter((row) => row !== undefined);
+  if (!added.length && !dropped.length)
+    return null;
+  const fanouts = [...new Set([...added, ...dropped].map(fanoutOf))].join(", ");
+  const lines = [
+    `Workit: the lead changed the standing orders for fanout ${fanouts} while you run. They apply to you now and override your brief's STANDING list.`,
+    ...added.map((row) => `  - new: ${String(row.what)}`),
+    ...dropped.map((row) => `  - no longer in force: ${String(row.what)}${row.stop ? " (the stop is lifted: continue your brief)" : ""}`)
+  ];
+  if (added.some((row) => row.stop === true))
+    lines.push("Stop now: make no further changes, close what you opened, and report to the lead with your branch, head SHA, what is done and what is not.");
+  return lines.join(`
+`);
+};
+var sinceStart = new Map;
+var standingSinceStart = (input) => {
+  try {
+    const store = input.session.id ? gitStoreDir(input.cwd) : null;
+    if (!store)
+      return null;
+    const rev = readStandingRev(store) ?? "";
+    const file = standingSeenFile(store, input.session.id, input.session.agentId);
+    const cached = sinceStart.get(file);
+    if (cached?.rev === rev)
+      return cached.text;
+    let text = null;
+    if (rev) {
+      const now = standingFor(input, store, rev);
+      const seen = readStandingSeen(file);
+      let ids = seen.ids;
+      if (seen.rev === null) {
+        ids = cached ? [] : [...now.orders.keys()];
+        writeStandingSeen(file, { rev, ids });
+      }
+      text = changedSince(now, ids);
+    }
+    sinceStart.set(file, { rev, text });
+    if (sinceStart.size > 256)
+      sinceStart.delete(sinceStart.keys().next().value);
+    return text;
+  } catch {
+    return null;
+  }
+};
 // packages/workit-core/src/hooks/handle.ts
 var offered = new Set;
+var PRE_TOOL = new Set(["shell.pre", "write.pre", "tool.pre"]);
 // packages/workit-core/src/hooks/deadline.ts
 var QUIET = new Set([
   "stop",
@@ -24026,11 +24207,11 @@ var OPENCODE_DESCRIPTOR = {
   ]
 };
 // packages/workit-opencode/src/shared/init-apply.ts
-import path35 from "node:path";
+import path37 from "node:path";
 // packages/workit-core/src/core/gitignore.ts
 import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import path31 from "node:path";
+import path33 from "node:path";
 var GITIGNORE_ENTRIES = [
   "# workit: SDD working state (never commit)",
   "docs/*/sdd/",
@@ -24050,7 +24231,7 @@ var GITIGNORE_ENTRIES = [
 var ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
-  const file = path31.join(workspaceRoot, ".gitignore");
+  const file = path33.join(workspaceRoot, ".gitignore");
   const existing = existsSync9(file) ? readFileSync6(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
@@ -24078,25 +24259,25 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
 // packages/workit-core/src/core/hygiene.ts
 import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import path32 from "node:path";
+import path34 from "node:path";
 var repoRoot3 = assetRoot();
-var templatesDir = () => path32.join(repoRoot3, "templates", "hygiene");
+var templatesDir = () => path34.join(repoRoot3, "templates", "hygiene");
 var packageJson = (root) => {
-  if (!existsSync10(path32.join(root, "package.json")))
+  if (!existsSync10(path34.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync7(path32.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync7(path34.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
 };
 var isOpenSource = (root) => {
-  if (existsSync10(path32.join(root, "LICENSE")))
+  if (existsSync10(path34.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
     return true;
-  return path32.basename(root) === "workflow-toolkit";
+  return path34.basename(root) === "workflow-toolkit";
 };
 var licenseHolder = (root) => {
   const pkg = packageJson(root);
@@ -24119,13 +24300,13 @@ var planHygieneFiles = (root, opts = {}) => {
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync10(path32.join(root, file)))
+    if (existsSync10(path34.join(root, file)))
       continue;
-    const tpl = path32.join(templatesDir(), file);
+    const tpl = path34.join(templatesDir(), file);
     if (!existsSync10(tpl))
       continue;
-    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path32.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
-    planned.push({ path: path32.join(root, file), content });
+    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path34.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    planned.push({ path: path34.join(root, file), content });
   }
   return planned;
 };
@@ -24135,19 +24316,19 @@ var ensureHygieneFiles = (root, opts) => {
   const created = [];
   for (const planned of planHygieneFiles(root, opts)) {
     writeFileSync5(planned.path, planned.content, "utf8");
-    created.push(path32.basename(planned.path));
+    created.push(path34.basename(planned.path));
   }
   return { ok: true, created };
 };
 // packages/workit-core/src/core/init.ts
-import fs22 from "node:fs";
-import path34 from "node:path";
+import fs24 from "node:fs";
+import path36 from "node:path";
 import { spawnSync as spawnSync19 } from "node:child_process";
 // packages/workit-core/src/core/workspace-branch-policy.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import path33 from "node:path";
+import path35 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var readFileSafe = (p) => {
   try {
@@ -24158,7 +24339,7 @@ var readFileSafe = (p) => {
 };
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path33.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path35.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -24170,7 +24351,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path33.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path35.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -24219,7 +24400,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync4(path33.dirname(wsPath), { recursive: true });
+  mkdirSync4(path35.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync6(tmp, JSON.stringify({ ...document, workspaces: next }, null, 2) + `
@@ -24254,7 +24435,7 @@ function applyWorkspaceBranchPolicy(opts) {
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE";
 var readJson3 = (p) => {
   try {
-    const parsed = JSON.parse(fs22.readFileSync(p, "utf8"));
+    const parsed = JSON.parse(fs24.readFileSync(p, "utf8"));
     return isConfigObject(parsed) ? parsed : null;
   } catch {
     return null;
@@ -24284,7 +24465,7 @@ var youtrackJsonContent = (dir) => {
   const meetingIssue = process.env.WORKFLOW_YT_MEETING_ISSUE;
   return {
     baseUrl: process.env.WORKFLOW_YT_BASE_URL ?? "https://youtrack.example.com",
-    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path34.join(dir, "youtrack.token"),
+    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path36.join(dir, "youtrack.token"),
     ...meetingIssue ? {
       meetingIssue,
       meetingIssues: { general: { issue: meetingIssue, label: "General meetings" } }
@@ -24314,19 +24495,19 @@ var vcsJsonContent = () => {
 };
 function initApplyData(action, env = process.env) {
   const dir = String(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
-  fs22.mkdirSync(dir, { recursive: true });
+  fs24.mkdirSync(dir, { recursive: true });
   switch (action) {
     case "youtrack_json": {
-      const out = path34.join(dir, "youtrack.json");
-      fs22.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const out = path36.join(dir, "youtrack.json");
+      fs24.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       return { action, ok: true, path: out };
     }
     case "youtrack_token_placeholder": {
-      const p = path34.join(dir, "youtrack.token");
+      const p = path36.join(dir, "youtrack.token");
       const preserved = writeFileExclusive(p, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const abs = path34.resolve(p);
+      const abs = path36.resolve(p);
       return {
         action,
         ok: true,
@@ -24338,14 +24519,14 @@ function initApplyData(action, env = process.env) {
       };
     }
     case "youtrack_scaffold": {
-      const jsonOut = path34.join(dir, "youtrack.json");
-      const tokenOut = path34.join(dir, "youtrack.token");
-      fs22.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const jsonOut = path36.join(dir, "youtrack.json");
+      const tokenOut = path36.join(dir, "youtrack.token");
+      fs24.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       const preserved = writeFileExclusive(tokenOut, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const configPath = path34.resolve(jsonOut);
-      const tokenPath = path34.resolve(tokenOut);
+      const configPath = path36.resolve(jsonOut);
+      const tokenPath = path36.resolve(tokenOut);
       const prev = process.env.WORKFLOW_YOUTRACK_CONFIG;
       process.env.WORKFLOW_YOUTRACK_CONFIG = configPath;
       let tokenCreate = {};
@@ -24397,10 +24578,10 @@ function initApplyData(action, env = process.env) {
       }
     }
     case "vcs_scaffold": {
-      const jsonOut = path34.join(dir, "vcs.json");
-      fs22.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
+      const jsonOut = path36.join(dir, "vcs.json");
+      fs24.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
 `, "utf8");
-      const configPath = path34.resolve(jsonOut);
+      const configPath = path36.resolve(jsonOut);
       const prev = process.env.WORKFLOW_VCS_CONFIG;
       process.env.WORKFLOW_VCS_CONFIG = configPath;
       try {
@@ -24519,7 +24700,7 @@ var executeInitApply = (args, directory, runtime) => {
       protectedNames: args.branch_policy_protected
     }, current);
     writeConfig(next);
-    return output(ok({ action: "config", path: path35.join(configDir(), "config.json"), ...next }));
+    return output(ok({ action: "config", path: path37.join(configDir(), "config.json"), ...next }));
   }
   const env = Object.fromEntries(Object.entries({
     WORKFLOW_YT_BASE_URL: args.base_url,
@@ -24536,14 +24717,14 @@ var executeInitApply = (args, directory, runtime) => {
 // packages/workit-opencode/src/shared/session.ts
 import { realpathSync as realpathSync7 } from "node:fs";
-import path36 from "node:path";
+import path38 from "node:path";
 var sameWorkspace = (expected, observed) => {
   if (typeof observed !== "string" || !observed)
     return false;
   try {
     return realpathSync7(expected) === realpathSync7(observed);
   } catch {
-    return path36.resolve(expected) === path36.resolve(observed);
+    return path38.resolve(expected) === path38.resolve(observed);
   }
 };
@@ -24615,7 +24796,7 @@ var workitFamilyOf = (toolName) => {
 // packages/workit-opencode/src/tools/context.ts
 import { realpathSync as realpathSync8 } from "node:fs";
-import path37 from "node:path";
+import path39 from "node:path";
 var createContextTool = () => ({
   description: "Read Git, pull request, YouTrack, issue, changelog, release, or affected-file context.",
   execute: async (args, context) => {
@@ -24625,7 +24806,7 @@ var createContextTool = () => ({
     let root;
     try {
       const cwd = parsed.data.cwd;
-      root = realpathSync8(cwd ? path37.resolve(context.directory, cwd) : context.directory);
+      root = realpathSync8(cwd ? path39.resolve(context.directory, cwd) : context.directory);
     } catch {
       return JSON.stringify(failure2("invalid_input", "context target directory cannot be resolved"), null, 2);
     }
@@ -24655,20 +24836,20 @@ var workerCoordinatorFor = (task, worker) => {
 };
 // packages/workit-core/src/fanout.ts
-import { createHash as createHash16 } from "node:crypto";
-import fs24 from "node:fs";
-import path40 from "node:path";
+import { createHash as createHash17 } from "node:crypto";
+import fs26 from "node:fs";
+import path42 from "node:path";
 // packages/workit-core/src/stack.ts
 import { spawnSync as spawnSync21 } from "node:child_process";
-import { createHash as createHash15, randomBytes as randomBytes4 } from "node:crypto";
-import fs23 from "node:fs";
-import path39 from "node:path";
+import { createHash as createHash16, randomBytes as randomBytes4 } from "node:crypto";
+import fs25 from "node:fs";
+import path41 from "node:path";
 // packages/workit-core/src/git/ops.ts
 import { spawnSync as spawnSync20 } from "node:child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import path38 from "node:path";
+import path40 from "node:path";
 // packages/workit-core/src/forge/redact.ts
 var KEY = String.raw`[A-Za-z0-9_.-]*?(?:token|secret|password|passwd|pwd|api[_-]?key|access[_-]?key|account[_-]?key|private[_-]?key|client[_-]?secret|credentials?|authorization|cookie|signature)[A-Za-z0-9_.-]*`;
@@ -24712,18 +24893,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path38.resolve(cwd, line.trim()));
+`).map((line) => path40.resolve(cwd, line.trim()));
   const conflicted = () => git5(cwd, ["ls-files", "-u"]).stdout.trim() !== "";
   for (const [index, [, operation]] of markers.entries()) {
     const marker = found[index];
     if (!marker || !existsSync11(marker))
       continue;
-    if (index === 1 && existsSync11(path38.join(marker, "applying")))
+    if (index === 1 && existsSync11(path40.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync11(path38.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync11(path40.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync9(path38.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync9(path40.join(marker, "head-name"), "utf8").trim();
       } catch {}
       const branch = headName.startsWith("refs/heads/") ? headName.slice("refs/heads/".length) : null;
       return { operation, commitAllowed: branch !== null, branch };
@@ -24835,7 +25016,7 @@ function rebasingBranch2(dir) {
     if (!found.ok)
       continue;
     try {
-      return fs23.readFileSync(found.stdout.trim(), "utf8").trim();
+      return fs25.readFileSync(found.stdout.trim(), "utf8").trim();
     } catch {}
   }
   return null;
@@ -24843,14 +25024,14 @@ function rebasingBranch2(dir) {
 function rebaseInProgress(dir) {
   for (const name of ["rebase-merge", "rebase-apply"]) {
     const found = gitRun3(dir, ["rev-parse", "--path-format=absolute", "--git-path", name]);
-    if (found.ok && fs23.existsSync(found.stdout.trim()))
+    if (found.ok && fs25.existsSync(found.stdout.trim()))
       return true;
   }
   return false;
 }
 var scratchDir = (cwd) => {
   const dir = stacksDir(cwd);
-  return dir.ok ? path39.join(dir.data, "worktrees") : null;
+  return dir.ok ? path41.join(dir.data, "worktrees") : null;
 };
 function gitRestack(cwd, input) {
   const owner = worktreeOf(cwd, input.branch);
@@ -24859,8 +25040,8 @@ function gitRestack(cwd, input) {
     const scratch = scratchDir(cwd);
     if (!scratch)
       return { ok: false, conflict: false, worktree: cwd, error: "no store root" };
-    fs23.mkdirSync(scratch, { recursive: true });
-    dir = path39.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    fs25.mkdirSync(scratch, { recursive: true });
+    dir = path41.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
     const added = gitRun3(cwd, ["worktree", "add", "-q", dir, input.branch], GIT_TIMEOUTS.worktree);
     if (!added.ok)
       return { ok: false, conflict: false, worktree: cwd, error: firstLine(added) };
@@ -24899,12 +25080,12 @@ function gitRestack(cwd, input) {
 var firstLine = (run) => (`${run.stderr}
 ${run.stdout}`.split(`
 `).find((line) => line.trim()) ?? "git failed").trim().slice(0, 300);
-var stackFileName = (name) => `${name.replace(/[^A-Za-z0-9._-]+/gu, "_").replace(/^[._]+/u, "").slice(0, 48).toLowerCase()}-${createHash15("sha256").update(name).digest("hex").slice(0, 12)}.json`;
+var stackFileName = (name) => `${name.replace(/[^A-Za-z0-9._-]+/gu, "_").replace(/^[._]+/u, "").slice(0, 48).toLowerCase()}-${createHash16("sha256").update(name).digest("hex").slice(0, 12)}.json`;
 function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path39.join(root.value.root, "stacks") };
+  return { ok: true, data: path41.join(root.value.root, "stacks") };
 }
 var HEARTBEAT_STALE_MS = 2 * 60000;
@@ -25009,13 +25190,13 @@ function sliceHash(slice) {
     issues: _issues,
     ...definition
   } = slice;
-  return createHash16("sha256").update(JSON.stringify(definition)).digest("hex").slice(0, 16);
+  return createHash17("sha256").update(JSON.stringify(definition)).digest("hex").slice(0, 16);
 }
 function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path40.join(root.value.root, "fanouts") };
+  return { ok: true, data: path42.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord7(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -25083,10 +25264,10 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path40.join(dir.data, stackFileName(name));
+  const file = path42.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
-    parsed = parseStored(JSON.parse(fs24.readFileSync(file, "utf8")));
+    parsed = parseStored(JSON.parse(fs26.readFileSync(file, "utf8")));
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -25100,7 +25281,7 @@ function listFanouts(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs24.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+    names = fs26.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -25108,7 +25289,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs24.readFileSync(path40.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs26.readFileSync(path42.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -25689,7 +25870,18 @@ var injectAgentContext = (root, session, directChildren, system) => {
   const verdict = session.parentID ? judgeVerdictText(root, session, workerContext) : null;
   if (verdict && !hasMarker(system, "<workit-verdict-line>"))
     system.push(textPart(`<workit-verdict-line>${verdict}</workit-verdict-line>`));
+  const standing = session.parentID ? standingFor2(root, session) : null;
+  if (standing && !hasMarker(system, "<workit-standing>"))
+    system.push(textPart(`<workit-standing>${standing}</workit-standing>`));
 };
+var standingFor2 = (root, session) => standingSinceStart({
+  host: "opencode",
+  cwd: session.directory ?? root,
+  session: { id: session.id, agentId: null, agentType: null, parentId: session.parentID ?? null },
+  permissionMode: null,
+  transcriptPath: null,
+  event: { kind: "context.turn" }
+});
 var workerRole = (workerContext) => {
   if (!workerContext)
     return null;
@@ -25789,7 +25981,7 @@ var childTaskMissing = (store, input) => {
 var childDenial = (identity) => `OpenCode child session has no validated Workit worker: as ${identity} it may only inspect the task summary (workit_task action "inspect") or record evidence or findings (workit_evidence/workit_finding action "record") on an existing task; for anything else the lead assigns it a worker with workit_worker before launching it`;
 // packages/workit-opencode/src/v2/shell.ts
-import path41 from "node:path";
+import path43 from "node:path";
 var commandOf = (input) => {
   if (input === null || typeof input !== "object")
     return null;
@@ -25798,7 +25990,7 @@ var commandOf = (input) => {
 };
 var hookInput = (root, sessionID, id, shell) => ({
   host: "opencode",
-  cwd: shell.workdir ? path41.resolve(root, shell.workdir) : root,
+  cwd: shell.workdir ? path43.resolve(root, shell.workdir) : root,
   session: { id: sessionID, agentId: null, agentType: null, parentId: null },
   permissionMode: null,
   transcriptPath: null,
@@ -26005,37 +26197,37 @@ var createStopControl = (root, port) => {
 // packages/workit-opencode/src/v2/registry.ts
 import { existsSync as existsSync13, readFileSync as readFileSync10 } from "node:fs";
-import path43 from "node:path";
+import path45 from "node:path";
 // packages/workit-opencode/src/shared/assets.ts
 import { existsSync as existsSync12, realpathSync as realpathSync9 } from "node:fs";
-import path42 from "node:path";
+import path44 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var moduleDir = () => {
   try {
-    return realpathSync9(path42.dirname(fileURLToPath2(import.meta.url)));
+    return realpathSync9(path44.dirname(fileURLToPath2(import.meta.url)));
   } catch {
-    return path42.dirname(fileURLToPath2(import.meta.url));
+    return path44.dirname(fileURLToPath2(import.meta.url));
   }
 };
 var packageRoot2 = () => {
   const dir = moduleDir();
   for (const candidate of [
-    path42.resolve(dir, ".."),
-    path42.resolve(dir, "..", ".."),
-    path42.resolve(dir, "..", "..", "..")
+    path44.resolve(dir, ".."),
+    path44.resolve(dir, "..", ".."),
+    path44.resolve(dir, "..", "..", "..")
   ]) {
-    if (existsSync12(path42.join(candidate, "package.json")))
+    if (existsSync12(path44.join(candidate, "package.json")))
       return candidate;
   }
-  return path42.resolve(dir, "..");
+  return path44.resolve(dir, "..");
 };
 var skillsRoot = () => {
   const root = packageRoot2();
-  const canonical = path42.resolve(root, "..", "workit-core", "skills");
-  if (existsSync12(path42.join(root, "src")) && existsSync12(canonical))
+  const canonical = path44.resolve(root, "..", "workit-core", "skills");
+  if (existsSync12(path44.join(root, "src")) && existsSync12(canonical))
     return canonical;
-  return path42.join(root, "assets", "skills");
+  return path44.join(root, "assets", "skills");
 };
 // packages/workit-opencode/src/v2/registry.ts
@@ -26062,11 +26254,11 @@ var registerSkills = async (ctx) => {
   if (!existsSync13(skillsDir))
     return new Set;
   const listed = await ctx.skill.list().catch(() => ({ data: [] }));
-  const own = (skill) => typeof skill.path === "string" && path43.resolve(skill.path).startsWith(skillsDir + path43.sep);
+  const own = (skill) => typeof skill.path === "string" && path45.resolve(skill.path).startsWith(skillsDir + path45.sep);
   const userSkills = new Set((listed?.data ?? []).filter((skill) => !own(skill)).map((skill) => skill.id));
   const packaged = new Map;
   for (const id of WORKIT_METHOD_SKILLS) {
-    const file = path43.join(skillsDir, id, "SKILL.md");
+    const file = path45.join(skillsDir, id, "SKILL.md");
     if (!userSkills.has(id) && existsSync13(file))
       packaged.set(id, file);
   }
@@ -26114,22 +26306,22 @@ var registerCommands = async (ctx, registeredSkills) => {
 // packages/workit-opencode/src/stale-sources.ts
 import { existsSync as existsSync14, readdirSync as readdirSync6 } from "node:fs";
-import path44 from "node:path";
+import path46 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var typescriptFiles = (directory) => {
   if (!existsSync14(directory))
     return [];
   return readdirSync6(directory, { withFileTypes: true }).flatMap((entry) => {
-    const file = path44.join(directory, entry.name);
+    const file = path46.join(directory, entry.name);
     return entry.isDirectory() ? typescriptFiles(file) : entry.isFile() && file.endsWith(".ts") ? [file] : [];
   });
 };
 var pluginSourceFiles = [
   ...new Set([
     fileURLToPath3(import.meta.url),
-    ...typescriptFiles(path44.join(packageRoot2(), "src")),
-    path44.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
-    ...typescriptFiles(path44.join(packageRoot2(), "..", "workit-core", "src", "core"))
+    ...typescriptFiles(path46.join(packageRoot2(), "src")),
+    path46.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
+    ...typescriptFiles(path46.join(packageRoot2(), "..", "workit-core", "src", "core"))
   ])
 ].filter((file) => existsSync14(file)).toSorted();