@nonbot/cli 0.5.15 → 0.7.0

package/dist/lib/choir/progress-events.js

@@ -0,0 +1,228 @@
+import { SCHEMA_VERSION, SUMMARY_MAX, EGRESS_ALLOWED_TOP_KEYS, EGRESS_FORBIDDEN_KEYS, BRANCH_RE, } from './types.js';
+const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+const TIME_LEN = 10;
+const RAND_LEN = 16;
+function encodeTime(ms) {
+    let t = Math.floor(ms);
+    const out = new Array(TIME_LEN);
+    for (let i = TIME_LEN - 1; i >= 0; i--) {
+        const mod = t % 32;
+        out[i] = CROCKFORD[mod];
+        t = Math.floor(t / 32);
+    }
+    return out.join('');
+}
+function encodeRandom(random) {
+    const out = new Array(RAND_LEN);
+    for (let i = 0; i < RAND_LEN; i++) {
+        out[i] = Math.floor(random() * 32) % 32;
+    }
+    return out;
+}
+function indicesToString(idx) {
+    let s = '';
+    for (const i of idx)
+        s += CROCKFORD[i];
+    return s;
+}
+export function ulid(ms, random = Math.random) {
+    return encodeTime(ms) + indicesToString(encodeRandom(random));
+}
+export function makeUlidFactory(deps) {
+    const random = deps.random ?? Math.random;
+    let lastMs = -1;
+    let lastRand = [];
+    return function next() {
+        const ms = Math.floor(deps.now());
+        if (ms === lastMs) {
+            lastRand = incrementBase32(lastRand);
+        }
+        else {
+            lastMs = ms;
+            lastRand = encodeRandom(random);
+        }
+        return encodeTime(ms) + indicesToString(lastRand);
+    };
+}
+function incrementBase32(idx) {
+    const out = idx.slice();
+    for (let i = out.length - 1; i >= 0; i--) {
+        if (out[i] < 31) {
+            out[i] += 1;
+            return out;
+        }
+        out[i] = 0;
+    }
+    return out;
+}
+const STAGE_TABLE = {
+    queued: { category: 'lifecycle', severity: 'info', terminal: false },
+    accepted: { category: 'lifecycle', severity: 'info', terminal: false },
+    launching: { category: 'provisioning', severity: 'progress', terminal: false },
+    'agent-started': { category: 'lifecycle', severity: 'progress', terminal: false },
+    working: { category: 'work', severity: 'progress', terminal: false },
+    'awaiting-input': { category: 'work', severity: 'blocked', terminal: false },
+    resumed: { category: 'work', severity: 'progress', terminal: false },
+    finished: { category: 'lifecycle', severity: 'info', terminal: true },
+    failed: { category: 'fault', severity: 'error', terminal: true },
+    stopped: { category: 'control', severity: 'info', terminal: true },
+    'session-created': { category: 'lifecycle', severity: 'info', terminal: false },
+    'worktrees-provisioned': { category: 'provisioning', severity: 'progress', terminal: false },
+    'panes-spawned': { category: 'provisioning', severity: 'progress', terminal: false },
+    'collision-detected': { category: 'coordination', severity: 'attention-needed', terminal: false },
+    'collision-cleared': { category: 'coordination', severity: 'progress', terminal: false },
+    'all-complete': { category: 'lifecycle', severity: 'attention-needed', terminal: false },
+    'reconcile-started': { category: 'reconcile', severity: 'progress', terminal: false },
+    'reconcile-complete': { category: 'reconcile', severity: 'info', terminal: true },
+    'reconcile-blocked': { category: 'reconcile', severity: 'blocked', terminal: true },
+    'session-ended': { category: 'lifecycle', severity: 'info', terminal: true },
+    'pane-spawned': { category: 'provisioning', severity: 'progress', terminal: false },
+    'claim-announced': { category: 'coordination', severity: 'progress', terminal: false },
+    'broadcast-sent': { category: 'coordination', severity: 'attention-needed', terminal: false },
+    'pane-complete': { category: 'work', severity: 'progress', terminal: true },
+    'pane-failed': { category: 'fault', severity: 'error', terminal: true },
+    'pane-stopped': { category: 'control', severity: 'info', terminal: true },
+    'merge-step': { category: 'reconcile', severity: 'progress', terminal: false },
+    'build-gate': { category: 'verification', severity: 'progress', terminal: false },
+    slow: { category: 'fault', severity: 'attention-needed', terminal: false },
+    stalled: { category: 'fault', severity: 'attention-needed', terminal: false },
+    'monitor-offline': { category: 'fault', severity: 'error', terminal: false },
+};
+const UNKNOWN_STAGE_META = {
+    category: 'work',
+    severity: 'progress',
+    terminal: false,
+};
+export function stageMapping(stage) {
+    return STAGE_TABLE[stage] ?? UNKNOWN_STAGE_META;
+}
+function clampStr(s, max = SUMMARY_MAX) {
+    if (typeof s !== 'string')
+        return '';
+    return s.slice(0, max);
+}
+export function makeEvent(input, deps) {
+    const meta = stageMapping(input.stage);
+    const eventId = ulid(Math.floor(deps.now()), deps.random);
+    const event = {
+        schemaVersion: SCHEMA_VERSION,
+        eventId,
+        sessionId: clampStr(input.sessionId),
+        engine: input.engine,
+        paneId: input.paneId ?? null,
+        parentEventId: input.parentEventId ?? null,
+        stage: input.stage,
+        category: meta.category,
+        severity: meta.severity,
+        terminal: meta.terminal,
+        summary: clampStr(input.summary),
+        ts: Math.floor(input.ts),
+    };
+    if (input.metrics) {
+        event.metrics = sanitizeMetrics(input.metrics);
+    }
+    if (input.refs) {
+        event.refs = sanitizeRefs(input.refs);
+    }
+    return event;
+}
+const FORBIDDEN_KEY_SET = new Set(EGRESS_FORBIDDEN_KEYS);
+const ALLOWED_TOP_SET = new Set(EGRESS_ALLOWED_TOP_KEYS);
+function isForbiddenKey(key) {
+    return FORBIDDEN_KEY_SET.has(key);
+}
+function sanitizeMetrics(m) {
+    const out = {};
+    if (m && typeof m === 'object') {
+        for (const [k, v] of Object.entries(m)) {
+            if (isForbiddenKey(k))
+                continue;
+            if (typeof v === 'number' && Number.isFinite(v))
+                out[k] = v;
+        }
+    }
+    return out;
+}
+function sanitizeRefs(r) {
+    return deepClean(r);
+}
+function deepClean(value) {
+    if (typeof value === 'string')
+        return value.slice(0, SUMMARY_MAX);
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'boolean' || value === null)
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => deepClean(v));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (isForbiddenKey(k))
+                continue;
+            out[k] = deepClean(v);
+        }
+        return out;
+    }
+    return null;
+}
+export function sanitizeForEgress(obj) {
+    const out = {};
+    if (!obj || typeof obj !== 'object')
+        return out;
+    for (const [k, v] of Object.entries(obj)) {
+        if (!ALLOWED_TOP_SET.has(k))
+            continue;
+        if (isForbiddenKey(k))
+            continue;
+        if (k === 'metrics') {
+            out[k] = sanitizeMetrics(v);
+            continue;
+        }
+        out[k] = deepClean(v);
+    }
+    return out;
+}
+const SECRET_RE = /\b(pat_[A-Za-z0-9_-]{4,}|sk_[A-Za-z0-9_-]{4,})/;
+const DIFF_RE = /^(diff --git |@@ |[+-]{3} )|(\n[+-])/;
+const PATH_RE = /(^|[\s'"])\/[\w.-]+\/[\w./-]+/;
+function looksLikePath(s) {
+    return PATH_RE.test(s);
+}
+function looksLikeDiff(s) {
+    return DIFF_RE.test(s);
+}
+function looksLikeSecret(s) {
+    return SECRET_RE.test(s);
+}
+export function assertNoForbiddenFields(payload, keyPath = '$') {
+    walk(payload, keyPath, false);
+}
+function walk(value, keyPath, parentIsBranch) {
+    if (typeof value === 'string') {
+        if (parentIsBranch && BRANCH_RE.test(value))
+            return;
+        if (looksLikeSecret(value)) {
+            throw new Error(`assertNoForbiddenFields: secret-like value at ${keyPath}`);
+        }
+        if (looksLikeDiff(value)) {
+            throw new Error(`assertNoForbiddenFields: diff-like value at ${keyPath}`);
+        }
+        if (looksLikePath(value)) {
+            throw new Error(`assertNoForbiddenFields: path-like value at ${keyPath}`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((v, i) => walk(v, `${keyPath}[${i}]`, false));
+        return;
+    }
+    if (value && typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            if (isForbiddenKey(k)) {
+                throw new Error(`assertNoForbiddenFields: forbidden key '${k}' at ${keyPath}.${k}`);
+            }
+            walk(v, `${keyPath}.${k}`, k === 'branch');
+        }
+    }
+}

package/dist/lib/choir/reconcile.js

@@ -0,0 +1,271 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { assertValidBranch } from './names.js';
+import { makeEvent } from './progress-events.js';
+export function planMergeOrder(branches, baseBranch) {
+    assertValidBranch(baseBranch, 'base branch');
+    for (const b of branches)
+        assertValidBranch(b, 'branch');
+    const seen = new Set();
+    const out = [];
+    for (const b of branches) {
+        if (b === baseBranch)
+            continue;
+        if (seen.has(b))
+            continue;
+        seen.add(b);
+        out.push(b);
+    }
+    out.sort();
+    return out;
+}
+export function tokenizeGateCommand(cmd) {
+    const tokens = [];
+    let cur = '';
+    let inSingle = false;
+    let inDouble = false;
+    let started = false;
+    for (let i = 0; i < cmd.length; i++) {
+        const ch = cmd[i];
+        if (inSingle) {
+            if (ch === "'")
+                inSingle = false;
+            else
+                cur += ch;
+            continue;
+        }
+        if (inDouble) {
+            if (ch === '"')
+                inDouble = false;
+            else
+                cur += ch;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            started = true;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            started = true;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+            if (cur.length > 0 || started) {
+                tokens.push(cur);
+                cur = '';
+                started = false;
+            }
+            continue;
+        }
+        cur += ch;
+        started = true;
+    }
+    if (cur.length > 0 || started)
+        tokens.push(cur);
+    return tokens;
+}
+function runGit(spawnImpl, repoRoot, args) {
+    return spawnImpl('git', ['-C', repoRoot, ...args], {
+        encoding: 'utf-8',
+        timeout: 60_000,
+        windowsHide: true,
+    });
+}
+function countConflictFiles(stdout) {
+    let n = 0;
+    for (const line of stdout.split('\n')) {
+        if (/^CONFLICT\b/.test(line.trim()))
+            n += 1;
+    }
+    return n;
+}
+export function runReconcile(args) {
+    const { repoRoot, baseBranch, buildTestCommand, sessionId = 'choir', spawnImpl = nodeSpawnSync, emit = () => { }, now = () => Date.now(), random, } = args;
+    const order = planMergeOrder(args.branches, baseBranch);
+    const evDeps = { now, random };
+    const ts = () => Math.floor(now());
+    const total = order.length;
+    const startEvent = makeEvent({
+        sessionId,
+        engine: 'choir',
+        paneId: null,
+        stage: 'reconcile-started',
+        summary: `Reconciling ${total} branch${total === 1 ? '' : 'es'} into ${baseBranch}`,
+        ts: ts(),
+        refs: { branch: baseBranch },
+        metrics: { paneTotal: total },
+    }, evDeps);
+    emit(startEvent);
+    const parentEventId = startEvent.eventId;
+    const gateTokens = buildTestCommand.trim() ? tokenizeGateCommand(buildTestCommand) : [];
+    const merged = [];
+    for (let i = 0; i < order.length; i++) {
+        const branch = order[i];
+        const r = runGit(spawnImpl, repoRoot, ['merge', '--no-ff', branch]);
+        const stdout = typeof r.stdout === 'string' ? r.stdout : '';
+        const conflictFiles = countConflictFiles(stdout);
+        const isConflict = r.status !== 0 && (conflictFiles > 0 || /^CONFLICT\b/m.test(stdout));
+        if (isConflict) {
+            runGit(spawnImpl, repoRoot, ['merge', '--abort']);
+            emitBlockedMergeStep(emit, evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                baseBranch,
+                conflictFiles,
+                index: i + 1,
+                total,
+                ts: ts(),
+            });
+            emit(blockedEvent(evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                baseBranch,
+                reason: 'merge-conflict',
+                conflictFiles,
+                merged: merged.length,
+                total,
+                ts: ts(),
+            }));
+            return { blocked: true, merged, conflictedBranch: branch, reason: 'merge-conflict' };
+        }
+        if (r.status !== 0) {
+            runGit(spawnImpl, repoRoot, ['merge', '--abort']);
+            emit(blockedEvent(evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                baseBranch,
+                reason: 'merge-error',
+                merged: merged.length,
+                total,
+                ts: ts(),
+            }));
+            return { blocked: true, merged, erroredBranch: branch, reason: 'merge-error' };
+        }
+        emit(makeEvent({
+            sessionId,
+            engine: 'choir',
+            paneId: null,
+            parentEventId,
+            stage: 'merge-step',
+            summary: `Merged ${branch} into ${baseBranch}`,
+            ts: ts(),
+            refs: { branch },
+            metrics: { storyIndex: i + 1, storyTotal: total, panesComplete: merged.length + 1 },
+        }, evDeps));
+        if (gateTokens.length > 0) {
+            const [gateCmd, ...gateArgs] = gateTokens;
+            const g = spawnImpl(gateCmd, gateArgs, {
+                cwd: repoRoot,
+                encoding: 'utf-8',
+                timeout: 600_000,
+                windowsHide: true,
+            });
+            if (g.status !== 0) {
+                emit(gateEvent(evDeps, {
+                    sessionId,
+                    parentEventId,
+                    branch,
+                    pass: false,
+                    exitCode: typeof g.status === 'number' ? g.status : 1,
+                    index: i + 1,
+                    total,
+                    ts: ts(),
+                }));
+                emit(blockedEvent(evDeps, {
+                    sessionId,
+                    parentEventId,
+                    branch,
+                    baseBranch,
+                    reason: 'build-failed',
+                    merged: merged.length,
+                    total,
+                    ts: ts(),
+                }));
+                return { blocked: true, merged, gateFailedAfter: branch, reason: 'build-failed' };
+            }
+            emit(gateEvent(evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                pass: true,
+                exitCode: 0,
+                index: i + 1,
+                total,
+                ts: ts(),
+            }));
+        }
+        merged.push(branch);
+    }
+    emit(makeEvent({
+        sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId,
+        stage: 'reconcile-complete',
+        summary: `Reconciled ${merged.length} branch${merged.length === 1 ? '' : 'es'} into ${baseBranch}, build green`,
+        ts: ts(),
+        refs: { branch: baseBranch },
+        metrics: { paneTotal: total, panesComplete: merged.length },
+    }, evDeps));
+    return { blocked: false, merged };
+}
+function emitBlockedMergeStep(emit, deps, o) {
+    const base = makeEvent({
+        sessionId: o.sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId: o.parentEventId,
+        stage: 'merge-step',
+        summary: `Conflict merging ${o.branch} into ${o.baseBranch} (${o.conflictFiles} file${o.conflictFiles === 1 ? '' : 's'})`,
+        ts: o.ts,
+        refs: { branch: o.branch, blockReason: 'merge-conflict' },
+        metrics: { filesChanged: o.conflictFiles, storyIndex: o.index, storyTotal: o.total },
+    }, deps);
+    emit({ ...base, severity: 'blocked' });
+}
+function gateEvent(deps, o) {
+    const base = makeEvent({
+        sessionId: o.sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId: o.parentEventId,
+        stage: 'build-gate',
+        summary: o.pass
+            ? `Build gate passed after ${o.branch}`
+            : `Build gate FAILED after ${o.branch}`,
+        ts: o.ts,
+        refs: o.pass ? { branch: o.branch } : { branch: o.branch, blockReason: 'build-failed' },
+        metrics: { storyIndex: o.index, storyTotal: o.total, exitCode: o.exitCode },
+    }, deps);
+    return o.pass ? base : { ...base, severity: 'blocked' };
+}
+function blockedEvent(deps, o) {
+    const blockReason = o.reason === 'merge-conflict'
+        ? 'merge-conflict'
+        : o.reason === 'build-failed'
+            ? 'build-failed'
+            : undefined;
+    const summary = o.reason === 'merge-conflict'
+        ? `BLOCKED — conflict on ${o.branch}; human merge gate required`
+        : o.reason === 'build-failed'
+            ? `BLOCKED — build gate failed after ${o.branch}`
+            : `BLOCKED — merge of ${o.branch} could not proceed`;
+    const metrics = { panesComplete: o.merged, paneTotal: o.total };
+    if (typeof o.conflictFiles === 'number')
+        metrics.filesChanged = o.conflictFiles;
+    return makeEvent({
+        sessionId: o.sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId: o.parentEventId,
+        stage: 'reconcile-blocked',
+        summary,
+        ts: o.ts,
+        refs: blockReason ? { branch: o.branch, blockReason } : { branch: o.branch },
+        metrics,
+    }, deps);
+}

