@brainervirus/workit-cursor 0.9.0 → 0.10.0

package/dist/mcp-server.js

@@ -20376,7 +20376,7 @@ var init_config = __esm(() => {
     "trunk-based": { allowed: ["*"], protected: ["main"] },
     custom: { allowed: [], protected: [] }
   };
-  LOCALE_RE = /^[a-z]{2,3}(-[A-Z]{2})?$/;
+  LOCALE_RE = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
   DEFAULTS = {
     locale: "en",
     localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
@@ -20630,15 +20630,28 @@ var run = (cwd, args) => {
 var init_git = () => {};
 
 // packages/workit-core/src/core/branch.ts
-import { readFileSync as readFileSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  copyFileSync as copyFileSync2,
+  cpSync as cpSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync3,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
 import path4 from "node:path";
 var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot)), policy = (root) => resolveBranchPolicyFor(root), allowedBranch = (root, name) => policy(root).allowed.some((r) => r.test(name)), isProtected = (root, name) => policy(root).protected.has(name.toLowerCase()), baseBranch = (cwd) => {
   const resolved = vcsConfig("resolve", cwd);
   if (resolved.ok === false)
     return { error: String(resolved.error) };
   return { base: String(resolved.defaultTargetBranch ?? "develop") };
-}, DECLARE_RE, USE_CURRENT_RE, readSafe2 = (p) => {
+}, DECLARE_RE, USE_CURRENT_RE, toPosix = (p) => p.split(path4.sep).join("/"), readSafe2 = (p) => {
   try {
     return readFileSync3(p, "utf8");
   } catch {
@@ -20767,10 +20780,7 @@ var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig()
     };
   }
   return { error: `cannot resolve docs branch from HEAD ${JSON.stringify(current)}` };
-}, ensureBaseBranch = (cwd, base) => {
-  const git = gitContext(cwd);
-  if (!git.branch || git.branch === "unknown")
-    return { ok: false, error: "not in a git repository" };
+}, originBaseReady = (cwd, base) => {
   const run2 = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   try {
     try {
@@ -20778,20 +20788,27 @@ var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig()
     } catch {
       run2(["fetch", "origin", "--prune"]);
     }
-    let hasOriginBase = true;
     try {
       execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
         cwd,
         stdio: "pipe"
       });
     } catch {
-      hasOriginBase = false;
-    }
-    if (!hasOriginBase)
       return {
         ok: false,
         error: `origin/${base} missing — push ${base} before creating feature/* or bugfix/* branches`
       };
+    }
+    return { ok: true };
+  } catch (error2) {
+    return {
+      ok: false,
+      error: error2 instanceof Error ? error2.message : "ensure-base-branch failed"
+    };
+  }
+}, fastForwardBase = (cwd, base) => {
+  const run2 = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  try {
     let hasLocalBase = true;
     try {
       execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
@@ -20816,12 +20833,91 @@ var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig()
       error: error2 instanceof Error ? error2.message : "ensure-base-branch failed"
     };
   }
+}, ensureBaseBranch = (cwd, base) => {
+  const git = gitContext(cwd);
+  if (!git.branch || git.branch === "unknown")
+    return { ok: false, error: "not in a git repository" };
+  const ready = originBaseReady(cwd, base);
+  if (!ready.ok)
+    return ready;
+  return fastForwardBase(cwd, base);
+}, purgeStaleFlowGuardRoots = (now) => {
+  const cutoff = now - 24 * 3600000;
+  let entries;
+  try {
+    entries = readdirSync3(tmpdir());
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("workit-flow-guard-"))
+      continue;
+    try {
+      if (statSync(path4.join(tmpdir(), entry)).mtimeMs < cutoff)
+        rmSync(path4.join(tmpdir(), entry), { recursive: true, force: true });
+    } catch {}
+  }
+}, snapshotFlowState = (cwd) => {
+  purgeStaleFlowGuardRoots(Date.now());
+  const root = path4.join(tmpdir(), `workit-flow-guard-${createHash("sha256").update(path4.resolve(cwd)).digest("hex").slice(0, 16)}.${process.pid}.${process.hrtime.bigint()}`);
+  mkdirSync3(root, { recursive: true });
+  const docsDir = path4.join(path4.resolve(cwd), "docs");
+  let slugs = [];
+  try {
+    slugs = readdirSync3(docsDir);
+  } catch {
+    return root;
+  }
+  for (const slug of slugs) {
+    for (const rel of [["sdd", "flow.json"], ["spec.md"], ["plan.md"]]) {
+      const src = path4.join(docsDir, slug, ...rel);
+      try {
+        if (!statSync(src).isFile())
+          continue;
+      } catch {
+        continue;
+      }
+      const dest = path4.join(root, "docs", slug, ...rel);
+      mkdirSync3(path4.dirname(dest), { recursive: true });
+      cpSync2(src, dest);
+    }
+  }
+  return root;
+}, restoreFlowSnapshot = (snapDir, cwd) => {
+  const walk = (dir, rel) => readdirSync3(dir, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? walk(path4.join(dir, entry.name), path4.join(rel, entry.name)) : [path4.join(rel, entry.name)]);
+  const restored = [];
+  try {
+    const workspace = path4.resolve(cwd);
+    for (const rel of walk(snapDir, "")) {
+      const dest = path4.join(workspace, rel);
+      if (existsSync2(dest))
+        continue;
+      mkdirSync3(path4.dirname(dest), { recursive: true });
+      const tmpDest = `${dest}.tmp-${process.pid}`;
+      try {
+        copyFileSync2(path4.join(snapDir, rel), tmpDest);
+        renameSync(tmpDest, dest);
+      } catch (error2) {
+        rmSync(tmpDest, { force: true });
+        throw error2;
+      }
+      restored.push(toPosix(rel));
+    }
+    rmSync(snapDir, { recursive: true, force: true });
+    return { restored };
+  } catch (error2) {
+    return {
+      restored,
+      warning: `flow state snapshot restore failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  }
 }, branchSetup = ({
   action,
   sdd_dir,
   target_branch,
   stash,
-  workspace_root
+  workspace_root,
+  log
 }) => {
   const cwd = path4.resolve(workspace_root);
   const exec = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
@@ -20840,20 +20936,74 @@ var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig()
   };
   const writeManifest = (data) => writeFileSync2(manifestPath, JSON.stringify(data, null, 2) + `
 `, "utf8");
+  let snapDir = null;
+  const journal = (message) => log?.(`flow-guard: ${message}`);
+  const snapshotRelPaths = () => {
+    const dir = snapDir;
+    if (!dir)
+      return [];
+    try {
+      const walk = (from, rel) => readdirSync3(from, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? walk(path4.join(from, entry.name), path4.join(rel, entry.name)) : [path4.join(rel, entry.name)]);
+      return walk(dir, "").map(toPosix);
+    } catch {
+      return [];
+    }
+  };
+  const journalSnapshot = () => {
+    const dir = snapDir;
+    if (!dir || !log)
+      return;
+    const rels = snapshotRelPaths();
+    journal(`snapshot: ${rels.length} file(s)`);
+    for (const rel of rels) {
+      let shortHash = "";
+      try {
+        shortHash = createHash("sha256").update(readFileSync3(path4.join(dir, rel))).digest("hex").slice(0, 8);
+      } catch {}
+      journal(`snapshot: ${rel} sha=${shortHash}`);
+    }
+  };
+  const journalPresence = (phase) => {
+    for (const rel of snapshotRelPaths()) {
+      journal(`${phase}: ${rel} ${existsSync2(path4.join(cwd, rel)) ? "present" : "MISSING"}`);
+    }
+  };
+  const restoreWithWarning = (dir) => {
+    if (!dir)
+      return { restored: [], warnings: [] };
+    const total = log ? snapshotRelPaths().length : 0;
+    const { restored, warning } = restoreFlowSnapshot(dir, cwd);
+    if (log)
+      journal(`restore: restored=${restored.length} skipped=${total - restored.length}${warning ? ` warning: ${warning}` : ""}`);
+    else if (warning)
+      journal(`restore warning: ${warning}`);
+    return { restored, warnings: warning ? [warning] : [] };
+  };
   if (action === "reapply_stash") {
-    const manifest2 = readManifest();
-    const ref = manifest2.stash_ref;
+    const manifest = readManifest();
+    const ref = manifest.stash_ref;
     if (!ref)
       return { error: "no stash_ref in manifest" };
+    snapDir = snapshotFlowState(cwd);
+    journalSnapshot();
+    journal(`pre-pop: ${String(ref)}`);
     try {
       exec(["stash", "pop", String(ref)]);
     } catch (error2) {
-      return { error: error2 instanceof Error ? error2.message : "stash pop failed" };
+      journal("pop: failed");
+      const {
+        warnings: [warning]
+      } = restoreWithWarning(snapDir);
+      return {
+        error: `${error2 instanceof Error ? error2.message : "stash pop failed"}${warning ? `; ${warning}` : ""}`
+      };
     }
-    delete manifest2.stash_ref;
-    delete manifest2.stash_created_at;
-    writeManifest(manifest2);
-    return { action: "reapply_stash", ok: true };
+    journal("pop: ok");
+    delete manifest.stash_ref;
+    delete manifest.stash_created_at;
+    writeManifest(manifest);
+    const { warnings: warnings2 } = restoreWithWarning(snapDir);
+    return { action: "reapply_stash", ok: true, ...warnings2.length > 0 ? { warnings: warnings2 } : {} };
   }
   const target = target_branch ?? "";
   if (!target)
@@ -20862,61 +21012,141 @@ var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig()
     return { error: `protected branch ${target}` };
   if (!allowedBranch(cwd, target))
     return { error: `target branch ${target} is not allowed by the branch policy` };
+  let base;
+  let targetExists = true;
+  try {
+    exec(["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]);
+  } catch {
+    targetExists = false;
+  }
+  if (!targetExists) {
+    const baseResolved = baseBranch(cwd);
+    if ("error" in baseResolved)
+      return { error: baseResolved.error };
+    base = baseResolved.base;
+  }
+  journal(`entry: current=${current} target=${target} base=${base ?? "-"}`);
   let stash_ref;
+  const failAfterStash = (message) => {
+    let suffix = "";
+    if (stash_ref) {
+      journal(`pre-pop: ${stash_ref}`);
+      try {
+        exec(["stash", "pop", stash_ref]);
+        stash_ref = undefined;
+        journal("pop: ok");
+      } catch {
+        journal("pop: failed");
+        suffix = " (changes preserved in stash)";
+      }
+    }
+    const {
+      warnings: [warning]
+    } = restoreWithWarning(snapDir);
+    return { error: `${message}${suffix}${warning ? `; ${warning}` : ""}` };
+  };
   if (current !== target) {
     const dirty = Boolean(gitContext(cwd).status_short.trim());
+    if (dirty && stash !== "yes") {
+      return {
+        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes"
+      };
+    }
+    let validatedBase;
+    if (!targetExists && base !== undefined) {
+      const ready = originBaseReady(cwd, base);
+      if (!ready.ok)
+        return { error: ready.error ?? "ensure-base-branch failed" };
+      validatedBase = base;
+    }
     if (dirty) {
-      if (stash !== "yes") {
-        return {
-          error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes"
-        };
-      }
       try {
+        snapDir = snapshotFlowState(cwd);
+        journalSnapshot();
         exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`, "--", ":!docs/*/sdd"]);
       } catch (error2) {
         return { error: error2 instanceof Error ? error2.message : "stash push failed" };
       }
       stash_ref = "stash@{0}";
