@brainervirus/workit-opencode 0.9.0 → 0.10.0

package/assets/skills/wk-init/SKILL.md

@@ -19,7 +19,7 @@ Never ask for or accept tokens in chat. For missing YouTrack configuration, prev
 
 When the user wants to personalize the toolkit (locale, timezone, branch policy), ask native questions one at a time:
 
-1. **Locale** — present a combobox of `localeOptions` (en, es-CL, es-MX, es-AR, pt-BR) + custom answer; validate the answer against BCP-47 (`^[a-z]{2,3}(-[A-Z]{2})?$`) before passing it.
+1. **Locale** — present a combobox of `localeOptions` (en, es-CL, es-MX, es-AR, pt-BR) + custom answer; validate the answer against BCP-47 (`^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$`, so `es-419` is valid) before passing it.
 2. **Timezone** — e.g. `America/Santiago`, custom allowed.
 3. **Branch policy preset** — gitflow / github-flow / trunk-based / custom.
 4. **Custom branch lists** (only when preset = custom): allowed patterns (`feature/*`, `codex/*`, …) and protected names (`main`, …).

package/dist/plugin.js

@@ -14,7 +14,7 @@ var __export = (target, all) => {
 };
 
 // packages/workit-opencode/src/plugin.ts
-import { existsSync as existsSync21, readdirSync as readdirSync12 } from "node:fs";
+import { existsSync as existsSync22, readdirSync as readdirSync13 } from "node:fs";
 import path39 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -125,7 +125,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   return dir;
 };
 var configDir = () => ensureConfigDir();
-var LOCALE_RE = /^[a-z]{2,3}(-[A-Z]{2})?$/;
+var LOCALE_RE = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
 var DEFAULTS = {
   locale: "en",
   localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
@@ -455,7 +455,7 @@ var shouldInjectConfigGuard = (currentText) => !currentText.includes(CONFIG_GUAR
 var shouldInjectIssueRail = (currentText) => !currentText.includes(ISSUE_RAIL_TEXT);
 
 // packages/workit-core/src/core/detector.ts
-import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync17, readdirSync as readdirSync8, readFileSync as readFileSync17 } from "node:fs";
 import path23 from "node:path";
 
 // packages/workit-core/src/core/init.ts
@@ -2115,8 +2115,21 @@ import path13 from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
 
 // packages/workit-core/src/core/branch.ts
-import { readFileSync as readFileSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import {
+  copyFileSync as copyFileSync3,
+  cpSync as cpSync3,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync10,
+  readdirSync as readdirSync5,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync4,
+  writeFileSync as writeFileSync8
+} from "node:fs";
 import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
 import path12 from "node:path";
 
 // packages/workit-core/src/core/git.ts
@@ -2200,6 +2213,7 @@ var baseBranch = (cwd) => {
 };
 var DECLARE_RE = /^\s*\*+Branch:\*+\s*`?([^`\s|]+)`?\s*$/gim;
 var USE_CURRENT_RE = /^\s*\*+Branch:\*+\s*use-current\s*$/im;
+var toPosix = (p) => p.split(path12.sep).join("/");
 var readSafe2 = (p) => {
   try {
     return readFileSync10(p, "utf8");
@@ -2335,10 +2349,7 @@ var docsBranch = ({
   }
   return { error: `cannot resolve docs branch from HEAD ${JSON.stringify(current)}` };
 };
-var ensureBaseBranch = (cwd, base) => {
-  const git = gitContext(cwd);
-  if (!git.branch || git.branch === "unknown")
-    return { ok: false, error: "not in a git repository" };
+var originBaseReady = (cwd, base) => {
   const run2 = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   try {
     try {
@@ -2346,20 +2357,28 @@ var ensureBaseBranch = (cwd, base) => {
     } 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 (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "ensure-base-branch failed"
+    };
+  }
+};
+var 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}`], {
@@ -2385,12 +2404,95 @@ var ensureBaseBranch = (cwd, base) => {
     };
   }
 };
