@a5c-ai/babysitter-sdk 0.0.28 → 0.0.30

package/dist/cli/main.js

@@ -35,11 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBabysitterCli = createBabysitterCli;
-const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
-const node_module_1 = require("node:module");
 const path = __importStar(require("node:path"));
-const os = __importStar(require("node:os"));
 const nodeTaskRunner_1 = require("./nodeTaskRunner");
 const orchestrateIteration_1 = require("../runtime/orchestrateIteration");
 const createRun_1 = require("../runtime/createRun");
@@ -48,17 +45,17 @@ const stateCache_1 = require("../runtime/replay/stateCache");
 const tasks_1 = require("../storage/tasks");
 const journal_1 = require("../storage/journal");
 const runFiles_1 = require("../storage/runFiles");
+const runIterate_1 = require("./commands/runIterate");
 const USAGE = `Usage:
   babysitter run:create --process-id <id> --entry <path#export> [--runs-dir <dir>] [--inputs <file>] [--run-id <id>] [--process-revision <rev>] [--request <id>] [--json] [--dry-run]
   babysitter run:status <runDir> [--runs-dir <dir>] [--json]
   babysitter run:events <runDir> [--runs-dir <dir>] [--json] [--limit <n>] [--reverse] [--filter-type <type>]
   babysitter run:rebuild-state <runDir> [--runs-dir <dir>] [--json] [--dry-run]
+  babysitter run:iterate <runDir> [--runs-dir <dir>] [--json] [--verbose] [--iteration <n>]
   babysitter task:run <runDir> <effectId> [--runs-dir <dir>] [--json] [--dry-run]
   babysitter run:step <runDir> [--runs-dir <dir>] [--json] [--now <iso8601>]
-  babysitter run:continue <runDir> [--runs-dir <dir>] [--json] [--dry-run] [--auto-node-tasks] [--auto-node-max <n>] [--auto-node-label <text>]
   babysitter task:list <runDir> [--runs-dir <dir>] [--pending] [--kind <kind>] [--json]
   babysitter task:show <runDir> <effectId> [--runs-dir <dir>] [--json]
-  babysitter skill:install [--type <claude|codex|cursor>] [--scope <local|global>] [--force] [--json] [--dry-run]
 
 Global flags:
   --runs-dir <dir>   Override the runs directory (defaults to .a5c/runs).
@@ -67,23 +64,15 @@ Global flags:
   --verbose          Log resolved paths and options to stderr for debugging.
   --help, -h         Show this help text.`;
 const LARGE_RESULT_PREVIEW_LIMIT = 1024 * 1024; // 1 MiB