+      journal(`stash push: ${stash_ref}`);
     }
     try {
       exec(["checkout", target]);
+      journalPresence("post-checkout");
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : "checkout failed";
       if (/worktree/i.test(message)) {
-        return {
-          error: `branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`
-        };
+        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`);
       }
       try {
-        const baseResolved = baseBranch(cwd);
-        if ("error" in baseResolved)
-          return { error: baseResolved.error };
-        const baseResult = ensureBaseBranch(cwd, baseResolved.base);
+        let effectiveBase = base;
+        if (effectiveBase === undefined) {
+          const lateResolved = baseBranch(cwd);
+          if ("error" in lateResolved)
+            return failAfterStash(lateResolved.error);
+          effectiveBase = lateResolved.base;
+        }
+        const baseResult = validatedBase !== undefined ? fastForwardBase(cwd, effectiveBase) : ensureBaseBranch(cwd, effectiveBase);
         if (!baseResult.ok)
-          return { error: baseResult.error };
+          return failAfterStash(baseResult.error ?? "ensure-base-branch failed");
         exec(["checkout", "-b", target]);
+        journalPresence("post-create");
       } catch (createError) {
-        return {
-          error: createError instanceof Error ? createError.message : "branch create failed"
-        };
+        return failAfterStash(createError instanceof Error ? createError.message : "branch create failed");
       }
     }
   }
-  const manifest = readManifest();
-  manifest.branch = target;
-  manifest.previous_branch = current;
-  if (stash_ref) {
-    manifest.stash_ref = stash_ref;
-    manifest.stash_created_at = new Date().toISOString();
+  try {
+    const manifest = readManifest();
+    manifest.branch = target;
+    manifest.previous_branch = current;
+    if (stash_ref) {
+      manifest.stash_ref = stash_ref;
+      manifest.stash_created_at = new Date().toISOString();
+    }
+    writeManifest(manifest);
+  } catch (error2) {
+    const result = failAfterStash(error2 instanceof Error ? `manifest update failed: ${error2.message}` : "manifest update failed");
+    if (stash_ref === undefined && gitContext(cwd).branch !== current) {
+      try {
+        exec(["checkout", current]);
+      } catch {}
+    }
+    return result;
+  }
+  const { restored: restoredRels, warnings } = restoreWithWarning(snapDir);
+  if (stash_ref && snapDir && warnings.length === 0) {
+    const covered = new Set(restoredRels.map(toPosix));
+    try {
+      const stashed = exec([
+        "stash",
+        "show",
+        "--include-untracked",
+        "--name-only",
+        String(stash_ref)
+      ]).split(`
+`).map((line) => toPosix(line.trim())).filter(Boolean);
+      if (stashed.length > 0 && stashed.every((p) => covered.has(p))) {
+        exec(["stash", "drop", String(stash_ref)]);
+        stash_ref = undefined;
+        journal("dropped redundant stash (fully covered by snapshot restore)");
+        const manifest = readManifest();
+        delete manifest.stash_ref;
+        delete manifest.stash_created_at;
+        writeManifest(manifest);
+      } else {
+        journal(`kept stash ref ${stash_ref} (not fully covered by actual restores)`);
+      }
+    } catch {}
   }
-  writeManifest(manifest);
   return {
     action: "setup",
     ok: true,
     branch: target,
     previous_branch: current,
     stash_ref: stash_ref ?? null,
-    manifest: manifestPath
+    manifest: manifestPath,
+    ...warnings.length > 0 ? { warnings } : {}
   };
 };
 var init_branch = __esm(() => {
@@ -21232,7 +21462,7 @@ var init_vcs_config = __esm(() => {
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "node:fs";
 import path6 from "node:path";
 function resolvePrBranchContext(cwd) {
   const branch = currentBranch(cwd);
@@ -21350,7 +21580,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync2(path6.join(cwd, "package.json"))) {
+  if (existsSync3(path6.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -21359,7 +21589,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync2(path6.join(cwd, "Cargo.toml")) || existsSync2(path6.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync3(path6.join(cwd, "Cargo.toml")) || existsSync3(path6.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -21400,7 +21630,7 @@ function changelogContext(root, range) {
 `;
   stdout += printSection("Existing CHANGELOG.md");
   const changelogPath = path6.join(cwd, "CHANGELOG.md");
-  if (existsSync2(changelogPath)) {
+  if (existsSync3(changelogPath)) {
     stdout += readTrimmed(changelogPath, 260) + `
 `;
   } else {
@@ -21438,7 +21668,7 @@ function docsRefreshContext(root, range) {
 `;
   stdout += printSection("README Preview");
   const readme = path6.join(cwd, "README.md");
-  if (existsSync2(readme)) {
+  if (existsSync3(readme)) {
     stdout += readTrimmed(readme, 220) + `
 `;
   } else {
@@ -21447,7 +21677,7 @@ function docsRefreshContext(root, range) {
   }
   stdout += printSection("Package Scripts");
   const pkgPath = path6.join(cwd, "package.json");
-  if (existsSync2(pkgPath)) {
+  if (existsSync3(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
@@ -21494,7 +21724,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync2(path6.join(cwd, rel)))
+    if (existsSync3(path6.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -21531,7 +21761,7 @@ var runGit = (cwd, args) => {
 
 `, probeCaseInsensitive = (dir, wanted) => {
   try {
-    for (const entry of readdirSync3(dir)) {
+    for (const entry of readdirSync4(dir)) {
       if (entry.toLowerCase() === wanted.toLowerCase())
         return entry;
     }
@@ -21577,7 +21807,7 @@ var runGit = (cwd, args) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 }, packageScripts = (cwd, keys) => {
   const pkgPath = path6.join(cwd, "package.json");
-  if (!existsSync2(pkgPath))
+  if (!existsSync3(pkgPath))
     return [];
   try {
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
@@ -21593,7 +21823,7 @@ var runGit = (cwd, args) => {
       return;
     let entries;
     try {
-      entries = readdirSync3(dir, { withFileTypes: true });
+      entries = readdirSync4(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -21610,7 +21840,7 @@ var runGit = (cwd, args) => {
   walk(cwd, 1);
   return matches.sort().slice(0, 200);
 }, readTrimmed = (file, maxLines) => {
-  if (!existsSync2(file))
+  if (!existsSync3(file))
     return "";
   const lines = readFileSync4(file, "utf8").split(`
 `);
@@ -21629,7 +21859,7 @@ var init_repo_context = __esm(() => {
 
 // packages/workit-core/src/core/verify-project.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync5, statSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
 import path7 from "node:path";
 function runVerifyProject(root, dryRun = false) {
   const cwd = repoRoot(root);
@@ -21688,7 +21918,7 @@ root: ${cwd}
   lines.push(`dry_run: ${String(dryRun)}
 `);
   const pkgPath = path7.join(cwd, "package.json");
-  if (existsSync3(pkgPath)) {
+  if (existsSync4(pkgPath)) {
     const runner = packageRunner(cwd);
     for (const script of ["lint", "format:check", "test", "build"]) {
       if (hasScript(cwd, script)) {
@@ -21703,7 +21933,7 @@ root: ${cwd}
   } else {
     skipCheck("javascript", "package.json not found");
   }
-  const cargoManifest = existsSync3(path7.join(cwd, "Cargo.toml")) ? "Cargo.toml" : existsSync3(path7.join(cwd, "src-tauri/Cargo.toml")) ? "src-tauri/Cargo.toml" : "";
+  const cargoManifest = existsSync4(path7.join(cwd, "Cargo.toml")) ? "Cargo.toml" : existsSync4(path7.join(cwd, "src-tauri/Cargo.toml")) ? "src-tauri/Cargo.toml" : "";
   if (cargoManifest) {
     runCheck("cargo fmt", "cargo", ["fmt", "--manifest-path", cargoManifest, "--", "--check"]);
     runCheck("cargo clippy", "cargo", [
@@ -21719,7 +21949,7 @@ root: ${cwd}
   } else {
     skipCheck("rust", "Cargo.toml not found");
   }
-  if (existsSync3(path7.join(cwd, "pyproject.toml")) || existsSync3(path7.join(cwd, "pytest.ini")) || existsSync3(path7.join(cwd, "tests"))) {
+  if (existsSync4(path7.join(cwd, "pyproject.toml")) || existsSync4(path7.join(cwd, "pytest.ini")) || existsSync4(path7.join(cwd, "tests"))) {
     if (commandOnPath("pytest"))
       runCheck("pytest", "pytest", []);
     else
@@ -21741,7 +21971,7 @@ root: ${cwd}
     lines.push(`status: skipped (dry run)
 `);
     skipped += 1;
-  } else if (existsSync3(changelogPath)) {
+  } else if (existsSync4(changelogPath)) {
     if (/## \[Unreleased\]/i.test(readFileSync5(changelogPath, "utf8"))) {
       lines.push(`status: pass
 `);
@@ -21783,9 +22013,9 @@ var commandOnPath = (name) => {
     for (const candidateName of names) {
       const candidate = path7.join(dir, candidateName);
       try {
-        statSync(candidate);
+        statSync2(candidate);
         if (process.platform !== "win32") {
-          const mode = statSync(candidate).mode & 73;
+          const mode = statSync2(candidate).mode & 73;
           if (mode === 0)
             continue;
         }
@@ -21796,7 +22026,7 @@ var commandOnPath = (name) => {
   return false;
 }, hasScript = (cwd, name) => {
   const pkgPath = path7.join(cwd, "package.json");
-  if (!existsSync3(pkgPath))
+  if (!existsSync4(pkgPath))
     return false;
   try {
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
@@ -21805,10 +22035,10 @@ var commandOnPath = (name) => {
     return false;
   }
 }, packageRunner = (cwd) => {
-  if (existsSync3(path7.join(cwd, "pnpm-lock.yaml")))
+  if (existsSync4(path7.join(cwd, "pnpm-lock.yaml")))
     return "pnpm";
   const pkgPath = path7.join(cwd, "package.json");
-  if (existsSync3(pkgPath)) {
+  if (existsSync4(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
       if (typeof pkg.packageManager === "string" && pkg.packageManager.startsWith("pnpm")) {
@@ -21816,7 +22046,7 @@ var commandOnPath = (name) => {
       }
     } catch {}
   }
-  if (existsSync3(path7.join(cwd, "yarn.lock")))
+  if (existsSync4(path7.join(cwd, "yarn.lock")))
     return "yarn";
   return "npm";
 };
@@ -21836,21 +22066,21 @@ var init_support_matrix = __esm(() => {
 });
 
 // packages/workit-core/src/core/package-root.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import path8 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
   let dir = path8.dirname(fileURLToPath(import.meta.url));
   while (true) {
     const parent = path8.dirname(dir);
-    if (existsSync4(path8.join(dir, "package.json")) || parent === dir)
+    if (existsSync5(path8.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
 }, assetRoot = () => {
   const root = packageRoot();
   const assets = path8.join(root, "assets");
-  return existsSync4(assets) ? assets : root;
+  return existsSync5(assets) ? assets : root;
 };
 var init_package_root = () => {};
 
@@ -21883,9 +22113,9 @@ var named = (s, name) => s === name || s.startsWith(`${name}@`), CURSOR_RUNTIME_
 var init_registration = () => {};
 
 // packages/workit-core/src/core/skill-manifests.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
 import path9 from "node:path";
-var CANONICAL_SKILLS, skillManifestNames = (root) => existsSync5(root) ? readdirSync4(root).filter((name) => existsSync5(path9.join(root, name, "SKILL.md"))).sort() : [], validateSkillManifests = (root, expected, label) => {
+var CANONICAL_SKILLS, skillManifestNames = (root) => existsSync6(root) ? readdirSync5(root).filter((name) => existsSync6(path9.join(root, name, "SKILL.md"))).sort() : [], validateSkillManifests = (root, expected, label) => {
   const actual = skillManifestNames(root);
   const missing = expected.filter((name) => !actual.includes(name));
   const extra = actual.filter((name) => !expected.includes(name));
@@ -21901,11 +22131,11 @@ var CANONICAL_SKILLS, skillManifestNames = (root) => existsSync5(root) ? readdir
   const pending = [vendor];
   while (pending.length > 0) {
     const dir = pending.pop();
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
       const file = path9.join(dir, entry.name);
       if (entry.isDirectory())
         pending.push(file);
-      else if ((statSync2(file).mode & 73) !== 0 || readFileSync6(file).subarray(0, 2).toString("latin1") === "#!") {
+      else if ((statSync3(file).mode & 73) !== 0 || readFileSync6(file).subarray(0, 2).toString("latin1") === "#!") {
         return `Cursor vendor contains active file: ${file}`;
       }
     }
@@ -21950,13 +22180,13 @@ var init_skill_manifests = __esm(() => {
 
 // packages/workit-core/src/core/doctor.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import os3 from "node:os";
 import path10 from "node:path";
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   let dir = path10.resolve(cwd);
   while (true) {
-    if (existsSync6(path10.join(dir, "packages", "workit-core", "package.json")))
+    if (existsSync7(path10.join(dir, "packages", "workit-core", "package.json")))
       return dir;
     const parent = path10.dirname(dir);
     if (parent === dir)
@@ -22010,7 +22240,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     for (const candidateName of names) {
       const candidate = path10.join(dir, candidateName);
       try {
-        const st = statSync3(candidate);
+        const st = statSync4(candidate);
         if (process.platform !== "win32" && (st.mode & 73) === 0)
           continue;
         return true;
@@ -22034,14 +22264,14 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
   return true;
 }, resolveBun = (env) => {
-  if (env.BUN && existsSync6(env.BUN))
+  if (env.BUN && existsSync7(env.BUN))
     return env.BUN;
   for (const candidate of [
     path10.join(os3.homedir(), ".bun/bin/bun"),
     "/usr/local/bin/bun",
     "/usr/bin/bun"
   ]) {
-    if (existsSync6(candidate))
+    if (existsSync7(candidate))
       return candidate;
   }
   return commandOnPath2("bun", env) ? "bun" : null;
@@ -22155,7 +22385,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
 }, hostsFor = (host) => host === "cli" ? ["opencode", "cursor", "cli"] : [host], checkAssets = (res) => {
   const dev = res.dev;
-  const missing = dev ? hostsFor(res.host).flatMap((h) => assetPathsFor(h, dev).filter((p) => !existsSync6(p)).map((p) => `${h}: ${p}`)) : [];
+  const missing = dev ? hostsFor(res.host).flatMap((h) => assetPathsFor(h, dev).filter((p) => !existsSync7(p)).map((p) => `${h}: ${p}`)) : [];
   if (res.host === "cursor" || res.host === "cli") {
     const cursorError = validateCursorSkills(res.cursorPluginDir);
     if (cursorError)
@@ -22196,7 +22426,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
 }, validNodeEntry = (entry, runtime, env) => {
   try {
-    const stat = statSync3(entry);
+    const stat = statSync4(entry);
     if (!stat.isFile() || stat.size === 0 || !readFileSync7(entry, "utf8").startsWith(`#!/usr/bin/env node
 `)) {
       return false;
@@ -22206,7 +22436,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return false;
   }
 }, registeredCursorLauncher = (res) => {
-  if (!existsSync6(res.cursorMcp))
+  if (!existsSync7(res.cursorMcp))
     return "invalid";
   const config2 = readJson(res.cursorMcp);
   if (!config2)
@@ -22235,7 +22465,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   };
 }, canonicalCursorHook, registeredCursorHook = (res) => {
   const hooksFile = path10.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
-  if (!existsSync6(hooksFile))
+  if (!existsSync7(hooksFile))
     return "invalid";
   const config2 = readJson(hooksFile);
   if (!config2)
@@ -22278,7 +22508,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     }
   }
   if (dev) {
-    missing.push(...hosts.filter((h) => h !== "cursor").flatMap((h) => launcherSlotsFor(h, dev).filter((slot) => !slot.some((p) => existsSync6(p))).map((slot) => `${h}: ${slot.join(" or ")}`)));
+    missing.push(...hosts.filter((h) => h !== "cursor").flatMap((h) => launcherSlotsFor(h, dev).filter((slot) => !slot.some((p) => existsSync7(p))).map((slot) => `${h}: ${slot.join(" or ")}`)));
   }
   if (missing.length > 0) {
     return {
@@ -22330,7 +22560,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return "stale";
   if (entry.startsWith("file:")) {
     const target = entry.replace(/^file:\/\//, "").replace(/^file:/, "");
-    return existsSync6(target) ? "ok" : "missing-file";
+    return existsSync7(target) ? "ok" : "missing-file";
   }
   return "ok";
 }, checkStalePin = (res) => {
@@ -22341,7 +22571,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       detail: "opencode pin not inspected on the cursor host"
     };
   }
-  if (!existsSync6(res.opencodeConfig)) {
+  if (!existsSync7(res.opencodeConfig)) {
     return {
       id: "stale_pin",
       status: "pass",
@@ -22378,7 +22608,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   return { id: "stale_pin", status: "pass", detail: "opencode pin resolves" };
 }, pluginMcpSelectors = (res) => {
   const p = path10.join(res.cursorPluginDir, "mcp.json");
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return null;
   const cfg = readJson(p);
   const server = cfg?.mcpServers?.workit;
@@ -22488,13 +22718,13 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const problems = [];
   const opencodeHost = res.host !== "cursor";
   const cursorHost = res.host !== "opencode";
-  if (opencodeHost && existsSync6(res.opencodeConfig)) {
+  if (opencodeHost && existsSync7(res.opencodeConfig)) {
     const cfg = readJson(res.opencodeConfig);
     const entries = pluginEntries(cfg);
     if (entries.length > 1)
       problems.push(`opencode registers ${entries.length} workit plugin entries`);
   }
-  if (cursorHost && existsSync6(res.cursorSettings)) {
+  if (cursorHost && existsSync7(res.cursorSettings)) {
     const settings = readJson(res.cursorSettings);
     const enabled = settings?.enabled_plugins;
     if (enabled && typeof enabled === "object") {
@@ -22509,7 +22739,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     if (dirs.length > 1)
       problems.push(`cursor plugin_dirs has ${dirs.length} workit entries`);
   }
-  if (cursorHost && existsSync6(res.cursorMcp)) {
+  if (cursorHost && existsSync7(res.cursorMcp)) {
     const mcp = readJson(res.cursorMcp);
     const servers = mcp?.mcpServers ?? {};
     if (servers && typeof servers === "object") {
@@ -22535,16 +22765,16 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const files = [];
   for (const name of ["config.json", "youtrack.json", "vcs.json", "workspaces.json"]) {
     const p = path10.join(res.configDir, name);
-    if (existsSync6(p))
+    if (existsSync7(p))
       files.push(p);
   }
   const opencodeHost = res.host !== "cursor";
   const cursorHost = res.host !== "opencode";
-  if (opencodeHost && existsSync6(res.opencodeConfig))
+  if (opencodeHost && existsSync7(res.opencodeConfig))
     files.push(res.opencodeConfig);
-  if (cursorHost && existsSync6(res.cursorSettings))
+  if (cursorHost && existsSync7(res.cursorSettings))
     files.push(res.cursorSettings);
-  if (cursorHost && existsSync6(res.cursorMcp))
+  if (cursorHost && existsSync7(res.cursorMcp))
     files.push(res.cursorMcp);
   const bad = files.filter((p) => !parsesAsConfigObject(p));
   if (bad.length === 0)
@@ -22561,7 +22791,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   };
 }, checkWorkspaceMismatch = (res) => {
   const file = path10.join(res.configDir, "workspaces.json");
-  if (!existsSync6(file))
+  if (!existsSync7(file))
     return {
       id: "workspace_mismatch",
       status: "pass",
@@ -22599,7 +22829,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const youtrackJson = readJson(path10.join(res.configDir, "youtrack.json"));
   if (youtrackJson) {
     tokenPaths.push(typeof youtrackJson.tokenFile === "string" ? youtrackJson.tokenFile : path10.join(res.configDir, "youtrack.token"));
-  } else if (existsSync6(path10.join(res.configDir, "youtrack.token"))) {
+  } else if (existsSync7(path10.join(res.configDir, "youtrack.token"))) {
     tokenPaths.push(path10.join(res.configDir, "youtrack.token"));
   }
   const vcsJson = readJson(path10.join(res.configDir, "vcs.json"));
@@ -22608,7 +22838,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     if (provider && typeof provider === "object") {
       const tf = provider.tokenFile;
       tokenPaths.push(typeof tf === "string" ? tf : path10.join(res.configDir, `${key}.token`));
-    } else if (!vcsJson && existsSync6(path10.join(res.configDir, `${key}.token`))) {
+    } else if (!vcsJson && existsSync7(path10.join(res.configDir, `${key}.token`))) {
       tokenPaths.push(path10.join(res.configDir, `${key}.token`));
     }
   }
@@ -22622,12 +22852,12 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const problems = [];
   for (const raw of tokenPaths) {
     const p = path10.isAbsolute(raw) ? raw : path10.resolve(res.configDir, raw);
-    if (!existsSync6(p)) {
+    if (!existsSync7(p)) {
       problems.push(`${p} is missing`);
       continue;
     }
     if (process.platform !== "win32") {
-      const mode = statSync3(p).mode & 511;
+      const mode = statSync4(p).mode & 511;
       if (mode !== 384)
         problems.push(`${p} must be mode 0600 (found ${mode.toString(8)})`);
     }
@@ -23318,10 +23548,10 @@ var init_changelog = __esm(() => {
 });
 
 // packages/workit-core/src/core/hygiene.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
 import path13 from "node:path";
 var repoRoot3, templatesDir = () => path13.join(repoRoot3, "templates", "hygiene"), packageJson = (root) => {
-  if (!existsSync7(path13.join(root, "package.json")))
+  if (!existsSync8(path13.join(root, "package.json")))
     return null;
   try {
     return JSON.parse(readFileSync8(path13.join(root, "package.json"), "utf8"));
@@ -23329,7 +23559,7 @@ var repoRoot3, templatesDir = () => path13.join(repoRoot3, "templates", "hygiene
     return null;
   }
 }, isOpenSource = (root) => {
-  if (existsSync7(path13.join(root, "LICENSE")))
+  if (existsSync8(path13.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
@@ -23360,10 +23590,10 @@ var repoRoot3, templatesDir = () => path13.join(repoRoot3, "templates", "hygiene
     "CONTRIBUTING.md"
   ]) {
     if (file === "LICENSE" || file === "CONTRIBUTING.md") {
-      state[file] = openSource ? existsSync7(path13.join(root, file)) ? "ok" : "missing" : "skip";
+      state[file] = openSource ? existsSync8(path13.join(root, file)) ? "ok" : "missing" : "skip";
       continue;
     }
-    if (!existsSync7(path13.join(root, file))) {
+    if (!existsSync8(path13.join(root, file))) {
       state[file] = "missing";
       continue;
     }
@@ -23382,10 +23612,10 @@ var repoRoot3, templatesDir = () => path13.join(repoRoot3, "templates", "hygiene
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync7(path13.join(root, file)))
+    if (existsSync8(path13.join(root, file)))
       continue;
     const tpl = path13.join(templatesDir(), file);
-    if (!existsSync7(tpl))
+    if (!existsSync8(tpl))
       continue;
     const content = readFileSync8(tpl, "utf8").replace(/<PROJECT>/g, path13.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
     planned.push({ path: path13.join(root, file), content });
@@ -23408,12 +23638,12 @@ var init_hygiene = __esm(() => {
 });
 
 // packages/workit-core/src/core/docs-layout.ts
-import { existsSync as existsSync8, lstatSync, mkdirSync as mkdirSync5, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync9, lstatSync, mkdirSync as mkdirSync5, realpathSync as realpathSync2, statSync as statSync5 } from "node:fs";
 import path14 from "node:path";
 var SLUG_RE, LEGACY_SLUG = "superpowers", posix = (p) => p.split(path14.sep).join("/"), canonicalize = (base, candidate) => {
   const abs = path14.resolve(base, candidate);
   let ancestor = abs;
-  while (!existsSync8(ancestor))
+  while (!existsSync9(ancestor))
     ancestor = path14.dirname(ancestor);
   let real;
   try {
@@ -23442,8 +23672,8 @@ var SLUG_RE, LEGACY_SLUG = "superpowers", posix = (p) => p.split(path14.sep).joi
     sdd: path14.join(dir, "sdd")
   };
 }, probeLegacyDocs = (workspace) => ({
-  legacy_sdd: existsSync8(path14.join(workspace, ".superpowers", "sdd")),
-  superpowers_dir: existsSync8(path14.join(workspace, "docs", LEGACY_SLUG))
+  legacy_sdd: existsSync9(path14.join(workspace, ".superpowers", "sdd")),
+  superpowers_dir: existsSync9(path14.join(workspace, "docs", LEGACY_SLUG))
 }), resolveCanonicalLayout = (input) => {
   const { workspace_root, slug, spec_path, plan_path } = input;
   if (!workspace_root)
@@ -23536,11 +23766,11 @@ var SLUG_RE, LEGACY_SLUG = "superpowers", posix = (p) => p.split(path14.sep).joi
   const { layout } = resolved;
   const created = [];
   const ensure = (dir) => {
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       mkdirSync5(dir, { recursive: true });
       const rel = posix(path14.relative(layout.workspace, dir));
       created.push(rel || ".");
-    } else if (!statSync4(dir).isDirectory()) {
+    } else if (!statSync5(dir).isDirectory()) {
       throw new Error(`path exists but is not a directory: ${posix(path14.relative(layout.workspace, dir))}`);
     }
   };
@@ -23587,7 +23817,7 @@ var init_docs_layout = __esm(() => {
 });
 
 // packages/workit-core/src/core/docs-validate.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
 import { execFileSync as execFileSync3 } from "node:child_process";
 import path15 from "node:path";
 var BRANCH_RE, SPEC_LINK_RE, TASK_RE, err = (code, message, path16) => {
@@ -23840,7 +24070,7 @@ var BRANCH_RE, SPEC_LINK_RE, TASK_RE, err = (code, message, path16) => {
   return findings;
 }, sddIgnored = (cwd, slug) => {
   const sddDir = path15.join(cwd, "docs", slug, "sdd");
-  if (!existsSync9(sddDir))
+  if (!existsSync10(sddDir))
     return true;
   try {
     execFileSync3("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
@@ -23920,11 +24150,11 @@ var init_plan_tasks = __esm(() => {
 var init_core3 = () => {};
 
 // packages/workit-core/src/core/handoff-context.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync6 } from "node:fs";
 import path17 from "node:path";
 var DOC_RE, listMd = (dir) => {
   try {
-    return readdirSync5(dir).filter((f) => f.endsWith(".md")).sort();
+    return readdirSync6(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -23938,7 +24168,7 @@ var DOC_RE, listMd = (dir) => {
   const slug = slugs[0];
   const plan = `docs/${slug}/plan.md`;
   const spec = `docs/${slug}/spec.md`;
-  if (!existsSync10(path17.join(root, plan)) || !existsSync10(path17.join(root, spec))) {
+  if (!existsSync11(path17.join(root, plan)) || !existsSync11(path17.join(root, spec))) {
     return { error: `docs/${slug}/ must contain both plan.md and spec.md` };
   }
   return { spec, plan, source: "message_paths" };
@@ -23947,7 +24177,7 @@ var DOC_RE, listMd = (dir) => {
   let best = null;
   let entries = [];
   try {
-    entries = readdirSync5(docsDir);
+    entries = readdirSync6(docsDir);
   } catch {
     return { error: "no pair" };
   }
@@ -23956,9 +24186,9 @@ var DOC_RE, listMd = (dir) => {
       continue;
     const plan = path17.join("docs", slug, "plan.md");
     const spec = path17.join("docs", slug, "spec.md");
-    if (!existsSync10(path17.join(root, plan)) || !existsSync10(path17.join(root, spec)))
+    if (!existsSync11(path17.join(root, plan)) || !existsSync11(path17.join(root, spec)))
       continue;
-    const score = Math.max(statSync5(path17.join(root, spec)).mtimeMs, statSync5(path17.join(root, plan)).mtimeMs);
+    const score = Math.max(statSync6(path17.join(root, spec)).mtimeMs, statSync6(path17.join(root, plan)).mtimeMs);
     if (best === null || score > best.score || score === best.score && slug < best.spec.split("/")[1]) {
       best = { score, spec, plan, source: "active_pair" };
     }
@@ -23976,7 +24206,7 @@ var DOC_RE, listMd = (dir) => {
   if (!("error" in active))
     return active;
   const docsDir = path17.join(root, "docs");
-  if (!existsSync10(docsDir) || listMd(docsDir).length === 0) {
+  if (!existsSync11(docsDir) || listMd(docsDir).length === 0) {
     return { error: "no docs/<slug>/ features found under docs/" };
   }
   return {
@@ -24051,10 +24281,10 @@ var init_handoff_tools = __esm(() => {
 // packages/workit-core/src/core/sdd.ts
 import {
   appendFileSync as appendFileSync2,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync12,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -24078,7 +24308,7 @@ function ledgerCompletion(root, slug) {
   let started = false;
   const completed = [];
   const absProgress = path19.join(root, "docs", slug, "sdd", "progress.md");
-  if (existsSync11(absProgress)) {
+  if (existsSync12(absProgress)) {
     try {
       for (const line of readFileSync12(absProgress, "utf8").split(`
 `)) {
@@ -24094,7 +24324,7 @@ function ledgerCompletion(root, slug) {
   const required2 = [];
   try {
     const absPlan = path19.join(root, "docs", slug, "plan.md");
-    if (existsSync11(absPlan)) {
+    if (existsSync12(absPlan)) {
       for (const task of parseTasksFromPlan(readFileSync12(absPlan, "utf8")))
         required2.push(task.id);
     }
@@ -24127,7 +24357,7 @@ function sddContext({
   let progress_lines = [];
   let completed_task_ids = [];
   const absProgress = path19.join(resolved.layout.sdd, "progress.md");
-  if (existsSync11(absProgress)) {
+  if (existsSync12(absProgress)) {
     progress_lines = readFileSync12(absProgress, "utf8").split(`
 `).map((ln) => ln.trim()).filter(Boolean);
     const pat = /^Task\s+(\d+):\s+complete\b/i;
@@ -24135,7 +24365,7 @@ function sddContext({
   }
   let manifest = {};
   const absManifest = path19.join(resolved.layout.sdd, "manifest.json");
-  if (existsSync11(absManifest)) {
+  if (existsSync12(absManifest)) {
     try {
       manifest = JSON.parse(readFileSync12(absManifest, "utf8"));
     } catch {
@@ -24143,7 +24373,7 @@ function sddContext({
     }
   }
   const legacy_path = path19.join(cwd, ".superpowers/sdd");
-  const legacy_exists = existsSync11(legacy_path);
+  const legacy_exists = existsSync12(legacy_path);
   let todos = [];
   let task_count = 0;
   if (plan_path) {
@@ -24174,7 +24404,7 @@ function sddContext({
     progress_lines,
     completed_task_ids,
     manifest,
-    created: existsSync11(path19.join(cwd, sdd_dir)),
+    created: existsSync12(path19.join(cwd, sdd_dir)),
     forbidden_legacy_path: ".superpowers/sdd",
     legacy_sdd_exists: legacy_exists,
     warning: legacy_exists ? "Ignore .superpowers/sdd — use sdd_dir from this tool only" : undefined,
@@ -24257,7 +24487,7 @@ function sddAppendProgress({
   if (!match || match[1].toLowerCase() === match[2].toLowerCase()) {
     return { error: "invalid progress line format" };
   }
-  if (existsSync11(path_) && statSync6(path_).isDirectory()) {
+  if (existsSync12(path_) && statSync7(path_).isDirectory()) {
     return { error: `progress path is a directory: ${progress_path}` };
   }
   mkdirSync6(path19.dirname(path_), { recursive: true });
@@ -24305,7 +24535,7 @@ function sddAppendAdvisory({
   if (!contained.ok)
     return { error: contained.error, code: "advisory_path_invalid" };
   const abs = contained.path;
-  if (existsSync11(abs) && statSync6(abs).isDirectory()) {
+  if (existsSync12(abs) && statSync7(abs).isDirectory()) {
     return {
       error: `advisory target is a directory: ${advisories_path}`,
       code: "advisory_target_invalid"
@@ -24333,20 +24563,20 @@ var init_menu = () => {};
 // packages/workit-core/src/core/flow-state.ts
 import {
   closeSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   fstatSync,
   fsyncSync,
   mkdirSync as mkdirSync7,
   openSync,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   readFileSync as readFileSync13,
-  renameSync,
-  rmSync,
-  statSync as statSync7,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync8,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import path20 from "node:path";
 
 class HostReceiptStore {
@@ -24500,7 +24730,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
   updated_at: Date.now()
 }), readFlowState = (root, slug) => {
   const file = flowPath(root, slug);
-  if (!existsSync12(file))
+  if (!existsSync13(file))
     return emptyState(slug);
   try {
     return normalizeState(JSON.parse(readFileSync13(file, "utf8")), slug);
@@ -24635,7 +24865,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
 }, readFlowStrict = (root, slug) => {
   const file = flowPath(root, slug);
   const rel = path20.posix.join("docs", slug, "sdd", "flow.json");
-  if (!existsSync12(file)) {
+  if (!existsSync13(file)) {
     return err2("flow_not_activated", `flow not activated for ${slug} — run workit_flow_status first`);
   }
   let text;
@@ -24670,26 +24900,26 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
-    renameSync(tmp, file);
+    renameSync2(tmp, file);
   } finally {
     try {
       if (fd !== null)
         closeSync(fd);
     } catch {}
     try {
-      if (existsSync12(tmp))
-        rmSync(tmp, { force: true });
+      if (existsSync13(tmp))
+        rmSync2(tmp, { force: true });
     } catch {}
   }
 }, MAX_WRITE_ATTEMPTS = 5, STALE_LOCK_MS = 1000, lockMtimeMs = (lock) => {
   try {
-    return statSync7(lock).mtimeMs;
+    return statSync8(lock).mtimeMs;
   } catch {
     return null;
   }
 }, lockOwnedBy = (fd, lock) => {
   try {
-    return fstatSync(fd).ino === statSync7(lock).ino;
+    return fstatSync(fd).ino === statSync8(lock).ino;
   } catch {
     return false;
   }
@@ -24704,7 +24934,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
   const tmp = uniqueTempPath(file);
   let fd = null;
   try {
-    const currentText = existsSync12(file) ? readFileSync13(file, "utf8") : null;
+    const currentText = existsSync13(file) ? readFileSync13(file, "utf8") : null;
     if (currentText !== expectedText)
       return { ok: false, conflict: true };
     mkdirSync7(path20.dirname(file), { recursive: true });
@@ -24713,10 +24943,10 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
-    const reRead = existsSync12(file) ? readFileSync13(file, "utf8") : null;
+    const reRead = existsSync13(file) ? readFileSync13(file, "utf8") : null;
     if (reRead !== expectedText)
       return { ok: false, conflict: true };
-    renameSync(tmp, file);
+    renameSync2(tmp, file);
     return { ok: true };
   } catch (error2) {
     return { ok: false, io_error: error2 instanceof Error ? error2.message : String(error2) };
@@ -24726,8 +24956,8 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
         closeSync(fd);
     } catch {}
     try {
-      if (existsSync12(tmp))
-        rmSync(tmp, { force: true });
+      if (existsSync13(tmp))
+        rmSync2(tmp, { force: true });
     } catch {}
   }
 }, readCanonicalDigest = (root, rel) => {
@@ -24747,7 +24977,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
   } catch {
     return { ok: false, code: "document_unreadable" };
   }
-  return { ok: true, text, digest: createHash("sha256").update(bytes).digest("hex") };
+  return { ok: true, text, digest: createHash2("sha256").update(bytes).digest("hex") };
 }, resetForSpecDrift = (state) => ({
   ...state,
   spec: { ...state.spec, status: "draft", evidence: null, approved_digest: null },
@@ -24816,11 +25046,11 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
   return { state, changed: false };
 }, withFlowLock = (file, fn) => {
   const lock = `${file}.lock`;
-  if (!existsSync12(path20.dirname(file)))
+  if (!existsSync13(path20.dirname(file)))
     return { locked: true, value: fn() };
   try {
-    if (existsSync12(`${lock}.stale`))
-      rmSync(`${lock}.stale`, { force: true });
+    if (existsSync13(`${lock}.stale`))
+      rmSync2(`${lock}.stale`, { force: true });
   } catch {}
   const wait = new Int32Array(new SharedArrayBuffer(4));
   let fd = null;
@@ -24839,7 +25069,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
       const mtime = lockMtimeMs(lock);
       if (mtime !== null && Date.now() - mtime > STALE_LOCK_MS) {
         try {
-          renameSync(lock, `${lock}.stale`);
+          renameSync2(lock, `${lock}.stale`);
           unlinkSync3(`${lock}.stale`);
         } catch {}
         try {
@@ -24875,7 +25105,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
   } finally {
     try {
       if (fd !== null && lockOwnedBy(fd, lock))
-        rmSync(lock, { force: true });
+        rmSync2(lock, { force: true });
     } catch {}
     try {
       if (fd !== null)
@@ -25073,7 +25303,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
   const planPath = path20.posix.join("docs", slug, "plan.md");
   const file = flowPath(root, slug);
   const locked = withFlowLock(file, () => {
-    if (!existsSync12(file)) {
+    if (!existsSync13(file)) {
       writeFlowFileAtomic(file, {
         slug,
         activated: true,
@@ -25113,7 +25343,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
     return err2("path_invalid", doc2.error);
   const relPath = path20.posix.join("docs", slug, "spec.md");
   return readModifyWrite(root, slug, (state) => {
-    if (!existsSync12(doc2.path))
+    if (!existsSync13(doc2.path))
       return err2("spec_missing", `spec not found: ${specPath}`);
     if (state.spec.status === "draft" || state.spec.status === "self_reviewed") {
       const digest = readCanonicalDigest(root, relPath);
@@ -25157,7 +25387,7 @@ var COORDINATOR_RECOVERY_TEXT, CURSOR_SUBAGENT_UNSUPPORTED_TEXT, MENU_CHOICES, e
     return err2("path_invalid", doc2.error);
   const relPath = path20.posix.join("docs", slug, "plan.md");
   return readModifyWrite(root, slug, (state) => {
-    if (!existsSync12(doc2.path))
+    if (!existsSync13(doc2.path))
       return err2("plan_missing", `plan not found: ${planPath}`);
     if (state.spec.status !== "approved") {
       return err2("spec_not_approved", "spec must be approved before the plan can be approved");
@@ -25593,15 +25823,15 @@ var init_flow_evidence = __esm(() => {
 // packages/workit-core/src/core/docs-migration.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync8,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync8,
   readFileSync as readFileSync14,
   realpathSync as realpathSync3,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  statSync as statSync8,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  statSync as statSync9,
   writeFileSync as writeFileSync7
 } from "node:fs";
 import path21 from "node:path";
@@ -25640,14 +25870,14 @@ var LEGACY_DIR = "docs/superpowers", MIGRATION_CHOICES, SLUG_RE3, RESERVED_SLUG
 }, detectLegacyDocs = (workspace_root) => {
   const root = legacyRoot(workspace_root);
   const raw = [];
-  if (existsSync13(root)) {
-    for (const entry of readdirSync7(root, { withFileTypes: true })) {
+  if (existsSync14(root)) {
+    for (const entry of readdirSync8(root, { withFileTypes: true })) {
       const abs = path21.join(root, entry.name);
       const rel = posix3(path21.relative(workspace_root, abs));
       if (entry.isDirectory()) {
-        const hasSpec = existsSync13(path21.join(abs, "spec.md"));
-        const hasPlan = existsSync13(path21.join(abs, "plan.md"));
-        if (!hasSpec && !hasPlan && !existsSync13(path21.join(abs, "sdd")))
+        const hasSpec = existsSync14(path21.join(abs, "spec.md"));
+        const hasPlan = existsSync14(path21.join(abs, "plan.md"));
+        if (!hasSpec && !hasPlan && !existsSync14(path21.join(abs, "sdd")))
           continue;
         const explicit = explicitTargetSlug(hasPlan ? readFileSafe(path21.join(abs, "plan.md")) : null);
         raw.push({
@@ -25655,7 +25885,7 @@ var LEGACY_DIR = "docs/superpowers", MIGRATION_CHOICES, SLUG_RE3, RESERVED_SLUG
           legacy_dir: rel,
           spec: hasSpec ? posix3(path21.join(rel, "spec.md")) : null,
           plan: hasPlan ? posix3(path21.join(rel, "plan.md")) : null,
-          sdd: existsSync13(path21.join(abs, "sdd")),
+          sdd: existsSync14(path21.join(abs, "sdd")),
           explicit: explicit !== null
         });
       } else if (entry.name === "spec.md" || entry.name === "plan.md") {
@@ -25775,7 +26005,7 @@ var LEGACY_DIR = "docs/superpowers", MIGRATION_CHOICES, SLUG_RE3, RESERVED_SLUG
   if (visits.has(real))
     return { ok: true };
   visits.add(real);
-  for (const entry of readdirSync7(real, { withFileTypes: true })) {
+  for (const entry of readdirSync8(real, { withFileTypes: true })) {
     const fromAbs = path21.join(real, entry.name);
     const fromRel = posix3(path21.join(legacyRel, entry.name));
     const toRel = posix3(path21.join(destRelRoot, entry.name));
@@ -25795,7 +26025,7 @@ var LEGACY_DIR = "docs/superpowers", MIGRATION_CHOICES, SLUG_RE3, RESERVED_SLUG
         if (target !== workspaceReal && !target.startsWith(workspaceReal + path21.sep)) {
           return { ok: false, error: `symlink escape refused: ${fromRel}` };
         }
-        if (statSync8(target).isDirectory()) {
+        if (statSync9(target).isDirectory()) {
           const sub = planTree(workspace, fromAbs, fromRel, toRel, path21.join(destAbsRoot, entry.name), legacyName, slug, plan, visits);
           if (!sub.ok)
             return sub;
@@ -25898,7 +26128,7 @@ var LEGACY_DIR = "docs/superpowers", MIGRATION_CHOICES, SLUG_RE3, RESERVED_SLUG
   }
   const collisions = [];
   for (const item of plan) {
-    if (!existsSync13(item.destAbs))
+    if (!existsSync14(item.destAbs))
       continue;
     let identical = false;
     try {
@@ -25939,10 +26169,10 @@ var LEGACY_DIR = "docs/superpowers", MIGRATION_CHOICES, SLUG_RE3, RESERVED_SLUG
     try {
       mkdirSync8(path21.dirname(item.destAbs), { recursive: true });
       writeFileSync7(tmp, item.bytes);
-      renameSync2(tmp, item.destAbs);
+      renameSync3(tmp, item.destAbs);
     } catch (error2) {
       try {
-        rmSync2(tmp, { force: true });
+        rmSync3(tmp, { force: true });
       } catch {}
       return abort(`legacy migration retry required: failed to copy ${item.fromRel}: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
@@ -25964,7 +26194,7 @@ var init_docs_migration = __esm(() => {
 });
 
 // packages/workit-core/src/core/docs-repo.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8, readdirSync as readdirSync8 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8, readdirSync as readdirSync9 } from "node:fs";
 import { execFileSync as execFileSync6 } from "node:child_process";
 import path22 from "node:path";
 var configPath = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path22.join(configDir(), "docs-repo.json"), readDocsRepoConfig = () => {
@@ -25980,7 +26210,7 @@ var configPath = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path22.join(conf
   writeFileSync8(file, JSON.stringify({ path: docsPath }, null, 2) + `
 `, "utf8");
 }, docsRepoPath = () => readDocsRepoConfig()?.path ?? null, validateDocsRepo = (docsPath) => {
-  if (!existsSync14(docsPath))
+  if (!existsSync15(docsPath))
     return { ok: false, error: `docs repo path does not exist: ${docsPath}` };
   try {
     execFileSync6("git", ["-C", docsPath, "rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
@@ -25988,7 +26218,7 @@ var configPath = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path22.join(conf
     return { ok: false, error: `docs repo is not a git repository: ${docsPath}` };
   }
   const featuresDir = path22.join(docsPath, "features");
-  if (!existsSync14(featuresDir))
+  if (!existsSync15(featuresDir))
     mkdirSync9(featuresDir, { recursive: true });
   return { ok: true };
 }, linkDocsRepo = (docsPath, confirmed) => {
@@ -26003,19 +26233,19 @@ var configPath = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path22.join(conf
   const repoPath = docsRepoPath();
   const specs = [];
   const docsDir = path22.join(workspaceRoot, "docs");
-  if (existsSync14(docsDir)) {
-    for (const slug of readdirSync8(docsDir)) {
+  if (existsSync15(docsDir)) {
+    for (const slug of readdirSync9(docsDir)) {
       if (slug.startsWith("."))
         continue;
       const spec = path22.posix.join("docs", slug, "spec.md");
-      if (!existsSync14(path22.join(workspaceRoot, spec)))
+      if (!existsSync15(path22.join(workspaceRoot, spec)))
         continue;
       let promoted = false;
       let target = null;
       if (repoPath) {
         const featuresDir = path22.join(repoPath, "features");
-        if (existsSync14(featuresDir)) {
-          const match = readdirSync8(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
+        if (existsSync15(featuresDir)) {
+          const match = readdirSync9(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
           if (match) {
             promoted = true;
             target = path22.join(repoPath, "features", match);
@@ -26084,7 +26314,7 @@ var configPath = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path22.join(conf
   }
   if (!opts.force) {
     const sddDir = path22.join(workspaceRootCanonical, "docs", slug, "sdd");
-    if (existsSync14(sddDir)) {
+    if (existsSync15(sddDir)) {
       try {
         execFileSync6("git", [
           "-C",
@@ -26102,7 +26332,7 @@ var configPath = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path22.join(conf
   }
   const prefix = monthPrefix();
   const featuresDir = path22.join(repoPath, "features");
-  const existing = existsSync14(featuresDir) ? readdirSync8(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d)) : undefined;
+  const existing = existsSync15(featuresDir) ? readdirSync9(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d)) : undefined;
   const targetDir = path22.join(featuresDir, existing ?? `${prefix}-${slug}`);
   mkdirSync9(targetDir, { recursive: true });
   const files = ["spec.md"];
@@ -26164,13 +26394,13 @@ var init_docs_repo = __esm(() => {
 });
 
 // packages/workit-core/src/core/gitignore.ts
-import { existsSync as existsSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "node:fs";
 import path23 from "node:path";
 var GITIGNORE_ENTRIES, ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
   const file = path23.join(workspaceRoot, ".gitignore");
-  const existing = existsSync15(file) ? readFileSync16(file, "utf8") : "";
+  const existing = existsSync16(file) ? readFileSync16(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
   const added = [];
@@ -26189,7 +26419,7 @@ var GITIGNORE_ENTRIES, ensureProjectGitignore = (workspaceRoot, confirmed) => {
 ` : "") + append.join(`
 `) + `
 `, "utf8");
-  } else if (!existsSync15(file)) {
+  } else if (!existsSync16(file)) {
     writeFileSync9(file, "", "utf8");
   }
   return { ok: true, path: file, added };
@@ -26214,11 +26444,11 @@ var init_gitignore = __esm(() => {
 });
 
 // packages/workit-core/src/core/templates.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "node:fs";
 import path24 from "node:path";
 var repoRoot4, templatePath = (name) => path24.join(configDir(), "templates", `${name}.md`), readTemplate = (name) => {
   const cfg = templatePath(name);
-  if (existsSync16(cfg))
+  if (existsSync17(cfg))
     return { source: "config", content: readFileSync17(cfg, "utf8") };
   return {
     source: "repo",
@@ -26234,9 +26464,9 @@ var repoRoot4, templatePath = (name) => path24.join(configDir(), "templates", `$
 }, listTemplates = () => ["issue-update", "greeting", "headers"].map((name) => {
   const cfg = templatePath(name);
   const repoFile = path24.join(repoRoot4, "templates", `${name}.md`);
-  if (existsSync16(cfg))
+  if (existsSync17(cfg))
     return { name, source: "config", path: cfg };
-  if (existsSync16(repoFile))
+  if (existsSync17(repoFile))
     return { name, source: "repo", path: repoFile };
   return { name, source: "missing", path: cfg };
 });
@@ -26247,7 +26477,7 @@ var init_templates = __esm(() => {
 });
 
 // packages/workit-core/src/core/rules.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, readFileSync as readFileSync18, readdirSync as readdirSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync18, readdirSync as readdirSync10, writeFileSync as writeFileSync11 } from "node:fs";
 import path25 from "node:path";
 var rulesDir = () => path25.join(configDir(), "rules"), parseRule = (markdown) => {
   const fm = markdown.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -26276,10 +26506,10 @@ var rulesDir = () => path25.join(configDir(), "rules"), parseRule = (markdown) =
 }, listRules = () => {
   const result = [];
   const dir = rulesDir();
-  if (existsSync17(dir)) {
-    for (const entry of readdirSync9(dir)) {
+  if (existsSync18(dir)) {
+    for (const entry of readdirSync10(dir)) {
       const file = path25.join(dir, entry, "rule.md");
-      if (!existsSync17(file))
+      if (!existsSync18(file))
         continue;
       const parsed = parseRule(readFileSync18(file, "utf8"));
       if ("error" in parsed)
@@ -26394,16 +26624,16 @@ var init_setup_state = __esm(() => {
 
 // packages/workit-core/src/core/setup.ts
 import {
-  copyFileSync as copyFileSync2,
-  cpSync as cpSync2,
-  existsSync as existsSync18,
+  copyFileSync as copyFileSync3,
+  cpSync as cpSync3,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync12,
   mkdtempSync,
   readFileSync as readFileSync19,
-  readdirSync as readdirSync10,
-  renameSync as renameSync3,
-  rmSync as rmSync3,
-  statSync as statSync9,
+  readdirSync as readdirSync11,
+  renameSync as renameSync4,
+  rmSync as rmSync4,
+  statSync as statSync10,
   writeFileSync as writeFileSync13
 } from "node:fs";
 import path26 from "node:path";
@@ -27999,7 +28229,8 @@ var init_server3 = __esm(async () => {
       sdd_dir,
       target_branch,
       stash,
-      workspace_root
+      workspace_root,
+      log: (message) => logger.info(message)
     });
     if (data.error)
       return jsonResult({ error: data.error });
@@ -28348,7 +28579,7 @@ var init_server3 = __esm(async () => {
       return jsonResult(result);
     }
     if (action === "config") {
-      if (locale !== undefined && !/^[a-z]{2,3}(-[A-Z]{2})?$/.test(locale)) {
+      if (locale !== undefined && !/^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/.test(locale)) {
         return jsonResult({
           error: `invalid locale: ${JSON.stringify(locale)} — expected BCP-47 like en or es-CL`
         });
@@ -28710,17 +28941,17 @@ var init_server3 = __esm(async () => {
 });
 
 // packages/workit-cursor/mcp/run-server.ts
-import { existsSync as existsSync19, readFileSync as readFileSync21 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync21 } from "node:fs";
 import path29 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var mcpDir = path29.dirname(fileURLToPath2(import.meta.url));
 var pluginDir = path29.resolve(mcpDir, "..");
 var marker = path29.join(pluginDir, ".workit-root");
 var resolveRoot = () => {
-  if (process.env.WORKFLOW_TOOLKIT_ROOT && existsSync19(path29.join(process.env.WORKFLOW_TOOLKIT_ROOT, "scripts"))) {
+  if (process.env.WORKFLOW_TOOLKIT_ROOT && existsSync20(path29.join(process.env.WORKFLOW_TOOLKIT_ROOT, "scripts"))) {
     return process.env.WORKFLOW_TOOLKIT_ROOT;
   }
-  if (existsSync19(marker)) {
+  if (existsSync20(marker)) {
     return readFileSync21(marker, "utf8").replace(/\n+$/, "");
   }
   return pluginDir;