+var 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);
+};
+var purgeStaleFlowGuardRoots = (now) => {
+  const cutoff = now - 24 * 3600000;
+  let entries;
+  try {
+    entries = readdirSync5(tmpdir());
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("workit-flow-guard-"))
+      continue;
+    try {
+      if (statSync4(path12.join(tmpdir(), entry)).mtimeMs < cutoff)
+        rmSync2(path12.join(tmpdir(), entry), { recursive: true, force: true });
+    } catch {}
+  }
+};
+var snapshotFlowState = (cwd) => {
+  purgeStaleFlowGuardRoots(Date.now());
+  const root2 = path12.join(tmpdir(), `workit-flow-guard-${createHash("sha256").update(path12.resolve(cwd)).digest("hex").slice(0, 16)}.${process.pid}.${process.hrtime.bigint()}`);
+  mkdirSync5(root2, { recursive: true });
+  const docsDir = path12.join(path12.resolve(cwd), "docs");
+  let slugs = [];
+  try {
+    slugs = readdirSync5(docsDir);
+  } catch {
+    return root2;
+  }
+  for (const slug of slugs) {
+    for (const rel of [["sdd", "flow.json"], ["spec.md"], ["plan.md"]]) {
+      const src = path12.join(docsDir, slug, ...rel);
+      try {
+        if (!statSync4(src).isFile())
+          continue;
+      } catch {
+        continue;
+      }
+      const dest = path12.join(root2, "docs", slug, ...rel);
+      mkdirSync5(path12.dirname(dest), { recursive: true });
+      cpSync3(src, dest);
+    }
+  }
+  return root2;
+};
+var restoreFlowSnapshot = (snapDir, cwd) => {
+  const walk = (dir, rel) => readdirSync5(dir, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? walk(path12.join(dir, entry.name), path12.join(rel, entry.name)) : [path12.join(rel, entry.name)]);
+  const restored = [];
+  try {
+    const workspace = path12.resolve(cwd);
+    for (const rel of walk(snapDir, "")) {
+      const dest = path12.join(workspace, rel);
+      if (existsSync9(dest))
+        continue;
+      mkdirSync5(path12.dirname(dest), { recursive: true });
+      const tmpDest = `${dest}.tmp-${process.pid}`;
+      try {
+        copyFileSync3(path12.join(snapDir, rel), tmpDest);
+        renameSync2(tmpDest, dest);
+      } catch (error) {
+        rmSync2(tmpDest, { force: true });
+        throw error;
+      }
+      restored.push(toPosix(rel));
+    }
+    rmSync2(snapDir, { recursive: true, force: true });
+    return { restored };
+  } catch (error) {
+    return {
+      restored,
+      warning: `flow state snapshot restore failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+};
 var branchSetup = ({
   action,
   sdd_dir,
   target_branch,
   stash,
-  workspace_root
+  workspace_root,
+  log
 }) => {
   const cwd = path12.resolve(workspace_root);
   const exec = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
@@ -2409,20 +2511,74 @@ var branchSetup = ({
   };
   const writeManifest = (data) => writeFileSync8(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) => readdirSync5(from, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? walk(path12.join(from, entry.name), path12.join(rel, entry.name)) : [path12.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(readFileSync10(path12.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} ${existsSync9(path12.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 (error) {
-      return { error: error instanceof Error ? error.message : "stash pop failed" };
+      journal("pop: failed");
+      const {
+        warnings: [warning]
+      } = restoreWithWarning(snapDir);
+      return {
+        error: `${error instanceof Error ? error.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)
@@ -2431,61 +2587,141 @@ var branchSetup = ({
     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 (error) {
         return { error: error instanceof Error ? error.message : "stash push failed" };
       }
       stash_ref = "stash@{0}";
+      journal(`stash push: ${stash_ref}`);
     }
     try {
       exec(["checkout", target]);
+      journalPresence("post-checkout");
     } catch (error) {
       const message = error instanceof Error ? error.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 (error) {
+    const result = failAfterStash(error instanceof Error ? `manifest update failed: ${error.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 } : {}
   };
 };
 
@@ -2792,13 +3028,13 @@ import fs3 from "node:fs";
 import path15 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
 import path14 from "node:path";
 var repoRoot2 = assetRoot();
 var templatePath = (name) => path14.join(configDir(), "templates", `${name}.md`);
 var readTemplate = (name) => {
   const cfg = templatePath(name);
-  if (existsSync9(cfg))
+  if (existsSync10(cfg))
     return { source: "config", content: readFileSync11(cfg, "utf8") };
   return {
     source: "repo",
@@ -2816,9 +3052,9 @@ var writeTemplate = (name, content, confirmed) => {
 var listTemplates = () => ["issue-update", "greeting", "headers"].map((name) => {
   const cfg = templatePath(name);
   const repoFile = path14.join(repoRoot2, "templates", `${name}.md`);
-  if (existsSync9(cfg))
+  if (existsSync10(cfg))
     return { name, source: "config", path: cfg };
-  if (existsSync9(repoFile))
+  if (existsSync10(repoFile))
     return { name, source: "repo", path: repoFile };
   return { name, source: "missing", path: cfg };
 });
@@ -3868,29 +4104,29 @@ function configGuardError(missing) {
 // packages/workit-core/src/core/flow-state.ts
 import {
   closeSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   fstatSync,
   fsyncSync,
   mkdirSync as mkdirSync9,
   openSync,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   readFileSync as readFileSync16,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  statSync as statSync7,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  statSync as statSync8,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import path22 from "node:path";
 
 // packages/workit-core/src/core/docs-validate.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
 import { execFileSync as execFileSync3 } from "node:child_process";
 import path18 from "node:path";
 
 // packages/workit-core/src/core/docs-layout.ts
-import { existsSync as existsSync10, lstatSync, mkdirSync as mkdirSync7, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync7, realpathSync as realpathSync2, statSync as statSync5 } from "node:fs";
 import path17 from "node:path";
 var SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 var LEGACY_SLUG = "superpowers";
@@ -3898,7 +4134,7 @@ var posix = (p) => p.split(path17.sep).join("/");
 var canonicalize = (base, candidate) => {
   const abs = path17.resolve(base, candidate);
   let ancestor = abs;
-  while (!existsSync10(ancestor))
+  while (!existsSync11(ancestor))
     ancestor = path17.dirname(ancestor);
   let real;
   try {
@@ -3929,8 +4165,8 @@ var buildLayout = (workspace, slug) => {
   };
 };
 var probeLegacyDocs = (workspace) => ({
-  legacy_sdd: existsSync10(path17.join(workspace, ".superpowers", "sdd")),
-  superpowers_dir: existsSync10(path17.join(workspace, "docs", LEGACY_SLUG))
+  legacy_sdd: existsSync11(path17.join(workspace, ".superpowers", "sdd")),
+  superpowers_dir: existsSync11(path17.join(workspace, "docs", LEGACY_SLUG))
 });
 var resolveCanonicalLayout = (input) => {
   const { workspace_root, slug, spec_path, plan_path } = input;
@@ -4025,11 +4261,11 @@ var prepareDocsLayout = (input) => {
   const { layout } = resolved;
   const created = [];
   const ensure = (dir) => {
-    if (!existsSync10(dir)) {
+    if (!existsSync11(dir)) {
       mkdirSync7(dir, { recursive: true });
       const rel = posix(path17.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(path17.relative(layout.workspace, dir))}`);
     }
   };
@@ -4353,7 +4589,7 @@ var qualitySpec = (text) => {
 };
 var sddIgnored = (cwd, slug) => {
   const sddDir = path18.join(cwd, "docs", slug, "sdd");
-  if (!existsSync11(sddDir))
+  if (!existsSync12(sddDir))
     return true;
   try {
     execFileSync3("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
@@ -4371,10 +4607,10 @@ var sddIgnored = (cwd, slug) => {
 // packages/workit-core/src/core/sdd.ts
 import {
   appendFileSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync13,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -4399,7 +4635,7 @@ function ledgerCompletion(root2, slug) {
   let started = false;
   const completed = [];
   const absProgress = path19.join(root2, "docs", slug, "sdd", "progress.md");
-  if (existsSync12(absProgress)) {
+  if (existsSync13(absProgress)) {
     try {
       for (const line of readFileSync13(absProgress, "utf8").split(`
 `)) {
@@ -4415,7 +4651,7 @@ function ledgerCompletion(root2, slug) {
   const required = [];
   try {
     const absPlan = path19.join(root2, "docs", slug, "plan.md");
-    if (existsSync12(absPlan)) {
+    if (existsSync13(absPlan)) {
       for (const task of parseTasksFromPlan(readFileSync13(absPlan, "utf8")))
         required.push(task.id);
     }
@@ -4448,7 +4684,7 @@ function sddContext({
   let progress_lines = [];
   let completed_task_ids = [];
   const absProgress = path19.join(resolved.layout.sdd, "progress.md");
-  if (existsSync12(absProgress)) {
+  if (existsSync13(absProgress)) {
     progress_lines = readFileSync13(absProgress, "utf8").split(`
 `).map((ln) => ln.trim()).filter(Boolean);
     const pat = /^Task\s+(\d+):\s+complete\b/i;
@@ -4456,7 +4692,7 @@ function sddContext({
   }
   let manifest = {};
   const absManifest = path19.join(resolved.layout.sdd, "manifest.json");
-  if (existsSync12(absManifest)) {
+  if (existsSync13(absManifest)) {
     try {
       manifest = JSON.parse(readFileSync13(absManifest, "utf8"));
     } catch {
@@ -4464,7 +4700,7 @@ function sddContext({
     }
   }
   const legacy_path = path19.join(cwd, ".superpowers/sdd");
-  const legacy_exists = existsSync12(legacy_path);
+  const legacy_exists = existsSync13(legacy_path);
   let todos = [];
   let task_count = 0;
   if (plan_path) {
@@ -4495,7 +4731,7 @@ function sddContext({
     progress_lines,
     completed_task_ids,
     manifest,
-    created: existsSync12(path19.join(cwd, sdd_dir)),
+    created: existsSync13(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,
@@ -4579,7 +4815,7 @@ function sddAppendProgress({
   if (!match || match[1].toLowerCase() === match[2].toLowerCase()) {
     return { error: "invalid progress line format" };
   }
-  if (existsSync12(path_) && statSync5(path_).isDirectory()) {
+  if (existsSync13(path_) && statSync6(path_).isDirectory()) {
     return { error: `progress path is a directory: ${progress_path}` };
   }
   mkdirSync8(path19.dirname(path_), { recursive: true });
@@ -4627,7 +4863,7 @@ function sddAppendAdvisory({
   if (!contained.ok)
     return { error: contained.error, code: "advisory_path_invalid" };
   const abs = contained.path;
-  if (existsSync12(abs) && statSync5(abs).isDirectory()) {
+  if (existsSync13(abs) && statSync6(abs).isDirectory()) {
     return {
       error: `advisory target is a directory: ${advisories_path}`,
       code: "advisory_target_invalid"
@@ -4643,12 +4879,12 @@ function sddAppendAdvisory({
 
 // packages/workit-core/src/core/verify-project.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync15, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync15, statSync as statSync7 } from "node:fs";
 import path21 from "node:path";
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync14, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync14, readdirSync as readdirSync6 } from "node:fs";
 import path20 from "node:path";
 var runGit = (cwd, args) => {
   const result = spawnSync4("git", args, { cwd, encoding: "utf8" });
@@ -4738,7 +4974,7 @@ var printSection = (title) => `
 `;
 var probeCaseInsensitive = (dir, wanted) => {
   try {
-    for (const entry of readdirSync5(dir)) {
+    for (const entry of readdirSync6(dir)) {
       if (entry.toLowerCase() === wanted.toLowerCase())
         return entry;
     }
@@ -4790,7 +5026,7 @@ var diffStatForRange = (cwd, range) => {
 };
 var packageScripts = (cwd, keys) => {
   const pkgPath = path20.join(cwd, "package.json");
-  if (!existsSync13(pkgPath))
+  if (!existsSync14(pkgPath))
     return [];
   try {
     const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
@@ -4807,7 +5043,7 @@ var documentationFiles = (cwd) => {
       return;
     let entries;
     try {
-      entries = readdirSync5(dir, { withFileTypes: true });
+      entries = readdirSync6(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4825,7 +5061,7 @@ var documentationFiles = (cwd) => {
   return matches.sort().slice(0, 200);
 };
 var readTrimmed = (file, maxLines) => {
-  if (!existsSync13(file))
+  if (!existsSync14(file))
     return "";
   const lines = readFileSync14(file, "utf8").split(`
 `);
@@ -4899,7 +5135,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync13(path20.join(cwd, "package.json"))) {
+  if (existsSync14(path20.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -4908,7 +5144,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync13(path20.join(cwd, "Cargo.toml")) || existsSync13(path20.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync14(path20.join(cwd, "Cargo.toml")) || existsSync14(path20.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -4956,7 +5192,7 @@ function changelogContext(root2, range) {
 `;
   stdout += printSection("Existing CHANGELOG.md");
   const changelogPath = path20.join(cwd, "CHANGELOG.md");
-  if (existsSync13(changelogPath)) {
+  if (existsSync14(changelogPath)) {
     stdout += readTrimmed(changelogPath, 260) + `
 `;
   } else {
@@ -4994,7 +5230,7 @@ function docsRefreshContext(root2, range) {
 `;
   stdout += printSection("README Preview");
   const readme = path20.join(cwd, "README.md");
-  if (existsSync13(readme)) {
+  if (existsSync14(readme)) {
     stdout += readTrimmed(readme, 220) + `
 `;
   } else {
@@ -5003,7 +5239,7 @@ function docsRefreshContext(root2, range) {
   }
   stdout += printSection("Package Scripts");
   const pkgPath = path20.join(cwd, "package.json");
-  if (existsSync13(pkgPath)) {
+  if (existsSync14(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
@@ -5050,7 +5286,7 @@ function releaseNotesContext(root2, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync13(path20.join(cwd, rel)))
+    if (existsSync14(path20.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -5067,9 +5303,9 @@ var commandOnPath2 = (name) => {
     for (const candidateName of names) {
       const candidate = path21.join(dir, candidateName);
       try {
-        statSync6(candidate);
+        statSync7(candidate);
         if (process.platform !== "win32") {
-          const mode = statSync6(candidate).mode & 73;
+          const mode = statSync7(candidate).mode & 73;
           if (mode === 0)
             continue;
         }
@@ -5081,7 +5317,7 @@ var commandOnPath2 = (name) => {
 };
 var hasScript = (cwd, name) => {
   const pkgPath = path21.join(cwd, "package.json");
-  if (!existsSync14(pkgPath))
+  if (!existsSync15(pkgPath))
     return false;
   try {
     const pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
@@ -5091,10 +5327,10 @@ var hasScript = (cwd, name) => {
   }
 };
 var packageRunner = (cwd) => {
-  if (existsSync14(path21.join(cwd, "pnpm-lock.yaml")))
+  if (existsSync15(path21.join(cwd, "pnpm-lock.yaml")))
     return "pnpm";
   const pkgPath = path21.join(cwd, "package.json");
-  if (existsSync14(pkgPath)) {
+  if (existsSync15(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
       if (typeof pkg.packageManager === "string" && pkg.packageManager.startsWith("pnpm")) {
@@ -5102,7 +5338,7 @@ var packageRunner = (cwd) => {
       }
     } catch {}
   }
-  if (existsSync14(path21.join(cwd, "yarn.lock")))
+  if (existsSync15(path21.join(cwd, "yarn.lock")))
     return "yarn";
   return "npm";
 };
@@ -5163,7 +5399,7 @@ root: ${cwd}
   lines.push(`dry_run: ${String(dryRun)}
 `);
   const pkgPath = path21.join(cwd, "package.json");
-  if (existsSync14(pkgPath)) {
+  if (existsSync15(pkgPath)) {
     const runner = packageRunner(cwd);
     for (const script of ["lint", "format:check", "test", "build"]) {
       if (hasScript(cwd, script)) {
@@ -5178,7 +5414,7 @@ root: ${cwd}
   } else {
     skipCheck("javascript", "package.json not found");
   }
-  const cargoManifest = existsSync14(path21.join(cwd, "Cargo.toml")) ? "Cargo.toml" : existsSync14(path21.join(cwd, "src-tauri/Cargo.toml")) ? "src-tauri/Cargo.toml" : "";
+  const cargoManifest = existsSync15(path21.join(cwd, "Cargo.toml")) ? "Cargo.toml" : existsSync15(path21.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", [
@@ -5194,7 +5430,7 @@ root: ${cwd}
   } else {
     skipCheck("rust", "Cargo.toml not found");
   }
-  if (existsSync14(path21.join(cwd, "pyproject.toml")) || existsSync14(path21.join(cwd, "pytest.ini")) || existsSync14(path21.join(cwd, "tests"))) {
+  if (existsSync15(path21.join(cwd, "pyproject.toml")) || existsSync15(path21.join(cwd, "pytest.ini")) || existsSync15(path21.join(cwd, "tests"))) {
     if (commandOnPath2("pytest"))
       runCheck("pytest", "pytest", []);
     else
@@ -5216,7 +5452,7 @@ root: ${cwd}
     lines.push(`status: skipped (dry run)
 `);
     skipped += 1;
-  } else if (existsSync14(changelogPath)) {
+  } else if (existsSync15(changelogPath)) {
     if (/## \[Unreleased\]/i.test(readFileSync15(changelogPath, "utf8"))) {
       lines.push(`status: pass
 `);
@@ -5330,7 +5566,7 @@ var emptyState = (slug) => ({
 });
 var readFlowState = (root2, slug) => {
   const file = flowPath(root2, slug);
-  if (!existsSync15(file))
+  if (!existsSync16(file))
     return emptyState(slug);
   try {
     return normalizeState(JSON.parse(readFileSync16(file, "utf8")), slug);
@@ -5472,7 +5708,7 @@ var validateState = (parsed, slug) => {
 var readFlowStrict = (root2, slug) => {
   const file = flowPath(root2, slug);
   const rel = path22.posix.join("docs", slug, "sdd", "flow.json");
-  if (!existsSync15(file)) {
+  if (!existsSync16(file)) {
     return err2("flow_not_activated", `flow not activated for ${slug} — run workit_flow_status first`);
   }
   let text;
@@ -5509,15 +5745,15 @@ var writeFlowFileAtomic = (file, state) => {
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
-    renameSync2(tmp, file);
+    renameSync3(tmp, file);
   } finally {
     try {
       if (fd !== null)
         closeSync(fd);
     } catch {}
     try {
-      if (existsSync15(tmp))
-        rmSync2(tmp, { force: true });
+      if (existsSync16(tmp))
+        rmSync3(tmp, { force: true });
     } catch {}
   }
 };
@@ -5525,14 +5761,14 @@ var MAX_WRITE_ATTEMPTS = 5;
 var STALE_LOCK_MS = 1000;
 var lockMtimeMs = (lock) => {
   try {
-    return statSync7(lock).mtimeMs;
+    return statSync8(lock).mtimeMs;
   } catch {
     return null;
   }
 };
 var lockOwnedBy = (fd, lock) => {
   try {
-    return fstatSync(fd).ino === statSync7(lock).ino;
+    return fstatSync(fd).ino === statSync8(lock).ino;
   } catch {
     return false;
   }
@@ -5548,7 +5784,7 @@ var writeFlowStateIfCurrent = (root2, expected, next) => {
   const tmp = uniqueTempPath(file);
   let fd = null;
   try {
-    const currentText = existsSync15(file) ? readFileSync16(file, "utf8") : null;
+    const currentText = existsSync16(file) ? readFileSync16(file, "utf8") : null;
     if (currentText !== expectedText)
       return { ok: false, conflict: true };
     mkdirSync9(path22.dirname(file), { recursive: true });
@@ -5557,10 +5793,10 @@ var writeFlowStateIfCurrent = (root2, expected, next) => {
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
-    const reRead = existsSync15(file) ? readFileSync16(file, "utf8") : null;
+    const reRead = existsSync16(file) ? readFileSync16(file, "utf8") : null;
     if (reRead !== expectedText)
       return { ok: false, conflict: true };
-    renameSync2(tmp, file);
+    renameSync3(tmp, file);
     return { ok: true };
   } catch (error) {
     return { ok: false, io_error: error instanceof Error ? error.message : String(error) };
@@ -5570,8 +5806,8 @@ var writeFlowStateIfCurrent = (root2, expected, next) => {
         closeSync(fd);
     } catch {}
     try {
-      if (existsSync15(tmp))
-        rmSync2(tmp, { force: true });
+      if (existsSync16(tmp))
+        rmSync3(tmp, { force: true });
     } catch {}
   }
 };
@@ -5592,7 +5828,7 @@ var readCanonicalDigest = (root2, rel) => {
   } 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") };
 };
 var resetForSpecDrift = (state) => ({
   ...state,
@@ -5668,11 +5904,11 @@ var normalizeCompatibility = (root2, slug, parsed, state) => {
 };
 var withFlowLock = (file, fn) => {
   const lock = `${file}.lock`;
-  if (!existsSync15(path22.dirname(file)))
+  if (!existsSync16(path22.dirname(file)))
     return { locked: true, value: fn() };
   try {
-    if (existsSync15(`${lock}.stale`))
-      rmSync2(`${lock}.stale`, { force: true });
+    if (existsSync16(`${lock}.stale`))
+      rmSync3(`${lock}.stale`, { force: true });
   } catch {}
   const wait = new Int32Array(new SharedArrayBuffer(4));
   let fd = null;
@@ -5691,7 +5927,7 @@ var withFlowLock = (file, fn) => {
       const mtime = lockMtimeMs(lock);
       if (mtime !== null && Date.now() - mtime > STALE_LOCK_MS) {
         try {
-          renameSync2(lock, `${lock}.stale`);
+          renameSync3(lock, `${lock}.stale`);
           unlinkSync2(`${lock}.stale`);
         } catch {}
         try {
@@ -5727,7 +5963,7 @@ var withFlowLock = (file, fn) => {
   } finally {
     try {
       if (fd !== null && lockOwnedBy(fd, lock))
-        rmSync2(lock, { force: true });
+        rmSync3(lock, { force: true });
     } catch {}
     try {
       if (fd !== null)
@@ -6044,7 +6280,7 @@ var prepareFlowState = (root2, slug, opts = {}, ctx) => {
   const planPath = path22.posix.join("docs", slug, "plan.md");
   const file = flowPath(root2, slug);
   const locked = withFlowLock(file, () => {
-    if (!existsSync15(file)) {
+    if (!existsSync16(file)) {
       writeFlowFileAtomic(file, {
         slug,
         activated: true,
@@ -6085,7 +6321,7 @@ var transitionSpec = (root2, slug, specPath, evidence, ctx) => {
     return err2("path_invalid", doc.error);
   const relPath = path22.posix.join("docs", slug, "spec.md");
   return readModifyWrite(root2, slug, (state) => {
-    if (!existsSync15(doc.path))
+    if (!existsSync16(doc.path))
       return err2("spec_missing", `spec not found: ${specPath}`);
     if (state.spec.status === "draft" || state.spec.status === "self_reviewed") {
       const digest = readCanonicalDigest(root2, relPath);
@@ -6130,7 +6366,7 @@ var transitionPlan = (root2, slug, planPath, evidence, ctx) => {
     return err2("path_invalid", doc.error);
   const relPath = path22.posix.join("docs", slug, "plan.md");
   return readModifyWrite(root2, slug, (state) => {
-    if (!existsSync15(doc.path))
+    if (!existsSync16(doc.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");
@@ -6796,7 +7032,7 @@ var subagentDrivenInterception = (input) => {
 var findActiveSubagentDrivenContexts = (root2) => {
   let entries = [];
   try {
-    entries = readdirSync6(path22.join(root2, "docs"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    entries = readdirSync7(path22.join(root2, "docs"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -6910,7 +7146,7 @@ var detectBacktickDocRefs = (text) => {
 };
 var scanActiveSubagentDrivenPlans = (root2) => {
   const docsDir = path23.join(root2, "docs");
-  if (!existsSync16(docsDir))
+  if (!existsSync17(docsDir))
     return { slugs: [], read_errors: [] };
   const slugs = [];
   const readErrors = [];
@@ -6931,9 +7167,9 @@ var scanActiveSubagentDrivenPlans = (root2) => {
     if (exec.status === "active" && exec.mode === "subagent-driven")
       slugs.push(slug);
   };
-  for (const slug of readdirSync7(docsDir)) {
+  for (const slug of readdirSync8(docsDir)) {
     const file = path23.join(docsDir, slug, "sdd", "flow.json");
-    if (!existsSync16(file))
+    if (!existsSync17(file))
       continue;
     let raw;
     try {
@@ -19276,7 +19512,7 @@ function tool(input) {
 tool.schema = exports_external;
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync17, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync18, realpathSync as realpathSync3 } from "node:fs";
 import path24 from "node:path";
 var ok = (data) => ({ ok: true, data, error: null });
 var fail = (error45, data = null) => ({
@@ -19316,7 +19552,7 @@ function resolveInside(root2, candidate) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
-  while (!existsSync17(ancestor))
+  while (!existsSync18(ancestor))
     ancestor = path24.dirname(ancestor);
   const canonicalAncestor = realpathSync3(ancestor);
   if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path24.sep)) {
@@ -19926,12 +20162,14 @@ function createRepoTools(runtime = defaultRuntime) {
         } catch (error45) {
           return output(fail(error45 instanceof Error ? error45.message : "invalid SDD path"));
         }
+        const diagnostic = getDiagnosticLogger();
         const result = branchSetup({
           action,
           sdd_dir: resolvedSdd,
           target_branch,
           stash,
-          workspace_root: context2.directory
+          workspace_root: context2.directory,
+          log: diagnostic ? (message) => diagnostic.info(message) : undefined
         });
         return output(legacyScriptResult({
           stdout: JSON.stringify(result),
@@ -20056,7 +20294,7 @@ function createRepoTools(runtime = defaultRuntime) {
           return output(result.ok ? ok(result) : fail(result.error));
         }
         if (action === "config") {
-          const LOCALE_RE2 = /^[a-z]{2,3}(-[A-Z]{2})?$/;
+          const LOCALE_RE2 = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
           if (locale !== undefined && !LOCALE_RE2.test(locale)) {
             return output(fail(`invalid locale: ${JSON.stringify(locale)} — expected BCP-47 like en or es-CL`));
           }
@@ -20562,12 +20800,12 @@ import path32 from "node:path";
 import path31 from "node:path";
 
 // packages/workit-core/src/core/handoff-context.ts
-import { existsSync as existsSync18, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync20, readdirSync as readdirSync9, statSync as statSync9 } from "node:fs";
 import path30 from "node:path";
 var DOC_RE = /docs\/([A-Za-z0-9][A-Za-z0-9._-]*)\/(spec|plan)\.md/g;
 var listMd = (dir) => {
   try {
-    return readdirSync8(dir).filter((f) => f.endsWith(".md")).sort();
+    return readdirSync9(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -20583,7 +20821,7 @@ var resolveFromMessagePaths = (root2, message) => {
   const slug = slugs[0];
   const plan = `docs/${slug}/plan.md`;
   const spec = `docs/${slug}/spec.md`;
-  if (!existsSync18(path30.join(root2, plan)) || !existsSync18(path30.join(root2, spec))) {
+  if (!existsSync19(path30.join(root2, plan)) || !existsSync19(path30.join(root2, spec))) {
     return { error: `docs/${slug}/ must contain both plan.md and spec.md` };
   }
   return { spec, plan, source: "message_paths" };
@@ -20593,7 +20831,7 @@ var resolveActivePair = (root2) => {
   let best = null;
   let entries = [];
   try {
-    entries = readdirSync8(docsDir);
+    entries = readdirSync9(docsDir);
   } catch {
     return { error: "no pair" };
   }
@@ -20602,9 +20840,9 @@ var resolveActivePair = (root2) => {
       continue;
     const plan = path30.join("docs", slug, "plan.md");
     const spec = path30.join("docs", slug, "spec.md");
-    if (!existsSync18(path30.join(root2, plan)) || !existsSync18(path30.join(root2, spec)))
+    if (!existsSync19(path30.join(root2, plan)) || !existsSync19(path30.join(root2, spec)))
       continue;
-    const score = Math.max(statSync8(path30.join(root2, spec)).mtimeMs, statSync8(path30.join(root2, plan)).mtimeMs);
+    const score = Math.max(statSync9(path30.join(root2, spec)).mtimeMs, statSync9(path30.join(root2, plan)).mtimeMs);
     if (best === null || score > best.score || score === best.score && slug < best.spec.split("/")[1]) {
       best = { score, spec, plan, source: "active_pair" };
     }
@@ -20623,7 +20861,7 @@ var resolveWorkflowPaths = (root2, message) => {
   if (!("error" in active))
     return active;
   const docsDir = path30.join(root2, "docs");
-  if (!existsSync18(docsDir) || listMd(docsDir).length === 0) {
+  if (!existsSync19(docsDir) || listMd(docsDir).length === 0) {
     return { error: "no docs/<slug>/ features found under docs/" };
   }
   return {
@@ -20793,7 +21031,7 @@ function createHandoffTools(client, state) {
 import path34 from "node:path";
 
 // packages/workit-core/src/core/youtrack-tools.ts
-import { readFileSync as readFileSync21, statSync as statSync9 } from "node:fs";
+import { readFileSync as readFileSync21, statSync as statSync10 } from "node:fs";
 import os3 from "node:os";
 import path33 from "node:path";
 var ISSUE_RE2 = /^[A-Z]+-\d+$/;
@@ -20813,7 +21051,7 @@ function readCredentials(env = process.env, home = os3.homedir()) {
   const config2 = parsed;
   const tokenFile = config2.tokenFile ?? "youtrack.token";
   const tokenPath = path33.resolve(path33.dirname(resolvedConfig), tokenFile.replace(/^~(?=\/)/, home));
-  if (process.platform !== "win32" && (statSync9(tokenPath).mode & 511) !== 384)
+  if (process.platform !== "win32" && (statSync10(tokenPath).mode & 511) !== 384)
     throw new Error("youtrack.token mode must be 0600");
   const token = readFileSync21(tokenPath, "utf8").trim();
   if (!token)
@@ -21271,7 +21509,7 @@ function createPresentTools() {
 }
 
 // packages/workit-core/src/core/docs-repo.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync12, readdirSync as readdirSync9 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync12, readdirSync as readdirSync10 } from "node:fs";
 import { execFileSync as execFileSync5 } from "node:child_process";
 import path35 from "node:path";
 var configPath2 = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path35.join(configDir(), "docs-repo.json");
@@ -21291,7 +21529,7 @@ var writeDocsRepoConfig = (docsPath) => {
 };
 var docsRepoPath = () => readDocsRepoConfig()?.path ?? null;
 var validateDocsRepo = (docsPath) => {
-  if (!existsSync19(docsPath))
+  if (!existsSync20(docsPath))
     return { ok: false, error: `docs repo path does not exist: ${docsPath}` };
   try {
     execFileSync5("git", ["-C", docsPath, "rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
@@ -21299,7 +21537,7 @@ var validateDocsRepo = (docsPath) => {
     return { ok: false, error: `docs repo is not a git repository: ${docsPath}` };
   }
   const featuresDir = path35.join(docsPath, "features");
-  if (!existsSync19(featuresDir))
+  if (!existsSync20(featuresDir))
     mkdirSync10(featuresDir, { recursive: true });
   return { ok: true };
 };
@@ -21316,19 +21554,19 @@ var listSpecs = (workspaceRoot) => {
   const repoPath = docsRepoPath();
   const specs = [];
   const docsDir = path35.join(workspaceRoot, "docs");
-  if (existsSync19(docsDir)) {
-    for (const slug of readdirSync9(docsDir)) {
+  if (existsSync20(docsDir)) {
+    for (const slug of readdirSync10(docsDir)) {
       if (slug.startsWith("."))
         continue;
       const spec = path35.posix.join("docs", slug, "spec.md");
-      if (!existsSync19(path35.join(workspaceRoot, spec)))
+      if (!existsSync20(path35.join(workspaceRoot, spec)))
         continue;
       let promoted = false;
       let target = null;
       if (repoPath) {
         const featuresDir = path35.join(repoPath, "features");
-        if (existsSync19(featuresDir)) {
-          const match = readdirSync9(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
+        if (existsSync20(featuresDir)) {
+          const match = readdirSync10(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
           if (match) {
             promoted = true;
             target = path35.join(repoPath, "features", match);
@@ -21402,7 +21640,7 @@ var promoteSpec = (workspaceRoot, slug, opts) => {
   }
   if (!opts.force) {
     const sddDir = path35.join(workspaceRootCanonical, "docs", slug, "sdd");
-    if (existsSync19(sddDir)) {
+    if (existsSync20(sddDir)) {
       try {
         execFileSync5("git", [
           "-C",
@@ -21420,7 +21658,7 @@ var promoteSpec = (workspaceRoot, slug, opts) => {
   }
   const prefix = monthPrefix();
   const featuresDir = path35.join(repoPath, "features");
-  const existing = existsSync19(featuresDir) ? readdirSync9(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d)) : undefined;
+  const existing = existsSync20(featuresDir) ? readdirSync10(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d)) : undefined;
   const targetDir = path35.join(featuresDir, existing ?? `${prefix}-${slug}`);
   mkdirSync10(targetDir, { recursive: true });
   const files = ["spec.md"];
@@ -21479,15 +21717,15 @@ ${row}
 // packages/workit-core/src/core/docs-migration.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync11,
-  readdirSync as readdirSync10,
+  readdirSync as readdirSync11,
   readFileSync as readFileSync23,
   realpathSync as realpathSync5,
-  renameSync as renameSync3,
-  rmSync as rmSync3,
-  statSync as statSync10,
+  renameSync as renameSync4,
+  rmSync as rmSync4,
+  statSync as statSync11,
   writeFileSync as writeFileSync13
 } from "node:fs";
 import path36 from "node:path";
@@ -21536,14 +21774,14 @@ var explicitTargetSlug = (planText) => {
 var detectLegacyDocs = (workspace_root) => {
   const root2 = legacyRoot(workspace_root);
   const raw = [];
-  if (existsSync20(root2)) {
-    for (const entry of readdirSync10(root2, { withFileTypes: true })) {
+  if (existsSync21(root2)) {
+    for (const entry of readdirSync11(root2, { withFileTypes: true })) {
       const abs = path36.join(root2, entry.name);
       const rel = posix3(path36.relative(workspace_root, abs));
       if (entry.isDirectory()) {
-        const hasSpec = existsSync20(path36.join(abs, "spec.md"));
-        const hasPlan = existsSync20(path36.join(abs, "plan.md"));
-        if (!hasSpec && !hasPlan && !existsSync20(path36.join(abs, "sdd")))
+        const hasSpec = existsSync21(path36.join(abs, "spec.md"));
+        const hasPlan = existsSync21(path36.join(abs, "plan.md"));
+        if (!hasSpec && !hasPlan && !existsSync21(path36.join(abs, "sdd")))
           continue;
         const explicit = explicitTargetSlug(hasPlan ? readFileSafe(path36.join(abs, "plan.md")) : null);
         raw.push({
@@ -21551,7 +21789,7 @@ var detectLegacyDocs = (workspace_root) => {
           legacy_dir: rel,
           spec: hasSpec ? posix3(path36.join(rel, "spec.md")) : null,
           plan: hasPlan ? posix3(path36.join(rel, "plan.md")) : null,
-          sdd: existsSync20(path36.join(abs, "sdd")),
+          sdd: existsSync21(path36.join(abs, "sdd")),
           explicit: explicit !== null
         });
       } else if (entry.name === "spec.md" || entry.name === "plan.md") {
@@ -21679,7 +21917,7 @@ var planTree = (workspace, legacyAbs, legacyRel, destRelRoot, destAbsRoot, legac
   if (visits.has(real))
     return { ok: true };
   visits.add(real);
-  for (const entry of readdirSync10(real, { withFileTypes: true })) {
+  for (const entry of readdirSync11(real, { withFileTypes: true })) {
     const fromAbs = path36.join(real, entry.name);
     const fromRel = posix3(path36.join(legacyRel, entry.name));
     const toRel = posix3(path36.join(destRelRoot, entry.name));
@@ -21699,7 +21937,7 @@ var planTree = (workspace, legacyAbs, legacyRel, destRelRoot, destAbsRoot, legac
         if (target !== workspaceReal && !target.startsWith(workspaceReal + path36.sep)) {
           return { ok: false, error: `symlink escape refused: ${fromRel}` };
         }
-        if (statSync10(target).isDirectory()) {
+        if (statSync11(target).isDirectory()) {
           const sub = planTree(workspace, fromAbs, fromRel, toRel, path36.join(destAbsRoot, entry.name), legacyName, slug, plan, visits);
           if (!sub.ok)
             return sub;
@@ -21806,7 +22044,7 @@ var migrateLegacyDocs = (input) => {
   }
   const collisions = [];
   for (const item of plan) {
-    if (!existsSync20(item.destAbs))
+    if (!existsSync21(item.destAbs))
       continue;
     let identical = false;
     try {
@@ -21847,10 +22085,10 @@ var migrateLegacyDocs = (input) => {
     try {
       mkdirSync11(path36.dirname(item.destAbs), { recursive: true });
       writeFileSync13(tmp, item.bytes);
-      renameSync3(tmp, item.destAbs);
+      renameSync4(tmp, item.destAbs);
     } catch (error45) {
       try {
-        rmSync3(tmp, { force: true });
+        rmSync4(tmp, { force: true });
       } catch {}
       return abort(`legacy migration retry required: failed to copy ${item.fromRel}: ${error45 instanceof Error ? error45.message : String(error45)}`);
     }
@@ -22050,7 +22288,7 @@ SDD: ${value.sdd}` : null;
 }
 
 // packages/workit-core/src/core/logger.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync12, readdirSync as readdirSync11, unlinkSync as unlinkSync3 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync12, readdirSync as readdirSync12, unlinkSync as unlinkSync3 } from "node:fs";
 import os4 from "node:os";
 import path37 from "node:path";
 var REDACTED = "[REDACTED]";
@@ -22185,7 +22423,7 @@ var dailyFileName = (date5) => {
 };
 var pruneOldFiles = (dir) => {
   try {
-    const files = readdirSync11(dir).filter((name) => DAY_FILE.test(name)).sort().reverse();
+    const files = readdirSync12(dir).filter((name) => DAY_FILE.test(name)).sort().reverse();
     for (const file2 of files.slice(RETAINED_DAYS)) {
       try {
         unlinkSync3(path37.join(dir, file2));
@@ -22348,16 +22586,16 @@ var worktreeDenials = {
 };
 var hasMarkedDestination = (root3) => {
   const docsDir = path39.join(root3, "docs");
-  if (!existsSync21(docsDir))
+  if (!existsSync22(docsDir))
     return false;
   let slugs;
   try {
-    slugs = readdirSync12(docsDir);
+    slugs = readdirSync13(docsDir);
   } catch {
     return false;
   }
   for (const slug of slugs) {
-    if (!existsSync21(path39.join(docsDir, slug, "sdd", "flow.json")))
+    if (!existsSync22(path39.join(docsDir, slug, "sdd", "flow.json")))
       continue;
     const effective = readEffectiveFlowState(root3, slug);
     if (effective.ok && effective.state.handoff_destination)
@@ -22482,7 +22720,7 @@ var plugin = async ({ client, directory }) => {
       const skillPath = path39.join(root2, "skills");
       const vendoredSkillsPath = path39.join(root2, "vendor", "superpowers", "skills");
       for (const p of [skillPath, vendoredSkillsPath]) {
-        if (existsSync21(p) && !mutable.skills.paths.includes(p)) {
+        if (existsSync22(p) && !mutable.skills.paths.includes(p)) {
           mutable.skills.paths.push(p);
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "private": false,
   "description": "Workit OpenCode plugin (thin wrapper over @brainervirus/workit-core)",
   "keywords": [
@@ -34,7 +34,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^0.9.0"
+    "@brainervirus/workit-core": "^0.10.0"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.17.7"