-const DEFAULT_SKILL_TARGET = "codex";
-const DEFAULT_SKILL_SCOPE = "local";
-const breakpointsRequire = (0, node_module_1.createRequire)(__filename);
 function parseArgs(argv) {
     const [initialCommand, ...rest] = argv;
     const parsed = {
         command: initialCommand,
         runsDir: ".a5c/runs",
-        skillsDir: undefined,
-        skillType: DEFAULT_SKILL_TARGET,
-        skillScope: DEFAULT_SKILL_SCOPE,
         json: false,
         dryRun: false,
         verbose: false,
-        force: false,
         helpRequested: false,
-        autoNodeTasks: false,
         pendingOnly: false,
         reverseOrder: false,
     };
@@ -102,18 +91,6 @@ function parseArgs(argv) {
             parsed.runsDir = expectFlagValue(rest, ++i, "--runs-dir");
             continue;
         }
-        if (arg === "--skills-dir") {
-            parsed.skillsDir = expectFlagValue(rest, ++i, "--skills-dir");
-            continue;
-        }
-        if (arg === "--type") {
-            parsed.skillType = expectSkillTarget(expectFlagValue(rest, ++i, "--type"), "--type");
-            continue;
-        }
-        if (arg === "--scope") {
-            parsed.skillScope = expectSkillScope(expectFlagValue(rest, ++i, "--scope"), "--scope");
-            continue;
-        }
         if (arg === "--json") {
             parsed.json = true;
             continue;
@@ -122,18 +99,10 @@ function parseArgs(argv) {
             parsed.dryRun = true;
             continue;
         }
-        if (arg === "--force") {
-            parsed.force = true;
-            continue;
-        }
         if (arg === "--verbose") {
             parsed.verbose = true;
             continue;
         }
-        if (arg === "--auto-node-tasks") {
-            parsed.autoNodeTasks = true;
-            continue;
-        }
         if (arg === "--pending") {
             parsed.pendingOnly = true;
             continue;
@@ -147,6 +116,11 @@ function parseArgs(argv) {
             parsed.limit = parsePositiveInteger(raw, "--limit");
             continue;
         }
+        if (arg === "--iteration") {
+            const raw = expectFlagValue(rest, ++i, "--iteration");
+            parsed.iteration = parsePositiveInteger(raw, "--iteration");
+            continue;
+        }
         if (arg === "--reverse") {
             parsed.reverseOrder = true;
             continue;
@@ -183,23 +157,11 @@ function parseArgs(argv) {
             parsed.nowOverride = expectFlagValue(rest, ++i, "--now");
             continue;
         }
-        if (arg === "--auto-node-max") {
-            const raw = expectFlagValue(rest, ++i, "--auto-node-max");
-            parsed.autoNodeMax = parsePositiveInteger(raw, "--auto-node-max");
-            continue;
-        }
-        if (arg === "--auto-node-label") {
-            parsed.autoNodeLabel = expectFlagValue(rest, ++i, "--auto-node-label");
-            continue;
-        }
         positionals.push(arg);
     }
     if (parsed.command === "task:run") {
         [parsed.runDirArg, parsed.effectId] = positionals;
     }
-    else if (parsed.command === "run:continue") {
-        [parsed.runDirArg] = positionals;
-    }
     else if (parsed.command === "task:list") {
         [parsed.runDirArg] = positionals;
     }
@@ -209,6 +171,9 @@ function parseArgs(argv) {
     else if (parsed.command === "run:status") {
         [parsed.runDirArg] = positionals;
     }
+    else if (parsed.command === "run:iterate") {
+        [parsed.runDirArg] = positionals;
+    }
     else if (parsed.command === "run:events") {
         [parsed.runDirArg] = positionals;
     }
@@ -239,29 +204,6 @@ function parsePositiveInteger(raw, flag) {
     }
     return Math.floor(parsed);
 }
-function expectSkillTarget(raw, flag) {
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "claude" || normalized === "codex" || normalized === "cursor") {
-        return normalized;
-    }
-    throw new Error(`${flag} must be one of: claude, codex, cursor`);
-}
-function expectSkillScope(raw, flag) {
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "local" || normalized === "global") {
-        return normalized;
-    }
-    throw new Error(`${flag} must be one of: local, global`);
-}
-function resolveSkillsDir(parsed) {
-    if (parsed.skillsDir) {
-        return path.resolve(parsed.skillsDir);
-    }
-    const scopeBase = parsed.skillScope === "global"
-        ? path.join(os.homedir(), `.${parsed.skillType}`)
-        : path.resolve(`.${parsed.skillType}`);
-    return path.join(scopeBase, "skills");
-}
 function summarizeActions(actions) {
     return actions.map((action) => ({
         effectId: action.effectId,
@@ -269,13 +211,6 @@ function summarizeActions(actions) {
         label: action.label,
     }));
 }
-function matchesAutoNodeLabel(action, filter) {
-    if (!filter)
-        return true;
-    const needle = filter.toLowerCase();
-    const haystacks = [action.label, ...(action.labels ?? []), action.effectId];
-    return haystacks.some((value) => (value ? value.toLowerCase().includes(needle) : false));
-}
 function logPendingActions(actions, options = {}) {
     const summaries = summarizeActions(actions);
     if (options.command && options.includeHeader !== false) {
@@ -324,27 +259,6 @@ function logSleepHints(command, actions) {
         console.error(`[${command}] sleep-until=${iso} effect=${action.effectId}${label}${pendingInfo}`);
     }
 }
-function logRunContinueStatus(iterationStatus, executedCount, metadataParts, options) {
-    const parts = [`[run:continue] status=${iterationStatus}`];
-    if (options.dryRun) {
-        parts.push("dryRun=true");
-    }
-    if (executedCount > 0) {
-        parts.push(`autoNode=${executedCount}`);
-    }
-    parts.push(...metadataParts);
-    console.error(parts.join(" "));
-}
-function logAutoRunPlan(nodeSummaries) {
-    console.error(`[run:continue] dry-run auto-node tasks count=${nodeSummaries.length}`);
-    if (!nodeSummaries.length) {
-        return;
-    }
-    for (const summary of nodeSummaries) {
-        const label = summary.label ? ` ${summary.label}` : "";
-        console.error(`  - ${summary.effectId} [${summary.kind}]${label}`);
-    }
-}
 function formatResolvedEntrypoint(importPath, exportName) {
     return `${importPath}${exportName ? `#${exportName}` : ""}`;
 }
@@ -359,140 +273,6 @@ function formatVerboseValue(value) {
         return String(value);
     return JSON.stringify(value);
 }
-function resolveBundledSkillsRoot() {
-    return path.resolve(__dirname, "..", "..", "skills");
-}
-async function listBundledSkillDirs() {
-    const root = resolveBundledSkillsRoot();
-    const entries = await node_fs_1.promises.readdir(root, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-}
-async function pathExists(filePath) {
-    try {
-        await node_fs_1.promises.stat(filePath);
-        return true;
-    }
-    catch (error) {
-        const err = error;
-        if (err.code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-function toPosixPath(value) {
-    return value.replace(/\\/g, "/");
-}
-function resolveBreakpointsBin() {
-    const pkgPath = breakpointsRequire.resolve("@a5c-ai/babysitter-breakpoints/package.json");
-    const pkgDir = path.dirname(pkgPath);
-    const pkgJson = breakpointsRequire(pkgPath);
-    let binRelative;
-    if (typeof pkgJson.bin === "string") {
-        binRelative = pkgJson.bin;
-    }
-    else if (pkgJson.bin && typeof pkgJson.bin === "object") {
-        binRelative = pkgJson.bin.breakpoints ?? pkgJson.bin["babysitter-breakpoints"] ?? Object.values(pkgJson.bin)[0];
-    }
-    if (!binRelative) {
-        throw new Error("missing bin entry in @a5c-ai/babysitter-breakpoints package.json");
-    }
-    return path.resolve(pkgDir, binRelative);
-}
-async function installBreakpointsSkill(parsed, skillsDir) {
-    if (parsed.dryRun) {
-        return { status: "planned", message: "dry-run: skipped breakpoints install" };
-    }
-    let binPath;
-    try {
-        binPath = resolveBreakpointsBin();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { status: "error", message };
-    }
-    const args = [binPath, "install-skill", "--target", parsed.skillType, "--scope", parsed.skillScope];
-    if (parsed.skillsDir) {
-        args.push("--skills-dir", skillsDir);
-    }
-    if (parsed.json) {
-        args.push("--json");
-    }
-    const child = (0, node_child_process_1.spawn)(process.execPath, args, {
-        stdio: parsed.json ? ["ignore", "pipe", "pipe"] : "inherit",
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    if (parsed.json) {
-        child.stdout?.on("data", (chunk) => stdoutChunks.push(Buffer.from(chunk)));
-        child.stderr?.on("data", (chunk) => stderrChunks.push(Buffer.from(chunk)));
-    }
-    const exitCode = await new Promise((resolve) => {
-        child.on("close", (code) => resolve(code ?? 1));
-        child.on("error", () => resolve(1));
-    });
-    const stdout = parsed.json ? Buffer.concat(stdoutChunks).toString().trim() : undefined;
-    const stderr = parsed.json ? Buffer.concat(stderrChunks).toString().trim() : undefined;
-    if (exitCode === 0) {
-        return { status: "installed", exitCode, stdout: stdout || undefined, stderr: stderr || undefined };
-    }
-    const message = stderr || stdout || `breakpoints install-skill exited with code ${exitCode}`;
-    return { status: "error", exitCode, message, stdout: stdout || undefined, stderr: stderr || undefined };
-}
-async function installBundledSkillDir(skillName, options) {
-    const sourceDir = path.join(resolveBundledSkillsRoot(), skillName);
-    const destinationDir = path.join(options.skillsDir, skillName);
-    try {
-        const sourceExists = await pathExists(sourceDir);
-        if (!sourceExists) {
-            return {
-                name: skillName,
-                status: "error",
-                sourceDir,
-                destinationDir,
-                message: "bundled skill missing",
-            };
-        }
-        const destinationExists = await pathExists(destinationDir);
-        if (destinationExists && !options.force) {
-            return {
-                name: skillName,
-                status: "skipped",
-                sourceDir,
-                destinationDir,
-                message: "already installed",
-            };
-        }
-        if (options.dryRun) {
-            return {
-                name: skillName,
-                status: "planned",
-                sourceDir,
-                destinationDir,
-            };
-        }
-        if (destinationExists && options.force) {
-            await node_fs_1.promises.rm(destinationDir, { recursive: true, force: true });
-        }
-        await node_fs_1.promises.mkdir(options.skillsDir, { recursive: true });
-        await node_fs_1.promises.cp(sourceDir, destinationDir, { recursive: true });
-        return {
-            name: skillName,
-            status: "installed",
-            sourceDir,
-            destinationDir,
-        };
-    }
-    catch (error) {
-        return {
-            name: skillName,
-            status: "error",
-            sourceDir,
-            destinationDir,
-            message: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
 function allowSecretLogs(parsed) {
     if (!parsed.json || !parsed.verbose) {
         return false;
@@ -745,6 +525,43 @@ async function handleRunStatus(parsed) {
     console.log(`[run:status] state=${state} last=${lastSummary}${suffix}`);
     return 0;
 }
+async function handleRunIterate(parsed) {
+    if (!parsed.runDirArg) {
+        console.error(USAGE);
+        return 1;
+    }
+    const runDir = resolveRunDir(parsed.runsDir, parsed.runDirArg);
+    logVerbose("run:iterate", parsed, {
+        runDir,
+        iteration: parsed.iteration,
+        json: parsed.json,
+        verbose: parsed.verbose,
+    });
+    try {
+        const result = await (0, runIterate_1.runIterate)({
+            runDir,
+            iteration: parsed.iteration,
+            verbose: parsed.verbose,
+            json: parsed.json,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            const countInfo = result.count ? ` count=${result.count}` : "";
+            const actionInfo = result.action ? ` action=${result.action}` : "";
+            console.log(`[run:iterate] iteration=${result.iteration} status=${result.status}${actionInfo}${countInfo} reason=${result.reason}`);
+            if (result.status === "waiting" && result.until) {
+                console.log(`[run:iterate] Waiting until: ${new Date(result.until).toISOString()}`);
+            }
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(`[run:iterate] Error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}
 async function handleRunEvents(parsed) {
     if (!parsed.runDirArg) {
         console.error(USAGE);
@@ -902,169 +719,6 @@ async function handleTaskRun(parsed) {
     }
     return status === "ok" || status === "skipped" ? 0 : 1;
 }
-async function autoRunNodeTasks(runDir, actions, executed) {
-    for (const action of actions) {
-        const summary = {
-            effectId: action.effectId,
-            kind: action.kind,
-            label: action.label,
-        };
-        executed.push(summary);
-        const label = summary.label ? ` ${summary.label}` : "";
-        console.error(`[auto-run] ${summary.effectId} [${summary.kind}]${label}`);
-        await (0, nodeTaskRunner_1.runNodeTaskFromCli)({
-            runDir,
-            effectId: action.effectId,
-            task: action.taskDef,
-            invocationKey: action.invocationKey,
-            dryRun: false,
-        });
-    }
-}
-function emitJsonResult(iteration, context) {
-    const payload = {
-        status: iteration.status,
-        autoRun: { executed: context.executed, pending: context.autoPending },
-        metadata: context.metadata ?? null,
-    };
-    if (iteration.status === "completed") {
-        payload.output = context.output;
-    }
-    else if (iteration.status === "failed") {
-        payload.error = context.error ?? null;
-    }
-    else {
-        payload.pending = context.pending;
-    }
-    console.log(JSON.stringify(payload));
-}
-async function handleRunContinue(parsed) {
-    if (!parsed.runDirArg) {
-        console.error(USAGE);
-        return 1;
-    }
-    if (parsed.nowOverride) {
-        console.error("[run:continue] --now is not supported; use run:step for single iterations");
-        return 1;
-    }
-    if ((parsed.autoNodeMax !== undefined || parsed.autoNodeLabel) && !parsed.autoNodeTasks) {
-        console.error("[run:continue] --auto-node-max/--auto-node-label require --auto-node-tasks");
-        return 1;
-    }
-    const runDir = resolveRunDir(parsed.runsDir, parsed.runDirArg);
-    logVerbose("run:continue", parsed, {
-        runDir,
-        dryRun: parsed.dryRun,
-        json: parsed.json,
-        autoNodeTasks: parsed.autoNodeTasks,
-        autoNodeMax: parsed.autoNodeMax ?? null,
-        autoNodeLabel: parsed.autoNodeLabel ?? null,
-    });
-    if (!(await readRunMetadataSafe(runDir, "run:continue")))
-        return 1;
-    const stateSnapshot = await readStateCacheSafe(runDir, "run:continue");
-    const executed = [];
-    const autoNodeLimit = parsed.autoNodeMax ?? Number.POSITIVE_INFINITY;
-    let autoNodeRemaining = autoNodeLimit;
-    let autoNodeLimitLogged = false;
-    while (true) {
-        const iteration = await (0, orchestrateIteration_1.orchestrateIteration)({ runDir });
-        const pendingActions = iteration.status === "waiting" ? iteration.nextActions : undefined;
-        const pendingCounts = pendingActions ? countActionsByKind(pendingActions) : undefined;
-        const enrichedMetadata = enrichIterationMetadata(iteration.metadata, pendingActions);
-        const metadata = mergeMetadataSources(enrichedMetadata, {
-            snapshot: stateSnapshot,
-            pendingByKind: pendingCounts,
-        });
-        const formattedMetadata = formatIterationMetadata(metadata);
-        logRunContinueStatus(iteration.status, executed.length, formattedMetadata.textParts, {
-            dryRun: parsed.dryRun,
-        });
-        if (iteration.status === "waiting") {
-            const pending = logPendingActions(iteration.nextActions, {
-                command: "run:continue",
-                includeHeader: false,
-            });
-            logSleepHints("run:continue", iteration.nextActions);
-            const nodeActions = iteration.nextActions.filter((action) => action.kind === "node");
-            const eligibleAutoActions = parsed.autoNodeTasks
-                ? nodeActions.filter((action) => matchesAutoNodeLabel(action, parsed.autoNodeLabel))
-                : nodeActions;
-            const planCap = parsed.autoNodeTasks
-                ? Math.min(eligibleAutoActions.length, Number.isFinite(autoNodeRemaining) ? Math.max(0, Math.floor(autoNodeRemaining)) : eligibleAutoActions.length)
-                : eligibleAutoActions.length;
-            const plannedAutoActions = eligibleAutoActions.slice(0, planCap);
-            const nodeSummaries = summarizeActions(nodeActions);
-            const autoPendingSummaries = parsed.autoNodeTasks ? summarizeActions(plannedAutoActions) : nodeSummaries;
-            if (parsed.autoNodeTasks && eligibleAutoActions.length > 0 && autoNodeRemaining <= 0 && Number.isFinite(autoNodeLimit)) {
-                if (!autoNodeLimitLogged) {
-                    console.error(`[auto-run] reached --auto-node-max=${parsed.autoNodeMax}`);
-                    autoNodeLimitLogged = true;
-                }
-            }
-            if (parsed.autoNodeTasks && parsed.autoNodeLabel && eligibleAutoActions.length === 0 && nodeActions.length > 0) {
-                console.error(`[auto-run] no node tasks matched --auto-node-label=${parsed.autoNodeLabel}; ${nodeActions.length} pending`);
-            }
-            if (parsed.autoNodeTasks && plannedAutoActions.length > 0) {
-                if (parsed.dryRun) {
-                    logAutoRunPlan(autoPendingSummaries);
-                    if (parsed.json) {
-                        emitJsonResult({ status: "waiting" }, {
-                            executed,
-                            pending,
-                            autoPending: autoPendingSummaries,
-                            metadata: formattedMetadata.jsonMetadata ?? null,
-                        });
-                    }
-                    return 0;
-                }
-                await autoRunNodeTasks(runDir, plannedAutoActions, executed);
-                if (Number.isFinite(autoNodeRemaining)) {
-                    autoNodeRemaining = Math.max(0, autoNodeRemaining - plannedAutoActions.length);
-                    if (autoNodeRemaining <= 0 && !autoNodeLimitLogged && parsed.autoNodeMax !== undefined) {
-                        console.error(`[auto-run] reached --auto-node-max=${parsed.autoNodeMax}`);
-                        autoNodeLimitLogged = true;
-                    }
-                }
-                continue;
-            }
-            if (parsed.json) {
-                emitJsonResult({ status: "waiting" }, {
-                    executed,
-                    pending,
-                    autoPending: autoPendingSummaries,
-                    metadata: formattedMetadata.jsonMetadata ?? null,
-                });
-            }
-            return 0;
-        }
-        if (iteration.status === "completed") {
-            if (parsed.json) {
-                emitJsonResult({ status: "completed", output: iteration.output }, {
-                    executed,
-                    pending: [],
-                    autoPending: [],
-                    metadata: formattedMetadata.jsonMetadata ?? null,
-                    output: iteration.output,
-                });
-            }
-            return 0;
-        }
-        if (parsed.json) {
-            emitJsonResult({ status: "failed", error: iteration.error ?? null }, {
-                executed,
-                pending: [],
-                autoPending: [],
-                metadata: formattedMetadata.jsonMetadata ?? null,
-                error: iteration.error ?? null,
-            });
-        }
-        else if (iteration.error !== undefined) {
-            console.error(iteration.error);
-        }
-        return 1;
-    }
-}
 function parseNowOverride(nowOverride) {
     if (!nowOverride)
         return null;
@@ -1221,92 +875,6 @@ async function handleTaskShow(parsed) {
     }
     return 0;
 }
-async function handleSkillInstall(parsed) {
-    const skillsDir = resolveSkillsDir(parsed);
-    logVerbose("skill:install", parsed, {
-        skillsDir,
-        type: parsed.skillType,
-        scope: parsed.skillScope,
-        dryRun: parsed.dryRun,
-        force: parsed.force,
-        json: parsed.json,
-    });
-    const results = [];
-    let skillNames;
-    try {
-        skillNames = await listBundledSkillDirs();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (parsed.json) {
-            console.log(JSON.stringify({ skillsDir, type: parsed.skillType, scope: parsed.skillScope, error: message, results: [] }));
-        }
-        else {
-            console.error(`[skill:install] failed to read bundled skills: ${message}`);
-        }
-        return 1;
-    }
-    if (!skillNames.length) {
-        if (parsed.json) {
-            console.log(JSON.stringify({ skillsDir, type: parsed.skillType, scope: parsed.skillScope, error: "no bundled skills found", results: [] }));
-        }
-        else {
-            console.error("[skill:install] no bundled skills found");
-        }
-        return 1;
-    }
-    for (const skillName of skillNames) {
-        results.push(await installBundledSkillDir(skillName, { skillsDir, dryRun: parsed.dryRun, force: parsed.force }));
-    }
-    const counts = { installed: 0, skipped: 0, planned: 0, error: 0 };
-    for (const result of results) {
-        if (result.status === "installed")
-            counts.installed += 1;
-        else if (result.status === "skipped")
-            counts.skipped += 1;
-        else if (result.status === "planned")
-            counts.planned += 1;
-        else
-            counts.error += 1;
-    }
-    const breakpointsSummary = await installBreakpointsSkill(parsed, skillsDir);
-    const breakpointsFailed = breakpointsSummary.status === "error";
-    if (parsed.json) {
-        console.log(JSON.stringify({ skillsDir, type: parsed.skillType, scope: parsed.skillScope, results, breakpoints: breakpointsSummary }));
-        return counts.error > 0 || breakpointsFailed ? 1 : 0;
-    }
-    const parts = [`[skill:install] dir=${skillsDir}`];
-    if (!parsed.skillsDir) {
-        parts.push(`type=${parsed.skillType}`);
-        parts.push(`scope=${parsed.skillScope}`);
-    }
-    if (parsed.dryRun)
-        parts.push("dryRun=true");
-    if (parsed.force)
-        parts.push("force=true");
-    parts.push(`breakpoints=${breakpointsSummary.status}`);
-    if (counts.installed)
-        parts.push(`installed=${counts.installed}`);
-    if (counts.skipped)
-        parts.push(`skipped=${counts.skipped}`);
-    if (counts.planned)
-        parts.push(`planned=${counts.planned}`);
-    if (counts.error)
-        parts.push(`errors=${counts.error}`);
-    console.log(parts.join(" "));
-    if (breakpointsSummary.status === "error") {
-        console.error(`[skill:install] breakpoints install failed: ${breakpointsSummary.message ?? "unknown error"}`);
-    }
-    for (const result of results) {
-        const relativeDest = toPosixPath(path.relative(skillsDir, result.destinationDir));
-        const relativeSource = toPosixPath(path.relative(skillsDir, result.sourceDir));
-        const destLabel = relativeDest.startsWith("..") ? toPosixPath(result.destinationDir) : relativeDest;
-        const sourceLabel = relativeSource.startsWith("..") ? toPosixPath(result.sourceDir) : relativeSource;
-        const messageSuffix = result.message ? ` message=${result.message}` : "";
-        console.log(`- ${result.name} status=${result.status} dest=${destLabel} src=${sourceLabel}${messageSuffix}`);
-    }
-    return counts.error > 0 || breakpointsFailed ? 1 : 0;
-}
 function toTaskListEntry(record, runDir) {
     return {
         effectId: record.effectId,
@@ -1578,6 +1146,9 @@ function createBabysitterCli() {
                 if (parsed.command === "run:status") {
                     return await handleRunStatus(parsed);
                 }
+                if (parsed.command === "run:iterate") {
+                    return await handleRunIterate(parsed);
+                }
                 if (parsed.command === "run:events") {
                     return await handleRunEvents(parsed);
                 }
@@ -1587,18 +1158,12 @@ function createBabysitterCli() {
                 if (parsed.command === "run:step") {
                     return await handleRunStep(parsed);
                 }
-                if (parsed.command === "run:continue") {
-                    return await handleRunContinue(parsed);
-                }
                 if (parsed.command === "task:list") {
                     return await handleTaskList(parsed);
                 }
                 if (parsed.command === "task:show") {
                     return await handleTaskShow(parsed);
                 }
-                if (parsed.command === "skill:install") {
-                    return await handleSkillInstall(parsed);
-                }
                 console.error(USAGE);
                 return 1;
             }

package/dist/cli/nodeTaskRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeTaskRunner.d.ts","sourceRoot":"","sources":["../../src/cli/nodeTaskRunner.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAiC,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE9E,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACvG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE,2BAA2B,CAAC;CACzC;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA4BtG"}
+{"version":3,"file":"nodeTaskRunner.d.ts","sourceRoot":"","sources":["../../src/cli/nodeTaskRunner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAiC,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAG9E,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACvG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE,2BAA2B,CAAC;CACzC;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqEtG"}