package/dist/lib/choir/types.js

@@ -0,0 +1,54 @@
+export const NAME_RE = /^[a-z0-9][a-z0-9-]{0,30}$/;
+export const BRANCH_RE = /^[a-z0-9][a-z0-9/-]{0,60}$/;
+export const PANE_ID_RE = /^%\d+$/;
+export const SUMMARY_MAX = 200;
+export const LOCAL_TEXT_MAX = 4096;
+export const RADAR_OFFLINE = Object.freeze({ status: 'radar offline' });
+export const SCHEMA_VERSION = 1;
+export const EGRESS_ALLOWED_TOP_KEYS = Object.freeze([
+    'schemaVersion',
+    'eventId',
+    'sessionId',
+    'engine',
+    'paneId',
+    'parentEventId',
+    'stage',
+    'category',
+    'severity',
+    'terminal',
+    'summary',
+    'ts',
+    'metrics',
+    'refs',
+]);
+export const EGRESS_FORBIDDEN_KEYS = Object.freeze([
+    'paths',
+    'path',
+    'worktreePath',
+    'diff',
+    'patch',
+    'transcript',
+    'content',
+    'fileContents',
+    'token',
+    'pat',
+    'secret',
+    'apiKey',
+    'nonce',
+    'msg',
+]);
+export const HEALTH_DEFAULTS = Object.freeze({
+    SLOW: 90_000,
+    STALL: 8 * 60_000,
+    AWAIT_CONFIRM: 20_000,
+    LOOP_WINDOW: 5 * 60_000,
+    POLL: 5_000,
+    CRASH_GRACE: 10_000,
+});
+export const SEVERITY_WEIGHT = Object.freeze({
+    info: 0,
+    progress: 1,
+    'attention-needed': 2,
+    blocked: 3,
+    error: 4,
+});

