@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.1

package/dist/skills/bundled/batch.js

@@ -1,617 +0,0 @@
-/**
- * `pugi batch` — fan-out multi-step parallel execution scaffold.
- *
- * Bundled skill, batch 2 (backlog). The operator describes N
- * independent engine tasks in a YAML recipe; this skill spawns up to
- * `--concurrency=N` subprocesses, each running `pugi --print "<prompt>"`
- * with the configured model / max-turns / timeout, captures their
- * stdout to per-task log files under `<repo>/.pugi/batch/<batch-id>/`,
- * and aggregates the verdicts into a JSONL ledger plus a summary
- * table.
- *
- * # Recipe schema (YAML)
- *
- * ```yaml
- * concurrency: 5           # optional, defaults to 5, hard cap 30
- * tasks:
- *  - id: scaffold-button
- *    prompt: "Scaffold a shadcn button at apps/console-web/src/components/button.tsx"
- *    model: claude-sonnet-4-5
- *    maxTurns: 8
- *    timeoutMs: 600000
- *  - id: scaffold-input
- *    prompt: "Scaffold a shadcn input at apps/console-web/src/components/input.tsx"
- * ```
- *
- * # Hard cap on concurrency
- *
- * The CEO memory `feedback_max_3_parallel_agents_mac_safety.md` caps
- * unscoped parallel agent spawns at 3 because the Mac kernel-paniced
- * during a 5+ run on. The operator explicitly OK'd higher
- * caps for worktree-isolated batches — this skill enforces a HARD
- * upper bound of 30 to stay well below the regression threshold while
- * letting power-users fan out.
- *
- * # Worktree isolation (deferred)
- *
- * True per-task worktrees are backlog. Today every subprocess
- * runs in the operator's current working directory and relies on its
- * own scratch files to avoid stepping on siblings. The TODO marker is
- * preserved so the upgrade path is unambiguous.
- *
- * # Provenance
- *
- * Inspired by the external bundled-skills pattern (intel from
- * leak-research memos, independent implementation TS). No upstream code reused.
- */
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-/**
- * Default subprocess concurrency. Five is the sweet spot on a 16 GB
- * Mac with the Anvil-routed CLI — each task averages ~600 MB resident
- * during the engine turn, leaving headroom for the operator's REPL.
- */
-const DEFAULT_CONCURRENCY = 5;
-/**
- * Hard upper bound on concurrency. Operator override stops at 30 per
- * the worktree-isolated batch carve-out in the CEO memory. Beyond 30
- * we have observed kernel-level pressure on Apple Silicon — even with
- * worktree isolation, the model gateway becomes the bottleneck and
- * the marginal value vanishes.
- */
-const MAX_CONCURRENCY = 30;
-/**
- * Default per-task wall-clock ceiling. Ten minutes is enough for a
- * non-trivial engine turn (multi-tool, several file edits) while
- * keeping a wedged subprocess from hanging the whole batch forever.
- */
-const DEFAULT_TASK_TIMEOUT_MS = 10 * 60 * 1000;
-function parseFlags(args) {
-    const flags = {
-        json: false,
-        concurrency: null,
-        recipePath: null,
-        dryRun: false,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === undefined)
-            continue;
-        if (arg === '--json') {
-            flags.json = true;
-            continue;
-        }
-        if (arg === '--dry-run') {
-            flags.dryRun = true;
-            continue;
-        }
-        if (arg === '--concurrency') {
-            const next = args[i + 1];
-            if (next === undefined)
-                return { flags, error: '--concurrency requires a value' };
-            const parsed = Number.parseInt(next, 10);
-            if (!Number.isFinite(parsed) || parsed <= 0) {
-                return { flags, error: '--concurrency must be a positive integer' };
-            }
-            if (parsed > MAX_CONCURRENCY) {
-                return {
-                    flags,
-                    error: `--concurrency must be <= ${MAX_CONCURRENCY} (Mac safety cap)`,
-                };
-            }
-            flags.concurrency = parsed;
-            i += 1;
-            continue;
-        }
-        if (arg === '--help' || arg === '-h') {
-            return { flags, error: 'help' };
-        }
-        if (arg.startsWith('--')) {
-            return { flags, error: `unknown flag: ${arg}` };
-        }
-        if (flags.recipePath === null) {
-            flags.recipePath = arg;
-            continue;
-        }
-        return { flags, error: `unexpected positional argument: ${arg}` };
-    }
-    return { flags, error: null };
-}
-/**
- * Minimal YAML parser tuned for the batch recipe shape. We deliberately
- * do NOT pull in a real YAML dep — the recipe surface is a tightly
- * constrained subset (top-level `concurrency:` scalar + `tasks:` list of
- * mappings with scalar fields), and a 60-line parser keeps the bundled
- * skill dep-free. Anything fancier raises a parse error so the operator
- * is forced into the supported shape.
- *
- * Public for direct test coverage.
- */
-export function parseBatchRecipe(text) {
-    const lines = text.split('\n');
-    let concurrency = DEFAULT_CONCURRENCY;
-    const tasks = [];
-    let i = 0;
-    let inTasks = false;
-    // current task accumulator
-    let cur = null;
-    const flushTask = () => {
-        if (cur === null)
-            return null;
-        if (cur.id === undefined || cur.id === '') {
-            return 'task missing required `id`';
-        }
-        if (!/^[a-zA-Z0-9_-]+$/.test(cur.id)) {
-            return `task id '${cur.id}' must match [a-zA-Z0-9_-]+`;
-        }
-        if (cur.prompt === undefined || cur.prompt === '') {
-            return `task '${cur.id}' missing required \`prompt\``;
-        }
-        const spec = {
-            id: cur.id,
-            prompt: cur.prompt,
-            ...(cur.model !== undefined ? { model: cur.model } : {}),
-            ...(cur.maxTurns !== undefined ? { maxTurns: cur.maxTurns } : {}),
-            ...(cur.timeoutMs !== undefined ? { timeoutMs: cur.timeoutMs } : {}),
-        };
-        tasks.push(spec);
-        cur = null;
-        return null;
-    };
-    while (i < lines.length) {
-        const raw = lines[i] ?? '';
-        i += 1;
-        // strip trailing CR + trailing inline comment (only when preceded by space)
-        const stripped = raw.replace(/\r$/, '').replace(/\s+#.*$/, '');
-        if (stripped.trim() === '')
-            continue;
-        // Top-level `concurrency: N`
-        const concMatch = /^concurrency:\s*(\d+)\s*$/.exec(stripped);
-        if (concMatch && !inTasks) {
-            const parsed = Number.parseInt(concMatch[1] ?? '', 10);
-            if (!Number.isFinite(parsed) || parsed <= 0) {
-                return { ok: false, error: 'concurrency must be a positive integer' };
-            }
-            if (parsed > MAX_CONCURRENCY) {
-                return {
-                    ok: false,
-                    error: `concurrency must be <= ${MAX_CONCURRENCY}`,
-                };
-            }
-            concurrency = parsed;
-            continue;
-        }
-        if (/^tasks:\s*$/.test(stripped)) {
-            inTasks = true;
-            continue;
-        }
-        if (!inTasks) {
-            return { ok: false, error: `unexpected top-level line: ${stripped}` };
-        }
-        // task entry start: " - id: <value>" or " - <field>: <value>" on the
-        // same line as the dash.
-        const dashMatch = /^(\s*)-\s+(.*)$/.exec(stripped);
-        if (dashMatch) {
-            const flushErr = flushTask();
-            if (flushErr)
-                return { ok: false, error: flushErr };
-            cur = {};
-            // The dash line itself may already carry a field.
-            const tail = dashMatch[2] ?? '';
-            const fieldOnDash = /^([a-zA-Z]+):\s*(.*)$/.exec(tail);
-            if (fieldOnDash) {
-                const field = fieldOnDash[1] ?? '';
-                const value = fieldOnDash[2] ?? '';
-                const assignErr = assignField(cur, field, value);
-                if (assignErr)
-                    return { ok: false, error: assignErr };
-            }
-            else if (tail.trim() !== '') {
-                return { ok: false, error: `unexpected task-list entry: ${stripped}` };
-            }
-            continue;
-        }
-        // Continuation field inside the current task: "   <field>: <value>"
-        const fieldMatch = /^(\s+)([a-zA-Z]+):\s*(.*)$/.exec(stripped);
-        if (fieldMatch && cur !== null) {
-            const field = fieldMatch[2] ?? '';
-            const value = fieldMatch[3] ?? '';
-            const assignErr = assignField(cur, field, value);
-            if (assignErr)
-                return { ok: false, error: assignErr };
-            continue;
-        }
-        return { ok: false, error: `cannot parse line: ${stripped}` };
-    }
-    const flushErr = flushTask();
-    if (flushErr)
-        return { ok: false, error: flushErr };
-    if (tasks.length === 0) {
-        return { ok: false, error: 'recipe declares zero tasks' };
-    }
-    return {
-        ok: true,
-        recipe: { concurrency, tasks },
-    };
-}
-function assignField(target, field, rawValue) {
-    // strip surrounding quotes for scalar string values
-    const stripQuotes = (s) => {
-        const trimmed = s.trim();
-        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-            (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-            return trimmed.slice(1, -1);
-        }
-        return trimmed;
-    };
-    switch (field) {
-        case 'id':
-            target.id = stripQuotes(rawValue);
-            return null;
-        case 'prompt':
-            target.prompt = stripQuotes(rawValue);
-            return null;
-        case 'model':
-            target.model = stripQuotes(rawValue);
-            return null;
-        case 'maxTurns': {
-            const parsed = Number.parseInt(rawValue.trim(), 10);
-            if (!Number.isFinite(parsed) || parsed <= 0) {
-                return `maxTurns must be a positive integer (got '${rawValue}')`;
-            }
-            target.maxTurns = parsed;
-            return null;
-        }
-        case 'timeoutMs': {
-            const parsed = Number.parseInt(rawValue.trim(), 10);
-            if (!Number.isFinite(parsed) || parsed <= 0) {
-                return `timeoutMs must be a positive integer (got '${rawValue}')`;
-            }
-            target.timeoutMs = parsed;
-            return null;
-        }
-        default:
-            return `unknown task field '${field}'`;
-    }
-}
-/**
- * Default subprocess runner — shells out to the same `pugi` binary that
- * invoked us via `--print "<prompt>"`. Tests inject their own runner so
- * the spec suite never spawns real subprocesses.
- *
- * Public so the dispatcher can pass a custom invocation when a session
- * wants to point at a wrapper binary (e.g. the dev-mode `tsx src/index.ts`).
- */
-export function spawnPugiSubprocess(task, ctx) {
-    return new Promise((resolveTask) => {
-        const startedAt = Date.now();
-        const timeoutMs = task.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
-        const args = ['--print', task.prompt];
-        if (task.maxTurns !== undefined) {
-            args.unshift('--max-turns', String(task.maxTurns));
-        }
-        if (task.model !== undefined) {
-            args.unshift('--model', task.model);
-        }
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        // TODO worktree-isolate per — currently every task spawns in
-        // the operator cwd; full per-task worktree comes when the worktree
-        // manager exposes a public batch-friendly factory.
-        const child = spawn('pugi', args, {
-            cwd: ctx.cwd,
-            env: ctx.env,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        let timer = setTimeout(() => {
-            timer = null;
-            try {
-                child.kill('SIGKILL');
-            }
-            catch {
-                // best-effort
-            }
-        }, timeoutMs);
-        child.stdout.setEncoding('utf8');
-        child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
-        child.stderr.setEncoding('utf8');
-        child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
-        child.on('error', (err) => {
-            if (timer !== null) {
-                clearTimeout(timer);
-                timer = null;
-            }
-            resolveTask({
-                status: 'failed',
-                exitCode: null,
-                stdout: stdoutChunks.join(''),
-                stderr: `spawn error: ${err.message}\n${stderrChunks.join('')}`,
-                durationMs: Date.now() - startedAt,
-            });
-        });
-        child.on('exit', (code, signal) => {
-            const killedByTimeout = timer === null;
-            if (timer !== null) {
-                clearTimeout(timer);
-                timer = null;
-            }
-            const durationMs = Date.now() - startedAt;
-            let status = 'ok';
-            if (killedByTimeout || signal === 'SIGKILL') {
-                status = 'timeout';
-            }
-            else if (code !== 0) {
-                status = 'failed';
-            }
-            resolveTask({
-                status,
-                exitCode: code,
-                stdout: stdoutChunks.join(''),
-                stderr: stderrChunks.join(''),
-                durationMs,
-            });
-        });
-    });
-}
-/**
- * Atomic write helper — same tmp + rename pattern the agent-progress
- * writer uses. Public so the test suite can exercise the path.
- */
-export function atomicWriteFile(targetPath, body) {
-    const parent = dirname(targetPath);
-    if (!existsSync(parent)) {
-        mkdirSync(parent, { recursive: true });
-    }
-    const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.floor(Math.random() * 1_000_000)}`;
-    try {
-        writeFileSync(tmpPath, body, 'utf8');
-        renameSync(tmpPath, targetPath);
-    }
-    catch (err) {
-        try {
-            rmSync(tmpPath, { force: true });
-        }
-        catch {
-            // ignore cleanup failure
-        }
-        throw err;
-    }
-}
-function renderSummary(result) {
-    const lines = [];
-    lines.push(`pugi batch — id=${result.batchId}`);
-    lines.push(`recipe: ${result.recipePath}`);
-    lines.push(`results: ${result.resultsPath}`);
-    lines.push('');
-    const okCount = result.results.filter((r) => r.status === 'ok').length;
-    const failed = result.results.filter((r) => r.status === 'failed').length;
-    const timeouts = result.results.filter((r) => r.status === 'timeout').length;
-    const skipped = result.results.filter((r) => r.status === 'skipped').length;
-    lines.push(`tasks: ${result.results.length} ok=${okCount} failed=${failed} timeout=${timeouts} skipped=${skipped}`);
-    lines.push('');
-    // ASCII summary table — no external dep required.
-    const header = 'id'.padEnd(30) + ' | status  | exit | duration';
-    lines.push(header);
-    lines.push('-'.repeat(header.length));
-    for (const r of result.results) {
-        const idCell = (r.id.length > 30 ? `${r.id.slice(0, 27)}...` : r.id).padEnd(30);
-        const statusCell = r.status.padEnd(8);
-        const exitCell = (r.exitCode === null ? '-' : String(r.exitCode)).padStart(4);
-        const dur = `${(r.durationMs / 1000).toFixed(1)}s`;
-        lines.push(`${idCell} | ${statusCell} | ${exitCell} | ${dur}`);
-    }
-    return lines.join('\n');
-}
-/**
- * Bounded concurrent map. Exposed so tests can drive it directly when
- * the runner is async-deterministic and we want to assert that the
- * pool never exceeds the requested concurrency.
- */
-export async function runWithConcurrency(items, concurrency, worker) {
-    if (concurrency <= 0) {
-        throw new Error('runWithConcurrency: concurrency must be > 0');
-    }
-    const cap = Math.min(concurrency, items.length);
-    const results = new Array(items.length);
-    let cursor = 0;
-    const launchOne = async () => {
-        while (true) {
-            const idx = cursor;
-            cursor += 1;
-            if (idx >= items.length)
-                return;
-            const item = items[idx];
-            if (item === undefined)
-                continue;
-            const out = await worker(item);
-            results[idx] = out;
-        }
-    };
-    const lanes = [];
-    for (let i = 0; i < cap; i += 1)
-        lanes.push(launchOne());
-    await Promise.all(lanes);
-    return results;
-}
-function makeBatchId(now) {
-    const iso = now.toISOString().replace(/[:.]/g, '-');
-    const suffix = Math.floor(Math.random() * 0xfffff)
-        .toString(16)
-        .padStart(5, '0');
-    return `batch-${iso}-${suffix}`;
-}
-function summarizeError(stdout, stderr) {
-    const candidate = (stderr || stdout).trim();
-    if (candidate === '')
-        return null;
-    // Keep summaries short so the printed table stays readable; the
-    // full text is on disk via the per-task log files.
-    const firstLine = candidate.split('\n', 1)[0] ?? '';
-    return firstLine.slice(0, 200);
-}
-export async function runBatchCommand(args, ctx) {
-    const { flags, error } = parseFlags(args);
-    if (error === 'help') {
-        ctx.writeOutput({ ok: true, command: 'batch', usage: BATCH_USAGE }, BATCH_USAGE);
-        return emptyResult('help', '');
-    }
-    if (error !== null) {
-        ctx.writeOutput({ ok: false, command: 'batch', error }, `pugi batch: ${error}`);
-        return { ...emptyResult('args-error', ''), exitCode: 2 };
-    }
-    if (flags.recipePath === null) {
-        const msg = 'recipe path is required';
-        ctx.writeOutput({ ok: false, command: 'batch', error: msg }, `pugi batch: ${msg}\n\n${BATCH_USAGE}`);
-        return { ...emptyResult('args-error', ''), exitCode: 2 };
-    }
-    const recipePath = isAbsolute(flags.recipePath)
-        ? flags.recipePath
-        : resolve(ctx.cwd, flags.recipePath);
-    if (!existsSync(recipePath)) {
-        const msg = `recipe not found: ${recipePath}`;
-        ctx.writeOutput({ ok: false, command: 'batch', error: msg }, `pugi batch: ${msg}`);
-        return { ...emptyResult('args-error', recipePath), exitCode: 2 };
-    }
-    let recipeText;
-    try {
-        recipeText = readFileSync(recipePath, 'utf8');
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        ctx.writeOutput({ ok: false, command: 'batch', error: message }, `pugi batch: cannot read ${recipePath}: ${message}`);
-        return { ...emptyResult('args-error', recipePath), exitCode: 2 };
-    }
-    const parsed = parseBatchRecipe(recipeText);
-    if (!parsed.ok) {
-        ctx.writeOutput({ ok: false, command: 'batch', error: parsed.error }, `pugi batch: recipe parse error — ${parsed.error}`);
-        return { ...emptyResult('args-error', recipePath), exitCode: 2 };
-    }
-    const recipe = parsed.recipe;
-    const concurrency = flags.concurrency !== null ? flags.concurrency : recipe.concurrency;
-    const batchId = ctx.newBatchId ? ctx.newBatchId() : makeBatchId(ctx.now());
-    const batchDir = join(ctx.cwd, '.pugi', 'batch', batchId);
-    mkdirSync(batchDir, { recursive: true });
-    const resultsPath = join(batchDir, 'results.jsonl');
-    if (flags.dryRun) {
-        const result = {
-            batchId,
-            recipePath,
-            resultsPath,
-            results: recipe.tasks.map((t) => ({
-                id: t.id,
-                status: 'skipped',
-                exitCode: null,
-                durationMs: 0,
-                outputPath: join(batchDir, `${t.id}.stdout.log`),
-                errorPath: join(batchDir, `${t.id}.stderr.log`),
-                errorSummary: null,
-            })),
-            exitCode: 0,
-        };
-        ctx.writeOutput({ ok: true, command: 'batch', dryRun: true, result }, `pugi batch: dry-run, ${recipe.tasks.length} tasks would run with concurrency=${concurrency}`);
-        return result;
-    }
-    const runner = ctx.runner ?? spawnPugiSubprocess;
-    const results = [];
-    await runWithConcurrency(recipe.tasks, concurrency, async (task) => {
-        const outputPath = join(batchDir, `${task.id}.stdout.log`);
-        const errorPath = join(batchDir, `${task.id}.stderr.log`);
-        let out;
-        try {
-            out = await runner(task, { batchDir, cwd: ctx.cwd, env: ctx.env });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            out = {
-                status: 'failed',
-                exitCode: null,
-                stdout: '',
-                stderr: `runner threw: ${message}`,
-                durationMs: 0,
-            };
-        }
-        try {
-            atomicWriteFile(outputPath, out.stdout);
-            atomicWriteFile(errorPath, out.stderr);
-        }
-        catch {
-            // best-effort; we still record the in-memory result so the
-            // operator can tell what happened from the summary table.
-        }
-        const taskResult = {
-            id: task.id,
-            status: out.status,
-            exitCode: out.exitCode,
-            durationMs: out.durationMs,
-            outputPath,
-            errorPath,
-            errorSummary: out.status === 'ok' ? null : summarizeError(out.stdout, out.stderr),
-        };
-        results.push(taskResult);
-    });
-    // Preserve recipe order for idempotent re-runs and stable JSONL.
-    results.sort((a, b) => {
-        const idxA = recipe.tasks.findIndex((t) => t.id === a.id);
-        const idxB = recipe.tasks.findIndex((t) => t.id === b.id);
-        return idxA - idxB;
-    });
-    const jsonl = results.map((r) => JSON.stringify(r)).join('\n');
-    try {
-        atomicWriteFile(resultsPath, jsonl === '' ? '' : `${jsonl}\n`);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        ctx.writeOutput({ ok: false, command: 'batch', error: `failed to persist results: ${message}` }, `pugi batch: failed to persist results — ${message}`);
-        return {
-            batchId,
-            recipePath,
-            resultsPath,
-            results,
-            exitCode: 1,
-        };
-    }
-    const failedCount = results.filter((r) => r.status === 'failed' || r.status === 'timeout').length;
-    const exitCode = failedCount === 0 ? 0 : 1;
-    const result = {
-        batchId,
-        recipePath,
-        resultsPath,
-        results,
-        exitCode,
-    };
-    ctx.writeOutput({ ok: true, command: 'batch', result }, renderSummary(result));
-    return result;
-}
-function emptyResult(reason, recipePath) {
-    return {
-        batchId: reason,
-        recipePath,
-        resultsPath: '',
-        results: [],
-        exitCode: 0,
-    };
-}
-const BATCH_USAGE = [
-    'pugi batch — fan-out multi-task parallel execution scaffold.',
-    '',
-    'Usage:',
-    ' pugi batch <recipe.yml> [--concurrency <N>] [--json] [--dry-run]',
-    '',
-    'Flags:',
-    ' --concurrency <N> Override recipe concurrency (1..30). Default: 5.',
-    ' --json            Emit a JSON envelope instead of human text.',
-    ' --dry-run         Validate the recipe + plan paths; do not spawn anything.',
-    '',
-    'Recipe shape (YAML):',
-    ' concurrency: 5           # optional, defaults to 5, hard cap 30',
-    ' tasks:',
-    '   - id: <kebab-id>',
-    '     prompt: "<text>"',
-    '     model: <slug>        # optional',
-    '     maxTurns: <int>      # optional',
-    '     timeoutMs: <int>     # optional, default 600000',
-    '',
-    'Results land in .pugi/batch/<batch-id>/results.jsonl (one line per task).',
-].join('\n');
-//# sourceMappingURL=batch.js.map

package/dist/skills/bundled/index.js

@@ -1,45 +0,0 @@
-/**
- * Bundled-skills registry — batch 1 (backlog) + batch 2 (backlog).
- *
- * Bundled skills ship as in-binary commands rather than user
- * `.pugi/skills/` markdown:
- *
- *  - Batch 1 (`#168`):
- *    - `pugi stuck`   — non-invasive self-diagnosis (no process kill).
- *    - `pugi simplify` — local 3-agent parallel review + auto-fix.
- *    - `pugi remember` — proposal-first memory curator.
- *
- *  - Batch 2 (`#169`, external independent implementation):
- *    - `pugi batch`   — fan-out multi-task parallel execution scaffold.
- *    - `pugi verify`  — post-execution claim verification.
- *    - `pugi loop`    — drive a prompt against the engine to a stop condition.
- *    - `pugi skillify` — codify a freeform description into a skill scaffold.
- *
- * Each skill exports its runner from this index so the CLI dispatcher
- * in `runtime/cli.ts` (and any future REPL slash wrapper) imports
- * through one barrel. New batches append to the union types here.
- *
- * Inspired by the upstream tool / external bundled-skills patterns (intel from
- * leak-research memos, independent implementation TS).
- */
-export { runStuckCommand, classifyPeers, classifyChildren, readDebugTail, captureSampleStack, postSnapshotToWebhook, readProcessTable, } from './stuck.js';
-export { runSimplifyCommand, aggregateReviewerResults, parseReviewerFindings, defaultCaptureDiff, } from './simplify.js';
-export { runRememberCommand, classifyMemoryCandidate, } from './remember.js';
-export { runBatchCommand, parseBatchRecipe, spawnPugiSubprocess, runWithConcurrency, atomicWriteFile as atomicWriteFileBatch, } from './batch.js';
-export { runVerifyCommand, parseClaimsDocument, parseExpectedPattern, resolveTargetPath, tokenizeCommand, } from './verify.js';
-export { runLoopCommand, parseStopRegex, atomicWriteFile as atomicWriteFileLoop, } from './loop.js';
-export { runSkillifyCommand, parseScaffoldEnvelope, extractJsonBlock, renderSkillMarkdown, } from './skillify.js';
-/**
- * Names of every bundled skill. Kept as a frozen tuple so the help
- * renderer and the dispatcher reuse a single source of truth.
- */
-export const BUNDLED_SKILL_NAMES = Object.freeze([
-    'stuck',
-    'simplify',
-    'remember',
-    'batch',
-    'verify',
-    'loop',
-    'skillify',
-]);
-//# sourceMappingURL=index.js.map