@brainervirus/workit-core 0.6.0 → 0.6.1

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "private": false,
   "description": "Workit — workflow rails for agentic coding: specs, plans, YouTrack, CI-gated commits (shared core)",
-  "license": "MIT",
   "keywords": [
-    "opencode",
+    "agent",
     "cursor",
-    "workflow",
     "mcp",
-    "youTrack",
-    "agent"
+    "opencode",
+    "workflow",
+    "youTrack"
   ],
   "bugs": {
     "url": "https://github.com/BrainerVirus/workit/issues"
   },
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/BrainerVirus/workit.git"
@@ -37,12 +37,12 @@
     "./src/*": "./src/*.ts",
     "./package.json": "./package.json"
   },
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.24.0"

package/scripts/_shared/common.sh

@@ -53,7 +53,6 @@ is_pr_branch() {
   esac
 }
 
-# ponytail: develop-only base — main is release-only in this workflow; never compare PRs to main
 resolve_pr_branch_context() {
   branch=$(current_branch)
 
@@ -74,7 +73,23 @@ resolve_pr_branch_context() {
   best_ref=""
   best_mb=""
 
-  for ref in origin/develop develop; do
+  resolved=$(bash "$SCRIPT_DIR/vcs/config.sh" resolve 2>/dev/null) || {
+    printf 'ERROR: cannot resolve the configured PR target branch\n' >&2
+    return 1
+  }
+  base=$(printf '%s\n' "$resolved" | bun -e '
+    const value = JSON.parse(await Bun.stdin.text()).defaultTargetBranch;
+    if (typeof value === "string" && value) process.stdout.write(value);
+  ') || {
+    printf 'ERROR: invalid VCS target-branch configuration\n' >&2
+    return 1
+  }
+  if [ "$base" = "" ] || ! git check-ref-format --branch "$base" >/dev/null 2>&1; then
+    printf 'ERROR: invalid configured PR target branch %s\n' "$base" >&2
+    return 1
+  fi
+
+  for ref in "origin/$base" "$base"; do
     git rev-parse --verify "$ref" >/dev/null 2>&1 || continue
     mb=$(git merge-base "$ref" HEAD 2>/dev/null) || continue
     best_ref=$ref
@@ -83,7 +98,7 @@ resolve_pr_branch_context() {
   done
 
   if [ "$best_ref" = "" ] || [ "$best_mb" = "" ]; then
-    printf 'ERROR: develop branch not found — PRs target develop (not main). Fetch/checkout develop or pass an explicit git range\n' >&2
+    printf 'ERROR: configured PR target branch %s not found — fetch/checkout it or pass an explicit git range\n' "$base" >&2
     return 1
   fi
 

package/scripts/install-opencode-plugin.sh

@@ -3,14 +3,14 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
-ROOT="$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)"
+ROOT="$(CDPATH= cd -- "$SCRIPT_DIR/../../.." && pwd)"
+CORE_SCRIPTS="$ROOT/packages/workit-core/scripts"
 SHARE="${HOME}/.local/share/workflow-toolkit"
-DEV_DEFAULT="${HOME}/Documents/projects/personal/workflow-toolkit"
-DEV="${WORKFLOW_TOOLKIT_DEV:-$DEV_DEFAULT}"
+DEV="${WORKFLOW_TOOLKIT_DEV:-$ROOT}"
 CONFIG="${HOME}/.config/opencode/opencode.json"
 
-chmod +x "$ROOT/scripts/sync-runtime.sh"
-WORKFLOW_TOOLKIT_DEV="$ROOT" "$ROOT/scripts/sync-runtime.sh"
+chmod +x "$CORE_SCRIPTS/sync-runtime.sh"
+WORKFLOW_TOOLKIT_DEV="$ROOT" "$CORE_SCRIPTS/sync-runtime.sh"
 
 # Prefer monorepo with .git. file:// pins skip opencode's bundled npm installer —
 # git+file:// installs an EMPTY cache dir and fails silently, so the plugin never
@@ -40,9 +40,14 @@ const pin = process.env.PIN_PATH!;
 const data = JSON.parse(fs.readFileSync(path, "utf8"));
 let plugins = data.plugin || [];
 if (typeof plugins === "string") plugins = [plugins];
-// Drop stale workflow-toolkit pins — the new file:// pin is written fresh.
-data.plugin = plugins.filter((p) => !String(p).includes("workflow-toolkit"));
-data.plugin.push(pin);
+// Load the dev pin first and remove every stale/current Workit identity.
+const isWorkit = (p) => {
+  const value = String(p);
+  return value.includes("workflow-toolkit") ||
+    value.includes("@brainervirus/workit-opencode") ||
+    value.includes("/packages/workit-opencode/");
+};
+data.plugin = [pin, ...plugins.filter((p) => !isWorkit(p))];
 // Drop share skills.paths — native ~/.config/opencode/skills links avoid triple-load dups
 const skills = data.skills;
 if (skills && typeof skills === "object") {
@@ -73,4 +78,4 @@ if [ ! -s "$PLUGIN_ENTRY" ]; then
   exit 1
 fi
 
-echo "OpenCode install done. Fully quit all opencode processes, then restart."
+echo "OpenCode install done. Fully quit all opencode processes, then restart."

package/src/core/branch.ts

@@ -3,22 +3,36 @@ import { execFileSync } from "node:child_process";
 import path from "node:path";
 import { gitContext } from "./git";
 import { readConfig, resolveBranchPolicy } from "./config";
+import { vcsConfig } from "./vcs-config";
 
 const policy = () => resolveBranchPolicy(readConfig());
 const allowedBranch = (name: string) => policy().allowed.some((r) => r.test(name));
 const isProtected = (name: string) => policy().protected.has(name.toLowerCase());
+const baseBranch = (cwd: string) =>
+  String(vcsConfig("resolve", cwd).defaultTargetBranch ?? "develop");
 const DECLARE_RE = /^\s*\*+Branch:\*+\s*`?([^`\s|]+)`?\s*$/gim;
 const USE_CURRENT_RE = /^\s*\*+Branch:\*+\s*use-current\s*$/im;
 const readSafe = (p: string): string | null => {
-  try { return readFileSync(p, "utf8"); } catch { return null; }
+  try {
+    return readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
 };
 
 const normalizeBranch = (name: string): string | null => {
   const n = name.trim().replace(/`/g, "").replace(/\.+$/, "");
   if (isProtected(n)) return null;
   if (!allowedBranch(n)) return null;
-  const parts = n.toLowerCase().split("/").map((p) =>
-    p.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-"));
+  const parts = n
+    .toLowerCase()
+    .split("/")
+    .map((p) =>
+      p
+        .replace(/[^\w.-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-"),
+    );
   if (parts.some((p) => !p)) return null;
   return parts.join("/");
 };
@@ -29,14 +43,21 @@ const deriveSlug = (planPath: string): string => {
   return dirName === "." || dirName === "/" || dirName === "" ? "" : dirName;
 };
 
-const deriveKind = (planPath: string, fallback: "feature" | "bugfix" = "feature"): "feature" | "bugfix" => {
+const deriveKind = (
+  planPath: string,
+  fallback: "feature" | "bugfix" = "feature",
+): "feature" | "bugfix" => {
   const slug = deriveSlug(planPath);
   const text = readSafe(planPath) ?? "";
   let kind = fallback;
   if (/\bbugfix\b/i.test(slug) || /^fix-/i.test(slug)) {
     kind = "bugfix";
   } else {
-    const goal = text.split("\n").find((line) => line.startsWith("**Goal:**"))?.toLowerCase() ?? "";
+    const goal =
+      text
+        .split("\n")
+        .find((line) => line.startsWith("**Goal:**"))
+        ?.toLowerCase() ?? "";
     if (/\b(bugfix|bug fix)\b/.test(goal) && !/\b(feat|feature|upgrade|add)\b/.test(goal)) {
       kind = "bugfix";
     }
@@ -49,7 +70,11 @@ export const resolveBranch = ({
   spec_path,
   plan_path,
   workspace_root,
-}: { spec_path: string; plan_path: string; workspace_root: string }) => {
+}: {
+  spec_path: string;
+  plan_path: string;
+  workspace_root: string;
+}) => {
   const cwd = path.resolve(workspace_root);
   const abs = (p: string) => (path.isAbsolute(p) ? p : path.join(cwd, p));
   const spec = abs(spec_path);
@@ -76,7 +101,8 @@ export const resolveBranch = ({
     }
   }
 
-  if (current && allowedBranch(current) && !isProtected(current)) return finish(current, "keep-current");
+  if (current && allowedBranch(current) && !isProtected(current))
+    return finish(current, "keep-current");
 
   let declaredButInvalid: string | null = null;
   for (const file of [spec, plan]) {
@@ -89,7 +115,9 @@ export const resolveBranch = ({
     }
   }
   if (declaredButInvalid) {
-    return { error: `declared branch ${JSON.stringify(declaredButInvalid)} is not allowed by the branch policy` };
+    return {
+      error: `declared branch ${JSON.stringify(declaredButInvalid)} is not allowed by the branch policy`,
+    };
   }
 
   const slug = deriveSlug(plan);
@@ -103,55 +131,101 @@ export const docsBranch = ({
   plan_path,
   kind,
   workspace_root,
-}: { plan_path?: string; kind?: string; workspace_root: string }) => {
+}: {
+  plan_path?: string;
+  kind?: string;
+  workspace_root: string;
+}) => {
   const cwd = path.resolve(workspace_root);
   const git = gitContext(cwd);
   const current = git.branch;
   const kindArg = (kind ?? "feature").toLowerCase();
+  const base = baseBranch(cwd);
 
-  if (current && allowedBranch(current) && !isProtected(current)) {
-    return { branch: current, action: "keep", current_branch: current, base: "develop", dirty: Boolean(git.status_short.trim()) };
-  }
-  if (current === "main" || current === "master" || current === "develop") {
+  if (current === base || current === "main" || current === "master" || current === "develop") {
     let slug = "";
     if (plan_path) {
       const plan = path.isAbsolute(plan_path) ? plan_path : path.join(cwd, plan_path);
       slug = deriveSlug(plan);
     }
     if (!slug) {
-      return { error: "plan_path required to derive branch slug when not on feature/* or bugfix/*" };
+      return {
+        error: "plan_path required to derive branch slug when not on feature/* or bugfix/*",
+      };
     }
     const branchKind = kindArg === "bugfix" ? "bugfix" : "feature";
-    return { branch: `${branchKind}/${slug}`, action: "create_from_develop", current_branch: current, base: "develop", dirty: Boolean(git.status_short.trim()) };
+    return {
+      branch: `${branchKind}/${slug}`,
+      action: base === "develop" ? "create_from_develop" : "create_from_base",
+      current_branch: current,
+      base,
+      dirty: Boolean(git.status_short.trim()),
+    };
+  }
+  if (current && allowedBranch(current) && !isProtected(current)) {
+    return {
+      branch: current,
+      action: "keep",
+      current_branch: current,
+      base,
+      dirty: Boolean(git.status_short.trim()),
+    };
   }
   return { error: `cannot resolve docs branch from HEAD ${JSON.stringify(current)}` };
 };
 
 // Port of scripts/lib/ensure-develop-base.sh
-export const ensureDevelopBase = (cwd: string): { ok: boolean; error?: string } => {
+export const ensureBaseBranch = (cwd: string, base: string): { ok: boolean; error?: string } => {
   const git = gitContext(cwd);
-  if (!git.branch || git.branch === "unknown") return { ok: false, error: "not in a git repository" };
-  const run = (args: string[]) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  if (!git.branch || git.branch === "unknown")
+    return { ok: false, error: "not in a git repository" };
+  const run = (args: string[]) =>
+    execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   try {
     try {
-      run(["fetch", "origin", "develop", "--prune"]);
+      run(["fetch", "origin", base, "--prune"]);
     } catch {
       run(["fetch", "origin", "--prune"]);
     }
-    let hasOriginDevelop = true;
-    try { execFileSync("git", ["show-ref", "--verify", "--quiet", "refs/remotes/origin/develop"], { cwd, stdio: "pipe" }); } catch { hasOriginDevelop = false; }
-    if (!hasOriginDevelop) return { ok: false, error: "origin/develop missing — push develop before creating feature/* or bugfix/* branches" };
-    let hasLocalDevelop = true;
-    try { execFileSync("git", ["show-ref", "--verify", "--quiet", "refs/heads/develop"], { cwd, stdio: "pipe" }); } catch { hasLocalDevelop = false; }
-    if (hasLocalDevelop) {
-      run(["checkout", "develop"]);
-      try { run(["merge", "--ff-only", "origin/develop"]); } catch { /* non-fast-forward: keep local */ }
+    let hasOriginBase = true;
+    try {
+      execFileSync("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`,
+      };
+    let hasLocalBase = true;
+    try {
+      execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
+        cwd,
+        stdio: "pipe",
+      });
+    } catch {
+      hasLocalBase = false;
+    }
+    if (hasLocalBase) {
+      run(["checkout", base]);
+      try {
+        run(["merge", "--ff-only", `origin/${base}`]);
+      } catch {
+        /* non-fast-forward: keep local */
+      }
     } else {
-      run(["checkout", "-b", "develop", "--track", "origin/develop"]);
+      run(["checkout", "-b", base, "--track", `origin/${base}`]);
     }
     return { ok: true };
   } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : "ensure-develop-base failed" };
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "ensure-base-branch failed",
+    };
   }
 };
 
@@ -162,17 +236,29 @@ export const branchSetup = ({
   target_branch,
   stash,
   workspace_root,
-}: { action?: string; sdd_dir?: string; target_branch?: string; stash?: string; workspace_root: string }) => {
+}: {
+  action?: string;
+  sdd_dir?: string;
+  target_branch?: string;
+  stash?: string;
+  workspace_root: string;
+}) => {
   const cwd = path.resolve(workspace_root);
   const exec = (args: string[]): string =>
     execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   const current = gitContext(cwd).branch;
   if (!current || current === "unknown") return { error: "not in a git repository" };
   const sdd = sdd_dir ?? "docs";
-  const manifestPath = path.isAbsolute(sdd) ? path.join(sdd, "manifest.json") : path.join(cwd, sdd, "manifest.json");
+  const manifestPath = path.isAbsolute(sdd)
+    ? path.join(sdd, "manifest.json")
+    : path.join(cwd, sdd, "manifest.json");
   mkdirSync(path.dirname(manifestPath), { recursive: true, mode: 0o755 });
   const readManifest = (): Record<string, unknown> => {
-    try { return JSON.parse(readFileSync(manifestPath, "utf8")); } catch { return {}; }
+    try {
+      return JSON.parse(readFileSync(manifestPath, "utf8"));
+    } catch {
+      return {};
+    }
   };
   const writeManifest = (data: Record<string, unknown>) =>
     writeFileSync(manifestPath, JSON.stringify(data, null, 2) + "\n", "utf8");
@@ -181,7 +267,9 @@ export const branchSetup = ({
     const manifest = readManifest();
     const ref = manifest.stash_ref;
     if (!ref) return { error: "no stash_ref in manifest" };
-    try { exec(["stash", "pop", String(ref)]); } catch (error) {
+    try {
+      exec(["stash", "pop", String(ref)]);
+    } catch (error) {
       return { error: error instanceof Error ? error.message : "stash pop failed" };
     }
     delete manifest.stash_ref;
@@ -193,14 +281,18 @@ export const branchSetup = ({
   const target = target_branch ?? "";
   if (!target) return { error: "target branch required" };
   if (isProtected(target)) return { error: `protected branch ${target}` };
-  if (!allowedBranch(target)) return { error: `target branch ${target} is not allowed by the branch policy` };
+  if (!allowedBranch(target))
+    return { error: `target branch ${target} is not allowed by the branch policy` };
 
   let stash_ref: string | undefined;
   if (current !== target) {
     const dirty = Boolean(gitContext(cwd).status_short.trim());
     if (dirty) {
       if (stash !== "yes") {
-        return { error: "dirty working tree — ask with native question, then call workflow_branch_setup with stash=yes" };
+        return {
+          error:
+            "dirty working tree — ask with native question, then call workflow_branch_setup with stash=yes",
+        };
       }
       try {
         exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`, "--", ":!docs/*/sdd"]);
@@ -214,22 +306,18 @@ export const branchSetup = ({
     } 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 {
+          error: `branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`,
+        };
       }
       try {
-        // Branch does not exist yet: base it on develop (never main/master).
-        const current = gitContext(cwd).branch;
-        if (current === "main" || current === "master") {
-          const baseResult = ensureDevelopBase(cwd);
-          if (!baseResult.ok) return { error: baseResult.error };
-        } else {
-          // Already on develop or another feature branch: still require origin/develop to exist.
-          const baseResult = ensureDevelopBase(cwd);
-          if (!baseResult.ok) return { error: baseResult.error };
-        }
+        const baseResult = ensureBaseBranch(cwd, baseBranch(cwd));
+        if (!baseResult.ok) return { error: baseResult.error };
         exec(["checkout", "-b", target]);
       } catch (createError) {
-        return { error: createError instanceof Error ? createError.message : "branch create failed" };
+        return {
+          error: createError instanceof Error ? createError.message : "branch create failed",
+        };
       }
     }
   }
@@ -242,5 +330,12 @@ export const branchSetup = ({
     manifest.stash_created_at = new Date().toISOString();
   }
   writeManifest(manifest);
-  return { action: "setup", ok: true, branch: target, previous_branch: current, stash_ref: stash_ref ?? null, manifest: manifestPath };
+  return {
+    action: "setup",
+    ok: true,
+    branch: target,
+    previous_branch: current,
+    stash_ref: stash_ref ?? null,
+    manifest: manifestPath,
+  };
 };

package/src/core/changelog.ts

@@ -2,14 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveWorkspaceRoot } from "./scripts";
 
-const CATEGORIES = [
-  "Added",
-  "Changed",
-  "Deprecated",
-  "Removed",
-  "Fixed",
-  "Security",
-];
+const CATEGORIES = ["Added", "Changed", "Deprecated", "Removed", "Fixed", "Security"];
 
 // Port of scripts/changelog/apply-unreleased.py — merge Keep a Changelog
 // entries into ## [Unreleased] without duplicating ### headings.
@@ -73,10 +66,21 @@ function splitUnreleased(text: string): [string, string, string] {
 function canonicalCategory(heading: string): string | null {
   const match = CAT_RE.exec(heading.replace(/\r?\n$/, ""));
   if (!match) return null;
-  return CATEGORIES.find((c) => c.toLowerCase() === match[0].replace(/^###\s+/, "").trim().toLowerCase()) ?? null;
+  return (
+    CATEGORIES.find(
+      (c) =>
+        c.toLowerCase() ===
+        match[0]
+          .replace(/^###\s+/, "")
+          .trim()
+          .toLowerCase(),
+    ) ?? null
+  );
 }
 
-function splitSections(body: string): [string[], Array<{ heading: string; category: string | null; body: string[] }>] {
+function splitSections(
+  body: string,
+): [string[], Array<{ heading: string; category: string | null; body: string[] }>] {
   const preamble: string[] = [];
   const sections: Array<{ heading: string; category: string | null; body: string[] }> = [];
   let current: { heading: string; category: string | null; body: string[] } | null = null;
@@ -207,7 +211,8 @@ function applyChangelog(
         break;
       }
     }
-    text = lines.slice(0, insertAt).join("") + "## [Unreleased]\n\n" + lines.slice(insertAt).join("");
+    text =
+      lines.slice(0, insertAt).join("") + "## [Unreleased]\n\n" + lines.slice(insertAt).join("");
   }
 
   const [before, body, after] = splitUnreleased(text);
@@ -290,9 +295,7 @@ export function changelogApply({
 
 export function changelogUnreleasedStats(workspace_root: string, changelogPath = "CHANGELOG.md") {
   const cwd = resolveWorkspaceRoot(workspace_root);
-  const abs = path.isAbsolute(changelogPath)
-    ? changelogPath
-    : path.join(cwd, changelogPath);
+  const abs = path.isAbsolute(changelogPath) ? changelogPath : path.join(cwd, changelogPath);
   if (!fs.existsSync(abs)) return { exists: false };
   const text = fs.readFileSync(abs, "utf8");
   const m = text.match(/##\s+\[Unreleased\]([\s\S]*?)(?=\n##\s+\[|$)/i);

package/src/core/config-guard.ts

@@ -1,13 +1,20 @@
 import { initStatus } from "./init";
 
-export const ALL_ITEM_IDS = ["youtrack_json", "youtrack_token", "vcs_json", "gitlab_token", "github_token"];
+export const ALL_ITEM_IDS = [
+  "youtrack_json",
+  "youtrack_token",
+  "vcs_json",
+  "gitlab_token",
+  "github_token",
+];
 export const CONFIG_GAP_MARKER = "workflow config missing";
 
 export function describeConfigGaps(scope?: string[]): { missing: string[]; ok: boolean } {
   const all = scope ?? ALL_ITEM_IDS;
   try {
     const status: unknown = initStatus();
-    if (!status || typeof status !== "object" || (status as Record<string, unknown>).error) return { missing: all, ok: false };
+    if (!status || typeof status !== "object" || (status as Record<string, unknown>).error)
+      return { missing: all, ok: false };
     const items = (status as Record<string, unknown>).items;
     if (!Array.isArray(items) || items.length === 0) return { missing: all, ok: false };
     const known = all;

package/src/core/config.ts

@@ -1,4 +1,12 @@
-import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -12,16 +20,19 @@ export type ToolkitConfig = {
 };
 
 export const PRESETS: Record<BranchPreset, { allowed: string[]; protected: string[] }> = {
-  gitflow: { allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"], protected: ["main", "develop", "master", "prod", "production"] },
+  gitflow: {
+    allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"],
+    protected: ["main", "develop", "master", "prod", "production"],
+  },
   "github-flow": { allowed: ["*"], protected: ["main"] },
   "trunk-based": { allowed: ["*"], protected: ["main"] },
   custom: { allowed: [], protected: [] },
 };
 
 export const resolveConfigDir = (): string =>
-  process.env.WORKFLOW_TOOLKIT_CONFIG
-  ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR
-  ?? path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "workit");
+  process.env.WORKFLOW_TOOLKIT_CONFIG ??
+  process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ??
+  path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "workit");
 
 // One-time lazy migration from the legacy ~/.config/workflow-toolkit dir.
 // migratedDir remembers the resolved dir already checked: configDir() is on
@@ -41,7 +52,10 @@ export const ensureConfigDir = (dir: string = resolveConfigDir()): string => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path.join(
+    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+    "workflow-toolkit",
+  );
   if (!existsSync(legacy)) {
     migratedDir = dir;
     return dir;
@@ -76,11 +90,19 @@ const DEFAULTS: ToolkitConfig = {
   locale: "en",
   localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
   timezone: "America/Santiago",
-  branchPolicy: { preset: "gitflow", allowed: [...PRESETS.gitflow.allowed], protected: [...PRESETS.gitflow.protected] },
+  branchPolicy: {
+    preset: "gitflow",
+    allowed: [...PRESETS.gitflow.allowed],
+    protected: [...PRESETS.gitflow.protected],
+  },
 };
 
 const readSafe = (p: string): string | null => {
-  try { return readFileSync(p, "utf8"); } catch { return null; }
+  try {
+    return readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
 };
 
 export const readConfig = (): ToolkitConfig => {
@@ -88,18 +110,26 @@ export const readConfig = (): ToolkitConfig => {
   if (!raw) return DEFAULTS;
   try {
     const parsed = JSON.parse(raw) as Partial<ToolkitConfig>;
-    const locale = LOCALE_RE.test(String(parsed.locale ?? "")) ? parsed.locale as string : DEFAULTS.locale;
+    const locale = LOCALE_RE.test(String(parsed.locale ?? ""))
+      ? (parsed.locale as string)
+      : DEFAULTS.locale;
     const preset = (parsed.branchPolicy?.preset ?? "gitflow") as BranchPreset;
     const presetOk = Object.hasOwn(PRESETS, preset) ? preset : "gitflow";
     const presetDefs = PRESETS[presetOk];
     return {
       locale,
-      localeOptions: Array.isArray(parsed.localeOptions) ? parsed.localeOptions : DEFAULTS.localeOptions,
+      localeOptions: Array.isArray(parsed.localeOptions)
+        ? parsed.localeOptions
+        : DEFAULTS.localeOptions,
       timezone: parsed.timezone ?? DEFAULTS.timezone,
       branchPolicy: {
         preset: presetOk,
-        allowed: Array.isArray(parsed.branchPolicy?.allowed) ? parsed.branchPolicy.allowed : presetDefs.allowed,
-        protected: Array.isArray(parsed.branchPolicy?.protected) ? parsed.branchPolicy.protected : presetDefs.protected,
+        allowed: Array.isArray(parsed.branchPolicy?.allowed)
+          ? parsed.branchPolicy.allowed
+          : presetDefs.allowed,
+        protected: Array.isArray(parsed.branchPolicy?.protected)
+          ? parsed.branchPolicy.protected
+          : presetDefs.protected,
       },
     };
   } catch {
@@ -113,8 +143,11 @@ export const writeConfig = (config: ToolkitConfig): void => {
   writeFileSync(path.join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
 };
 
-export const resolveBranchPolicy = (config: ToolkitConfig): { allowed: RegExp[]; protected: Set<string> } => {
-  const allowed = config.branchPolicy.allowed.map((p) =>
-    new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
+export const resolveBranchPolicy = (
+  config: ToolkitConfig,
+): { allowed: RegExp[]; protected: Set<string> } => {
+  const allowed = config.branchPolicy.allowed.map(
+    (p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"),
+  );
   return { allowed, protected: new Set(config.branchPolicy.protected.map((p) => p.toLowerCase())) };
 };