package/dist/lib/choir/worktree.js

@@ -0,0 +1,128 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import nodeFs from 'node:fs';
+import path from 'node:path';
+import { worktreePathFor, branchFor, assertValidBranch } from './names.js';
+const defaultFs = {
+    existsSync: nodeFs.existsSync,
+    readFileSync: nodeFs.readFileSync,
+    writeFileSync: nodeFs.writeFileSync,
+};
+function runGit(spawnImpl, cwd, args) {
+    return spawnImpl('git', ['-C', cwd, ...args], {
+        encoding: 'utf-8',
+        timeout: 15_000,
+        windowsHide: true,
+    });
+}
+function assertOk(r, op) {
+    if (r.status !== 0) {
+        throw new Error(`git ${op} failed`);
+    }
+}
+export function addWorktree(args) {
+    const { repoRoot, sessionName, paneName, baseBranch, spawnImpl = nodeSpawnSync } = args;
+    const worktreePath = worktreePathFor(repoRoot, sessionName, paneName);
+    const branch = branchFor(sessionName, paneName);
+    assertValidBranch(baseBranch, 'base branch');
+    const r = runGit(spawnImpl, repoRoot, [
+        'worktree',
+        'add',
+        worktreePath,
+        '-b',
+        branch,
+        baseBranch,
+    ]);
+    assertOk(r, 'worktree add');
+    return { worktreePath, branch };
+}
+export function listWorktrees(repoRoot, spawnImpl = nodeSpawnSync) {
+    const r = runGit(spawnImpl, repoRoot, ['worktree', 'list', '--porcelain']);
+    assertOk(r, 'worktree list');
+    const out = typeof r.stdout === 'string' ? r.stdout : '';
+    const entries = [];
+    let cur = null;
+    const flush = () => {
+        if (cur)
+            entries.push(cur);
+        cur = null;
+    };
+    for (const raw of out.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        if (line === '') {
+            flush();
+            continue;
+        }
+        const sp = line.indexOf(' ');
+        const key = sp === -1 ? line : line.slice(0, sp);
+        const val = sp === -1 ? '' : line.slice(sp + 1);
+        switch (key) {
+            case 'worktree':
+                flush();
+                cur = { worktree: val, detached: false, bare: false };
+                break;
+            case 'HEAD':
+                if (cur)
+                    cur.head = val;
+                break;
+            case 'branch':
+                if (cur)
+                    cur.branch = val.replace(/^refs\/heads\//, '');
+                break;
+            case 'detached':
+                if (cur)
+                    cur.detached = true;
+                break;
+            case 'bare':
+                if (cur)
+                    cur.bare = true;
+                break;
+            default:
+                break;
+        }
+    }
+    flush();
+    return entries;
+}
+export function removeWorktree(args) {
+    const { repoRoot, worktreePath, spawnImpl = nodeSpawnSync } = args;
+    const r = runGit(spawnImpl, repoRoot, ['worktree', 'remove', worktreePath]);
+    assertOk(r, 'worktree remove');
+}
+export function ensureChoirGitignored(repoRoot, fsImpl = defaultFs) {
+    const giPath = path.join(repoRoot, '.gitignore');
+    const ENTRY = '.choir/';
+    let existing = '';
+    if (fsImpl.existsSync(giPath)) {
+        existing = fsImpl.readFileSync(giPath, 'utf-8');
+    }
+    const lines = existing.split('\n').map((l) => l.replace(/\r$/, ''));
+    if (lines.includes(ENTRY))
+        return;
+    const needsNewline = existing.length > 0 && !existing.endsWith('\n');
+    const next = existing + (needsNewline ? '\n' : '') + ENTRY + '\n';
+    fsImpl.writeFileSync(giPath, next);
+}
+export function pollGitStatus(worktreePath, spawnImpl = nodeSpawnSync, base = 'HEAD') {
+    assertValidBranch(base, 'base ref');
+    const st = runGit(spawnImpl, worktreePath, ['status', '--porcelain']);
+    assertOk(st, 'status');
+    const stdout = typeof st.stdout === 'string' ? st.stdout : '';
+    const dirtyPaths = [];
+    for (const raw of stdout.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        if (line.trim() === '')
+            continue;
+        let p = line.slice(3);
+        const arrow = p.indexOf(' -> ');
+        if (arrow !== -1)
+            p = p.slice(arrow + 4);
+        p = p.replace(/^"(.*)"$/, '$1');
+        if (p.length > 0)
+            dirtyPaths.push(p);
+    }
+    const rev = runGit(spawnImpl, worktreePath, ['rev-list', '--count', `${base}..HEAD`]);
+    assertOk(rev, 'rev-list');
+    const revOut = typeof rev.stdout === 'string' ? rev.stdout.trim() : '';
+    const commitsAhead = Number.parseInt(revOut, 10) || 0;
+    return { dirtyPaths, dirtyFiles: dirtyPaths.length, commitsAhead };
+}

package/dist/lib/completion.js

@@ -60,7 +60,8 @@ export async function checkCompletions(opts) {
         const ok = await postCompletion(baseUrl, pat, id, opts.fetchImpl);
         if (ok) {
             reported.push(id);
-            opts.log?.(`✓ ${id} · run completed (pane closed)\n`);
+            const card = opts.renderComplete?.(id);
+            opts.log?.(card && card.length > 0 ? card : `✓ ${id} · run completed (pane closed)\n`);
         }
     }
     return reported;