@boopkit/cli 0.4.0 → 0.6.0

package/dist/capability-catalog.json

@@ -111,6 +111,13 @@
       "web"
     ]
   },
+  {
+    "name": "ux",
+    "description": "UX design judgement and the discovery/delivery workflows that operate it",
+    "type": "development",
+    "package": "@boopkit/cap-ux",
+    "requires": []
+  },
   {
     "name": "web",
     "description": "Web UI with Handlebars + Tailwind",

package/dist/capability-versions.json

@@ -1,18 +1,19 @@
 {
-  "@boopkit/cap-api": "0.4.0",
+  "@boopkit/cap-api": "0.4.1",
   "@boopkit/cap-background-jobs": "0.4.0",
   "@boopkit/cap-cloud-storage": "0.4.0",
-  "@boopkit/cap-coding": "0.4.0",
-  "@boopkit/cap-database": "0.4.0",
-  "@boopkit/cap-email": "0.4.0",
+  "@boopkit/cap-coding": "0.4.1",
+  "@boopkit/cap-database": "0.4.3",
+  "@boopkit/cap-email": "0.4.1",
   "@boopkit/cap-hello": "0.4.0",
   "@boopkit/cap-noticeboard": "0.4.0",
-  "@boopkit/cap-product-design": "0.4.0",
-  "@boopkit/cap-project-mgmt": "0.4.0",
-  "@boopkit/cap-services": "0.4.0",
-  "@boopkit/cap-skills": "0.4.0",
-  "@boopkit/cap-testing": "0.4.0",
-  "@boopkit/cap-users": "0.4.0",
-  "@boopkit/cap-web": "0.4.0",
+  "@boopkit/cap-product-design": "0.6.1",
+  "@boopkit/cap-project-mgmt": "0.4.1",
+  "@boopkit/cap-services": "0.4.2",
+  "@boopkit/cap-skills": "0.5.1",
+  "@boopkit/cap-testing": "0.5.0",
+  "@boopkit/cap-users": "0.4.2",
+  "@boopkit/cap-ux": "0.2.0",
+  "@boopkit/cap-web": "0.5.0",
   "@boopkit/logger": "0.4.0"
 }

package/dist/cli.js

@@ -44,6 +44,7 @@ const add_1 = require("./commands/add");
 const adopt_1 = require("./commands/adopt");
 const update_1 = require("./commands/update");
 const loop_1 = require("./commands/loop");
+const loop_merge_1 = require("./commands/loop-merge");
 const pkgJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
 const program = new commander_1.Command();
 program
@@ -101,23 +102,43 @@ program
     .action(adopt_1.runAdopt);
 program
     .command('loop')
-    .description('Continuously process ready beads issues via Claude Code sessions')
-    .option('--prefix <prefix>', 'Issue ID prefix to filter by')
-    .option('--work <path>', 'Spec file for planning phase')
-    .option('--flow <path>', 'Workflow file for planning phase')
-    .option('--run', 'Actually execute (dry-run by default)')
-    .option('--max <n>', 'Stop after N issues')
-    .option('--budget <amount>', 'Budget cap per issue in USD (default: 5.00)')
-    .option('--resume-limit <n>', 'Max resume attempts per issue (default: 3)')
-    .option('--poll', 'Keep polling when no ready issues found')
-    .option('--poll-interval <seconds>', 'Seconds between polls (default: 60)')
-    .option('--model <model>', 'Claude model to use (default: claude-opus-4-6)')
-    .option('--per-issue-branch', 'Create a separate branch per issue')
-    .option('--no-branch', 'Skip branch creation entirely')
-    .option('--features', 'Include feature-type issues (excluded by default)')
-    .option('--no-skip-perms', 'Do not skip permission prompts')
-    .option('--bare', 'Force API key auth (--bare mode); skips OAuth/keychain, uses ANTHROPIC_API_KEY strictly')
-    .option('--json', 'Output summary as JSON')
-    .addHelpText('after', '\nBy default runs in dry-run mode. Add --run to execute.')
-    .action(loop_1.runLoop);
+    .summary('Drive Claude Code sessions to build work autonomously')
+    .description('Drive Claude Code sessions to build work autonomously, in one of three modes:\n' +
+    '  spec-driven   --work <spec> --flow <flow>  plan a feature tree from a spec, then build every task\n' +
+    '  issue-driven  --prefix <issue-id>          process ready beads issues in scope: ID starts with the prefix, or any parent-chain ancestor ID does\n' +
+    '  merge         --merge [branch]             integrate completed feature worktrees into main')
+    // — Mode selection (pick exactly one mode) —
+    .option('--work <path>', 'spec-driven: spec/work file to plan from (requires --flow)')
+    .option('--flow <path>', 'spec-driven: workflow file or skill dir that drives planning (requires --work)')
+    .option('--prefix <prefix>', 'issue-driven: scope of issues to process — in scope if the issue ID starts with this prefix OR any ancestor (parent chain) ID does, so issues re-parented under a matching epic/feature are included even with unrelated IDs. Pass a full issue ID; a truncated one over-matches (boop-4 also matches boop-45j)')
+    .option('--merge [branch]', 'merge: integrate completed feature worktrees into main (optional single branch skips readiness)')
+    // — Mode-specific options —
+    .option('--features', 'issue-driven only: also process leaf feature-type issues (excluded by default; always on in spec-driven mode). Feature roots that own child tasks are never claimed directly — they are containers, not work.')
+    .option('--watch', 'merge only: poll for ready branches and merge them as they land')
+    // — Shared execution options —
+    .option('--run', 'actually execute (dry-run by default)')
+    .option('--max <n>', 'stop after N issues')
+    .option('--budget <amount>', `budget cap per issue in USD (default: ${loop_1.DEFAULT_BUDGET_USD})`)
+    .option('--model <model>', 'Claude model to use, applied to every spawned session and nested loop (falls back to $ANTHROPIC_MODEL, then claude-opus-4-8). Sub-agents keep their own declared model unless they opt into model: inherit.')
+    .option('--poll', 'keep polling when no ready issues found')
+    .option('--poll-interval <seconds>', 'seconds between polls (default: 60)')
+    .option('--resume-limit <n>', 'max resume attempts per issue (default: 3)')
+    .option('--per-issue-branch', 'create a separate branch per issue')
+    .option('--no-branch', 'skip branch/worktree creation; run in place on the current branch')
+    .option('--no-skip-perms', 'do not skip permission prompts')
+    .option('--bare', 'force API key auth; skip OAuth/keychain, use ANTHROPIC_API_KEY strictly')
+    .option('--json', 'output summary as JSON')
+    .addHelpText('after', [
+    '',
+    'Examples:',
+    '  boop loop --work specs/feature.spec.md --flow skills/my-flow/SKILL.md --run',
+    '  boop loop --prefix boop-abc --run --features',
+    '  boop loop --merge --run --watch',
+    '',
+    'Notes:',
+    '  • Dry-run by default; add --run to execute.',
+    '  • --work and --flow must be used together; --features and --watch only apply to their own mode.',
+    '  • Merge mode rebases ready work/<id> branches onto main, runs tests, ff-merges, and cleans up worktrees.',
+].join('\n'))
+    .action((options) => (options.merge ? (0, loop_merge_1.runMerge)(options) : (0, loop_1.runLoop)(options)));
 program.parse(process.argv);

package/dist/commands/loop-merge.d.ts

@@ -0,0 +1,83 @@
+import { LoopOptions, WorktreeMode } from './loop';
+/**
+ * Slice 2 — `boop loop --merge`.
+ *
+ * Sequential integration of completed feature worktrees back into main. No
+ * individual loop merges its own branch; this is the dedicated integrator.
+ *
+ * For each ready branch (sequential, failure-isolated):
+ *   record orig sha → rebase work/<id> onto main → npm test → ff-merge into main
+ *   → remove worktree + branch.
+ *
+ * Safety contract: main is NEVER left dirty. A rebase conflict aborts the rebase;
+ * a post-rebase test failure resets the branch to its original sha; either way we
+ * file a beads issue and skip to the next branch. Only `package.json` dependency
+ * additions are auto-resolved (the one documented known-safe pattern); every other
+ * conflict punts to a human via a beads issue.
+ */
+export interface WorktreeMeta {
+    version: number;
+    mode: WorktreeMode;
+    scope: string;
+    branch: string;
+    worktreePath: string;
+}
+export interface MergeCandidate {
+    branch: string;
+    worktreePath: string;
+    scope: string;
+    mode: WorktreeMode;
+    ready: boolean;
+}
+interface ScopeIssue {
+    id: string;
+    parent?: string;
+    status?: string;
+}
+export interface MergeDeps {
+    projectDir?: string;
+    execSyncFn?: (cmd: string, opts?: {
+        cwd?: string;
+        stdio?: unknown;
+    }) => string;
+    existsSyncFn?: (p: string) => boolean;
+    readFileFn?: (p: string) => string;
+    /** Returns beads issues at the given status (`bd list --status=<s> --json`). */
+    bdListFn?: (status: 'open' | 'closed') => ScopeIssue[];
+    /** Parent-id lookup for ancestors not present in the listed set. */
+    getParentFn?: (id: string) => string | null;
+    /** File a beads issue on merge failure. Returns the created issue id (or null). */
+    createIssueFn?: (title: string, description: string) => string | null;
+    /** Best-effort sleep between watch polls. */
+    sleepFn?: (ms: number) => Promise<void>;
+    /** Dolt server-mode guard (defaults to the real `assertDoltServerMode`). */
+    assertServerModeFn?: (projectDir: string) => void;
+}
+/**
+ * Pick the higher of two version specifiers for the same dependency key. Ties and
+ * unparseable specifiers prefer `ours` (the integration/main side) for stability.
+ */
+export declare function pickHigherVersion(ours: string, theirs: string): string;
+/**
+ * Union-merge two package.json sides that conflicted during a rebase. Dependency
+ * maps are unioned (same-key version conflict → higher semver). Every other
+ * top-level key must already agree between the two sides; if any non-dependency
+ * key differs, the conflict is NOT known-safe and this throws so the caller punts
+ * to a human. Returns the merged JSON text (2-space indent, trailing newline).
+ */
+export declare function mergePackageJsonContents(oursText: string, theirsText: string): string;
+/**
+ * A worktree is ready to merge when every beads issue in its scope is closed.
+ * That means: at least one closed in-scope issue exists AND zero open in-scope
+ * issues remain. `bd ready` is insufficient (it only returns *unblocked* issues),
+ * so we list by status and filter with the same scope rule the loop uses.
+ */
+export declare function isScopeComplete(scope: string, deps: MergeDeps): boolean;
+/**
+ * Enumerate registered git worktrees, read each `.boop-worktree.json`, and decide
+ * which are ready to merge. Worktrees without metadata (e.g. unrelated worktrees)
+ * are ignored.
+ */
+export declare function findMergeCandidates(deps: MergeDeps): MergeCandidate[];
+export declare function runMerge(options: LoopOptions, deps?: MergeDeps): Promise<void>;
+export {};

package/dist/commands/loop-merge.js

@@ -0,0 +1,436 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickHigherVersion = pickHigherVersion;
+exports.mergePackageJsonContents = mergePackageJsonContents;
+exports.isScopeComplete = isScopeComplete;
+exports.findMergeCandidates = findMergeCandidates;
+exports.runMerge = runMerge;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loop_1 = require("./loop");
+// ── Semver helpers (package.json conflict resolution, subsumes boop-7rb) ──────
+/** Strip range operators and parse a `x.y.z` prefix. Returns null if unparseable. */
+function parseSemver(version) {
+    const m = version.trim().replace(/^[\^~>=<\s]+/, '').match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!m)
+        return null;
+    return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
+}
+/**
+ * Pick the higher of two version specifiers for the same dependency key. Ties and
+ * unparseable specifiers prefer `ours` (the integration/main side) for stability.
+ */
+function pickHigherVersion(ours, theirs) {
+    if (ours === theirs)
+        return ours;
+    const a = parseSemver(ours);
+    const b = parseSemver(theirs);
+    if (!a || !b)
+        return ours;
+    for (let i = 0; i < 3; i++) {
+        if (b[i] > a[i])
+            return theirs;
+        if (b[i] < a[i])
+            return ours;
+    }
+    return ours;
+}
+const DEP_MAPS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+/**
+ * Union-merge two package.json sides that conflicted during a rebase. Dependency
+ * maps are unioned (same-key version conflict → higher semver). Every other
+ * top-level key must already agree between the two sides; if any non-dependency
+ * key differs, the conflict is NOT known-safe and this throws so the caller punts
+ * to a human. Returns the merged JSON text (2-space indent, trailing newline).
+ */
+function mergePackageJsonContents(oursText, theirsText) {
+    const ours = JSON.parse(oursText);
+    const theirs = JSON.parse(theirsText);
+    const merged = { ...ours };
+    for (const map of DEP_MAPS) {
+        const o = (ours[map] || {});
+        const t = (theirs[map] || {});
+        if (!ours[map] && !theirs[map])
+            continue;
+        const combined = { ...o };
+        for (const [name, version] of Object.entries(t)) {
+            combined[name] = name in combined ? pickHigherVersion(combined[name], version) : version;
+        }
+        // Sort keys for a deterministic, diff-friendly result.
+        merged[map] = Object.fromEntries(Object.entries(combined).sort(([a], [b]) => a.localeCompare(b)));
+    }
+    // Any non-dependency divergence is outside the known-safe pattern.
+    const keys = new Set([...Object.keys(ours), ...Object.keys(theirs)]);
+    for (const key of keys) {
+        if (DEP_MAPS.includes(key))
+            continue;
+        if (JSON.stringify(ours[key]) !== JSON.stringify(theirs[key])) {
+            throw new Error(`package.json conflict in non-dependency key "${key}" is not auto-resolvable`);
+        }
+    }
+    return JSON.stringify(merged, null, 2) + '\n';
+}
+// ── Scope-completion readiness ────────────────────────────────────────────────
+function makeParentLookup(issues, getParentFn) {
+    const cache = new Map();
+    for (const i of issues)
+        cache.set(i.id, i.parent ?? null);
+    return (id) => {
+        if (cache.has(id))
+            return cache.get(id) ?? null;
+        const p = getParentFn(id);
+        cache.set(id, p);
+        return p;
+    };
+}
+/**
+ * A worktree is ready to merge when every beads issue in its scope is closed.
+ * That means: at least one closed in-scope issue exists AND zero open in-scope
+ * issues remain. `bd ready` is insufficient (it only returns *unblocked* issues),
+ * so we list by status and filter with the same scope rule the loop uses.
+ */
+function isScopeComplete(scope, deps) {
+    const bdListFn = deps.bdListFn || defaultBdList(deps);
+    const getParentFn = deps.getParentFn || defaultGetParent(deps);
+    const open = bdListFn('open');
+    const closed = bdListFn('closed');
+    const getParent = makeParentLookup([...open, ...closed], getParentFn);
+    const inScope = (i) => (0, loop_1.isIssueInScope)(i, scope, getParent);
+    const openInScope = open.filter(inScope);
+    const closedInScope = closed.filter(inScope);
+    return openInScope.length === 0 && closedInScope.length > 0;
+}
+function defaultBdList(deps) {
+    const execSyncFn = deps.execSyncFn || defaultExec;
+    return (status) => {
+        try {
+            const raw = execSyncFn(`bd list --status=${status} --json 2>/dev/null`);
+            return JSON.parse(raw);
+        }
+        catch {
+            return [];
+        }
+    };
+}
+function defaultGetParent(deps) {
+    const execSyncFn = deps.execSyncFn || defaultExec;
+    return (id) => {
+        try {
+            const data = JSON.parse(execSyncFn(`bd show ${id} --json 2>/dev/null`));
+            return (data[0] || data).parent || null;
+        }
+        catch {
+            return null;
+        }
+    };
+}
+// ── Candidate discovery ───────────────────────────────────────────────────────
+/**
+ * Enumerate registered git worktrees, read each `.boop-worktree.json`, and decide
+ * which are ready to merge. Worktrees without metadata (e.g. unrelated worktrees)
+ * are ignored.
+ */
+function findMergeCandidates(deps) {
+    const projectDir = deps.projectDir || process.cwd();
+    const execSyncFn = deps.execSyncFn || defaultExec;
+    const existsSyncFn = deps.existsSyncFn || fs.existsSync;
+    const readFileFn = deps.readFileFn || ((p) => fs.readFileSync(p, 'utf8'));
+    let raw = '';
+    try {
+        raw = execSyncFn('git worktree list --porcelain', { cwd: projectDir });
+    }
+    catch {
+        return [];
+    }
+    const candidates = [];
+    for (const block of raw.split('\n\n')) {
+        const wtLine = block.split('\n').find((l) => l.startsWith('worktree '));
+        if (!wtLine)
+            continue;
+        const wtPath = path.resolve(wtLine.slice('worktree '.length).trim());
+        // Skip the integration tree itself.
+        if (wtPath === path.resolve(projectDir))
+            continue;
+        const metaPath = path.join(wtPath, '.boop-worktree.json');
+        if (!existsSyncFn(metaPath))
+            continue;
+        let meta;
+        try {
+            meta = JSON.parse(readFileFn(metaPath));
+        }
+        catch {
+            continue;
+        }
+        if (!meta.scope || !meta.branch)
+            continue;
+        candidates.push({
+            branch: meta.branch,
+            worktreePath: wtPath,
+            scope: meta.scope,
+            mode: meta.mode,
+            ready: isScopeComplete(meta.scope, deps),
+        });
+    }
+    return candidates;
+}
+// ── Merge engine ──────────────────────────────────────────────────────────────
+const defaultExec = (cmd, opts) => (0, child_process_1.execSync)(cmd, { encoding: 'utf8', ...opts });
+class MergeError extends Error {
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+    }
+}
+/** True if the integration tree is on `main` with a clean working tree. */
+function assertCleanMain(execSyncFn, projectDir) {
+    const exec = execSyncFn;
+    const branch = exec('git rev-parse --abbrev-ref HEAD', { cwd: projectDir }).trim();
+    if (branch !== 'main') {
+        throw new Error(`Integration tree at ${projectDir} is on "${branch}", not "main". Checkout main before merging.`);
+    }
+    const status = exec('git status --porcelain', { cwd: projectDir }).trim();
+    if (status) {
+        throw new Error(`Integration tree at ${projectDir} has uncommitted changes; commit or stash before merging.`);
+    }
+}
+/**
+ * Rebase the candidate branch onto main inside its worktree, auto-resolving only
+ * package.json dependency conflicts. Throws MergeError (rebase aborted) on any
+ * other conflict.
+ */
+function rebaseOntoMain(exec, wt) {
+    try {
+        exec('git rebase main', { cwd: wt, stdio: 'pipe' });
+        return;
+    }
+    catch {
+        // Conflict (or other failure). Inspect unmerged paths.
+    }
+    // Iteratively resolve package.json-only conflicts and continue.
+    for (let guard = 0; guard < 100; guard++) {
+        const conflicted = exec('git diff --name-only --diff-filter=U', { cwd: wt })
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        if (conflicted.length === 0)
+            break; // nothing unmerged — fall through to continue/finish
+        const nonSafe = conflicted.filter((f) => path.basename(f) !== 'package.json');
+        if (nonSafe.length > 0) {
+            try {
+                exec('git rebase --abort', { cwd: wt });
+            }
+            catch {
+                /* leave it for the human */
+            }
+            throw new MergeError('rebase conflict not auto-resolvable', `Conflicting files: ${conflicted.join(', ')}`);
+        }
+        // All conflicts are package.json — union the two sides.
+        for (const file of conflicted) {
+            const ours = exec(`git show :2:${file}`, { cwd: wt });
+            const theirs = exec(`git show :3:${file}`, { cwd: wt });
+            let merged;
+            try {
+                merged = mergePackageJsonContents(ours, theirs);
+            }
+            catch (e) {
+                try {
+                    exec('git rebase --abort', { cwd: wt });
+                }
+                catch {
+                    /* noop */
+                }
+                throw new MergeError('package.json conflict not auto-resolvable', e.message);
+            }
+            fs.writeFileSync(path.join(wt, file), merged);
+            exec(`git add ${file}`, { cwd: wt });
+        }
+        try {
+            // GIT_EDITOR=true keeps `--continue` non-interactive (reuses the commit message).
+            exec('GIT_EDITOR=true git rebase --continue', { cwd: wt, stdio: 'pipe' });
+            return; // rebase finished
+        }
+        catch {
+            // More commits ahead may conflict again — loop and re-inspect.
+        }
+    }
+}
+function mergeOne(candidate, deps) {
+    const projectDir = deps.projectDir || process.cwd();
+    const exec = deps.execSyncFn || defaultExec;
+    const createIssue = deps.createIssueFn || defaultCreateIssue(deps);
+    const { branch, worktreePath: wt } = candidate;
+    assertCleanMain(exec, projectDir);
+    const origSha = exec('git rev-parse HEAD', { cwd: wt }).trim();
+    try {
+        rebaseOntoMain(exec, wt);
+    }
+    catch (e) {
+        const err = e;
+        const issueId = createIssue(`Merge conflict: ${branch}`, `Rebasing ${branch} onto main failed: ${err.message}\n\n${err.detail || ''}\n\nResolve by hand, then re-run \`boop loop --merge ${branch}\`.`);
+        return { branch, status: 'skipped', reason: err.message, issueId };
+    }
+    // Post-rebase test gate. Failure → restore the branch, never touch main.
+    try {
+        exec('npm test', { cwd: wt, stdio: 'pipe' });
+    }
+    catch (e) {
+        try {
+            exec(`git reset --hard ${origSha}`, { cwd: wt });
+        }
+        catch {
+            /* best-effort restore */
+        }
+        const issueId = createIssue(`Merge test failure: ${branch}`, `Tests failed after rebasing ${branch} onto main; branch reset to ${origSha} and main left untouched.\n\n${e.message}`);
+        return { branch, status: 'skipped', reason: 'tests failed post-rebase', issueId };
+    }
+    // Fast-forward into main (guaranteed possible: branch was just rebased onto it).
+    exec(`git merge --ff-only ${branch}`, { cwd: projectDir });
+    // Cleanup: remove the worktree and delete the now-merged branch.
+    try {
+        exec(`git worktree remove ${wt}`, { cwd: projectDir });
+    }
+    catch {
+        try {
+            exec(`git worktree remove --force ${wt}`, { cwd: projectDir });
+        }
+        catch {
+            /* leave the worktree; merge already succeeded */
+        }
+    }
+    try {
+        exec(`git branch -d ${branch}`, { cwd: projectDir });
+    }
+    catch {
+        /* branch may be kept by the operator; non-fatal */
+    }
+    return { branch, status: 'merged' };
+}
+function defaultCreateIssue(deps) {
+    const exec = deps.execSyncFn || defaultExec;
+    return (title, description) => {
+        try {
+            const raw = exec(`bd create ${JSON.stringify(title)} --description=${JSON.stringify(description)} -t bug -p 1 --json`);
+            return JSON.parse(raw).id || null;
+        }
+        catch {
+            return null;
+        }
+    };
+}
+// ── Orchestrator ──────────────────────────────────────────────────────────────
+async function runMerge(options, deps) {
+    const d = deps || {};
+    const projectDir = d.projectDir || process.cwd();
+    d.projectDir = projectDir;
+    const sleepFn = d.sleepFn || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    try {
+        (d.assertServerModeFn || ((dir) => (0, loop_1.assertDoltServerMode)(dir, undefined)))(projectDir);
+    }
+    catch (e) {
+        console.error(`\x1b[31m[bd-merge]\x1b[0m ${e.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const dryRun = !options.run;
+    const watch = options.watch || false;
+    const pollInterval = parseInt(options.pollInterval || '60', 10);
+    const explicitBranch = typeof options.merge === 'string' ? options.merge : undefined;
+    const collect = () => {
+        const all = findMergeCandidates(d);
+        if (explicitBranch) {
+            // Explicit override: merge the named branch regardless of readiness.
+            const match = all.find((c) => c.branch === explicitBranch || c.branch === `work/${explicitBranch}`);
+            if (match)
+                return [{ ...match, ready: true }];
+            console.error(`\x1b[31m[bd-merge]\x1b[0m No worktree found for branch "${explicitBranch}". Known: ${all.map((c) => c.branch).join(', ') || 'none'}`);
+            return [];
+        }
+        return all.filter((c) => c.ready);
+    };
+    const outcomes = [];
+    do {
+        const candidates = collect();
+        if (dryRun) {
+            console.log('\x1b[33m[bd-merge]\x1b[0m DRY RUN — add --run to execute');
+            if (candidates.length === 0) {
+                console.log('\x1b[36m[bd-merge]\x1b[0m No branches ready to merge.');
+            }
+            for (const c of candidates) {
+                console.log(`  \x1b[34m${c.branch}\x1b[0m (scope ${c.scope}, ${c.mode}) — would rebase onto main, npm test, ff-merge, cleanup ${c.worktreePath}`);
+            }
+            break;
+        }
+        if (candidates.length === 0 && !watch) {
+            console.log('\x1b[36m[bd-merge]\x1b[0m No branches ready to merge.');
+        }
+        for (const c of candidates) {
+            console.log(`\x1b[32m[bd-merge]\x1b[0m Merging \x1b[34m${c.branch}\x1b[0m (scope ${c.scope})...`);
+            let outcome;
+            try {
+                outcome = mergeOne(c, d);
+            }
+            catch (e) {
+                // Unexpected failure (e.g. dirty main) — isolate and continue.
+                outcome = { branch: c.branch, status: 'skipped', reason: e.message };
+                console.error(`\x1b[31m[bd-merge]\x1b[0m   ${c.branch}: ${e.message}`);
+            }
+            outcomes.push(outcome);
+            if (outcome.status === 'merged') {
+                console.log(`\x1b[32m[bd-merge]\x1b[0m   ✓ merged ${c.branch} into main; cleaned up worktree`);
+            }
+            else {
+                console.warn(`\x1b[33m[bd-merge]\x1b[0m   ⤳ skipped ${c.branch}: ${outcome.reason}${outcome.issueId ? ` (filed ${outcome.issueId})` : ''}`);
+            }
+        }
+        if (watch) {
+            console.log(`\x1b[36m[bd-merge]\x1b[0m Watching for ready branches; next poll in ${pollInterval}s...`);
+            await sleepFn(pollInterval * 1000);
+        }
+    } while (watch);
+    if (!dryRun && !watch) {
+        const merged = outcomes.filter((o) => o.status === 'merged').length;
+        const skipped = outcomes.filter((o) => o.status === 'skipped').length;
+        console.log('');
+        console.log('\x1b[32m[bd-merge]\x1b[0m ━━━ Merge summary ━━━');
+        console.log(`\x1b[32m[bd-merge]\x1b[0m   Merged:  ${merged}`);
+        if (skipped > 0)
+            console.log(`\x1b[33m[bd-merge]\x1b[0m   Skipped: ${skipped}`);
+    }
+    if (options.json) {
+        console.log(JSON.stringify({ outcomes }, null, 2));
+    }
+}