@brainervirus/workit-codex 8.11.0 → 8.12.1

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

@@ -26,7 +26,7 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
 // packages/workit-core/src/hooks/context.ts
 import { createHash as createHash11 } from "node:crypto";
 import fs14 from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // packages/workit-core/src/core/methods.ts
 var METHODS = {
@@ -91,9 +91,9 @@ Autonomy contract:
   ship), go to the effective endpoint in \`workit grant show\`: \`pr\` opens
   the PR; \`green\` babysits it without asking (workit-ship) to merge-ready,
   never merging; \`merged\` also lands it with \`workit pr merge\`.
-  Merge and release need a workspace grant, which only the user raises from
-  their own terminal (a blocked verb names how); never edit workspaces.json or
-  route around a grant_required.
+  Merge and release need a workspace grant only the user raises from their
+  own terminal (a blocked verb names how); never edit workspaces.json or route
+  around a grant_required.
 - Ask only for a product or preference choice, or for authority you lack, with
   your recommended answer. Facts are yours: read, run or prototype.
 - Label claims measured (run and seen this session), inferred, or guess.
@@ -102,17 +102,19 @@ Autonomy contract:
 - Author is not verifier: your own verdict is \`--self\`, shown as
   self-reviewed, never verified. High risk, \`verification: independent\` and
   merge need a verifier with its own host-derived session (a subagent's
-  \`<lead>:<child>\`, set by the host); never hand-mint one such as \`<lead>-v1\`.
+  \`<lead>:<child>\`); never hand-mint one (\`<lead>-v1\`).
 - A local-commit endpoint does not imply PR readiness, and a local commit alone
   is not evidence of a requested remote push. Before reporting delivery,
   reconcile every requested item and observe it (\`workit verify-delivery\`).
 
 CLI first: if a step has one right answer, use the \`workit\` verb instead of
 hand-running git, gh or glab (\`workit git|pr|ci|check\`; \`workit help\` lists
-the rest; without \`workit\` on PATH, \`npx -y @brainervirus/workit-cli\`).
+the rest; lacking \`workit\`, \`npx -y @brainervirus/workit-cli\`).
+Add Co-Authored-By via \`workit git commit --trailer "K: v" -- <paths>\`, never
+an amend.
 The task families (task, policy, evidence, finding, decision, worker, state)
 are optional continuity for tracked work; each branch has one implicit task,
-created by the first recording, and a solo edit needs no task. A decision
+and a solo edit needs no task. A decision
 records a user choice; it never authorizes an effect. Judge work once with
 \`workit policy assess --judge risk= behavior= product-choice= plan=\`.
 Across repositories, bind each item to its checkout, branch and endpoint,
@@ -8791,7 +8793,7 @@ function requirementId(input) {
 import { createHash as createHash10 } from "node:crypto";
 import * as fs13 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -8960,7 +8962,7 @@ function loadCheckConfig(cwd) {
       gates[gate] = names;
     }
   }
-  return { source: CHECKS_FILE, root, checks, gates, error: null };
+  return { source: CHECKS_FILE, root, checks, gates, error: null, resources: parsed.resources };
 }
 var sameArgv = (left, right) => left.length === right.length && left.every((item, index) => item === right[index]);
 function matchesNamedCheck(config, name, argv, cwd) {
@@ -9182,7 +9184,7 @@ function pushRemoteName(cwd, branch) {
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
 import * as fs10 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -9788,7 +9790,68 @@ function acquireFileLockSync(targetPath, options) {
 // packages/workit-core/src/host-session.ts
 import { createHash as createHash4 } from "node:crypto";
 import fs7 from "node:fs";
+import path7 from "node:path";
+
+// packages/workit-core/src/core/logger.ts
+import os2 from "node:os";
 import path6 from "node:path";
+var SENSITIVE_WORDS = new Set([
+  "token",
+  "secret",
+  "password",
+  "passwd",
+  "authorization",
+  "credential",
+  "credentials",
+  "cookie",
+  "api",
+  "apikey",
+  "apitoken",
+  "accesstoken",
+  "clientsecret",
+  "refreshtoken",
+  "key",
+  "bearer",
+  "prompt",
+  "message",
+  "messages",
+  "content",
+  "body",
+  "args",
+  "argument",
+  "result",
+  "results",
+  "output",
+  "issue",
+  "description",
+  "summary",
+  "payload",
+  "script",
+  "command",
+  "text",
+  "query"
+]);
+var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var resolveStateDir = () => {
+  const override = process.env.WORKFLOW_TOOLKIT_STATE;
+  if (override)
+    return override;
+  const home = os2.homedir();
+  if (process.env.XDG_STATE_HOME)
+    return path6.join(process.env.XDG_STATE_HOME, "workit");
+  switch (os2.platform()) {
+    case "darwin":
+      return path6.join(home, "Library", "Application Support", "workit");
+    case "win32":
+      return path6.join(process.env.LOCALAPPDATA ?? path6.join(home, "AppData", "Local"), "workit");
+    default:
+      return path6.join(process.env.HOME ?? home, ".local", "state", "workit");
+  }
+};
+var homePattern = new RegExp(`${escapeRegExp(os2.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+
+// packages/workit-core/src/host-session.ts
 var HOST_SESSION_VARS = [
   ["OPENCODE_SESSION_ID", () => "opencode"],
   ["PI_SESSION_ID", () => "pi"],
@@ -9817,43 +9880,77 @@ function hostSessionFromEnv(env) {
   return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
 }
 var ISSUED_PER_LEAD = 64;
-var ISSUED_SESSIONS_MARKER = "workit-issued-sessions/1";
+var ISSUED_SESSIONS_MARKER = "workit-issued-sessions/2";
 var hash = (value) => createHash4("sha256").update(value).digest("hex").slice(0, 32);
-var issuedRoot = (cwd) => {
-  const location = resolveStore(cwd);
-  return location instanceof Error ? null : path6.join(location.dir, "hooks", "issued");
+var userIssuedRoot = () => path7.join(resolveStateDir(), "issued");
+function migrateRepoIssued(cwd) {
+  if (cwd === undefined)
+    return;
+  let old;
+  try {
+    const location = resolveStore(cwd);
+    if (location instanceof Error)
+      return;
+    old = path7.join(location.dir, "hooks", "issued");
+    if (!fs7.existsSync(old))
+      return;
+  } catch {
+    return;
+  }
+  for (const lead of safeList(old)) {
+    try {
+      const from = path7.join(old, lead);
+      if (!fs7.statSync(from).isDirectory())
+        continue;
+      const to = path7.join(userIssuedRoot(), lead);
+      fs7.mkdirSync(to, { recursive: true, mode: 448 });
+      for (const id of fs7.readdirSync(from)) {
+        fs7.copyFileSync(path7.join(from, id), path7.join(to, id));
+        fs7.rmSync(path7.join(from, id), { force: true });
+      }
+      removeIfEmpty(from);
+    } catch {}
+  }
+  removeIfEmpty(old);
+}
+var safeList = (dir) => {
+  try {
+    return fs7.readdirSync(dir);
+  } catch {
+    return [];
+  }
 };
-var issuedDir = (cwd, lead) => {
-  const root = issuedRoot(cwd);
-  return root === null ? null : path6.join(root, hash(lead));
+var removeIfEmpty = (dir) => {
+  try {
+    fs7.rmdirSync(dir);
+  } catch {}
 };
 function recordIssuedSession(cwd, lead, issued) {
   try {
-    const dir = issuedDir(cwd, lead);
-    if (!dir)
-      return;
-    fs7.mkdirSync(dir, { recursive: true });
+    migrateRepoIssued(cwd);
+    const dir = path7.join(userIssuedRoot(), hash(lead));
+    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
     const own = hash(issued);
-    fs7.writeFileSync(path6.join(dir, own), ISSUED_SESSIONS_MARKER);
+    fs7.writeFileSync(path7.join(dir, own), ISSUED_SESSIONS_MARKER);
     const entries = fs7.readdirSync(dir);
     if (entries.length <= ISSUED_PER_LEAD)
       return;
-    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs7.statSync(path6.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
+    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs7.statSync(path7.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
     for (const { name } of byAge.slice(0, entries.length - ISSUED_PER_LEAD))
-      fs7.rmSync(path6.join(dir, name), { force: true });
+      fs7.rmSync(path7.join(dir, name), { force: true });
   } catch {}
 }
 var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
 
 // packages/workit-core/src/core/package-root.ts
 import { existsSync } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path7.dirname(fileURLToPath(import.meta.url));
+  let dir = path8.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path7.dirname(dir);
-    if (existsSync(path7.join(dir, "package.json")) || parent === dir)
+    const parent = path8.dirname(dir);
+    if (existsSync(path8.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
@@ -10002,7 +10099,7 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
 // packages/workit-core/src/store/event-log.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs9 from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 var EVENT_VERSION = 1;
 
 class LogDamage extends Error {
@@ -10113,7 +10210,7 @@ function appendEvent(file, event, validEnd) {
     fs9.closeSync(fd);
   }
   if (created)
-    fsyncDirectory(path8.dirname(file));
+    fsyncDirectory(path9.dirname(file));
   return validEnd;
 }
 function replaceFile(file, bytes, durable) {
@@ -10129,7 +10226,7 @@ function replaceFile(file, bytes, durable) {
     }
     renameWithRetry(temporary, file);
     if (durable)
-      fsyncDirectory(path8.dirname(file));
+      fsyncDirectory(path9.dirname(file));
   } catch (error) {
     try {
       fs9.unlinkSync(temporary);
@@ -10472,7 +10569,7 @@ var cachedRuntimeVersion = null;
 var runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs10.readFileSync(path9.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs10.readFileSync(path10.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -10505,7 +10602,7 @@ var readText = (file) => {
 };
 var REFLOG_LINE = /^[0-9a-f]+ ([0-9a-f]+) .* (\d+) [+-]\d{4}\t(.*)$/u;
 var branchStart = (location, branch, aliases) => {
-  const first = readText(path9.join(path9.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+  const first = readText(path10.join(path10.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
 `, 1)[0];
   const created = REFLOG_LINE.exec(first);
   const start = created && /^branch: Created from (\S+)$/u.exec(created[3])?.[1];
@@ -10515,7 +10612,7 @@ var branchStart = (location, branch, aliases) => {
     return start;
   if (!location.git)
     return null;
-  for (const line of readText(path9.join(location.git.gitDir, "logs", "HEAD")).split(`
+  for (const line of readText(path10.join(location.git.gitDir, "logs", "HEAD")).split(`
 `)) {
     const entry = REFLOG_LINE.exec(line);
     const moved = entry && /^checkout: moving from (\S+) to (\S+)$/u.exec(entry[3]);
@@ -10525,14 +10622,14 @@ var branchStart = (location, branch, aliases) => {
   }
   return null;
 };
-var refExists = (common, ref) => fs10.existsSync(path9.join(common, ref)) || readText(path9.join(common, "packed-refs")).includes(` ${ref}
+var refExists = (common, ref) => fs10.existsSync(path10.join(common, ref)) || readText(path10.join(common, "packed-refs")).includes(` ${ref}
 `);
 var origins = new Map;
 var sameDirectoryIdentity = (left, right) => {
-  if (!path9.isAbsolute(left) || !path9.isAbsolute(right))
+  if (!path10.isAbsolute(left) || !path10.isAbsolute(right))
     return false;
-  const normalizedLeft = path9.resolve(left);
-  const normalizedRight = path9.resolve(right);
+  const normalizedLeft = path10.resolve(left);
+  const normalizedRight = path10.resolve(right);
   try {
     const a = fs10.statSync(normalizedLeft, { bigint: true });
     const b = fs10.statSync(normalizedRight, { bigint: true });
@@ -10578,7 +10675,7 @@ class TaskStore {
   migrationChecked = false;
   compactDue = new Set;
   constructor(root, options = {}) {
-    const resolved = path9.resolve(root);
+    const resolved = path10.resolve(root);
     this.origin = fs10.existsSync(resolved) ? fs10.realpathSync(resolved) : resolved;
     this.located = resolveStore(this.origin);
     this.root = checkoutRootOf(this.origin, this.located);
@@ -10587,7 +10684,7 @@ class TaskStore {
     this.migrateOnRead = options.migrateOnRead;
   }
   location() {
-    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs10.existsSync(path9.join(this.root, ".git"))) {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs10.existsSync(path10.join(this.root, ".git"))) {
       this.located = undefined;
       this.migrationChecked = false;
     }
@@ -10743,7 +10840,7 @@ class TaskStore {
         const moved = this.bindLocked(again.data.id, key, input.now);
         return moved.ok ? success(moved.data.revision, null, { task: moved.data, created: false, key }) : moved;
       }
-      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path9.basename(this.root) || this.root;
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path10.basename(this.root) || this.root;
       const intent = {
         objective: input.objective?.trim() || `Work on ${label}`,
         scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
@@ -10803,14 +10900,14 @@ class TaskStore {
     const branch = key.ok ? key.data.branch : null;
     if (!branch || !location.ok)
       return success(null, null, null);
-    const common = path9.dirname(location.data.dir);
-    const heads = path9.join(common, "logs", "refs", "heads");
-    const headLog = location.data.git ? path9.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    const common = path10.dirname(location.data.dir);
+    const heads = path10.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path10.join(location.data.git.gitDir, "logs", "HEAD") : "";
     const signatures = [
-      path9.join(heads, branch),
+      path10.join(heads, branch),
       headLog,
       heads,
-      path9.join(common, "packed-refs")
+      path10.join(common, "packed-refs")
     ].map((file) => fileSignature(file) ?? "-");
     const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
     let resolved = origins.get(slot);
@@ -10822,7 +10919,7 @@ class TaskStore {
           aliases.push(rename.from);
       const start = branchStart(location.data, branch, aliases);
       const slash = start?.indexOf("/") ?? -1;
-      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path9.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path10.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
       const name = start && (remote ? start.slice(slash + 1) : start);
       resolved = {
         signature: signatures.join("|"),
@@ -11060,13 +11157,13 @@ class TaskStore {
     if (!ready.ok)
       return ready;
     const dirs = this.paths();
-    const recovery = path9.join(this.root, ".workit", "recovery");
+    const recovery = path10.join(this.root, ".workit", "recovery");
     if (fs10.existsSync(recovery)) {
       let files = 0;
       let bytes = 0;
       try {
         for (const name of fs10.readdirSync(recovery)) {
-          const stat = fs10.lstatSync(path9.join(recovery, name));
+          const stat = fs10.lstatSync(path10.join(recovery, name));
           if (!stat.isFile())
             continue;
           files += 1;
@@ -11119,7 +11216,7 @@ class TaskStore {
       if (fs10.existsSync(dirs.blobs))
         for (const name of fs10.readdirSync(dirs.blobs)) {
           const digest = name.replace(/\.json$/, "");
-          const file = path9.join(dirs.blobs, name);
+          const file = path10.join(dirs.blobs, name);
           let stat;
           try {
             stat = fs10.lstatSync(file);
@@ -11137,7 +11234,7 @@ class TaskStore {
         }
       return success(null, null, null);
     };
-    const swept = dryRun ? sweep() : this.withLock(path9.join(dirs.dir, "gc.lock"), sweep);
+    const swept = dryRun ? sweep() : this.withLock(path10.join(dirs.dir, "gc.lock"), sweep);
     if (!swept.ok)
       return swept;
     const temporaryDirs = [
@@ -11145,7 +11242,7 @@ class TaskStore {
       dirs.tasks,
       dirs.blobs,
       dirs.checkout,
-      ...names.map((name) => path9.join(dirs.tasks, name))
+      ...names.map((name) => path10.join(dirs.tasks, name))
     ];
     for (const directory of temporaryDirs) {
       if (!fs10.existsSync(directory))
@@ -11153,7 +11250,7 @@ class TaskStore {
       for (const name of fs10.readdirSync(directory)) {
         if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
           continue;
-        const file = path9.join(directory, name);
+        const file = path10.join(directory, name);
         try {
           const stat = fs10.lstatSync(file);
           if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
@@ -11170,30 +11267,30 @@ class TaskStore {
   }
   paths() {
     const location = this.location();
-    const dir = location.ok ? location.data.dir : path9.join(this.root, ".workit");
-    const checkout = path9.join(dir, "checkouts", checkoutSlug(this.root));
+    const dir = location.ok ? location.data.dir : path10.join(this.root, ".workit");
+    const checkout = path10.join(dir, "checkouts", checkoutSlug(this.root));
     return {
       dir,
       shared: location.ok ? location.data.shared : false,
-      marker: path9.join(dir, "store.json"),
+      marker: path10.join(dir, "store.json"),
       checkout,
-      workspace: path9.join(checkout, "workspace.json"),
-      checkoutLock: path9.join(checkout, "metadata.lock"),
-      tasks: path9.join(dir, "tasks"),
-      index: path9.join(dir, "task-index.json"),
-      blobs: path9.join(dir, "blobs", "candidates"),
-      legacy: path9.join(dir, "legacy", checkoutSlug(this.root), "v2"),
-      v2: path9.join(this.root, ".workit")
+      workspace: path10.join(checkout, "workspace.json"),
+      checkoutLock: path10.join(checkout, "metadata.lock"),
+      tasks: path10.join(dir, "tasks"),
+      index: path10.join(dir, "task-index.json"),
+      blobs: path10.join(dir, "blobs", "candidates"),
+      legacy: path10.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path10.join(this.root, ".workit")
     };
   }
   eventsPath(taskId) {
-    return path9.join(this.paths().tasks, taskId, "events.jsonl");
+    return path10.join(this.paths().tasks, taskId, "events.jsonl");
   }
   snapshotPath(taskId) {
-    return path9.join(this.paths().tasks, taskId, "snapshot.json");
+    return path10.join(this.paths().tasks, taskId, "snapshot.json");
   }
   taskLockPath(taskId) {
-    return path9.join(this.paths().tasks, taskId, "lock");
+    return path10.join(this.paths().tasks, taskId, "lock");
   }
   ready(write = false) {
     const location = this.location();
@@ -11232,13 +11329,13 @@ class TaskStore {
     return {
       read: (digest) => {
         try {
-          return JSON.parse(fs10.readFileSync(path9.join(dir, `${digest}.json`), "utf8"));
+          return JSON.parse(fs10.readFileSync(path10.join(dir, `${digest}.json`), "utf8"));
         } catch (error) {
           throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
         }
       },
       write: (digest, value) => {
-        const file = path9.join(dir, `${digest}.json`);
+        const file = path10.join(dir, `${digest}.json`);
         if (fs10.existsSync(file)) {
           const stamp = new Date;
           try {
@@ -11430,7 +11527,7 @@ class TaskStore {
     }
   }
   openTask(record, type, key, legacy = null) {
-    const dir = path9.join(this.paths().tasks, record.id);
+    const dir = path10.join(this.paths().tasks, record.id);
     fs10.mkdirSync(dir, { recursive: true });
     const blobs = this.blobStore();
     const bound = key ? { ...key, boundAt: key.boundAt ?? new Date().toISOString() } : null;
@@ -11523,7 +11620,7 @@ class TaskStore {
   }
   withKeyLock(key, operation) {
     const digest = createHash6("sha256").update(key).digest("hex").slice(0, 32);
-    return this.withLock(path9.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+    return this.withLock(path10.join(this.paths().dir, "keys", `${digest}.lock`), operation);
   }
   bindLocked(taskId, key, timestamp) {
     const current = this.readWorkspace();
@@ -11664,7 +11761,7 @@ class TaskStore {
   writeWorkspace(record) {
     const file = this.paths().workspace;
     try {
-      fs10.mkdirSync(path9.dirname(file), { recursive: true });
+      fs10.mkdirSync(path10.dirname(file), { recursive: true });
       replaceFile(file, `${canonicalJson(record)}
 `, true);
       return success(null, null, null);
@@ -11742,23 +11839,23 @@ class TaskStore {
     return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
   }
   v2Dirs() {
-    return [...new Set([this.root, this.origin])].map((dir) => path9.join(dir, ".workit"));
+    return [...new Set([this.root, this.origin])].map((dir) => path10.join(dir, ".workit"));
   }
   pendingMigrations() {
     return this.v2Dirs().filter((dir) => {
-      const raw = this.readV2Workspace(path9.join(dir, "workspace.json"));
+      const raw = this.readV2Workspace(path10.join(dir, "workspace.json"));
       return raw !== null && raw !== TOMBSTONE;
     });
   }
   migrateV2(v2) {
     const dirs = this.paths();
-    const v2Workspace = path9.join(v2, "workspace.json");
-    const v2Tasks = path9.join(v2, "tasks");
-    const legacy = path9.join(dirs.dir, "legacy", checkoutSlug(path9.dirname(v2)), "v2");
+    const v2Workspace = path10.join(v2, "workspace.json");
+    const v2Tasks = path10.join(v2, "tasks");
+    const legacy = path10.join(dirs.dir, "legacy", checkoutSlug(path10.dirname(v2)), "v2");
     const raw = this.readV2Workspace(v2Workspace);
     if (raw === null || raw === TOMBSTONE)
       return success(null, null, null);
-    return this.withLock(dirs.checkoutLock, () => this.withLock(path9.join(v2, "metadata.lock"), () => {
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path10.join(v2, "metadata.lock"), () => {
       const workspace = this.readV2Workspace(v2Workspace);
       if (workspace === null || workspace === TOMBSTONE)
         return success(null, null, null);
@@ -11767,7 +11864,7 @@ class TaskStore {
         return failure2("recovery_required", `cannot migrate the 2.x store at ${v2}: ${parsedWorkspace.error}; move it aside to start fresh`, { path: v2Workspace });
       let files = [];
       try {
-        files = fs10.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path9.join(v2Tasks, name)));
+        files = fs10.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path10.join(v2Tasks, name)));
       } catch {}
       const current = this.readWorkspace();
       if (!current.ok)
@@ -11785,21 +11882,21 @@ class TaskStore {
       let skipped = 0;
       const done = new Map;
       try {
-        fs10.mkdirSync(path9.join(legacy, "tasks"), { recursive: true });
+        fs10.mkdirSync(path10.join(legacy, "tasks"), { recursive: true });
         for (const name of ["workspace.json", "index.json"])
-          if (fs10.existsSync(path9.join(v2, name)))
-            fs10.copyFileSync(path9.join(v2, name), path9.join(legacy, name));
+          if (fs10.existsSync(path10.join(v2, name)))
+            fs10.copyFileSync(path10.join(v2, name), path10.join(legacy, name));
         for (const name of files) {
           const id = name.slice(0, -5);
-          const file = path9.join(v2Tasks, name);
+          const file = path10.join(v2Tasks, name);
           const bytes = fs10.readFileSync(file, "utf8");
           const digest = sha256(bytes);
-          fs10.writeFileSync(path9.join(legacy, "tasks", name), bytes);
+          fs10.writeFileSync(path10.join(legacy, "tasks", name), bytes);
           const parsed = this.parseRecord(bytes, taskRecordSchema, "2.x task");
           if (!parsed.ok || parsed.data.id !== id)
             return failure2("recovery_required", `cannot migrate 2.x task ${id}: ${parsed.ok ? "file name and record ID differ" : parsed.error}; move ${file} aside to continue`, { path: file });
           const record = { ...parsed.data, workspaceId: target.id };
-          const origin = { path: path9.join(legacy, "tasks", name), digest };
+          const origin = { path: path10.join(legacy, "tasks", name), digest };
           if (!fs10.existsSync(this.eventsPath(id))) {
             this.openTask(record, "migrated.from_v2", null, origin);
             migrated += 1;
@@ -11835,7 +11932,7 @@ class TaskStore {
       try {
         let complete = true;
         for (const [name, digest] of done) {
-          const file = path9.join(v2Tasks, name);
+          const file = path10.join(v2Tasks, name);
           if (sha256(fs10.readFileSync(file, "utf8")) !== digest) {
             complete = false;
             continue;
@@ -11846,7 +11943,7 @@ class TaskStore {
           return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
             path: v2
           });
-        fs10.rmSync(path9.join(v2, "index.json"), { force: true });
+        fs10.rmSync(path10.join(v2, "index.json"), { force: true });
         this.writeTombstone(v2, target.id);
       } catch (error) {
         return failure2("storage_error", `cannot finish the 2.x migration: ${String(error)}`, {
@@ -11866,7 +11963,7 @@ class TaskStore {
   }
   adoptLocalStore() {
     const dirs = this.paths();
-    const marker = path9.join(dirs.v2, "store.json");
+    const marker = path10.join(dirs.v2, "store.json");
     if (!dirs.shared || !fs10.existsSync(marker))
       return success(null, null, null);
     return this.withLock(dirs.checkoutLock, () => {
@@ -11876,7 +11973,7 @@ class TaskStore {
       try {
         const merge = (from, to) => {
           if (!fs10.existsSync(to)) {
-            fs10.mkdirSync(path9.dirname(to), { recursive: true });
+            fs10.mkdirSync(path10.dirname(to), { recursive: true });
             try {
               fs10.renameSync(from, to);
             } catch {
@@ -11887,24 +11984,24 @@ class TaskStore {
           }
           if (fs10.lstatSync(from).isDirectory() && fs10.lstatSync(to).isDirectory())
             for (const name of fs10.readdirSync(from))
-              merge(path9.join(from, name), path9.join(to, name));
+              merge(path10.join(from, name), path10.join(to, name));
         };
         for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
-          const from = path9.join(dirs.v2, sub);
+          const from = path10.join(dirs.v2, sub);
           if (!fs10.existsSync(from))
             continue;
           if (sub === "tasks") {
             for (const name of fs10.readdirSync(from))
-              if (validId(name) && !fs10.existsSync(path9.join(dirs.dir, sub, name)))
+              if (validId(name) && !fs10.existsSync(path10.join(dirs.dir, sub, name)))
                 tasks += 1;
           }
-          merge(from, path9.join(dirs.dir, sub));
+          merge(from, path10.join(dirs.dir, sub));
         }
-        const ledger = path9.join(dirs.v2, "ledger");
-        if (fs10.existsSync(ledger) && !fs10.existsSync(path9.join(dirs.dir, "ledger")))
-          merge(ledger, path9.join(dirs.dir, "ledger"));
-        fs10.rmSync(path9.join(dirs.v2, "task-index.json"), { force: true });
-        fs10.renameSync(marker, path9.join(dirs.v2, "store.moved.json"));
+        const ledger = path10.join(dirs.v2, "ledger");
+        if (fs10.existsSync(ledger) && !fs10.existsSync(path10.join(dirs.dir, "ledger")))
+          merge(ledger, path10.join(dirs.dir, "ledger"));
+        fs10.rmSync(path10.join(dirs.v2, "task-index.json"), { force: true });
+        fs10.renameSync(marker, path10.join(dirs.v2, "store.moved.json"));
       } catch (error) {
         return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
           path: dirs.v2
@@ -11942,7 +12039,7 @@ class TaskStore {
       schemaVersion: SCHEMA_VERSION,
       id: workspaceId ?? newId(),
       revision: newRevision(),
-      root: path9.dirname(v2),
+      root: path10.dirname(v2),
       runtime: { createdWith: version, updatedWith: version },
       writer: null,
       store: {
@@ -11954,11 +12051,11 @@ class TaskStore {
       critical: ["store"]
     };
     fs10.mkdirSync(v2, { recursive: true });
-    const ignore = path9.join(v2, ".gitignore");
+    const ignore = path10.join(v2, ".gitignore");
     if (!fs10.existsSync(ignore))
       fs10.writeFileSync(ignore, `*
 `);
-    replaceFile(path9.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+    replaceFile(path10.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
 `, true);
   }
   stubFor(taskId) {
@@ -11982,8 +12079,8 @@ class TaskStore {
   }
   writeTombstoneIfMissing() {
     try {
-      const v2 = path9.join(this.root, ".workit");
-      if (fs10.existsSync(path9.join(v2, "workspace.json")))
+      const v2 = path10.join(this.root, ".workit");
+      if (fs10.existsSync(path10.join(v2, "workspace.json")))
         return;
       let id = null;
       try {
@@ -12000,7 +12097,7 @@ class TaskStore {
       replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
 `, false);
     if (!dirs.shared) {
-      const ignore = path9.join(dirs.dir, ".gitignore");
+      const ignore = path10.join(dirs.dir, ".gitignore");
       let current = null;
       try {
         current = fs10.readFileSync(ignore, "utf8");
@@ -12060,7 +12157,7 @@ class TaskStore {
   withLock(lockPath, operation) {
     try {
       this.initializeStorage();
-      fs10.mkdirSync(path9.dirname(lockPath), { recursive: true });
+      fs10.mkdirSync(path10.dirname(lockPath), { recursive: true });
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
         path: this.paths().dir
@@ -12123,7 +12220,7 @@ class TaskStore {
     if (isTransientWindowsError(error) && !this.lockHolderPresent(lockPath) && !this.lockDirWritable(lockPath))
       return failure2("storage_error", `cannot create the workit lock (${code}); no other Workit call holds it`, {
         path: lockPath,
-        guidance: `Check permissions and the read-only attribute on ${path9.dirname(lockPath)}.`
+        guidance: `Check permissions and the read-only attribute on ${path10.dirname(lockPath)}.`
       });
     if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
       let lock = null;
@@ -12143,17 +12240,17 @@ class TaskStore {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
 import { createHash as createHash9, randomBytes as randomBytes2 } from "node:crypto";
 import fs12 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // packages/workit-core/src/core/vcs-config.ts
 import fs11 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 import { spawnSync as spawnSync8 } from "node:child_process";
 
 // packages/workit-core/src/core/config.ts
@@ -12166,8 +12263,8 @@ import {
   readdirSync as readdirSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import os2 from "node:os";
-import path10 from "node:path";
+import os3 from "node:os";
+import path11 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 var EVENT = {
@@ -12211,7 +12308,7 @@ var mergePreset = (preset, input = {}, current = {
     protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
   };
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path11.join(process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -12221,7 +12318,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path11.join(process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config"), "workflow-toolkit");
   if (!existsSync3(legacy)) {
     migratedDir = dir;
     return dir;
@@ -12234,8 +12331,8 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync2(legacy, { withFileTypes: true })) {
-    const src = path10.join(legacy, entry.name);
-    const dest = path10.join(dir, entry.name);
+    const src = path11.join(legacy, entry.name);
+    const dest = path11.join(dir, entry.name);
     if (existsSync3(dest))
       continue;
     try {
@@ -12307,7 +12404,7 @@ var parseConfigResult = (raw, file) => {
   return { status: "valid", path: file, config };
 };
 var readConfigTyped = (dir) => {
-  const file = path10.join(dir ?? configDir(), "config.json");
+  const file = path11.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -12316,7 +12413,7 @@ var readConfig = () => {
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
 };
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.join(configDir(), "vcs.json");
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path11.join(configDir(), "vcs.json");
 var branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
 var resolveBranchPolicy = (config, workspace, repoPreset) => {
   const wp = workspace?.branchPolicy ?? {};
@@ -12360,7 +12457,7 @@ var resolveCommitPolicy = (config, workspace) => {
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
 import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // packages/workit-core/src/core/branch-policy.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -12486,7 +12583,7 @@ var releaseTrackSchema = object({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource?.kind === "package-json" && (path11.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource?.kind === "package-json" && (path12.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -12506,6 +12603,7 @@ var workspaceConfigSchema = object({
   autoApprove: union([boolean2(), array(nonBlank)]).optional(),
   defaultEndpoint: unknown().optional(),
   verification: _enum(["self", "independent"]).optional(),
+  trailers: boolean2().optional(),
   autonomy: object(Object.fromEntries(["push", "pr", "merge", "release", "rerun"].map((kind) => [
     kind,
     union([boolean2(), literal("verified")]).optional()
@@ -12584,7 +12682,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path11.join(dir, "workspaces.json");
+  const file = path12.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -12695,9 +12793,9 @@ var mainCheckoutOf = (cwd) => {
   let main = null;
   const dirs = git(["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
   const [gitDir, common] = (dirs ?? "").trim().split(/\r?\n/u);
-  if (gitDir && common && path11.resolve(gitDir) !== path11.resolve(common)) {
+  if (gitDir && common && path12.resolve(gitDir) !== path12.resolve(common)) {
     const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
-    main = listed?.trim() || (path11.basename(common) === ".git" ? path11.dirname(common) : common);
+    main = listed?.trim() || (path12.basename(common) === ".git" ? path12.dirname(common) : common);
   }
   mainCheckouts.set(cwd, main);
   return main;
@@ -12787,8 +12885,8 @@ var resolveRuntimeWorkspaceVcs = (cwd) => resolveRuntimeWorkspaceCandidate(cwd,
 var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
-var matchRuntimeWorkspace = (cwd) => {
-  const file = path11.join(configDir(), "workspaces.json");
+var matchRuntimeWorkspace = (cwd, dir = configDir()) => {
+  const file = path12.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -12817,12 +12915,30 @@ var matchRuntimeWorkspace = (cwd) => {
   const matches = matchingEntries(cwd, entries ?? []);
   const workspaceName = process.env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined;
   const selected = selectWorkspaceMatch(matches, cwd, workspaceName);
-  return selected ? { file, selected } : null;
+  return selected ? { file, selected, matches } : null;
 };
 var resolveRuntimeReleaseTracks = (cwd) => {
   const matched = matchRuntimeWorkspace(cwd);
   return matched ? { workspace: matched.selected.name, releaseTracks: matched.selected.releaseTracks } : null;
 };
+var workspaceTrailers = (cwd, dir) => {
+  let matched;
+  try {
+    matched = matchRuntimeWorkspace(cwd, dir);
+  } catch {
+    return { enabled: true, workspace: null, from: null };
+  }
+  if (!matched)
+    return { enabled: true, workspace: null, from: null };
+  const { selected, matches } = matched;
+  const enclosing = matches.filter((entry) => entry !== selected).toSorted((a, b) => globSpecificity(b.glob) - globSpecificity(a.glob));
+  const source = [selected, ...enclosing].find((entry) => typeof entry.trailers === "boolean");
+  return {
+    enabled: source?.trailers !== false,
+    workspace: selected.name,
+    from: source?.name ?? null
+  };
+};
 var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
   const matched = matchRuntimeWorkspace(cwd);
   if (!matched)
@@ -13159,7 +13275,7 @@ var git3 = (cwd, args) => {
   return run.status === 0 ? (run.stdout ?? "").trim() : null;
 };
 var recordedBaseKey = (branch) => `branch.${branch}.workitBase`;
-var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+var escapeRegExp2 = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 var reflog = (cwd, ref) => (git3(cwd, ["log", "-g", "--date=unix", "--format=%H%x09%gd%x09%gs", ref, "--"]) ?? "").split(`
 `).map((line) => {
   const [sha = "", selector = "", ...subject] = line.split("\t");
@@ -13191,7 +13307,7 @@ function gitTrackProbe(cwd) {
       const created = own.at(-1);
       if (!created || created.subject !== "branch: Created from HEAD")
         return null;
-      const pattern = new RegExp(`^checkout: moving from (\\S+) to ${escapeRegExp(branch)}$`, "u");
+      const pattern = new RegExp(`^checkout: moving from (\\S+) to ${escapeRegExp2(branch)}$`, "u");
       const entry = reflog(cwd, "HEAD").findLast((item) => item.time >= created.time && item.sha === created.sha && pattern.test(item.subject));
       return entry ? pattern.exec(entry.subject)?.[1] ?? null : null;
     },
@@ -13261,7 +13377,7 @@ function resolveTrackFor(cwd, options) {
 }
 
 // packages/workit-core/src/core/vcs-config.ts
-var workspacesPath = () => path12.join(configDir(), "workspaces.json");
+var workspacesPath = () => path13.join(configDir(), "workspaces.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
   const r = spawnSync8("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
@@ -13363,7 +13479,7 @@ function vcsConfig(mode, cwd, options = {}) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path12.resolve(cfgPath),
+    configPath: path13.resolve(cfgPath),
     provider,
     defaultTargetBranch: workspaceDefault,
     pr: cfg.pr ?? {},
@@ -13501,14 +13617,14 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path13.resolve(cwd));
+  const location = resolveStore(path14.resolve(cwd));
   if (location instanceof Error)
     return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
   return { ok: true, value: { root: location.dir, shared: location.shared } };
 }
 function ledgerPath(cwd) {
   const root = storeRoot(cwd);
-  return root.ok ? { ok: true, value: path13.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path14.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
@@ -13538,13 +13654,13 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs12.readFileSync(path13.join(lock, LOCK_OWNER), "utf8");
+    return fs12.readFileSync(path14.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path13.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path14.join(lock, LOCK_OWNER), lock]) {
     try {
       return Date.now() - fs12.statSync(target).mtimeMs;
     } catch {}
@@ -13561,7 +13677,7 @@ var ledgerLock = {
       throw error;
     }
     const token = `${process.pid}-${randomBytes2(8).toString("hex")}`;
-    fs12.writeFileSync(path13.join(lock, LOCK_OWNER), token);
+    fs12.writeFileSync(path14.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
@@ -13686,8 +13802,8 @@ function appendLine(file, build, options) {
     }
   };
   try {
-    fs12.mkdirSync(path13.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path13.dirname(file)))
+    fs12.mkdirSync(path14.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path14.dirname(file)))
       return write();
     const locked = withLedgerLock(file, write);
     return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
@@ -14250,7 +14366,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path14.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path15.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -14310,14 +14426,14 @@ function writeBlockers(task, root) {
 
 // packages/workit-core/src/core/task-evaluation.ts
 var digestBytes = (value) => createHash10("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path15.sep}`);
-var relative = (root, candidate) => path15.relative(root, candidate).split(path15.sep).join("/") || ".";
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path16.sep}`);
+var relative = (root, candidate) => path16.relative(root, candidate).split(path16.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path15.posix.normalize(value);
+  const normalized = path16.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -14365,14 +14481,14 @@ var gitPaths = (root) => {
       git: !/not a git repository/i.test(stderr)
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path16.sep).join("/")) : [];
   const stagedDeleted = spawnSync10("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
       return { paths, uncertain: true, git: true };
   } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path16.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
@@ -14387,7 +14503,7 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path15.join(directory, name);
+    const target = path16.join(directory, name);
     let stat;
     try {
       stat = fs13.lstatSync(target);
@@ -14405,12 +14521,12 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path15.resolve(root, item);
+    const target = path16.resolve(root, item);
     if (!inside(root, target))
       return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
     let ancestor = target;
     while (!fs13.existsSync(ancestor) && ancestor !== root)
-      ancestor = path15.dirname(ancestor);
+      ancestor = path16.dirname(ancestor);
     try {
       if (!inside(root, fs13.realpathSync(ancestor)))
         return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
@@ -14462,7 +14578,7 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path15.join(checkout, item);
+    const target = path16.join(checkout, item);
     try {
       const stat = fs13.lstatSync(target);
       if (stat.isSymbolicLink()) {
@@ -14646,23 +14762,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path15.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path15.sep}`))
+    const target = path16.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path16.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const below = path15.relative(root, target);
+      const below = path16.relative(root, target);
       let current = root;
-      for (const segment of below.split(path15.sep)) {
+      for (const segment of below.split(path16.sep)) {
         if (!segment)
           continue;
-        current = path15.join(current, segment);
+        current = path16.join(current, segment);
         const stat = fs13.lstatSync(current);
         const real = fs13.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path15.sep}`))
+        if (real !== root && !real.startsWith(`${root}${path16.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -15534,20 +15650,20 @@ var judgeInputSummary = (raw) => {
 };
 
 // packages/workit-core/src/autonomy.ts
-import os3 from "node:os";
-import path16 from "node:path";
+import os4 from "node:os";
+import path17 from "node:path";
 var accountHome = () => {
   try {
-    return os3.userInfo().homedir;
+    return os4.userInfo().homedir;
   } catch {
-    return os3.homedir();
+    return os4.homedir();
   }
 };
 var grantsHome = { resolve: accountHome };
-var grantsDir = () => path16.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path17.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path16.resolve(resolveConfigDir());
-  return configured === path16.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path16.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  const configured = path17.resolve(resolveConfigDir());
+  return configured === path17.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path17.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -17529,7 +17645,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" ? [path17.resolve(store.root, ref.path)] : []));
+  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path18.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)
@@ -17607,14 +17723,14 @@ var turnMarker = (input) => {
     if (location instanceof Error)
       return null;
     const session = [input.host, input.session.id, input.session.agentId ?? ""].join("\x00");
-    return path17.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
+    return path18.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
   } catch {
     return null;
   }
 };
 var writeTurnDigest = (file, digest) => {
   try {
-    fs14.mkdirSync(path17.dirname(file), { recursive: true });
+    fs14.mkdirSync(path18.dirname(file), { recursive: true });
     fs14.writeFileSync(file, `${JSON.stringify({ digest })}
 `);
   } catch {}
@@ -17629,7 +17745,7 @@ var pruneTurnDigests = (dir, now) => {
     for (const name of fs14.readdirSync(dir)) {
       if (!name.startsWith("turn-"))
         continue;
-      const file = path17.join(dir, name);
+      const file = path18.join(dir, name);
       try {
         if (now - fs14.statSync(file).mtimeMs > TURN_TTL_MS)
           fs14.rmSync(file, { force: true });
@@ -17659,7 +17775,7 @@ var seedTurnContext = (input, descriptor, text = turnContextText(input, descript
   const file = turnMarker(input);
   if (!file)
     return;
-  pruneTurnDigests(path17.dirname(file), Date.now());
+  pruneTurnDigests(path18.dirname(file), Date.now());
   if (text)
     writeTurnDigest(file, digestOf(text));
   else
@@ -17668,14 +17784,14 @@ var seedTurnContext = (input, descriptor, text = turnContextText(input, descript
 // packages/workit-core/src/core/route-intent.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 
 // packages/workit-core/src/hooks/raw-git.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
 import fs16 from "node:fs";
-import os4 from "node:os";
-import path19 from "node:path";
+import os5 from "node:os";
+import path20 from "node:path";
 
 // packages/workit-core/src/core/branch.ts
 import { createHash as createHash12 } from "node:crypto";
@@ -17888,7 +18004,7 @@ var globOf = (pattern) => pattern.source.replace(/^\^|\$$/gu, "").replaceAll(".*
 // packages/workit-core/src/hooks/session-marker.ts
 import { createHash as createHash13 } from "node:crypto";
 import fs15 from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 var sessionMarkerFile = (input, session, store) => {
   let dir = store;
   if (dir === undefined) {
@@ -17898,7 +18014,7 @@ var sessionMarkerFile = (input, session, store) => {
     dir = location.dir;
   }
   const name = createHash13("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path18.join(dir, "hooks", `skills-${name}.json`);
+  return path19.join(dir, "hooks", `skills-${name}.json`);
 };
 var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 var readSessionMarker = (file) => {
@@ -17911,7 +18027,7 @@ var readSessionMarker = (file) => {
 };
 var writeSessionMarker = (file, marker) => {
   try {
-    fs15.mkdirSync(path18.dirname(file), { recursive: true });
+    fs15.mkdirSync(path19.dirname(file), { recursive: true });
     fs15.writeFileSync(file, JSON.stringify(marker));
   } catch {}
 };
@@ -18056,12 +18172,12 @@ var GIT_VALUE_OPTIONS = new Set([
   "--config-env",
   "--super-prefix"
 ]);
-var isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var isAbsolute = (value) => path20.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 var joinDir = (base, next) => {
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path20.join(os5.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path20.join(base, expanded);
 };
 var cdTarget = (words) => {
   const args = words.slice(1);
@@ -18112,7 +18228,7 @@ function rawInvocations(command, dialect = "posix", depth = 0) {
     const name = commandName(words[0]);
     if (CD.has(name)) {
       const target = cdTarget(words);
-      dir = target === null ? os4.homedir() : joinDir(dir, target);
+      dir = target === null ? os5.homedir() : joinDir(dir, target);
       continue;
     }
     if (PUSHD.has(name)) {
@@ -18370,17 +18486,17 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs16.readFileSync(path19.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs16.readFileSync(path20.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 = path19.dirname(repo.location.dir);
+    const common = path20.dirname(repo.location.dir);
     try {
-      return fs16.readFileSync(path19.join(common, ref), "utf8").trim() || null;
+      return fs16.readFileSync(path20.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs16.readFileSync(path19.join(common, "packed-refs"), "utf8");
+    const packed = fs16.readFileSync(path20.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -18469,7 +18585,7 @@ var actionsIn = (cwd, command, dialect) => {
     const action = rawAction(invocation);
     if (!action)
       continue;
-    const dir = path19.resolve(cwd, invocation.dir ?? ".");
+    const dir = path20.resolve(cwd, invocation.dir ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -18549,7 +18665,7 @@ function rawGitPre(input, command, options = {}) {
 var deny = (reason) => ({ kind: "deny", reason, unblock: null });
 var NEXT_COMMAND = "next";
 var MARKER_TTL_SECONDS = 3600;
-var markerFile = (repo, session, key) => path19.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
+var markerFile = (repo, session, key) => path20.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 {
@@ -18560,7 +18676,7 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs16.mkdirSync(path19.dirname(file), { recursive: true });
+      fs16.mkdirSync(path20.dirname(file), { recursive: true });
       fs16.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
@@ -18733,7 +18849,7 @@ var shellBranchPolicyViolation = (root, command, dialect = "posix") => {
   for (const target of shellBranchTargets(command, dialect)) {
     if (target.dir === undefined)
       continue;
-    const dir = target.dir === null ? root : path20.resolve(root, target.dir);
+    const dir = target.dir === null ? root : path21.resolve(root, target.dir);
     if (target.dir !== null && (!existsSync6(dir) || !inWorkitWorkspace(dir)))
       continue;
     if (localBranchExists(dir, target.branch))
@@ -18753,27 +18869,27 @@ var shellPolicy = (cwd, command, dialect = "posix") => {
 };
 // packages/workit-core/src/hooks/write-gate.ts
 import { realpathSync as realpathSync5 } from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 var NONE3 = { kind: "none" };
 var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
 var canonical2 = (file) => {
   let rest = "";
-  for (let dir = path21.resolve(file);; dir = path21.dirname(dir)) {
+  for (let dir = path22.resolve(file);; dir = path22.dirname(dir)) {
     try {
-      return path21.join(realpathSync5(dir), rest);
+      return path22.join(realpathSync5(dir), rest);
     } catch {
-      if (path21.dirname(dir) === dir)
-        return path21.resolve(file);
-      rest = rest ? path21.join(path21.basename(dir), rest) : path21.basename(dir);
+      if (path22.dirname(dir) === dir)
+        return path22.resolve(file);
+      rest = rest ? path22.join(path22.basename(dir), rest) : path22.basename(dir);
     }
   }
 };
 var exempt = (cwd, root, file, plans) => {
   const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
-  if (relative.startsWith("..") || path21.isAbsolute(relative))
+  const relative = path22.relative(fold(canonical2(root)), fold(canonical2(path22.resolve(cwd, file))));
+  if (relative.startsWith("..") || path22.isAbsolute(relative))
     return true;
-  const posix = relative.split(path21.sep).join("/");
+  const posix = relative.split(path22.sep).join("/");
   const segments = posix.split("/");
   return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
 };
@@ -18871,7 +18987,7 @@ var shellWrites = (command) => {
   return { writes: true, targets: unknown ? null : targets };
 };
 var cache2 = new Map;
-var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path21.resolve(root, file)) ?? "-").join("\x00");
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path22.resolve(root, file)) ?? "-").join("\x00");
 var gateFor = (cwd) => {
   const store = new TaskStore(cwd);
   const listed = store.listTaskIndex();
@@ -19312,12 +19428,12 @@ ${line}` };
 };
 // packages/workit-core/src/hooks/hosts/fields.ts
 import { existsSync as existsSync7, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
 var optionalText = (value) => typeof value === "string" ? value : null;
 var existingDirectory = (value) => {
-  if (!nonEmpty2(value) || !path22.isAbsolute(value) || !existsSync7(value))
+  if (!nonEmpty2(value) || !path23.isAbsolute(value) || !existsSync7(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -19400,7 +19516,7 @@ var workitRole = (descriptor, agentType) => {
 };
 var subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128);
 var CLAUDE_WORKTREE = /[\\/]\.claude[\\/]worktrees[\\/]/;
-var ISOLATED_GIT = 'Run git as plain, separate commands inside your worktree (`git switch -c <branch> <base>`, `git commit --trailer "Workit-Session=<your session>"`, `git push`; `workit doctor --fix` can install a commit-msg hook that adds the trailer), never `workit git …`: Claude Code\'s worktree isolation refuses a command that wraps git and cannot be turned off (https://code.claude.com/docs/en/worktrees#how-claude-code-enforces-isolation). Never dodge that check by renaming or re-wrapping git. Use workit for the non-git verbs (`workit check`, `workit ledger`, `workit pr`).';
+var isolatedGit = (cwd) => `Run git as plain, separate commands inside your worktree (\`git switch -c <branch> <base>\`, ${workspaceTrailers(cwd).enabled ? '`git commit --trailer "Workit-Session=<your session>"`, `git push`; `workit doctor --fix` can install a prepare-commit-msg hook that adds the trailer' : "`git commit` (this workspace sets trailers: false: add no Workit-Session trailer), `git push`"}; add Co-Authored-By with \`git commit --trailer\` in the same commit, never by amending), never \`workit git …\`: Claude Code's worktree isolation refuses a command that wraps git and cannot be turned off (https://code.claude.com/docs/en/worktrees#how-claude-code-enforces-isolation). Never dodge that check by renaming or re-wrapping git. Use workit for the non-git verbs (\`workit check\`, \`workit ledger\`, \`workit pr\`).`;
 var subagentStartText = (input, descriptor, event) => {
   const session = input.session.id ?? null;
   const role = workitRole(descriptor, event.agentType);
@@ -19408,9 +19524,9 @@ var subagentStartText = (input, descriptor, event) => {
   const isolated = descriptor.subagents.worktreeIsolation === "native" && (role === "implementer" || CLAUDE_WORKTREE.test(input.cwd));
   const guide = role === "implementer" ? branchGuidance(input.cwd) : null;
   if (role === "implementer" && isolated)
-    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${ISOLATED_GIT} Plain git is expected here, and the branch name is still policy-checked: a raw \`git switch -c\`, \`git checkout -b\`, \`git branch\` or \`git worktree add -b\` onto a protected or non-compliant name is denied, so use a policy-compliant branch.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${isolatedGit(input.cwd)} Plain git is expected here, and the branch name is still policy-checked: a raw \`git switch -c\`, \`git checkout -b\`, \`git branch\` or \`git worktree add -b\` onto a protected or non-compliant name is denied, so use a policy-compliant branch.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   if (isolated)
-    return `${ISOLATED_GIT}
+    return `${isolatedGit(input.cwd)}
 ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
   if (role === "implementer")
     return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (or \`--kind <kind> --slug <slug>\`, which picks the base); branch policy hooks still deny protected or non-compliant branches, raw git included.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
@@ -20056,7 +20172,7 @@ var codexAdapter = {
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
 import fs17 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 var undocumented = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
 var CURSOR_DESCRIPTOR = {
@@ -20253,7 +20369,7 @@ var protocolEvent2 = (input) => {
 };
 var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 var lastAssistantText = (file) => {
-  if (!file || !path23.isAbsolute(file))
+  if (!file || !path24.isAbsolute(file))
     return null;
   try {
     const size = fs17.statSync(file).size;
@@ -20290,7 +20406,7 @@ var lastAssistantText = (file) => {
     return null;
   }
 };
-var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path23.sep) ? root : `${root}${path23.sep}`);
+var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path24.sep) ? root : `${root}${path24.sep}`);
 var hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")