@boopkit/cli 0.6.14 → 0.6.15

package/dist/commands/loop.js.orig-pre-maxbuffer

@@ -1,1455 +0,0 @@
-"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.RESUME_PROMPT = exports.DEFAULT_BUDGET_USD = void 0;
-exports.assertDoltServerMode = assertDoltServerMode;
-exports.discoverDoltServer = discoverDoltServer;
-exports.resolveDefaultBranch = resolveDefaultBranch;
-exports.createWorktree = createWorktree;
-exports.writeWorktreeMetadata = writeWorktreeMetadata;
-exports.buildPlanningPrompt = buildPlanningPrompt;
-exports.planWork = planWork;
-exports.findFallbackFeature = findFallbackFeature;
-exports.extractFeatureId = extractFeatureId;
-exports.isUsageLimitText = isUsageLimitText;
-exports.isStandaloneUsageLimitMessage = isStandaloneUsageLimitMessage;
-exports.resolveModel = resolveModel;
-exports.shouldResumeUnclosedIssue = shouldResumeUnclosedIssue;
-exports.isIssueInScope = isIssueInScope;
-exports.isClaimableReadyIssue = isClaimableReadyIssue;
-exports.shouldCloseFeatureRoot = shouldCloseFeatureRoot;
-exports.getMatchingReadyIssues = getMatchingReadyIssues;
-exports.shouldRotateSession = shouldRotateSession;
-exports.runLoop = runLoop;
-const child_process_1 = require("child_process");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const crypto_1 = require("crypto");
-/**
- * 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.
- */
-function assertDoltServerMode(projectDir, deps) {
-    const existsSyncFn = deps?.existsSyncFn || fs.existsSync;
-    const readFileFn = deps?.readFileFn || ((p, enc) => fs.readFileSync(p, enc));
-    const metaPath = path.join(projectDir, '.beads', 'metadata.json');
-    const fix = 'Migrate beads to Dolt server mode before running the loop; see skills/boop-dolt-recovery/SKILL.md';
-    if (!existsSyncFn(metaPath)) {
-        throw new Error(`beads metadata not found at ${metaPath}. The loop requires Dolt server mode for concurrent worktrees. ${fix}`);
-    }
-    let mode;
-    try {
-        const meta = JSON.parse(readFileFn(metaPath, 'utf8'));
-        mode = meta.dolt_mode;
-    }
-    catch (e) {
-        throw new Error(`Failed to parse ${metaPath}: ${e.message}. ${fix}`);
-    }
-    if (mode !== 'server') {
-        throw new Error(`beads is in dolt_mode="${mode ?? 'unset'}" (read from ${metaPath}); the loop requires dolt_mode="server" so concurrent worktrees share one issue DB. ${fix}`);
-    }
-}
-/**
- * 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.
- */
-function discoverDoltServer(projectDir, deps) {
-    const existsSyncFn = deps?.existsSyncFn || fs.existsSync;
-    const readFileFn = deps?.readFileFn || ((p, enc) => fs.readFileSync(p, enc));
-    const isPidAliveFn = deps?.isPidAliveFn ||
-        ((pid) => {
-            try {
-                process.kill(pid, 0);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        });
-    const portPath = path.join(projectDir, '.beads', 'dolt-server.port');
-    if (!existsSyncFn(portPath)) {
-        return null;
-    }
-    const port = parseInt(readFileFn(portPath, 'utf8').trim(), 10);
-    if (!Number.isFinite(port) || port <= 0) {
-        return null;
-    }
-    // Best-effort liveness: read pid file and probe; never throws/blocks.
-    let pid;
-    let alive;
-    const pidPath = path.join(projectDir, '.beads', 'dolt-server.pid');
-    if (existsSyncFn(pidPath)) {
-        const parsed = parseInt(readFileFn(pidPath, 'utf8').trim(), 10);
-        if (Number.isFinite(parsed) && parsed > 0) {
-            pid = parsed;
-            alive = isPidAliveFn(parsed);
-        }
-    }
-    return { port, pid, alive };
-}
-/**
- * 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.
- */
-/**
- * Best-effort resolution of the repo's default branch, used to move a launch dir
- * off a loop feature branch it should never have been parked on (boop-6iw).
- * Prefers `origin/HEAD`, then a local `main`/`master`, then `main`.
- */
-function resolveDefaultBranch(execSyncFn, cwd) {
-    try {
-        const ref = execSyncFn('git symbolic-ref --short refs/remotes/origin/HEAD', { encoding: 'utf8', cwd }).trim();
-        if (ref)
-            return ref.replace(/^origin\//, '');
-    }
-    catch {
-        // origin/HEAD not set — fall through to local candidates.
-    }
-    for (const cand of ['main', 'master']) {
-        try {
-            execSyncFn(`git rev-parse --verify --quiet refs/heads/${cand}`, { encoding: 'utf8', cwd });
-            return cand;
-        }
-        catch {
-            // not present — try next
-        }
-    }
-    return 'main';
-}
-function createWorktree(scope, mode, projectDir, deps) {
-    const execSyncFn = deps?.execSyncFn ||
-        ((cmd, o) => (0, child_process_1.execSync)(cmd, o));
-    const existsSyncFn = deps?.existsSyncFn || fs.existsSync;
-    const copyFileFn = deps?.copyFileFn || ((src, dest) => fs.copyFileSync(src, dest));
-    const readdirFn = deps?.readdirFn || ((p) => fs.readdirSync(p));
-    const readFileFn = deps?.readFileFn || ((p) => fs.readFileSync(p, 'utf8'));
-    const appendFileFn = deps?.appendFileFn || ((p, data) => fs.appendFileSync(p, data));
-    const branch = `work/${scope}`;
-    const worktreePath = path.resolve(projectDir, '..', `boop-${scope}`);
-    const ctx = { path: worktreePath, branch, scope, mode };
-    // A fresh worktree checks out its own (tracked) `.beads/` but NOT the gitignored
-    // runtime files dolt-server.port/pid. Without them, `bd` inside the worktree
-    // auto-starts a ROGUE Dolt server on a different port and can't see the issue DB.
-    // Propagate the shared server's discovery files so the worktree reuses it.
-    // (Verified in Task 1.7 — see specs/parallel-worktree-development-audit.md.)
-    const propagateServerFiles = () => {
-        for (const file of ['dolt-server.port', 'dolt-server.pid']) {
-            const src = path.join(projectDir, '.beads', file);
-            const dest = path.join(worktreePath, '.beads', file);
-            if (existsSyncFn(src) && existsSyncFn(path.join(worktreePath, '.beads'))) {
-                try {
-                    copyFileFn(src, dest);
-                }
-                catch {
-                    // Best-effort; discovery already validated the shared server in runLoop.
-                }
-            }
-        }
-    };
-    // Gitignored runtime config (`.env` and friends) lives only in the main working
-    // tree — `git worktree add` checks out tracked files only, so a fresh worktree
-    // would start with no environment and the agent's app/tests would fail. Seed
-    // copies of root-level `.env*` files. Copy (not symlink) to keep worktrees
-    // isolated, matching the spec's "each worktree is a full working copy (own
-    // node_modules, own .env)". Don't clobber a file the agent may already have
-    // customized in a reused worktree. (boop-bf3)
-    const propagateConfigFiles = () => {
-        let entries;
-        try {
-            entries = readdirFn(projectDir);
-        }
-        catch {
-            return; // best-effort — a missing/unreadable project dir shouldn't abort setup
-        }
-        for (const name of entries) {
-            if (name !== '.env' && !name.startsWith('.env.'))
-                continue;
-            const src = path.join(projectDir, name);
-            const dest = path.join(worktreePath, name);
-            try {
-                if (existsSyncFn(src) && !existsSyncFn(dest)) {
-                    copyFileFn(src, dest);
-                }
-            }
-            catch {
-                // Best-effort; one unreadable config file shouldn't abort worktree setup.
-            }
-        }
-    };
-    // `.boop-worktree.json` is per-worktree runtime state (scope/branch/in-scope
-    // issues), not source. It must NEVER be tracked: if a closeout `git add` sweeps
-    // it into a commit, sibling worktree branches inherit a stale copy, and a later
-    // `git stash`/`git pull --rebase` can silently revert THIS worktree's metadata
-    // to another scope (the wf-bir→wf-ayn regression — boop-g0l). Register the
-    // ignore in the repo's local git exclude (resolved per-worktree via
-    // `git rev-parse --git-path info/exclude`) rather than the tracked `.gitignore`,
-    // so adding the rule never itself becomes an uncommitted tracked change that
-    // blocks the closeout's `git pull --rebase`. Idempotent and best-effort.
-    const ensureMetadataIgnored = () => {
-        try {
-            const raw = execSyncFn('git rev-parse --git-path info/exclude', {
-                encoding: 'utf8',
-                cwd: worktreePath,
-            });
-            const rel = (raw || '').trim();
-            if (!rel)
-                return;
-            const excludePath = path.isAbsolute(rel) ? rel : path.join(worktreePath, rel);
-            let current = '';
-            try {
-                current = readFileFn(excludePath);
-            }
-            catch {
-                // Exclude file may not exist yet — treat as empty; append will create it.
-            }
-            const already = current.split('\n').some((l) => l.trim() === '.boop-worktree.json');
-            if (already)
-                return;
-            const sep = current.length > 0 && !current.endsWith('\n') ? '\n' : '';
-            appendFileFn(excludePath, `${sep}.boop-worktree.json\n`);
-        }
-        catch {
-            // Best-effort: worst case the metadata file shows as untracked — still safer
-            // than the pre-fix tracked state. Never abort worktree setup over this.
-        }
-    };
-    // Is this path already a registered worktree? Parse `git worktree list --porcelain`.
-    let existingBranch;
-    let pathAlreadyWorktree = false;
-    try {
-        const raw = execSyncFn('git worktree list --porcelain', { encoding: 'utf8', cwd: projectDir });
-        const blocks = raw.split('\n\n');
-        for (const block of blocks) {
-            const lines = block.split('\n');
-            const wtLine = lines.find((l) => l.startsWith('worktree '));
-            if (!wtLine)
-                continue;
-            const wtPath = path.resolve(wtLine.slice('worktree '.length).trim());
-            if (wtPath === worktreePath) {
-                pathAlreadyWorktree = true;
-                const brLine = lines.find((l) => l.startsWith('branch '));
-                if (brLine) {
-                    // refs/heads/work/<scope> → work/<scope>
-                    existingBranch = brLine.slice('branch '.length).trim().replace(/^refs\/heads\//, '');
-                }
-            }
-        }
-    }
-    catch {
-        // No git / no worktrees yet — proceed to create.
-    }
-    if (pathAlreadyWorktree) {
-        if (existingBranch && existingBranch !== branch) {
-            throw new Error(`Worktree at ${worktreePath} is on branch "${existingBranch}", not the expected "${branch}". ` +
-                `Remove it (git worktree remove ${worktreePath}) or choose a different scope.`);
-        }
-        // Seed gitignored runtime config before any (re)install/bd work.
-        propagateConfigFiles();
-        // Reuse: only install if dependencies are missing.
-        if (!existsSyncFn(path.join(worktreePath, 'node_modules'))) {
-            execSyncFn('npm install --prefer-offline', { encoding: 'utf8', cwd: worktreePath });
-        }
-        propagateServerFiles();
-        ensureMetadataIgnored();
-        return ctx;
-    }
-    if (existsSyncFn(worktreePath)) {
-        throw new Error(`Path ${worktreePath} already exists but is not a registered git worktree. ` +
-            `Remove it or choose a different scope before running the loop.`);
-    }
-    // Does the branch already exist? If so, attach the worktree to it; else create it.
-    let branchExists = false;
-    try {
-        execSyncFn(`git rev-parse --verify --quiet refs/heads/${branch}`, { encoding: 'utf8', cwd: projectDir });
-        branchExists = true;
-    }
-    catch {
-        branchExists = false;
-    }
-    if (branchExists) {
-        // Guard (boop-6iw): if the loop branch is checked out in the launch dir — e.g. a
-        // planning phase that ran `git checkout -b work/<id>` in place before the worktree
-        // existed — then `git worktree add <path> <branch>` fails with "already checked
-        // out at <launch-dir>". It also leaves the launch dir parked on the feature branch,
-        // so a concurrent session's next commit lands on the wrong branch. Move the launch
-        // dir back to its default branch first: it both unblocks the worktree add and undoes
-        // the mis-parking. (Flows should not create the branch during planning — see the
-        // light-dev-workflow skill — but this makes any that slip through non-fatal.)
-        let launchBranch = '';
-        try {
-            launchBranch = execSyncFn('git branch --show-current', { encoding: 'utf8', cwd: projectDir }).trim();
-        }
-        catch {
-            // Detached HEAD or no git — nothing of ours is parked; proceed.
-        }
-        if (launchBranch === branch) {
-            const defaultBranch = resolveDefaultBranch(execSyncFn, projectDir);
-            try {
-                execSyncFn(`git checkout ${defaultBranch}`, { encoding: 'utf8', cwd: projectDir });
-            }
-            catch {
-                throw new Error(`Loop branch "${branch}" is checked out in the launch directory (${projectDir}), which blocks ` +
-                    `creating its worktree. Moving the launch dir to "${defaultBranch}" failed — likely uncommitted ` +
-                    `changes there. Commit or stash them (or run \`git checkout ${defaultBranch}\`) and retry.`);
-            }
-        }
-        execSyncFn(`git worktree add ${worktreePath} ${branch}`, { encoding: 'utf8', cwd: projectDir });
-    }
-    else {
-        execSyncFn(`git worktree add ${worktreePath} -b ${branch}`, { encoding: 'utf8', cwd: projectDir });
-    }
-    // Point the worktree's bd at the shared server before any bd work happens.
-    propagateServerFiles();
-    // Seed gitignored runtime config (`.env` etc.) that `git worktree add` doesn't
-    // check out, so the app/tests have their environment before install/session. (boop-bf3)
-    propagateConfigFiles();
-    // Pre-warm dependencies so the agent doesn't burn budget on a deterministic step.
-    execSyncFn('npm install --prefer-offline', { encoding: 'utf8', cwd: worktreePath });
-    // Ignore the metadata file before it is ever written (writeWorktreeMetadata runs
-    // next in runLoop), so no later `git add` can track it.
-    ensureMetadataIgnored();
-    return ctx;
-}
-/**
- * Write `.boop-worktree.json` into the worktree root. This is the contract
- * Slice 2 (`boop loop --merge`) reads — `mode` drives its readiness query.
- */
-function writeWorktreeMetadata(ctx, meta, deps) {
-    const writeFileFn = deps?.writeFileFn || ((p, data) => fs.writeFileSync(p, data));
-    const data = {
-        version: 1,
-        mode: ctx.mode,
-        scope: ctx.scope,
-        branch: ctx.branch,
-        worktreePath: ctx.path,
-    };
-    if (ctx.mode === 'work-flow') {
-        if (meta.workPath)
-            data.workPath = meta.workPath;
-        if (meta.flowPath)
-            data.flowPath = meta.flowPath;
-    }
-    data.startTime = meta.startTime;
-    data.boopVersion = meta.boopVersion;
-    if (meta.operator)
-        data.operator = meta.operator;
-    if (meta.budget)
-        data.budget = meta.budget;
-    if (meta.model)
-        data.model = meta.model;
-    writeFileFn(path.join(ctx.path, '.boop-worktree.json'), JSON.stringify(data, null, 2) + '\n');
-    return data;
-}
-function getBoopVersion() {
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'));
-        return pkg.version || 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-function getGitUserName(projectDir) {
-    try {
-        return (0, child_process_1.execSync)('git config user.name', { encoding: 'utf8', cwd: projectDir }).trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function buildPlanningPrompt(workContent, flowContent, prefix) {
-    let prompt = `You are setting up work for a development project.
-
-## Work Specification
-${workContent}
-
-## Workflow Process
-${flowContent}
-
-## Instructions
-1. Read the work specification carefully.
-2. Follow the Workflow Process above to set up the work. The Workflow Process
-   governs the stages, the container issue (its type and title), and the child
-   issues created under it — use \`--parent <container-id>\` so they are its children.
-3. The setup MUST produce a single container issue with its child issues, each
-   carrying breadcrumbs (links to the work file, relevant specs, skills, and code),
-   with appropriate priorities and blocking deps.
-
-When finished, output exactly one line with the id of the container issue you created:
-FEATURE_ID=<the-container-issue-id>`;
-    if (prefix) {
-        prompt += `\n\nNaming hint: Use \`${prefix}\` as a naming hint for the container title.`;
-    }
-    return prompt;
-}
-async function planWork(opts) {
-    const workContent = fs.readFileSync(opts.workPath, 'utf8');
-    const flowContent = fs.readFileSync(opts.flowPath, 'utf8');
-    const prompt = buildPlanningPrompt(workContent, flowContent, opts.prefix);
-    const sessionId = (0, crypto_1.randomUUID)();
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
-    const logFile = path.join(opts.logDir, `_planning_${opts.prefix}_${timestamp}.log`);
-    const readableLogFile = path.join(opts.logDir, `_planning_${opts.prefix}_${timestamp}.readable.log`);
-    // Write readable log header
-    fs.writeFileSync(readableLogFile, `=== Planning Session ===\nSession: ${sessionId}\nStarted: ${new Date().toISOString()}\n\n`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m 📋 Starting planning phase...`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   Work: ${opts.workPath}`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   Flow: ${opts.flowPath}`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   Log:  ${logFile}`);
-    const runner = opts.runClaudeFn || runClaude;
-    const result = await runner(prompt, {
-        budget: opts.budget,
-        model: opts.model,
-        skipPerms: opts.skipPerms,
-        bare: opts.bare,
-        sessionId,
-    }, logFile, readableLogFile);
-    if (result.exitCode !== 0 && result.limitHit) {
-        console.error('\x1b[31m[bd-loop]\x1b[0m Planning phase hit usage limit');
-        return { featureId: null, costUsd: null };
-    }
-    if (result.exitCode !== 0) {
-        console.error(`\x1b[31m[bd-loop]\x1b[0m Planning phase exited with code ${result.exitCode}`);
-        console.error(`\x1b[31m[bd-loop]\x1b[0m Check log: ${logFile}`);
-        return { featureId: null, costUsd: null };
-    }
-    // Read log file and parse assistant text + cost
-    let accumulated = '';
-    let costUsd = null;
-    try {
-        const logContent = fs.readFileSync(logFile, 'utf8');
-        const lines = logContent.split('\n').filter(Boolean);
-        for (const line of lines) {
-            try {
-                const msg = JSON.parse(line);
-                if (msg.type === 'assistant') {
-                    const texts = (msg.message?.content || [])
-                        .filter((c) => c.type === 'text')
-                        .map((c) => c.text);
-                    accumulated += texts.join('');
-                }
-                else if (msg.type === 'result' && typeof msg.total_cost_usd === 'number') {
-                    costUsd = msg.total_cost_usd;
-                }
-            }
-            catch (e) {
-                console.warn(`\x1b[33m[bd-loop]\x1b[0m Failed to parse planning log line: ${e.message}`);
-            }
-        }
-    }
-    catch {
-        console.error(`\x1b[31m[bd-loop]\x1b[0m Failed to read planning log: ${logFile}`);
-        return { featureId: null, costUsd: null };
-    }
-    // Primary extraction
-    const featureId = extractFeatureId(accumulated);
-    if (featureId) {
-        return { featureId, costUsd };
-    }
-    // Fallback: query bd list for recently created features
-    console.log('\x1b[33m[bd-loop]\x1b[0m No FEATURE_ID in output, trying fallback query...');
-    try {
-        const execFn = opts.execSyncFn || ((cmd, o) => (0, child_process_1.execSync)(cmd, o));
-        const raw = execFn('bd list --json --type feature 2>/dev/null', { encoding: 'utf8' });
-        const features = JSON.parse(raw);
-        const fallbackId = findFallbackFeature(features, workContent, opts.workPath);
-        if (fallbackId) {
-            console.log(`\x1b[32m[bd-loop]\x1b[0m Fallback found feature: ${fallbackId}`);
-            return { featureId: fallbackId, costUsd };
-        }
-    }
-    catch (e) {
-        console.warn(`\x1b[33m[bd-loop]\x1b[0m Fallback feature query failed: ${e.message}`);
-    }
-    console.error(`\x1b[31m[bd-loop]\x1b[0m Planning phase failed to produce a feature ID`);
-    console.error(`\x1b[31m[bd-loop]\x1b[0m Check planning log: ${logFile}`);
-    return { featureId: null, costUsd };
-}
-function findFallbackFeature(features, workContent, workPath) {
-    const fiveMinAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
-    // Extract keywords from work file H1 heading or filename
-    const h1Match = workContent.match(/^#\s+(.+)$/m);
-    const keywords = h1Match
-        ? h1Match[1].toLowerCase().split(/\s+/).filter((w) => w.length > 3).slice(0, 3)
-        : [path.basename(workPath, path.extname(workPath)).toLowerCase()];
-    const match = features.find((f) => {
-        if (!f.created_at || f.created_at < fiveMinAgo)
-            return false;
-        const title = (f.title || '').toLowerCase();
-        return keywords.some((kw) => title.includes(kw));
-    });
-    return match?.id ?? null;
-}
-function extractFeatureId(text) {
-    const match = text.match(/FEATURE_ID=([\w.-]+)/);
-    return match ? match[1] : null;
-}
-function isUsageLimitText(text) {
-    // Normalize all whitespace (including NBSP) so provider text variants still match.
-    const normalized = text.toLowerCase().replace(/\s+/gu, ' ').trim();
-    return (normalized.includes("you've hit your limit") ||
-        normalized.includes('usage limit') ||
-        normalized.includes('rate limit') ||
-        normalized.includes('quota') ||
-        normalized.includes('credit balance is too low') ||
-        normalized.includes('credit balance too low') ||
-        /credit\s+balance\s+(?:is\s+)?too\s+low/u.test(normalized) ||
-        normalized.includes('insufficient credit') ||
-        normalized.includes('insufficient funds'));
-}
-function isStandaloneUsageLimitMessage(text) {
-    const trimmed = text.trim();
-    if (!trimmed || trimmed.includes('\n')) {
-        return false;
-    }
-    // Real provider limit responses are usually short single-line messages.
-    if (trimmed.length > 200) {
-        return false;
-    }
-    const normalized = trimmed.toLowerCase().replace(/\s+/gu, ' ');
-    return (/^credit\s+balance\s+(?:is\s+)?too\s+low\b/u.test(normalized) ||
-        /^insufficient\s+credit\b/u.test(normalized) ||
-        /^insufficient\s+funds\b/u.test(normalized) ||
-        /^you'?ve\s+hit\s+your\s+limit\b/u.test(normalized) ||
-        /^rate\s+limit\s+reached\b/u.test(normalized) ||
-        /^error:\s*usage\s+limit\s+exceeded\b/u.test(normalized) ||
-        /^quota\s+exceeded\b/u.test(normalized));
-}
-function findClaudeBinary() {
-    try {
-        return (0, child_process_1.execSync)('command -v claude', { encoding: 'utf8' }).trim();
-    }
-    catch {
-        // Check common locations
-        const candidates = [
-            path.join(process.env.HOME || '', '.nvm/versions/node'),
-            path.join(process.env.HOME || '', '.local/bin/claude'),
-            '/usr/local/bin/claude',
-        ];
-        for (const candidate of candidates) {
-            if (candidate.includes('.nvm')) {
-                // Glob for nvm versions
-                try {
-                    const result = (0, child_process_1.execSync)(`ls ${candidate}/*/bin/claude 2>/dev/null | head -1`, {
-                        encoding: 'utf8',
-                    }).trim();
-                    if (result)
-                        return result;
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (fs.existsSync(candidate))
-                return candidate;
-        }
-        return null;
-    }
-}
-/**
- * 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-5)
- * in sync with the `--model` help text in cli.ts.
- */
-function resolveModel(optionModel, env = process.env) {
-    return optionModel || env.ANTHROPIC_MODEL || 'claude-opus-5';
-}
-/**
- * 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.
- */
-function shouldResumeUnclosedIssue(status) {
-    return status !== 'blocked';
-}
-function findNextIssue(prefix, includeFeatures) {
-    const matching = getMatchingReadyIssues(prefix, includeFeatures);
-    return matching.length > 0 ? matching[0].id : null;
-}
-function getIssueParentId(id) {
-    try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
-        const data = JSON.parse(raw);
-        const issue = data[0] || data;
-        return issue.parent || null;
-    }
-    catch {
-        return null;
-    }
-}
-function isIssueInScope(issue, prefix, getParentById) {
-    if (issue.id.startsWith(prefix)) {
-        return true;
-    }
-    const seen = new Set();
-    let ancestor = issue.parent || null;
-    while (ancestor && !seen.has(ancestor)) {
-        if (ancestor.startsWith(prefix)) {
-            return true;
-        }
-        seen.add(ancestor);
-        ancestor = getParentById(ancestor);
-    }
-    return false;
-}
-/**
- * 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.
- */
-function isClaimableReadyIssue(issue, hasChildren) {
-    if (issue.issue_type === 'feature' && hasChildren(issue.id)) {
-        return false;
-    }
-    return true;
-}
-/**
- * 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.
- */
-function shouldCloseFeatureRoot(feature, children) {
-    if (!feature || (feature.issue_type !== 'feature' && feature.issue_type !== 'epic')) {
-        return false;
-    }
-    if (feature.status === 'closed') {
-        return false;
-    }
-    if (children.length === 0) {
-        return false;
-    }
-    return children.every((c) => c.status === 'closed');
-}
-function getIssueChildren(id) {
-    try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --children --json 2>/dev/null`, { encoding: 'utf8' });
-        const data = JSON.parse(raw);
-        const children = data[id];
-        return Array.isArray(children) ? children : [];
-    }
-    catch {
-        return [];
-    }
-}
-function issueHasChildren(id) {
-    return getIssueChildren(id).length > 0;
-}
-/**
- * Safety net for spec-driven runs: when the workflow chain completes but the
- * closeout child did not close the feature root, close it here so it is not
- * orphaned open after the filter removes it from claimable work. Returns true if
- * it closed the feature. Best-effort — failures are logged, not fatal.
- */
-function closeCompletedFeatureRoot(featureId) {
-    const feature = getIssueInfoWithStatus(featureId);
-    const children = getIssueChildren(featureId);
-    if (!shouldCloseFeatureRoot(feature, children)) {
-        return false;
-    }
-    try {
-        (0, child_process_1.execSync)(`bd close ${featureId} --reason "bd-loop: closed feature root on workflow chain completion (all child tasks closed; closeout did not close it)" 2>/dev/null`, { encoding: 'utf8' });
-        console.log(`\x1b[32m[bd-loop]\x1b[0m Closed feature root ${featureId} — workflow chain complete (safety net; closeout had not closed it).`);
-        return true;
-    }
-    catch {
-        console.warn(`\x1b[33m[bd-loop]\x1b[0m Feature root ${featureId} chain is complete but \`bd close\` failed — close it manually.`);
-        return false;
-    }
-}
-function getIssueInfoWithStatus(id) {
-    try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
-        const data = JSON.parse(raw);
-        const issue = data[0] || data;
-        return { status: issue.status || 'unknown', issue_type: issue.issue_type || 'task' };
-    }
-    catch {
-        return null;
-    }
-}
-function getMatchingReadyIssues(prefix, includeFeatures, deps) {
-    const execSyncFn = deps?.execSyncFn ||
-        ((cmd, opts) => (0, child_process_1.execSync)(cmd, opts));
-    try {
-        // -n 0 = unlimited. A bounded window (formerly -n 20) starves the scope
-        // filter below: with more than 20 ready issues globally, in-scope issues
-        // sorting outside the window are never seen and the loop exits with group
-        // work undone (boop-pra).
-        const raw = execSyncFn('bd ready --json -n 0 2>/dev/null', { encoding: 'utf8' });
-        const issues = JSON.parse(raw);
-        const typeFilter = includeFeatures
-            ? (i) => i.issue_type !== 'epic'
-            : (i) => i.issue_type !== 'epic' && i.issue_type !== 'feature';
-        const parentCache = new Map();
-        for (const issue of issues) {
-            parentCache.set(issue.id, issue.parent || null);
-        }
-        const getParentById = (id) => {
-            if (parentCache.has(id)) {
-                return parentCache.get(id) ?? null;
-            }
-            const parent = getIssueParentId(id);
-            parentCache.set(id, parent);
-            return parent;
-        };
-        const childrenCache = new Map();
-        const hasChildren = (id) => {
-            const cached = childrenCache.get(id);
-            if (cached !== undefined) {
-                return cached;
-            }
-            const result = issueHasChildren(id);
-            childrenCache.set(id, result);
-            return result;
-        };
-        return issues
-            .filter(typeFilter)
-            .filter((issue) => isIssueInScope(issue, prefix, getParentById))
-            .filter((issue) => isClaimableReadyIssue(issue, hasChildren));
-    }
-    catch {
-        return [];
-    }
-}
-function getIssueInfo(id) {
-    try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
-        const data = JSON.parse(raw);
-        const issue = data[0] || data;
-        return {
-            id,
-            title: issue.title || 'unknown',
-            priority: issue.priority ?? '?',
-            issue_type: issue.issue_type || 'task',
-            description: issue.description || 'No description',
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function isIssueClosed(id) {
-    try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
-        const data = JSON.parse(raw);
-        const status = (data[0] || data).status || 'unknown';
-        return status === 'closed';
-    }
-    catch {
-        return false;
-    }
-}
-function buildPrompt(issue) {
-    return `You are working on issue ${issue.id} in the boop project.
-
-## Issue: ${issue.title}
-Type: ${issue.issue_type} | Priority: ${issue.priority}
-
-## Description
-${issue.description}
-
-## Instructions
-1. Read AGENTS.md for project orientation
-2. Claim the issue: bd update ${issue.id} --claim
-3. Read relevant skills from skills/ (list folders, read each SKILL.md) before making changes
-4. Implement the changes following TDD-Lite: observe, implement, verify
-5. Run tests if applicable: npm test
-6. Commit your changes with a message referencing ${issue.id}
-7. Close the issue: bd close ${issue.id} --reason "<what you did>"
-8. Push: git pull --rebase && git push
-
-IMPORTANT: Complete the FULL workflow — implement, test, commit, close, and push.
-Do NOT pause for review. Work autonomously through to completion.
-
-If you discover additional issues during your work, file them with:
-  bd create "Title" -d "description" --deps discovered-from:${issue.id}`;
-}
-/**
- * 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.
- */
-exports.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.
- */
-exports.RESUME_PROMPT = `The previous session ended without closing this issue. Reload the state and continue.
-
-IMPORTANT: 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.
-
-Otherwise, complete the workflow:
-- Finish any remaining implementation
-- Run tests to verify
-- Commit changes referencing the issue ID
-- Close the issue with bd close
-- Push with: git pull --rebase && git push
-
-Do not pause for review of completed work. Complete everything now.`;
-/**
- * Fraction of the context window at which a reused session is rotated for a fresh
- * one. Deliberately well below Claude Code's auto-compaction point — compaction
- * silently discards the context the reuse exists to keep, so we rotate first.
- * The one knob a trial run should tune (specs/loop-session-reuse.spec.md).
- */
-const ROTATE_FRACTION = 0.55;
-/** Fallback context window (tokens) before the stream has reported a real one. */
-const DEFAULT_CONTEXT_WINDOW = 1000000;
-/**
- * Live context-window occupancy for one turn, from a stream-json `usage` object:
- * everything the model had to read this turn (fresh input + cached prompt).
- */
-function contextOccupancy(usage) {
-    if (!usage)
-        return 0;
-    return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-}
-/**
- * Decide whether a reused session should rotate before taking the next issue.
- * Rotates once peak observed occupancy reaches ROTATE_FRACTION of the window.
- * Pure so it is unit-testable without a running loop.
- */
-function shouldRotateSession(peakContext, contextWindow, fraction = ROTATE_FRACTION) {
-    const window = contextWindow > 0 ? contextWindow : DEFAULT_CONTEXT_WINDOW;
-    return peakContext >= fraction * window;
-}
-function runClaude(prompt, opts, logFile, readableLogFile) {
-    return new Promise((resolve) => {
-        const args = [
-            '-p',
-            '--max-budget-usd', opts.budget,
-            '--output-format', 'stream-json',
-            '--verbose',
-        ];
-        if (opts.bare)
-            args.push('--bare');
-        if (opts.skipPerms)
-            args.push('--dangerously-skip-permissions');
-        if (opts.model)
-            args.push('--model', opts.model);
-        if (opts.resume) {
-            args.push('--resume', opts.sessionId);
-        }
-        else {
-            args.push('--session-id', opts.sessionId);
-        }
-        const claudeBin = findClaudeBinary();
-        if (!claudeBin) {
-            console.error('\x1b[31m[bd-loop]\x1b[0m claude binary not found');
-            resolve({ exitCode: 1, limitHit: false });
-            return;
-        }
-        const logStream = fs.createWriteStream(logFile, { flags: 'a' });
-        const readableStream = readableLogFile
-            ? fs.createWriteStream(readableLogFile, { flags: 'a' })
-            : null;
-        // Propagate the chosen model beyond this session via the environment.
-        // `--model` (in args) sets this session; ANTHROPIC_MODEL additionally
-        // (a) reaches a nested `boop loop` — child processes inherit the env — so it
-        // doesn't reset to the default, and (b) is honored by any sub-agent whose
-        // definition opts into `model: inherit`. We deliberately do NOT set
-        // CLAUDE_CODE_SUBAGENT_MODEL: sub-agents keep their own declared model, so a
-        // deliberately-cheap agent (e.g. Explore on Haiku) stays cheap. The invoking
-        // agent can still override a sub-agent's model per-invocation when it needs
-        // to. See resolveModel().
-        const childEnv = opts.model
-            ? { ...process.env, ANTHROPIC_MODEL: opts.model }
-            : process.env;
-        const child = (0, child_process_1.spawn)(claudeBin, args, { cwd: opts.cwd, stdio: ['pipe', 'pipe', 'pipe'], env: childEnv });
-        let limitHit = false;
-        // Track context-window pressure from outside the agent (spec: the loop reads
-        // the stream it already parses; the agent is never told). Peak occupancy over
-        // the run drives session rotation; contextWindow comes from the result.
-        let peakContext = 0;
-        let contextWindow;
-        child.stdin.write(prompt);
-        child.stdin.end();
-        child.stdout.on('data', (chunk) => {
-            logStream.write(chunk);
-            const lines = chunk.toString().split('\n').filter(Boolean);
-            for (const line of lines) {
-                try {
-                    const msg = JSON.parse(line);
-                    if (msg.type === 'assistant') {
-                        // Live context occupancy for this turn (read from outside the agent).
-                        const occ = contextOccupancy(msg.message?.usage);
-                        if (occ > peakContext)
-                            peakContext = occ;
-                        const texts = (msg.message?.content || [])
-                            .filter((c) => c.type === 'text')
-                            .map((c) => c.text);
-                        if (texts.length > 0) {
-                            const textBlob = texts.join('');
-                            if (isStandaloneUsageLimitMessage(textBlob)) {
-                                limitHit = true;
-                            }
-                            const first = textBlob.split('\n')[0].substring(0, 120);
-                            console.log(`\x1b[32m[bd-loop]\x1b[0m     💬 ${first}`);
-                            if (readableStream) {
-                                readableStream.write(`[text] ${textBlob}\n\n`);
-                            }
-                        }
-                        const tools = (msg.message?.content || [])
-                            .filter((c) => c.type === 'tool_use')
-                            .map((c) => `${c.name} ${JSON.stringify(c.input).substring(0, 80)}`);
-                        for (const t of tools) {
-                            console.log(`\x1b[32m[bd-loop]\x1b[0m     🔧 ${t}`);
-                            if (readableStream) {
-                                readableStream.write(`[tool] ${t}\n`);
-                            }
-                        }
-                    }
-                    else if (msg.type === 'result') {
-                        const resultText = typeof msg.result === 'string' ? msg.result : '';
-                        if ((msg.is_error || msg.subtype === 'error') && isUsageLimitText(resultText)) {
-                            limitHit = true;
-                        }
-                        // The result reports the model's context window under modelUsage.<model>.
-                        const mu = msg.modelUsage;
-                        if (mu) {
-                            for (const m of Object.values(mu)) {
-                                if (typeof m?.contextWindow === 'number' && m.contextWindow > 0) {
-                                    contextWindow = m.contextWindow;
-                                    break;
-                                }
-                            }
-                        }
-                        const cost = msg.total_cost_usd || '?';
-                        const dur = Math.round((msg.duration_ms || 0) / 1000);
-                        const turns = msg.num_turns || '?';
-                        console.log(`\x1b[32m[bd-loop]\x1b[0m     📊 ${turns} turns, $${cost}, ${dur}s`);
-                        if (readableStream) {
-                            readableStream.write(`\n=== Result ===\nTurns: ${turns} | Cost: $${cost} | Duration: ${dur}s\n\n${resultText}\n`);
-                        }
-                    }
-                }
-                catch {
-                    if (isStandaloneUsageLimitMessage(line)) {
-                        limitHit = true;
-                    }
-                }
-            }
-        });
-        child.stderr.on('data', (chunk) => {
-            logStream.write(chunk);
-            if (isStandaloneUsageLimitMessage(chunk.toString())) {
-                limitHit = true;
-            }
-        });
-        child.on('close', (code) => {
-            logStream.end();
-            if (readableStream)
-                readableStream.end();
-            resolve({ exitCode: code ?? 1, limitHit, peakContext, contextWindow });
-        });
-    });
-}
-async function processIssue(issue, opts) {
-    const sessionId = opts.session?.id ?? (0, crypto_1.randomUUID)();
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
-    const logFile = path.join(opts.logDir, `${issue.id}_${timestamp}.log`);
-    const readableLogFile = path.join(opts.logDir, `${issue.id}_${timestamp}.readable.log`);
-    // Write readable log header
-    fs.writeFileSync(readableLogFile, `=== ${issue.id}: ${issue.title} ===\nSession: ${sessionId}\nStarted: ${new Date().toISOString()}\n\n`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m ━━━ \x1b[34m${issue.id}\x1b[0m (P${issue.priority} ${issue.issue_type}) ━━━`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   ${issue.title}`);
-    // Per-issue branches (when requested) are created *inside* the worktree cwd,
-    // so they nest under the loop's isolated tree rather than mutating main.
-    let originalBranch;
-    if (!opts.noBranch && opts.perIssueBranch) {
-        const branchName = `fix/${issue.id}`;
-        originalBranch = (0, child_process_1.execSync)('git branch --show-current', { encoding: 'utf8', cwd: opts.cwd }).trim();
-        console.log(`\x1b[32m[bd-loop]\x1b[0m   Creating branch: ${branchName}`);
-        try {
-            (0, child_process_1.execSync)(`git checkout -b ${branchName} 2>/dev/null`, { encoding: 'utf8', cwd: opts.cwd });
-        }
-        catch {
-            try {
-                (0, child_process_1.execSync)(`git checkout ${branchName} 2>/dev/null`, { encoding: 'utf8', cwd: opts.cwd });
-                console.log(`\x1b[33m[bd-loop]\x1b[0m   Branch ${branchName} exists, checked out`);
-            }
-            catch {
-                console.error(`\x1b[31m[bd-loop]\x1b[0m   Failed to create/checkout branch`);
-                return { issueId: issue.id, closed: false, resumes: 0, logFile, limitHit: false };
-            }
-        }
-    }
-    // Initial run
-    const prompt = buildPrompt(issue);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   🚀 Starting Claude session (budget: $${opts.budget}, session: ${sessionId.substring(0, 8)}...)`);
-    const initialRun = await runClaude(prompt, {
-        budget: opts.budget,
-        model: opts.model,
-        skipPerms: opts.skipPerms,
-        bare: opts.bare,
-        sessionId,
-        // Continue a carried session for this new issue (its normal prompt via --resume).
-        resume: opts.session?.resume,
-        cwd: opts.cwd,
-    }, logFile, readableLogFile);
-    let anyLimitHit = initialRun.limitHit;
-    let peakContext = initialRun.peakContext ?? 0;
-    let contextWindow = initialRun.contextWindow;
-    if (initialRun.limitHit) {
-        console.error('\x1b[31m[bd-loop]\x1b[0m   Claude usage limit reached; stopping retries for this issue');
-    }
-    // Resume loop
-    let resumeCount = 0;
-    while (resumeCount < opts.resumeLimit && !initialRun.limitHit) {
-        if (isIssueClosed(issue.id)) {
-            console.log(`\x1b[32m[bd-loop]\x1b[0m   ✅ Issue ${issue.id} closed successfully`);
-            break;
-        }
-        // Don't resume an issue the prior session deliberately blocked — that's a
-        // safety decision, not unfinished work. Resuming burns budget re-halting.
-        const statusInfo = getIssueInfoWithStatus(issue.id);
-        if (!shouldResumeUnclosedIssue(statusInfo?.status)) {
-            console.log(`\x1b[33m[bd-loop]\x1b[0m   ⛔ Issue ${issue.id} is marked '${statusInfo?.status}' — not resuming; operator review needed.`);
-            break;
-        }
-        resumeCount++;
-        console.log(`\x1b[33m[bd-loop]\x1b[0m   Issue not yet closed — resuming session (attempt ${resumeCount}/${opts.resumeLimit})`);
-        console.log(`\x1b[32m[bd-loop]\x1b[0m   🔄 Resuming session ${sessionId.substring(0, 8)}...`);
-        fs.appendFileSync(readableLogFile, `\n=== Resume attempt ${resumeCount} ===\nTime: ${new Date().toISOString()}\n\n`);
-        const resumeRun = await runClaude(exports.RESUME_PROMPT, {
-            budget: opts.budget,
-            model: opts.model,
-            skipPerms: opts.skipPerms,
-            bare: opts.bare,
-            sessionId,
-            resume: true,
-            cwd: opts.cwd,
-        }, logFile, readableLogFile);
-        if (resumeRun.peakContext && resumeRun.peakContext > peakContext)
-            peakContext = resumeRun.peakContext;
-        if (resumeRun.contextWindow)
-            contextWindow = resumeRun.contextWindow;
-        if (resumeRun.limitHit) {
-            anyLimitHit = true;
-            console.error('\x1b[31m[bd-loop]\x1b[0m   Claude usage limit reached during resume; stopping retries for this issue');
-            break;
-        }
-    }
-    const closed = isIssueClosed(issue.id);
-    if (closed) {
-        console.log(`\x1b[32m[bd-loop]\x1b[0m   ✅ Done: ${issue.id}`);
-    }
-    else {
-        console.error(`\x1b[31m[bd-loop]\x1b[0m   ⚠️  Issue ${issue.id} not closed after ${opts.resumeLimit} resume attempts`);
-        console.error(`\x1b[31m[bd-loop]\x1b[0m   Check log: ${logFile}`);
-    }
-    if (originalBranch) {
-        try {
-            (0, child_process_1.execSync)(`git checkout ${originalBranch} 2>/dev/null`, { cwd: opts.cwd });
-        }
-        catch {
-            // Best effort
-        }
-    }
-    return { issueId: issue.id, closed, resumes: resumeCount, logFile, limitHit: anyLimitHit, sessionId, peakContext, contextWindow };
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function runLoop(options) {
-    let prefix = options.prefix;
-    const work = options.work;
-    const flow = options.flow;
-    // Validate: need either --prefix OR both --work and --flow
-    if (!prefix && !work && !flow) {
-        console.error('\x1b[31mERR\x1b[0m Either --prefix or both --work and --flow are required');
-        console.error('Usage: boop loop --prefix <issue-prefix> [--run] [--max N] [--budget N.NN]');
-        console.error('       boop loop --work <spec-file> --flow <workflow-file> [--run]');
-        process.exitCode = 1;
-        return;
-    }
-    // --work and --flow must be used together
-    if ((work && !flow) || (!work && flow)) {
-        console.error('\x1b[31mERR\x1b[0m --work and --flow must be used together');
-        process.exitCode = 1;
-        return;
-    }
-    // --features is an issue-driven (--prefix) knob. Spec-driven runs always process
-    // the feature tree the planning phase produces, so a user-supplied --features is
-    // a no-op here — warn rather than silently ignore.
-    if (options.features && work && flow) {
-        console.warn('\x1b[33mWARN\x1b[0m --features has no effect with --work/--flow (spec-driven mode always processes the planned feature tree; feature roots that own child tasks are never claimed directly either way)');
-    }
-    // Validate that work/flow files exist
-    if (work && !fs.existsSync(work)) {
-        console.error(`\x1b[31mERR\x1b[0m --work file not found: ${work}`);
-        process.exitCode = 1;
-        return;
-    }
-    if (flow && !fs.existsSync(flow)) {
-        console.error(`\x1b[31mERR\x1b[0m --flow path not found: ${flow}`);
-        process.exitCode = 1;
-        return;
-    }
-    // If --flow points to a directory (e.g. a skill folder), resolve to its SKILL.md
-    let resolvedFlow = flow;
-    if (flow && fs.statSync(flow).isDirectory()) {
-        const skillPath = path.join(flow, 'SKILL.md');
-        if (!fs.existsSync(skillPath)) {
-            console.error(`\x1b[31mERR\x1b[0m --flow directory has no SKILL.md: ${flow}`);
-            process.exitCode = 1;
-            return;
-        }
-        resolvedFlow = skillPath;
-    }
-    const dryRun = !options.run;
-    const maxIssues = parseInt(options.max || '0', 10);
-    const budget = options.budget || exports.DEFAULT_BUDGET_USD;
-    const resumeLimit = parseInt(options.resumeLimit || '3', 10);
-    const pollInterval = parseInt(options.pollInterval || '60', 10);
-    const model = resolveModel(options.model);
-    const perIssueBranch = options.perIssueBranch || false;
-    const noBranch = options.branch === false;
-    let includeFeatures = options.features || false;
-    const skipPerms = options.skipPerms !== false; // default true
-    const bare = options.bare || false;
-    const poll = options.poll || false;
-    const reuseSession = options.reuseSession || false;
-    // --reuse-session is a --prefix-mode knob, mutually exclusive with the two things
-    // that imply one-session-per-issue. Errors are plain, not silent winners.
-    if (reuseSession && (work || flow)) {
-        console.error('\x1b[31mERR\x1b[0m --reuse-session is only for --prefix runs, not --work/--flow (spec-driven children are already session-sized)');
-        process.exitCode = 1;
-        return;
-    }
-    if (reuseSession && perIssueBranch) {
-        console.error('\x1b[31mERR\x1b[0m --reuse-session and --per-issue-branch are mutually exclusive (a branch per issue implies a session per issue)');
-        process.exitCode = 1;
-        return;
-    }
-    const projectDir = process.cwd();
-    const logDir = path.join(projectDir, 'labs', 'claude-runs');
-    fs.mkdirSync(logDir, { recursive: true });
-    // Hard requirement (Decision #6): beads must be in Dolt server mode so concurrent
-    // worktrees share one issue DB. Runs always — embedded mode is a footgun for any
-    // bd concurrency and the check is cheap.
-    try {
-        assertDoltServerMode(projectDir);
-    }
-    catch (e) {
-        console.error(`\x1b[31m[bd-loop]\x1b[0m ${e.message}`);
-        process.exitCode = 1;
-        return;
-    }
-    // Planning mode dry-run
-    if (dryRun && work && resolvedFlow) {
-        const workContent = fs.readFileSync(work, 'utf8');
-        const flowContent = fs.readFileSync(resolvedFlow, 'utf8');
-        console.log('[bd-loop] PLANNING MODE (dry-run)');
-        console.log(`[bd-loop]   Work file: ${work}`);
-        console.log(`[bd-loop]   Flow file: ${resolvedFlow}${resolvedFlow !== flow ? ` (resolved from ${flow})` : ''}`);
-        console.log('[bd-loop]   Planning prompt that would be sent:');
-        console.log('---');
-        console.log(buildPlanningPrompt(workContent, flowContent, prefix));
-        console.log('---');
-        console.log('[bd-loop] After planning, loop would process tasks under the created feature.');
-        return;
-    }
-    // Planning phase: create feature tree before looping
-    if (work && resolvedFlow) {
-        const planResult = await planWork({
-            workPath: work,
-            flowPath: resolvedFlow,
-            prefix,
-            budget,
-            model,
-            skipPerms,
-            bare,
-            logDir,
-        });
-        if (!planResult.featureId) {
-            console.error('[bd-loop] Planning phase failed to produce a feature ID');
-            console.error('[bd-loop] Check logs in: ' + logDir);
-            process.exitCode = 1;
-            return;
-        }
-        // Warn if planning consumed more than half the budget
-        const budgetNum = parseFloat(budget);
-        if (planResult.costUsd != null && budgetNum > 0) {
-            const pct = (planResult.costUsd / budgetNum) * 100;
-            if (pct > 50) {
-                console.warn(`\x1b[33m[bd-loop]\x1b[0m ⚠️  Planning phase used $${planResult.costUsd.toFixed(2)} of $${budget} budget (${pct.toFixed(0)}%). ` +
-                    `Per-task phases share the same budget cap — tasks may hit the limit early.`);
-            }
-        }
-        prefix = planResult.featureId;
-        includeFeatures = true;
-        console.log(`\x1b[32m[bd-loop]\x1b[0m Planning complete. Feature: ${planResult.featureId}`);
-    }
-    console.log(`\x1b[32m[bd-loop]\x1b[0m Starting bd-loop for prefix \x1b[34m${prefix}\x1b[0m`);
-    if (dryRun) {
-        console.log('\x1b[33m[bd-loop]\x1b[0m DRY RUN — add --run to execute');
-    }
-    // Always-worktree (Slice 1): the loop runs inside its own git worktree at
-    // ../boop-<scope> on branch work/<scope> so N loops run concurrently without
-    // colliding; main is never checked out. --no-branch opts out (in-place, today's
-    // single-tenant behavior). Manual merge is the v1 contract — no --merge yet.
-    const worktreeMode = work && resolvedFlow ? 'work-flow' : 'prefix';
-    let worktreeCtx;
-    let loopCwd = projectDir;
-    if (noBranch) {
-        console.log(`\x1b[32m[bd-loop]\x1b[0m Branch strategy: in-place on current branch (--no-branch)`);
-    }
-    else if (!dryRun) {
-        // Worktrees reuse the running shared Dolt server — they never start one.
-        const server = discoverDoltServer(projectDir);
-        if (!server) {
-            console.error(`\x1b[31m[bd-loop]\x1b[0m No shared Dolt server discovered (.beads/dolt-server.port missing). ` +
-                `Start it with \`bd dolt start\` before running the loop; worktrees never start their own server.`);
-            process.exitCode = 1;
-            return;
-        }
-        if (server.alive === false) {
-            console.warn(`\x1b[33m[bd-loop]\x1b[0m Dolt server pid ${server.pid} on port ${server.port} does not appear to be running; ` +
-                `bd calls may fail. Continuing (liveness check is best-effort).`);
-        }
-        try {
-            worktreeCtx = createWorktree(prefix, worktreeMode, projectDir);
-        }
-        catch (e) {
-            console.error(`\x1b[31m[bd-loop]\x1b[0m ${e.message}`);
-            process.exitCode = 1;
-            return;
-        }
-        loopCwd = worktreeCtx.path;
-        writeWorktreeMetadata(worktreeCtx, {
-            workPath: work,
-            flowPath: resolvedFlow,
-            boopVersion: getBoopVersion(),
-            startTime: new Date().toISOString(),
-            operator: getGitUserName(projectDir),
-            budget,
-            model,
-        });
-        console.log(`\x1b[32m[bd-loop]\x1b[0m Worktree: \x1b[34m${worktreeCtx.path}\x1b[0m on branch \x1b[34m${worktreeCtx.branch}\x1b[0m`);
-    }
-    let totalProcessed = 0;
-    let totalClosed = 0;
-    const results = [];
-    // --reuse-session state: a healthy session survives to the next issue; a fresh
-    // one is minted only on rotation (context full) or death. Off → activeSession
-    // stays null and every issue mints its own, exactly as before.
-    let activeSession = null;
-    let sessionCount = 0;
-    // Issue id at each session START (the first entry is the initial session, not a
-    // rotation). Actual rotations are everything after the first — see the summary.
-    const sessionStarts = [];
-    while (true) {
-        const nextId = prefix ? findNextIssue(prefix, includeFeatures) : null;
-        if (!nextId) {
-            // Spec-driven safety net: the filter removes the workflow-owned feature
-            // root from claimable work, so when its chain completes nobody may have
-            // closed it. Close it here (no-op if the closeout child already did, or if
-            // children remain open) before deciding to poll or terminate.
-            if (work && resolvedFlow && prefix) {
-                closeCompletedFeatureRoot(prefix);
-            }
-            if (poll) {
-                console.log(`\x1b[36m[bd-loop]\x1b[0m No ready issues for prefix '${prefix}'. Polling again in ${pollInterval}s...`);
-                await sleep(pollInterval * 1000);
-                continue;
-            }
-            else {
-                console.log(`\x1b[32m[bd-loop]\x1b[0m No more ready issues for prefix '${prefix}'.`);
-                break;
-            }
-        }
-        totalProcessed++;
-        if (maxIssues > 0 && totalProcessed > maxIssues) {
-            console.log(`\x1b[32m[bd-loop]\x1b[0m Reached --max ${maxIssues} issues. Stopping.`);
-            break;
-        }
-        if (dryRun) {
-            // Show all matching issues in dry-run mode
-            try {
-                const matching = getMatchingReadyIssues(prefix || '', includeFeatures);
-                for (const m of matching) {
-                    const info = getIssueInfo(m.id);
-                    if (!info)
-                        continue;
-                    if (maxIssues > 0 && totalProcessed > maxIssues)
-                        break;
-                    console.log(`  \x1b[34m${info.id}\x1b[0m (P${info.priority} ${info.issue_type}) — ${info.title}`);
-                    console.log(`    Would run: claude -p --max-budget-usd ${budget} --session-id <uuid>`);
-                    if (noBranch) {
-                        console.log(`    Branch: in-place (--no-branch)`);
-                    }
-                    else {
-                        console.log(`    Worktree: ../boop-${prefix} (branch work/${prefix})`);
-                        if (perIssueBranch) {
-                            console.log(`    Per-issue branch: fix/${info.id} (inside worktree)`);
-                        }
-                    }
-                    console.log(`    Resume limit: ${resumeLimit} attempts`);
-                    console.log('');
-                    if (m.id !== nextId)
-                        totalProcessed++;
-                }
-            }
-            catch {
-                // Fallback: just show the one issue
-                const info = getIssueInfo(nextId);
-                if (info) {
-                    console.log(`  \x1b[34m${info.id}\x1b[0m (P${info.priority} ${info.issue_type}) — ${info.title}`);
-                }
-            }
-            break;
-        }
-        // Process the issue
-        const issue = getIssueInfo(nextId);
-        if (!issue) {
-            console.error(`\x1b[31m[bd-loop]\x1b[0m   Failed to get issue details for ${nextId}`);
-            continue;
-        }
-        // Decide the session this issue runs under. Reuse a healthy carried session;
-        // otherwise (first issue, or the last one filled up) mint a fresh one. The
-        // decision lands here, between issues, so rotation can never split an issue.
-        let session;
-        if (reuseSession) {
-            if (activeSession && !shouldRotateSession(activeSession.peakContext, activeSession.contextWindow)) {
-                session = { id: activeSession.id, resume: true };
-            }
-            else {
-                if (activeSession) {
-                    console.log(`\x1b[36m[bd-loop]\x1b[0m Session context full (${Math.round(activeSession.peakContext / 1000)}k/${Math.round(activeSession.contextWindow / 1000)}k) — rotating to a fresh session at ${issue.id}`);
-                }
-                session = { id: (0, crypto_1.randomUUID)(), resume: false };
-                activeSession = { id: session.id, peakContext: 0, contextWindow: DEFAULT_CONTEXT_WINDOW };
-                sessionCount++;
-                sessionStarts.push(issue.id);
-            }
-        }
-        const result = await processIssue(issue, {
-            budget,
-            model,
-            skipPerms,
-            bare,
-            resumeLimit,
-            perIssueBranch,
-            noBranch,
-            logDir,
-            cwd: loopCwd,
-            session,
-        });
-        results.push(result);
-        if (result.closed)
-            totalClosed++;
-        // Fold this issue's observed context back into the carried session so the next
-        // iteration's rotation decision is current. A limit/death drops the session so
-        // the next issue starts clean (recovery lands between issues, same as rotation).
-        if (reuseSession && activeSession) {
-            if (result.peakContext)
-                activeSession.peakContext = Math.max(activeSession.peakContext, result.peakContext);
-            if (result.contextWindow)
-                activeSession.contextWindow = result.contextWindow;
-            if (result.limitHit)
-                activeSession = null;
-        }
-        if (result.limitHit) {
-            console.error('\x1b[31m[bd-loop]\x1b[0m   Credit/usage limit hit — stopping loop');
-            break;
-        }
-    }
-    // Always-worktree: leave the worktree and branch in place for the operator to
-    // review and merge by hand (manual merge is the v1 contract). No checkout-back —
-    // main's working tree was never touched.
-    // Summary
-    console.log('');
-    console.log('\x1b[32m[bd-loop]\x1b[0m ━━━ Summary ━━━');
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   Prefix:    ${prefix}`);
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   Processed: ${totalProcessed}`);
-    if (!dryRun) {
-        console.log(`\x1b[32m[bd-loop]\x1b[0m   Closed:    ${totalClosed}`);
-        if (totalProcessed > totalClosed) {
-            console.log(`\x1b[33m[bd-loop]\x1b[0m   Not closed: ${totalProcessed - totalClosed}`);
-        }
-        if (reuseSession) {
-            console.log(`\x1b[32m[bd-loop]\x1b[0m   Sessions:  ${sessionCount} (--reuse-session)`);
-            // The first session start is not a rotation; only entries after it are.
-            const rotatedAt = sessionStarts.slice(1);
-            if (rotatedAt.length > 0) {
-                console.log(`\x1b[32m[bd-loop]\x1b[0m   Rotated at: ${rotatedAt.join(', ')}`);
-            }
-        }
-    }
-    console.log(`\x1b[32m[bd-loop]\x1b[0m   Logs: ${logDir}/`);
-    if (worktreeCtx) {
-        console.log(`\x1b[32m[bd-loop]\x1b[0m   Worktree: ${worktreeCtx.path} (branch ${worktreeCtx.branch})`);
-        console.log(`\x1b[32m[bd-loop]\x1b[0m   Review and merge by hand, e.g.: git -C ${projectDir} merge ${worktreeCtx.branch}`);
-    }
-    if (options.json) {
-        console.log(JSON.stringify({
-            prefix,
-            totalProcessed,
-            totalClosed,
-            results,
-            worktree: worktreeCtx ? { path: worktreeCtx.path, branch: worktreeCtx.branch, mode: worktreeCtx.mode } : null,
-            sessions: reuseSession ? { count: sessionCount, rotatedAt: sessionStarts.slice(1) } : null,
-        }, null, 2));
-    }
-}