@brainervirus/workit-cursor 8.12.0 → 8.12.1

package/dist/mcp-server.js

@@ -16582,7 +16582,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync14 } from "node:child_process";
 import { existsSync as existsSync7, realpathSync as realpathSync5 } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -17839,7 +17839,7 @@ function parseAdvertisedOperation(family, input, host) {
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import * as fs7 from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -18442,11 +18442,85 @@ function acquireFileLockSync(targetPath, options) {
     }
   }
 }
+// packages/workit-core/src/core/logger.ts
+import os from "node:os";
+import path3 from "node:path";
+var REDACTED = "[REDACTED]";
+var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
+var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
+var URL_QUERY = /(https?:\/\/[^?#\s]+)\?[^#\s]*/g;
+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 = os.homedir();
+  if (process.env.XDG_STATE_HOME)
+    return path3.join(process.env.XDG_STATE_HOME, "workit");
+  switch (os.platform()) {
+    case "darwin":
+      return path3.join(home, "Library", "Application Support", "workit");
+    case "win32":
+      return path3.join(process.env.LOCALAPPDATA ?? path3.join(home, "AppData", "Local"), "workit");
+    default:
+      return path3.join(process.env.HOME ?? home, ".local", "state", "workit");
+  }
+};
+var homePattern = new RegExp(`${escapeRegExp(os.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+var applyPatterns = (value) => {
+  let out = value;
+  out = out.replace(SECRET_VALUE, REDACTED);
+  out = out.replace(KEY_EQ_VALUE, "$1$2[REDACTED]");
+  out = out.replace(URL_QUERY, "$1?[REDACTED]");
+  out = out.replace(homePattern, "~");
+  if (process.platform === "win32")
+    out = out.replace(/\\/g, "/");
+  return out;
+};
+var redactSecrets = (value) => applyPatterns(value);
+
 // packages/workit-core/src/store/paths.ts
 import { spawnSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import fs4 from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 var NOT_A_REPO = /not a git repository \(or any (of the parent directories|parent up to)/u;
 var gitRun = (cwd, args) => {
   const run = spawnSync("git", args, {
@@ -18488,14 +18562,14 @@ var DISCOVERY_ENV = [
 ];
 var isGitDir = (dir) => {
   try {
-    return fs4.statSync(path3.join(dir, "HEAD")).isFile() && fs4.statSync(path3.join(dir, "objects")).isDirectory() && fs4.statSync(path3.join(dir, "refs")).isDirectory();
+    return fs4.statSync(path4.join(dir, "HEAD")).isFile() && fs4.statSync(path4.join(dir, "objects")).isDirectory() && fs4.statSync(path4.join(dir, "refs")).isDirectory();
   } catch {
     return false;
   }
 };
 var reftableRefs = (common) => {
   try {
-    return /^\s*refstorage\s*=\s*reftable\s*$/imu.test(fs4.readFileSync(path3.join(common, "config"), "utf8"));
+    return /^\s*refstorage\s*=\s*reftable\s*$/imu.test(fs4.readFileSync(path4.join(common, "config"), "utf8"));
   } catch {
     return false;
   }
@@ -18515,7 +18589,7 @@ function fastGit(root) {
     if (device !== null && stat.dev !== device)
       return { kind: "none" };
     device = stat.dev;
-    const dotGit = path3.join(dir, ".git");
+    const dotGit = path4.join(dir, ".git");
     let entry = null;
     try {
       entry = fs4.statSync(dotGit);
@@ -18536,19 +18610,19 @@ function fastGit(root) {
         const match = /^gitdir: (.+)$/mu.exec(text);
         if (!match)
           return null;
-        gitDir = path3.resolve(dir, match[1].trim());
+        gitDir = path4.resolve(dir, match[1].trim());
       } else
         return null;
-      if (!fs4.existsSync(path3.join(gitDir, "HEAD")))
+      if (!fs4.existsSync(path4.join(gitDir, "HEAD")))
         return null;
     } else if (isGitDir(dir))
       gitDir = dir;
     if (gitDir) {
       let common = gitDir;
       try {
-        common = path3.resolve(gitDir, fs4.readFileSync(path3.join(gitDir, "commondir"), "utf8").trim());
+        common = path4.resolve(gitDir, fs4.readFileSync(path4.join(gitDir, "commondir"), "utf8").trim());
       } catch {}
-      if (!fs4.existsSync(path3.join(common, "objects")))
+      if (!fs4.existsSync(path4.join(common, "objects")))
         return null;
       return {
         kind: "repo",
@@ -18558,26 +18632,26 @@ function fastGit(root) {
         reftable: reftableRefs(common)
       };
     }
-    const parent = path3.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir)
       return { kind: "none" };
     dir = parent;
   }
 }
 function resolveStore(root) {
-  root = path3.resolve(root);
+  root = path4.resolve(root);
   let directory = false;
   try {
     directory = fs4.statSync(root).isDirectory();
   } catch {}
   if (!directory)
-    return { dir: path3.join(root, ".workit"), shared: false, top: null };
+    return { dir: path4.join(root, ".workit"), shared: false, top: null };
   const fast = fastGit(root);
   if (fast?.kind === "none")
-    return { dir: path3.join(root, ".workit"), shared: false, top: null };
+    return { dir: path4.join(root, ".workit"), shared: false, top: null };
   if (fast?.kind === "repo")
     return {
-      dir: path3.join(fast.common, "workit"),
+      dir: path4.join(fast.common, "workit"),
       shared: true,
       top: fast.top,
       git: { gitDir: fast.gitDir, top: fast.top, reftable: fast.reftable }
@@ -18587,20 +18661,20 @@ function resolveStore(root) {
   if (run.ok && common) {
     const top = gitRun(root, ["rev-parse", "--path-format=absolute", "--show-toplevel"]);
     return {
-      dir: path3.join(real(path3.resolve(root, common)), "workit"),
+      dir: path4.join(real(path4.resolve(root, common)), "workit"),
       shared: true,
       top: top.ok && top.stdout.trim() ? real(top.stdout.trim()) : null
     };
   }
   if (run.missing || !run.ok && NOT_A_REPO.test(run.stderr))
-    return { dir: path3.join(root, ".workit"), shared: false, top: null };
+    return { dir: path4.join(root, ".workit"), shared: false, top: null };
   return new Error(`cannot locate the workit store: git rev-parse failed (${run.stderr.trim().split(`
 `)[0] || "no output"}); fix the repository (git status should work here)`);
 }
 var rebasingBranch = (gitDir) => {
   for (const state of ["rebase-merge", "rebase-apply"]) {
     try {
-      const ref = fs4.readFileSync(path3.join(gitDir, state, "head-name"), "utf8").trim();
+      const ref = fs4.readFileSync(path4.join(gitDir, state, "head-name"), "utf8").trim();
       const match = /^refs\/heads\/(.+)$/u.exec(ref);
       if (match)
         return match[1];
@@ -18615,7 +18689,7 @@ function resolveTaskKey(root, location) {
   if (location.git && !location.git.reftable) {
     let head = "";
     try {
-      head = fs4.readFileSync(path3.join(location.git.gitDir, "HEAD"), "utf8").trim();
+      head = fs4.readFileSync(path4.join(location.git.gitDir, "HEAD"), "utf8").trim();
     } catch {}
     const ref = /^ref: refs\/heads\/(.+)$/u.exec(head);
     if (ref && ref[1] !== ".invalid")
@@ -18646,7 +18720,7 @@ function resolveTaskKey(root, location) {
   return { key: `detached-${shortHash(real(worktree))}`, kind: "detached", branch: null };
 }
 function checkoutRootOf(root, location) {
-  const resolved = path3.resolve(root);
+  const resolved = path4.resolve(root);
   let canonical = resolved;
   try {
     canonical = fs4.realpathSync(resolved);
@@ -18677,13 +18751,13 @@ function branchRenames(location) {
     }
     for (const entry of entries)
       if (entry.isDirectory())
-        walk(path3.join(dir, entry.name));
+        walk(path4.join(dir, entry.name));
       else
-        files.push(path3.join(dir, entry.name));
+        files.push(path4.join(dir, entry.name));
   };
-  walk(path3.join(path3.dirname(location.dir), "logs", "refs", "heads"));
+  walk(path4.join(path4.dirname(location.dir), "logs", "refs", "heads"));
   if (location.git)
-    files.push(path3.join(location.git.gitDir, "logs", "HEAD"));
+    files.push(path4.join(location.git.gitDir, "logs", "HEAD"));
   const seen = new Set;
   const renames = [];
   for (const file of files) {
@@ -18718,7 +18792,7 @@ var checkoutSlug = (root) => {
   let canonical = real(root);
   if (process.platform === "win32")
     canonical = canonical.toLowerCase();
-  const base = path3.basename(canonical).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 40) || "root";
+  const base = path4.basename(canonical).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 40) || "root";
   return `${base}-${shortHash(canonical)}`;
 };
 
@@ -18754,20 +18828,20 @@ var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
 
 // packages/workit-core/src/core/package-root.ts
 import { existsSync } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  let dir = path5.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path4.dirname(dir);
-    if (existsSync(path4.join(dir, "package.json")) || parent === dir)
+    const parent = path5.dirname(dir);
+    if (existsSync(path5.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
 };
 var assetRoot = () => {
   const root = packageRoot();
-  const assets = path4.join(root, "assets");
+  const assets = path5.join(root, "assets");
   return existsSync(assets) ? assets : root;
 };
 
@@ -18914,7 +18988,7 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
 // packages/workit-core/src/store/event-log.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs6 from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 var EVENT_VERSION = 1;
 
 class LogDamage extends Error {
@@ -19025,7 +19099,7 @@ function appendEvent(file, event, validEnd) {
     fs6.closeSync(fd);
   }
   if (created)
-    fsyncDirectory(path5.dirname(file));
+    fsyncDirectory(path6.dirname(file));
   return validEnd;
 }
 function replaceFile(file, bytes, durable) {
@@ -19041,7 +19115,7 @@ function replaceFile(file, bytes, durable) {
     }
     renameWithRetry(temporary, file);
     if (durable)
-      fsyncDirectory(path5.dirname(file));
+      fsyncDirectory(path6.dirname(file));
   } catch (error) {
     try {
       fs6.unlinkSync(temporary);
@@ -19384,7 +19458,7 @@ var cachedRuntimeVersion = null;
 var runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs7.readFileSync(path6.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs7.readFileSync(path7.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -19417,7 +19491,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(path6.join(path6.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+  const first = readText(path7.join(path7.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];
@@ -19427,7 +19501,7 @@ var branchStart = (location, branch, aliases) => {
     return start;
   if (!location.git)
     return null;
-  for (const line of readText(path6.join(location.git.gitDir, "logs", "HEAD")).split(`
+  for (const line of readText(path7.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]);
@@ -19437,14 +19511,14 @@ var branchStart = (location, branch, aliases) => {
   }
   return null;
 };
-var refExists = (common, ref) => fs7.existsSync(path6.join(common, ref)) || readText(path6.join(common, "packed-refs")).includes(` ${ref}
+var refExists = (common, ref) => fs7.existsSync(path7.join(common, ref)) || readText(path7.join(common, "packed-refs")).includes(` ${ref}
 `);
 var origins = new Map;
 var sameDirectoryIdentity = (left, right) => {
-  if (!path6.isAbsolute(left) || !path6.isAbsolute(right))
+  if (!path7.isAbsolute(left) || !path7.isAbsolute(right))
     return false;
-  const normalizedLeft = path6.resolve(left);
-  const normalizedRight = path6.resolve(right);
+  const normalizedLeft = path7.resolve(left);
+  const normalizedRight = path7.resolve(right);
   try {
     const a = fs7.statSync(normalizedLeft, { bigint: true });
     const b = fs7.statSync(normalizedRight, { bigint: true });
@@ -19490,7 +19564,7 @@ class TaskStore {
   migrationChecked = false;
   compactDue = new Set;
   constructor(root, options = {}) {
-    const resolved = path6.resolve(root);
+    const resolved = path7.resolve(root);
     this.origin = fs7.existsSync(resolved) ? fs7.realpathSync(resolved) : resolved;
     this.located = resolveStore(this.origin);
     this.root = checkoutRootOf(this.origin, this.located);
@@ -19499,7 +19573,7 @@ class TaskStore {
     this.migrateOnRead = options.migrateOnRead;
   }
   location() {
-    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs7.existsSync(path6.join(this.root, ".git"))) {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs7.existsSync(path7.join(this.root, ".git"))) {
       this.located = undefined;
       this.migrationChecked = false;
     }
@@ -19655,7 +19729,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" : path6.basename(this.root) || this.root;
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path7.basename(this.root) || this.root;
       const intent = {
         objective: input.objective?.trim() || `Work on ${label}`,
         scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
@@ -19715,14 +19789,14 @@ class TaskStore {
     const branch = key.ok ? key.data.branch : null;
     if (!branch || !location.ok)
       return success(null, null, null);
-    const common = path6.dirname(location.data.dir);
-    const heads = path6.join(common, "logs", "refs", "heads");
-    const headLog = location.data.git ? path6.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    const common = path7.dirname(location.data.dir);
+    const heads = path7.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path7.join(location.data.git.gitDir, "logs", "HEAD") : "";
     const signatures = [
-      path6.join(heads, branch),
+      path7.join(heads, branch),
       headLog,
       heads,
-      path6.join(common, "packed-refs")
+      path7.join(common, "packed-refs")
     ].map((file) => fileSignature(file) ?? "-");
     const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
     let resolved = origins.get(slot);
@@ -19734,7 +19808,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(path6.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path7.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
       const name = start && (remote ? start.slice(slash + 1) : start);
       resolved = {
         signature: signatures.join("|"),
@@ -19972,13 +20046,13 @@ class TaskStore {
     if (!ready.ok)
       return ready;
     const dirs = this.paths();
-    const recovery = path6.join(this.root, ".workit", "recovery");
+    const recovery = path7.join(this.root, ".workit", "recovery");
     if (fs7.existsSync(recovery)) {
       let files = 0;
       let bytes = 0;
       try {
         for (const name of fs7.readdirSync(recovery)) {
-          const stat = fs7.lstatSync(path6.join(recovery, name));
+          const stat = fs7.lstatSync(path7.join(recovery, name));
           if (!stat.isFile())
             continue;
           files += 1;
@@ -20031,7 +20105,7 @@ class TaskStore {
       if (fs7.existsSync(dirs.blobs))
         for (const name of fs7.readdirSync(dirs.blobs)) {
           const digest = name.replace(/\.json$/, "");
-          const file = path6.join(dirs.blobs, name);
+          const file = path7.join(dirs.blobs, name);
           let stat;
           try {
             stat = fs7.lstatSync(file);
@@ -20049,7 +20123,7 @@ class TaskStore {
         }
       return success(null, null, null);
     };
-    const swept = dryRun ? sweep() : this.withLock(path6.join(dirs.dir, "gc.lock"), sweep);
+    const swept = dryRun ? sweep() : this.withLock(path7.join(dirs.dir, "gc.lock"), sweep);
     if (!swept.ok)
       return swept;
     const temporaryDirs = [
@@ -20057,7 +20131,7 @@ class TaskStore {
       dirs.tasks,
       dirs.blobs,
       dirs.checkout,
-      ...names.map((name) => path6.join(dirs.tasks, name))
+      ...names.map((name) => path7.join(dirs.tasks, name))
     ];
     for (const directory of temporaryDirs) {
       if (!fs7.existsSync(directory))
@@ -20065,7 +20139,7 @@ class TaskStore {
       for (const name of fs7.readdirSync(directory)) {
         if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
           continue;
-        const file = path6.join(directory, name);
+        const file = path7.join(directory, name);
         try {
           const stat = fs7.lstatSync(file);
           if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
@@ -20082,30 +20156,30 @@ class TaskStore {
   }
   paths() {
     const location = this.location();
-    const dir = location.ok ? location.data.dir : path6.join(this.root, ".workit");
-    const checkout = path6.join(dir, "checkouts", checkoutSlug(this.root));
+    const dir = location.ok ? location.data.dir : path7.join(this.root, ".workit");
+    const checkout = path7.join(dir, "checkouts", checkoutSlug(this.root));
     return {
       dir,
       shared: location.ok ? location.data.shared : false,
-      marker: path6.join(dir, "store.json"),
+      marker: path7.join(dir, "store.json"),
       checkout,
-      workspace: path6.join(checkout, "workspace.json"),
-      checkoutLock: path6.join(checkout, "metadata.lock"),
-      tasks: path6.join(dir, "tasks"),
-      index: path6.join(dir, "task-index.json"),
-      blobs: path6.join(dir, "blobs", "candidates"),
-      legacy: path6.join(dir, "legacy", checkoutSlug(this.root), "v2"),
-      v2: path6.join(this.root, ".workit")
+      workspace: path7.join(checkout, "workspace.json"),
+      checkoutLock: path7.join(checkout, "metadata.lock"),
+      tasks: path7.join(dir, "tasks"),
+      index: path7.join(dir, "task-index.json"),
+      blobs: path7.join(dir, "blobs", "candidates"),
+      legacy: path7.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path7.join(this.root, ".workit")
     };
   }
   eventsPath(taskId) {
-    return path6.join(this.paths().tasks, taskId, "events.jsonl");
+    return path7.join(this.paths().tasks, taskId, "events.jsonl");
   }
   snapshotPath(taskId) {
-    return path6.join(this.paths().tasks, taskId, "snapshot.json");
+    return path7.join(this.paths().tasks, taskId, "snapshot.json");
   }
   taskLockPath(taskId) {
-    return path6.join(this.paths().tasks, taskId, "lock");
+    return path7.join(this.paths().tasks, taskId, "lock");
   }
   ready(write = false) {
     const location = this.location();
@@ -20144,13 +20218,13 @@ class TaskStore {
     return {
       read: (digest) => {
         try {
-          return JSON.parse(fs7.readFileSync(path6.join(dir, `${digest}.json`), "utf8"));
+          return JSON.parse(fs7.readFileSync(path7.join(dir, `${digest}.json`), "utf8"));
         } catch (error) {
           throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
         }
       },
       write: (digest, value) => {
-        const file = path6.join(dir, `${digest}.json`);
+        const file = path7.join(dir, `${digest}.json`);
         if (fs7.existsSync(file)) {
           const stamp = new Date;
           try {
@@ -20342,7 +20416,7 @@ class TaskStore {
     }
   }
   openTask(record, type, key, legacy = null) {
-    const dir = path6.join(this.paths().tasks, record.id);
+    const dir = path7.join(this.paths().tasks, record.id);
     fs7.mkdirSync(dir, { recursive: true });
     const blobs = this.blobStore();
     const bound = key ? { ...key, boundAt: key.boundAt ?? new Date().toISOString() } : null;
@@ -20435,7 +20509,7 @@ class TaskStore {
   }
   withKeyLock(key, operation) {
     const digest = createHash4("sha256").update(key).digest("hex").slice(0, 32);
-    return this.withLock(path6.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+    return this.withLock(path7.join(this.paths().dir, "keys", `${digest}.lock`), operation);
   }
   bindLocked(taskId, key, timestamp) {
     const current = this.readWorkspace();
@@ -20576,7 +20650,7 @@ class TaskStore {
   writeWorkspace(record) {
     const file = this.paths().workspace;
     try {
-      fs7.mkdirSync(path6.dirname(file), { recursive: true });
+      fs7.mkdirSync(path7.dirname(file), { recursive: true });
       replaceFile(file, `${canonicalJson(record)}
 `, true);
       return success(null, null, null);
@@ -20654,23 +20728,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) => path6.join(dir, ".workit"));
+    return [...new Set([this.root, this.origin])].map((dir) => path7.join(dir, ".workit"));
   }
   pendingMigrations() {
     return this.v2Dirs().filter((dir) => {
-      const raw = this.readV2Workspace(path6.join(dir, "workspace.json"));
+      const raw = this.readV2Workspace(path7.join(dir, "workspace.json"));
       return raw !== null && raw !== TOMBSTONE;
     });
   }
   migrateV2(v2) {
     const dirs = this.paths();
-    const v2Workspace = path6.join(v2, "workspace.json");
-    const v2Tasks = path6.join(v2, "tasks");
-    const legacy = path6.join(dirs.dir, "legacy", checkoutSlug(path6.dirname(v2)), "v2");
+    const v2Workspace = path7.join(v2, "workspace.json");
+    const v2Tasks = path7.join(v2, "tasks");
+    const legacy = path7.join(dirs.dir, "legacy", checkoutSlug(path7.dirname(v2)), "v2");
     const raw = this.readV2Workspace(v2Workspace);
     if (raw === null || raw === TOMBSTONE)
       return success(null, null, null);
-    return this.withLock(dirs.checkoutLock, () => this.withLock(path6.join(v2, "metadata.lock"), () => {
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path7.join(v2, "metadata.lock"), () => {
       const workspace = this.readV2Workspace(v2Workspace);
       if (workspace === null || workspace === TOMBSTONE)
         return success(null, null, null);
@@ -20679,7 +20753,7 @@ class TaskStore {
         return failure2("recovery_required", `cannot migrate the 2.x store at ${v2}: ${parsedWorkspace.error}; move it aside to start fresh`, { path: v2Workspace });
       let files = [];
       try {
-        files = fs7.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path6.join(v2Tasks, name)));
+        files = fs7.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path7.join(v2Tasks, name)));
       } catch {}
       const current = this.readWorkspace();
       if (!current.ok)
@@ -20697,21 +20771,21 @@ class TaskStore {
       let skipped = 0;
       const done = new Map;
       try {
-        fs7.mkdirSync(path6.join(legacy, "tasks"), { recursive: true });
+        fs7.mkdirSync(path7.join(legacy, "tasks"), { recursive: true });
         for (const name of ["workspace.json", "index.json"])
-          if (fs7.existsSync(path6.join(v2, name)))
-            fs7.copyFileSync(path6.join(v2, name), path6.join(legacy, name));
+          if (fs7.existsSync(path7.join(v2, name)))
+            fs7.copyFileSync(path7.join(v2, name), path7.join(legacy, name));
         for (const name of files) {
           const id = name.slice(0, -5);
-          const file = path6.join(v2Tasks, name);
+          const file = path7.join(v2Tasks, name);
           const bytes = fs7.readFileSync(file, "utf8");
           const digest = sha256(bytes);
-          fs7.writeFileSync(path6.join(legacy, "tasks", name), bytes);
+          fs7.writeFileSync(path7.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: path6.join(legacy, "tasks", name), digest };
+          const origin = { path: path7.join(legacy, "tasks", name), digest };
           if (!fs7.existsSync(this.eventsPath(id))) {
             this.openTask(record, "migrated.from_v2", null, origin);
             migrated += 1;
@@ -20747,7 +20821,7 @@ class TaskStore {
       try {
         let complete = true;
         for (const [name, digest] of done) {
-          const file = path6.join(v2Tasks, name);
+          const file = path7.join(v2Tasks, name);
           if (sha256(fs7.readFileSync(file, "utf8")) !== digest) {
             complete = false;
             continue;
@@ -20758,7 +20832,7 @@ class TaskStore {
           return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
             path: v2
           });
-        fs7.rmSync(path6.join(v2, "index.json"), { force: true });
+        fs7.rmSync(path7.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)}`, {
@@ -20778,7 +20852,7 @@ class TaskStore {
   }
   adoptLocalStore() {
     const dirs = this.paths();
-    const marker = path6.join(dirs.v2, "store.json");
+    const marker = path7.join(dirs.v2, "store.json");
     if (!dirs.shared || !fs7.existsSync(marker))
       return success(null, null, null);
     return this.withLock(dirs.checkoutLock, () => {
@@ -20788,7 +20862,7 @@ class TaskStore {
       try {
         const merge = (from, to) => {
           if (!fs7.existsSync(to)) {
-            fs7.mkdirSync(path6.dirname(to), { recursive: true });
+            fs7.mkdirSync(path7.dirname(to), { recursive: true });
             try {
               fs7.renameSync(from, to);
             } catch {
@@ -20799,24 +20873,24 @@ class TaskStore {
           }
           if (fs7.lstatSync(from).isDirectory() && fs7.lstatSync(to).isDirectory())
             for (const name of fs7.readdirSync(from))
-              merge(path6.join(from, name), path6.join(to, name));
+              merge(path7.join(from, name), path7.join(to, name));
         };
         for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
-          const from = path6.join(dirs.v2, sub);
+          const from = path7.join(dirs.v2, sub);
           if (!fs7.existsSync(from))
             continue;
           if (sub === "tasks") {
             for (const name of fs7.readdirSync(from))
-              if (validId(name) && !fs7.existsSync(path6.join(dirs.dir, sub, name)))
+              if (validId(name) && !fs7.existsSync(path7.join(dirs.dir, sub, name)))
                 tasks += 1;
           }
-          merge(from, path6.join(dirs.dir, sub));
+          merge(from, path7.join(dirs.dir, sub));
         }
-        const ledger = path6.join(dirs.v2, "ledger");
-        if (fs7.existsSync(ledger) && !fs7.existsSync(path6.join(dirs.dir, "ledger")))
-          merge(ledger, path6.join(dirs.dir, "ledger"));
-        fs7.rmSync(path6.join(dirs.v2, "task-index.json"), { force: true });
-        fs7.renameSync(marker, path6.join(dirs.v2, "store.moved.json"));
+        const ledger = path7.join(dirs.v2, "ledger");
+        if (fs7.existsSync(ledger) && !fs7.existsSync(path7.join(dirs.dir, "ledger")))
+          merge(ledger, path7.join(dirs.dir, "ledger"));
+        fs7.rmSync(path7.join(dirs.v2, "task-index.json"), { force: true });
+        fs7.renameSync(marker, path7.join(dirs.v2, "store.moved.json"));
       } catch (error) {
         return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
           path: dirs.v2
@@ -20854,7 +20928,7 @@ class TaskStore {
       schemaVersion: SCHEMA_VERSION,
       id: workspaceId ?? newId(),
       revision: newRevision(),
-      root: path6.dirname(v2),
+      root: path7.dirname(v2),
       runtime: { createdWith: version, updatedWith: version },
       writer: null,
       store: {
@@ -20866,11 +20940,11 @@ class TaskStore {
       critical: ["store"]
     };
     fs7.mkdirSync(v2, { recursive: true });
-    const ignore = path6.join(v2, ".gitignore");
+    const ignore = path7.join(v2, ".gitignore");
     if (!fs7.existsSync(ignore))
       fs7.writeFileSync(ignore, `*
 `);
-    replaceFile(path6.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+    replaceFile(path7.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
 `, true);
   }
   stubFor(taskId) {
@@ -20894,8 +20968,8 @@ class TaskStore {
   }
   writeTombstoneIfMissing() {
     try {
-      const v2 = path6.join(this.root, ".workit");
-      if (fs7.existsSync(path6.join(v2, "workspace.json")))
+      const v2 = path7.join(this.root, ".workit");
+      if (fs7.existsSync(path7.join(v2, "workspace.json")))
         return;
       let id = null;
       try {
@@ -20912,7 +20986,7 @@ class TaskStore {
       replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
 `, false);
     if (!dirs.shared) {
-      const ignore = path6.join(dirs.dir, ".gitignore");
+      const ignore = path7.join(dirs.dir, ".gitignore");
       let current = null;
       try {
         current = fs7.readFileSync(ignore, "utf8");
@@ -20972,7 +21046,7 @@ class TaskStore {
   withLock(lockPath, operation) {
     try {
       this.initializeStorage();
-      fs7.mkdirSync(path6.dirname(lockPath), { recursive: true });
+      fs7.mkdirSync(path7.dirname(lockPath), { recursive: true });
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
         path: this.paths().dir
@@ -21035,7 +21109,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 ${path6.dirname(lockPath)}.`
+        guidance: `Check permissions and the read-only attribute on ${path7.dirname(lockPath)}.`
       });
     if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
       let lock = null;
@@ -21061,12 +21135,12 @@ var workerBlocksTransition = (transition, state) => transition === "pause" ? fal
 import { createHash as createHash9 } from "node:crypto";
 import * as fs12 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import fs8 from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
 var CHECKS_FILE = "workit.checks.json";
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -21119,10 +21193,10 @@ var git = (cwd, args) => {
   return value || null;
 };
 function checkRoot(cwd) {
-  return path7.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+  return path8.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
 }
 var packageManager = (root) => {
-  const has = (file) => fs8.existsSync(path7.join(root, file));
+  const has = (file) => fs8.existsSync(path8.join(root, file));
   if (has("bun.lock") || has("bun.lockb"))
     return "bun";
   if (has("pnpm-lock.yaml"))
@@ -21142,7 +21216,7 @@ var CHECK_NAME = /^[a-z0-9][a-z0-9:._-]{0,63}$/u;
 function detectedChecks(root) {
   const read = (file) => {
     try {
-      return fs8.readFileSync(path7.join(root, file), "utf8");
+      return fs8.readFileSync(path8.join(root, file), "utf8");
     } catch {
       return null;
     }
@@ -21181,7 +21255,7 @@ function detectedChecks(root) {
 var GATES = ["testing", "verification"];
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = path7.join(root, CHECKS_FILE);
+  const file = path8.join(root, CHECKS_FILE);
   const none = (error = null) => ({
     source: error ? CHECKS_FILE : "none",
     root,
@@ -21254,10 +21328,10 @@ function workitAvailable(env = process.env) {
     return workitOnPath;
   const windows = process.platform === "win32";
   const exts = windows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-  const dirs = (env.PATH ?? env.Path ?? "").split(path7.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path8.delimiter).filter(Boolean);
   workitOnPath = dirs.some((dir) => exts.some((ext) => {
     try {
-      return fs8.statSync(path7.join(dir, `workit${ext}`)).isFile();
+      return fs8.statSync(path8.join(dir, `workit${ext}`)).isFile();
     } catch {
       return false;
     }
@@ -21272,8 +21346,8 @@ function checkCommand(args, version, onPath = workitAvailable()) {
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import fs9 from "node:fs";
-import os from "node:os";
-import path8 from "node:path";
+import os2 from "node:os";
+import path9 from "node:path";
 var MAX_BUFFER = 256 * 1024 * 1024;
 var GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
 var git2 = (cwd, args, options = {}) => {
@@ -21320,9 +21394,9 @@ function worktreeTree(cwd, options = {}) {
     return null;
   const cap = options.maxUntrackedBytes ?? MAX_UNTRACKED_BYTES;
   const timeoutMs = options.timeoutMs ?? GIT_TIMEOUTS.worktree;
-  const scratch = fs9.mkdtempSync(path8.join(os.tmpdir(), "workit-tree-"));
+  const scratch = fs9.mkdtempSync(path9.join(os2.tmpdir(), "workit-tree-"));
   try {
-    const tempIndex = path8.join(scratch, "index");
+    const tempIndex = path9.join(scratch, "index");
     if (fs9.existsSync(indexPath))
       seedIndex(indexPath, tempIndex);
     const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
@@ -21335,7 +21409,7 @@ function worktreeTree(cwd, options = {}) {
     const skipped = [];
     for (const file of untracked.stdout.split("\x00").filter(Boolean)) {
       try {
-        const stat = fs9.statSync(path8.join(top, file));
+        const stat = fs9.statSync(path9.join(top, file));
         if (stat.isFile() && stat.size > cap)
           skipped.push({ path: file, size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) });
       } catch {}
@@ -21381,7 +21455,7 @@ function worktreeSignal(cwd, options = {}) {
     if (entry.length < 4)
       continue;
     const file = entry.slice(3);
-    const absolute = path8.join(top, file);
+    const absolute = path9.join(top, file);
     let stat = "-";
     try {
       const info = fs9.lstatSync(absolute, { bigint: true });
@@ -21451,17 +21525,17 @@ function pushRemoteName(cwd, branch) {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
 import { createHash as createHash8, randomBytes as randomBytes2 } from "node:crypto";
 import fs11 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 
 // packages/workit-core/src/core/vcs-config.ts
 import fs10 from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 import { spawnSync as spawnSync8 } from "node:child_process";
 
 // packages/workit-core/src/core/config.ts
@@ -21474,8 +21548,8 @@ import {
   readdirSync as readdirSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import os2 from "node:os";
-import path9 from "node:path";
+import os3 from "node:os";
+import path10 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 import { statSync as statSync2 } from "node:fs";
@@ -21534,7 +21608,7 @@ var mergePreset = (preset, input = {}, current = {
     protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
   };
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path9.join(process.env.XDG_CONFIG_HOME || path9.join(os2.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path10.join(process.env.XDG_CONFIG_HOME || path10.join(os3.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -21544,7 +21618,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path9.join(process.env.XDG_CONFIG_HOME || path9.join(os2.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os3.homedir(), ".config"), "workflow-toolkit");
   if (!existsSync3(legacy)) {
     migratedDir = dir;
     return dir;
@@ -21557,8 +21631,8 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync2(legacy, { withFileTypes: true })) {
-    const src = path9.join(legacy, entry.name);
-    const dest = path9.join(dir, entry.name);
+    const src = path10.join(legacy, entry.name);
+    const dest = path10.join(dir, entry.name);
     if (existsSync3(dest))
       continue;
     try {
@@ -21630,7 +21704,7 @@ var parseConfigResult = (raw, file) => {
   return { status: "valid", path: file, config };
 };
 var readConfigTyped = (dir) => {
-  const file = path9.join(dir ?? configDir(), "config.json");
+  const file = path10.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -21639,7 +21713,7 @@ var readConfig = () => {
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
 };
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path9.join(configDir(), "vcs.json");
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.join(configDir(), "vcs.json");
 var branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
 var resolveBranchPolicy = (config, workspace, repoPreset) => {
   const wp = workspace?.branchPolicy ?? {};
@@ -21673,7 +21747,7 @@ var COMMIT_PRESETS = [
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // packages/workit-core/src/core/branch-policy.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -21798,7 +21872,7 @@ var releaseTrackSchema = object2({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource?.kind === "package-json" && (path10.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource?.kind === "package-json" && (path11.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -21897,7 +21971,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path10.join(dir, "workspaces.json");
+  const file = path11.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -22008,9 +22082,9 @@ var mainCheckoutOf = (cwd) => {
   let main = null;
   const dirs = git(["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
   const [gitDir, common] = (dirs ?? "").trim().split(/\r?\n/u);
-  if (gitDir && common && path10.resolve(gitDir) !== path10.resolve(common)) {
+  if (gitDir && common && path11.resolve(gitDir) !== path11.resolve(common)) {
     const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
-    main = listed?.trim() || (path10.basename(common) === ".git" ? path10.dirname(common) : common);
+    main = listed?.trim() || (path11.basename(common) === ".git" ? path11.dirname(common) : common);
   }
   mainCheckouts.set(cwd, main);
   return main;
@@ -22101,7 +22175,7 @@ var runtimeWorkspaceIndexSchema = object2({
   workspaces: array(object2({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
 var matchRuntimeWorkspace = (cwd, dir = configDir()) => {
-  const file = path10.join(dir, "workspaces.json");
+  const file = path11.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -22459,7 +22533,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");
@@ -22491,7 +22565,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;
     },
@@ -22561,7 +22635,7 @@ function resolveTrackFor(cwd, options) {
 }
 
 // packages/workit-core/src/core/vcs-config.ts
-var workspacesPath = () => path11.join(configDir(), "workspaces.json");
+var workspacesPath = () => path12.join(configDir(), "workspaces.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
   const r = spawnSync8("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
@@ -22736,7 +22810,7 @@ function vcsConfig(mode, cwd, options = {}) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path11.resolve(cfgPath),
+    configPath: path12.resolve(cfgPath),
     provider,
     defaultTargetBranch: workspaceDefault,
     pr: cfg.pr ?? {},
@@ -22959,14 +23033,14 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path12.resolve(cwd));
+  const location = resolveStore(path13.resolve(cwd));
   if (location instanceof Error)
     return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
   return { ok: true, value: { root: location.dir, shared: location.shared } };
 }
 function ledgerPath(cwd) {
   const root = storeRoot(cwd);
-  return root.ok ? { ok: true, value: path12.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path13.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
@@ -22996,13 +23070,13 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs11.readFileSync(path12.join(lock, LOCK_OWNER), "utf8");
+    return fs11.readFileSync(path13.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path12.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path13.join(lock, LOCK_OWNER), lock]) {
     try {
       return Date.now() - fs11.statSync(target).mtimeMs;
     } catch {}
@@ -23019,7 +23093,7 @@ var ledgerLock = {
       throw error;
     }
     const token = `${process.pid}-${randomBytes2(8).toString("hex")}`;
-    fs11.writeFileSync(path12.join(lock, LOCK_OWNER), token);
+    fs11.writeFileSync(path13.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
@@ -23144,8 +23218,8 @@ function appendLine(file, build, options) {
     }
   };
   try {
-    fs11.mkdirSync(path12.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path12.dirname(file)))
+    fs11.mkdirSync(path13.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path13.dirname(file)))
       return write();
     const locked = withLedgerLock(file, write);
     return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
@@ -23705,7 +23779,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path13.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path14.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -23754,14 +23828,14 @@ function derivedRuleStatus(task, requirement, root, ledger) {
 
 // packages/workit-core/src/core/task-evaluation.ts
 var digestBytes = (value) => createHash9("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path14.sep}`);
-var relative = (root, candidate) => path14.relative(root, candidate).split(path14.sep).join("/") || ".";
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path15.sep}`);
+var relative = (root, candidate) => path15.relative(root, candidate).split(path15.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path14.posix.normalize(value);
+  const normalized = path15.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -23809,14 +23883,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(path14.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")) : [];
   const stagedDeleted = spawnSync10("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
       return { paths, uncertain: true, git: true };
   } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path14.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
@@ -23831,7 +23905,7 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path14.join(directory, name);
+    const target = path15.join(directory, name);
     let stat;
     try {
       stat = fs12.lstatSync(target);
@@ -23849,12 +23923,12 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path14.resolve(root, item);
+    const target = path15.resolve(root, item);
     if (!inside(root, target))
       return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
     let ancestor = target;
     while (!fs12.existsSync(ancestor) && ancestor !== root)
-      ancestor = path14.dirname(ancestor);
+      ancestor = path15.dirname(ancestor);
     try {
       if (!inside(root, fs12.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` }] });
@@ -23906,7 +23980,7 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path14.join(checkout, item);
+    const target = path15.join(checkout, item);
     try {
       const stat = fs12.lstatSync(target);
       if (stat.isSymbolicLink()) {
@@ -24090,23 +24164,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path14.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path14.sep}`))
+    const target = path15.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path15.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const below = path14.relative(root, target);
+      const below = path15.relative(root, target);
       let current = root;
-      for (const segment of below.split(path14.sep)) {
+      for (const segment of below.split(path15.sep)) {
         if (!segment)
           continue;
-        current = path14.join(current, segment);
+        current = path15.join(current, segment);
         const stat = fs12.lstatSync(current);
         const real = fs12.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path14.sep}`))
+        if (real !== root && !real.startsWith(`${root}${path15.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -24931,20 +25005,20 @@ var judgeInputSummary = (raw) => {
 };
 
 // packages/workit-core/src/autonomy.ts
-import os3 from "node:os";
-import path15 from "node:path";
+import os4 from "node:os";
+import path16 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 = () => path15.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path16.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path15.resolve(resolveConfigDir());
-  return configured === path15.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path15.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  const configured = path16.resolve(resolveConfigDir());
+  return configured === path16.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path16.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -26716,7 +26790,7 @@ class WorkitCore {
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -26850,7 +26924,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path16.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path17.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -26881,7 +26955,7 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path16.join(cwd, "package.json");
+  const pkgPath = path17.join(cwd, "package.json");
   if (!existsSync6(pkgPath))
     return [];
   try {
@@ -26907,9 +26981,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path16.join(dir, entry.name), depth + 1);
+        walk(path17.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path16.relative(cwd, path16.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path17.relative(cwd, path17.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -26925,7 +26999,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path16.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -26983,7 +27057,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed2(path16.join(cwd, template), 220);
+    stdout += readTrimmed2(path17.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -26993,7 +27067,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync6(path16.join(cwd, "package.json"))) {
+  if (existsSync6(path17.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -27002,7 +27076,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync6(path16.join(cwd, "Cargo.toml")) || existsSync6(path16.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync6(path17.join(cwd, "Cargo.toml")) || existsSync6(path17.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -27035,7 +27109,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 = path16.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -27053,7 +27127,7 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path16.join(cwd, "CHANGELOG.md");
+  const changelogPath = path17.join(cwd, "CHANGELOG.md");
   if (existsSync6(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
@@ -27073,7 +27147,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path16.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -27095,7 +27169,7 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path16.join(cwd, "README.md");
+  const readme = path17.join(cwd, "README.md");
   if (existsSync6(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
@@ -27104,7 +27178,7 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path16.join(cwd, "package.json");
+  const pkgPath = path17.join(cwd, "package.json");
   if (existsSync6(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
@@ -27118,7 +27192,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path16.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -27156,7 +27230,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync6(path16.join(cwd, rel)))
+    if (existsSync6(path17.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -27188,7 +27262,7 @@ import { spawnSync as spawnSync13 } from "node:child_process";
 
 // packages/workit-core/src/core/pr-create.ts
 import fs13 from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 import { spawnSync as spawnSync12 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
@@ -27199,11 +27273,11 @@ 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(path17.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path18.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path17.join(dir, name);
+      const candidate = path18.join(dir, name);
       try {
         fs13.accessSync(candidate, fs13.constants.X_OK);
         return candidate;
@@ -27324,7 +27398,7 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 
 // packages/workit-core/src/core/youtrack.ts
 import fs14 from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -27337,8 +27411,8 @@ 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 ?? path18.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path18.join(resolveConfigDir(), "youtrack.json");
+var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path19.join(configDir(), "youtrack.json");
+var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path19.join(resolveConfigDir(), "youtrack.json");
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
@@ -27406,7 +27480,7 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path18.isAbsolute(tokenFile) ? path18.resolve(tokenFile) : path18.resolve(process.cwd(), tokenFile) : "";
+  const tokenPath = tokenFile ? path19.isAbsolute(tokenFile) ? path19.resolve(tokenFile) : path19.resolve(process.cwd(), tokenFile) : "";
   if (!tokenPath || !fs14.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
@@ -27748,15 +27822,15 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path19.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path19.sep)) {
+  const target = path20.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path20.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync7(ancestor))
-    ancestor = path19.dirname(ancestor);
+    ancestor = path20.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path19.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path20.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -27776,80 +27850,6 @@ function run2(root, executable, args, env = {}) {
   };
 }
 
-// packages/workit-core/src/core/logger.ts
-import os4 from "node:os";
-import path20 from "node:path";
-var REDACTED = "[REDACTED]";
-var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
-var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
-var URL_QUERY = /(https?:\/\/[^?#\s]+)\?[^#\s]*/g;
-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 escapeRegExp2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var resolveStateDir = () => {
-  const override = process.env.WORKFLOW_TOOLKIT_STATE;
-  if (override)
-    return override;
-  const home = os4.homedir();
-  if (process.env.XDG_STATE_HOME)
-    return path20.join(process.env.XDG_STATE_HOME, "workit");
-  switch (os4.platform()) {
-    case "darwin":
-      return path20.join(home, "Library", "Application Support", "workit");
-    case "win32":
-      return path20.join(process.env.LOCALAPPDATA ?? path20.join(home, "AppData", "Local"), "workit");
-    default:
-      return path20.join(process.env.HOME ?? home, ".local", "state", "workit");
-  }
-};
-var homePattern = new RegExp(`${escapeRegExp2(os4.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
-var applyPatterns = (value) => {
-  let out = value;
-  out = out.replace(SECRET_VALUE, REDACTED);
-  out = out.replace(KEY_EQ_VALUE, "$1$2[REDACTED]");
-  out = out.replace(URL_QUERY, "$1?[REDACTED]");
-  out = out.replace(homePattern, "~");
-  if (process.platform === "win32")
-    out = out.replace(/\\/g, "/");
-  return out;
-};
-var redactSecrets = (value) => applyPatterns(value);
-
 // packages/workit-mcp/src/server.ts
 class McpCapabilityUnavailableError extends Error {
   capability;