@boopkit/cli 0.4.1 → 0.6.1

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));
+    }
+}

package/dist/commands/loop.d.ts

@@ -15,6 +15,8 @@ export interface LoopOptions {
     skipPerms?: boolean;
     bare?: boolean;
     json?: boolean;
+    merge?: boolean | string;
+    watch?: boolean;
 }
 interface ClaudeRunResult {
     exitCode: number;
@@ -24,6 +26,79 @@ export interface PlanResult {
     featureId: string | null;
     costUsd: number | null;
 }
+export type WorktreeMode = 'work-flow' | 'prefix';
+export interface WorktreeContext {
+    path: string;
+    branch: string;
+    scope: string;
+    mode: WorktreeMode;
+}
+/**
+ * Hard requirement: beads must run in Dolt server mode so concurrent worktrees
+ * share one issue DB over TCP. Reads `.beads/metadata.json` and throws an
+ * actionable error on embedded/missing — call before any `bd` work.
+ */
+export declare function assertDoltServerMode(projectDir: string, deps?: {
+    existsSyncFn?: (p: string) => boolean;
+    readFileFn?: (p: string, enc: string) => string;
+}): void;
+/**
+ * Discover the running shared Dolt server's port from `.beads/dolt-server.port`.
+ * Worktrees never start their own server — they reuse this one over TCP.
+ * Returns null when no port file is present (caller errors clearly). Liveness
+ * (pid still running) is best-effort and never blocks discovery.
+ */
+export declare function discoverDoltServer(projectDir: string, deps?: {
+    existsSyncFn?: (p: string) => boolean;
+    readFileFn?: (p: string, enc: string) => string;
+    isPidAliveFn?: (pid: number) => boolean;
+}): {
+    port: number;
+    pid?: number;
+    alive?: boolean;
+} | null;
+/**
+ * Create (or reuse) the loop's own git worktree at `../boop-<scope>` on branch
+ * `work/<scope>`, then pre-warm `npm install --prefer-offline`. This is what
+ * makes N loops run concurrently without colliding — each gets its own tree and
+ * branch; main is never checked out.
+ *
+ * Collision (Decision #4): if a worktree already exists at the path on the same
+ * branch, reuse it (and skip install if node_modules is present); if the path is
+ * occupied by something else, throw a clear error rather than silently suffixing.
+ */
+export declare function createWorktree(scope: string, mode: WorktreeMode, projectDir: string, deps?: {
+    execSyncFn?: (cmd: string, opts: {
+        encoding: string;
+        cwd?: string;
+        stdio?: unknown;
+    }) => string;
+    existsSyncFn?: (p: string) => boolean;
+    copyFileFn?: (src: string, dest: string) => void;
+    readdirFn?: (p: string) => string[];
+    readFileFn?: (p: string) => string;
+    appendFileFn?: (p: string, data: string) => void;
+}): WorktreeContext;
+/**
+ * Write `.boop-worktree.json` into the worktree root. This is the contract
+ * Slice 2 (`boop loop --merge`) reads — `mode` drives its readiness query.
+ */
+export declare function writeWorktreeMetadata(ctx: WorktreeContext, meta: {
+    workPath?: string;
+    flowPath?: string;
+    boopVersion: string;
+    startTime: string;
+    operator?: string;
+    budget?: string;
+    model?: string;
+}, deps?: {
+    writeFileFn?: (p: string, data: string) => void;
+}): Record<string, unknown>;
+interface ReadyIssue {
+    id: string;
+    issue_type: string;
+    parent?: string;
+}
 export declare function buildPlanningPrompt(workContent: string, flowContent: string, prefix?: string): string;
 export type RunClaudeFn = (prompt: string, opts: {
     budget: string;
@@ -32,6 +107,7 @@ export type RunClaudeFn = (prompt: string, opts: {
     sessionId: string;
     resume?: boolean;
     bare?: boolean;
+    cwd?: string;
 }, logFile: string, readableLogFile?: string) => Promise<ClaudeRunResult>;
 export declare function planWork(opts: {
     workPath: string;
@@ -55,9 +131,76 @@ export declare function findFallbackFeature(features: Array<{
 export declare function extractFeatureId(text: string): string | null;
 export declare function isUsageLimitText(text: string): boolean;
 export declare function isStandaloneUsageLimitMessage(text: string): boolean;
+/**
+ * Resolve the model for a loop run. Precedence: an explicit `--model` flag, then
+ * the `ANTHROPIC_MODEL` environment variable, then the built-in default. The env
+ * fallback is what lets a nested `boop loop` (spawned by a Claude session that
+ * the parent loop launched with ANTHROPIC_MODEL set) inherit the same model
+ * instead of silently dropping to the default. Keep the default (claude-opus-4-8)
+ * in sync with the `--model` help text in cli.ts.
+ */
+export declare function resolveModel(optionModel: string | undefined, env?: NodeJS.ProcessEnv): string;
+/**
+ * Whether the loop should resume an issue that a session left open. A `blocked`
+ * issue was deliberately halted by the prior session because it judged it could
+ * not safely proceed — resuming just spends budget re-halting and risks the
+ * resume prompt being read as authorization to work past the block. Stop and
+ * surface it for the operator instead. Any other open status is genuinely
+ * unfinished work and is fine to resume.
+ */
+export declare function shouldResumeUnclosedIssue(status: string | undefined): boolean;
 export declare function isIssueInScope(issue: {
     id: string;
     parent?: string;
 }, prefix: string, getParentById: (id: string) => string | null): boolean;
+/**
+ * A workflow-owned feature root is a feature-type issue that owns child tasks
+ * (the workflow steps: understand → plan → … → closeout). Once those children
+ * close, `bd ready` surfaces the feature root itself — but it is a *container*,
+ * not directly claimable work. Claiming it lets a worker session absorb
+ * punch-list fixes or whole workflow steps (the boop-qna / wishfleet-O7 bug).
+ *
+ * `hasChildren` is only consulted for feature-type issues, so non-features never
+ * pay the cost of the children lookup.
+ */
+export declare function isClaimableReadyIssue(issue: {
+    id: string;
+    issue_type: string;
+}, hasChildren: (id: string) => boolean): boolean;
+/**
+ * Decide whether the loop should close a container root itself, as a safety net,
+ * when its workflow chain has completed. The intended owner of this close is the
+ * closeout child task (see the flow SKILL's closeout step), but if that task never
+ * closed the root — or no closeout task exists — the container would be orphaned
+ * open forever once filtered from claimable work. Applies to both container types
+ * the loop supports: a `feature` (feature-dev flow) or an `epic` (light-dev flow).
+ * Only close when the container is still open and every child is closed.
+ */
+export declare function shouldCloseFeatureRoot(feature: {
+    status: string;
+    issue_type: string;
+} | null, children: {
+    status: string;
+}[]): boolean;
+export declare function getMatchingReadyIssues(prefix: string, includeFeatures: boolean, deps?: {
+    execSyncFn?: (cmd: string, opts: {
+        encoding: string;
+    }) => string;
+}): ReadyIssue[];
+/**
+ * Default per-issue budget cap in USD. The planning phase and each task each get
+ * this cap. Single source of truth — imported by cli.ts for its --budget help
+ * text so the documented default and the runtime fallback can't drift.
+ */
+export declare const DEFAULT_BUDGET_USD = "25.00";
+/**
+ * Sent when resuming a session that ended without closing its issue. The opener
+ * must NOT read as operator authorization (the old "Approved. Continue..." text
+ * could be taken as permission to work past a block): an agent that marked the
+ * issue `blocked` made a deliberate safety call, and the block stands. The loop
+ * also skips resuming a `blocked` issue entirely (see shouldResumeUnclosedIssue)
+ * — this clause is the belt-and-suspenders for a block raised mid-resume.
+ */
+export declare const RESUME_PROMPT = "The previous session ended without closing this issue. Reload the state and continue.\n\nIMPORTANT: If the previous session marked this issue blocked with a diagnostic, the block stands. Do not re-open it or work around it. Read the issue's notes and the previous session's commits, confirm the block is still appropriate, and stop without taking further action.\n\nOtherwise, complete the workflow:\n- Finish any remaining implementation\n- Run tests to verify\n- Commit changes referencing the issue ID\n- Close the issue with bd close\n- Push with: git pull --rebase && git push\n\nDo not pause for review of completed work. Complete everything now.";
 export declare function runLoop(options: LoopOptions): Promise<void>;
 export {};