@brainervirus/workit-core 0.5.6 → 0.6.1

package/README.md

@@ -9,7 +9,7 @@ Multi-platform Superpowers workflow plugin for **Cursor** and **OpenCode**: veri
 | **Shared core** | `packages/workit-core/` (src, skills, commands, scripts, templates) | ![npm](https://img.shields.io/npm/v/@brainervirus/workit-core) |
 | **CLI** | `packages/workit-cli/` (Ink wizard, bin `workit`) | ![npm](https://img.shields.io/npm/v/@brainervirus/workit-cli) |
 
-Config directory (both platforms): `~/.config/workflow-toolkit/` (kept as-is for install stability).
+Config directory (both platforms): `~/.config/workit/` — legacy `~/.config/workflow-toolkit/` is auto-migrated on first run and kept as a fallback.
 
 [![npm version](https://img.shields.io/npm/v/@brainervirus/workit-opencode)](https://www.npmjs.com/package/@brainervirus/workit-opencode)
 [![CI](https://img.shields.io/github/actions/workflow/status/BrainerVirus/workit/ci.yml?branch=main&label=CI)](https://github.com/BrainerVirus/workit/actions)
@@ -119,7 +119,6 @@ GitHub Actions:
 
 - **CI** — on push/PR to `main`: matrix of 3 OS (ubuntu, macos, windows) running `actions/checkout@v7` + `oven-sh/setup-bun@v2`, then `bun install --frozen-lockfile` + `bun run check`
 - **Release** — on push to `main`: [semantic-release](https://github.com/semantic-release/semantic-release) computes the next version from Conventional Commits, publishes the four workspaces to npm in dependency order — `workit-core`, `workit-opencode`, `workit-cursor`, `workit-cli` (with provenance), and creates the git tag + GitHub Release
-- **Code review** — on every PR: the [OpenCode GitHub integration](https://opencode.ai/docs/github/) reviews the diff (see [Code review](#code-review))
 
 No manual tags — semantic-release owns the version/tag flow:
 
@@ -127,22 +126,10 @@ No manual tags — semantic-release owns the version/tag flow:
 git push origin main
 ```
 
-## Code review
+## Quality gates
 
-Every pull request is automatically reviewed by [OpenCode](https://opencode.ai/docs/github/) via `.github/workflows/opencode-review.yml` — it checks code quality, potential bugs, and this repo's own standards (the spec/plan contract, Conventional Commits, the CONTRIBUTING.md review flow). Model: `opencode-go/deepseek-v4-flash`.
-
-Checks fall into two categories:
-
-- **BLOCKING — the `pull_request` review** (`review` job): runs on every PR (opened/synchronized/reopened/ready_for_review) and is registered as a required check in branch protection — the PR cannot merge while it's red.
-- **ADVISORY — on-demand and triage flows** (never block merge): mention `/oc` or `/opencode` in a comment — issue, PR thread, or a specific line in the Files tab — to have OpenCode fix, explain, or update the PR (`oc` job); new issues are triaged with guidance and doc links (`triage` job).
-
-To activate the review on a fork or fresh clone:
-
-1. Install the [OpenCode GitHub app](https://github.com/apps/opencode-agent) on the repository.
-2. Add the `OPENCODE_API_KEY` secret under Settings → Secrets and variables → Actions.
-3. PRs trigger the review on opened/synchronized/reopened events automatically.
-
-[Cursor Bugbot](https://cursor.com/dashboard/bugbot) is an optional alternative to the OpenCode review.
+- **CI checks** — the per-package check jobs (workit-core/opencode/cursor/cli/shared) are required in branch protection; the PR cannot merge while any is red.
+- **Subagent review** — `wk-implement` runs a two-stage review (spec compliance + code quality) per task with fresh `general` agents.
 
 ## Architecture
 

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "0.5.6",
+  "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/scripts/lib/config-dir.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Resolve the config dir (workit default) with one-time legacy migration.
+# Mirrors src/core/config.ts resolveConfigDir + ensureConfigDir.
+# Env overrides bypass migration (explicit user intent wins); migration is
+# idempotent: only runs when workit/ is absent; never overwrites, never
+# deletes the legacy workflow-toolkit/ dir.
+resolve_config_dir() {
+  if [ -n "${WORKFLOW_TOOLKIT_CONFIG:-}" ]; then
+    printf '%s\n' "$WORKFLOW_TOOLKIT_CONFIG"
+    return
+  fi
+  if [ -n "${WORKFLOW_TOOLKIT_CONFIG_DIR:-}" ]; then
+    printf '%s\n' "$WORKFLOW_TOOLKIT_CONFIG_DIR"
+    return
+  fi
+  local base="${XDG_CONFIG_HOME:-$HOME/.config}"
+  local NEW="$base/workit"
+  local LEGACY="$base/workflow-toolkit"
+  if [ ! -d "$NEW" ] && [ -d "$LEGACY" ]; then
+    mkdir -p "$NEW"
+    if ! cp -r "$LEGACY/." "$NEW/"; then
+      printf 'workit: warning: partial config migration from %s (kept in place; retry on next run)\n' "$LEGACY" >&2
+    fi
+  fi
+  printf '%s\n' "$NEW"
+}

package/scripts/sync-runtime.sh

@@ -3,6 +3,9 @@
 # Prefer local monorepo (dev) when present; otherwise git-pull the share clone.
 set -euo pipefail
 
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+. "$SCRIPT_DIR/lib/config-dir.sh"
+
 SHARE="${HOME}/.local/share/workflow-toolkit"
 PLUGIN_DIR="${HOME}/.cursor/plugins/local/workflow-toolkit"
 OPENCODE_PLUGINS="${HOME}/.config/opencode/plugins"
@@ -54,7 +57,7 @@ if [ -d "$SHARE/packages/workit-core/vendor/superpowers/skills" ]; then
   rsync -a --delete "$SHARE/packages/workit-core/vendor/superpowers/skills" "$PLUGIN_DIR/vendor/superpowers/"
 fi
 # Canonical user rules -> Cursor .mdc (compiled by the shared core)
-CONFIG_RULES_DIR="${HOME}/.config/workflow-toolkit/rules"
+CONFIG_RULES_DIR="$(resolve_config_dir)/rules"
 if [ -d "$CONFIG_RULES_DIR" ]; then
   "$HOME/.bun/bin/bun" -e "
     import('${SHARE}/packages/workit-core/src/core/rules.ts').then(async ({ writeCompiledCursorRules }) => {

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;