@a5c-ai/babysitter-sdk 0.0.169 → 0.0.170-staging.00aac85c

package/dist/cli/commands/runExecuteTasks.js

@@ -0,0 +1,377 @@
+"use strict";
+/**
+ * run:execute-tasks command - Execute pending node tasks in a run
+ *
+ * This command replaces the shell-based task execution logic in native-orchestrator.sh.
+ * It:
+ * 1. Loads the journal and builds the effect index
+ * 2. Filters pending effects by kind (default "node")
+ * 3. Slices to maxTasks (default 3)
+ * 4. For each task: reads task.json, spawns `node`, captures stdout/stderr, commits result
+ * 5. Returns a summary of executed tasks
+ */
+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.runExecuteTasks = runExecuteTasks;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const effectIndex_1 = require("../../runtime/replay/effectIndex");
+const commitEffectResult_1 = require("../../runtime/commitEffectResult");
+const tasks_1 = require("../../storage/tasks");
+const defaults_1 = require("../../config/defaults");
+function log(verbose, ...args) {
+    if (verbose) {
+        console.error(`[run:execute-tasks]`, ...args);
+    }
+}
+/**
+ * Resolve a path relative to runDir unless it is already absolute.
+ */
+function resolveRelative(runDir, ref) {
+    if (path.isAbsolute(ref) || /^[A-Za-z]:[\\/]/.test(ref)) {
+        return ref;
+    }
+    return path.join(runDir, ref);
+}
+/**
+ * Make a path relative to runDir, using forward slashes.
+ */
+function toRunRelative(runDir, absolute) {
+    return path.relative(runDir, absolute).replace(/\\/g, "/");
+}
+/**
+ * Spawn a node process for the given task and capture its output.
+ */
+function spawnNodeTask(options) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)("node", [options.entry, ...options.args], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: options.timeout,
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        child.on("close", (code) => {
+            resolve({
+                exitCode: code ?? 1,
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+            });
+        });
+        child.on("error", (err) => {
+            resolve({
+                exitCode: 1,
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: `${Buffer.concat(stderrChunks).toString("utf8")}\n${err.message}`,
+            });
+        });
+    });
+}
+/**
+ * Execute a single task: read its definition, spawn node, commit the result.
+ */
+async function executeOneTask(runDir, record, timeout, verbose) {
+    const effectId = record.effectId;
+    const label = record.label ?? null;
+    log(verbose, `Executing: ${effectId}${label ? ` (${label})` : ""}`);
+    // Read task.json
+    const taskDef = await (0, tasks_1.readTaskDefinition)(runDir, effectId);
+    if (!taskDef) {
+        log(verbose, `Missing task definition for ${effectId}`);
+        const errorPayload = {
+            name: "Error",
+            message: `Missing task definition for effect ${effectId}`,
+        };
+        await (0, commitEffectResult_1.commitEffectResult)({
+            runDir,
+            effectId,
+            invocationKey: record.invocationKey,
+            result: {
+                status: "error",
+                error: errorPayload,
+                startedAt: new Date().toISOString(),
+                finishedAt: new Date().toISOString(),
+            },
+        });
+        return {
+            effectId,
+            label,
+            status: "error",
+            exitCode: 1,
+            durationMs: 0,
+            stdoutRef: null,
+            stderrRef: null,
+            resultRef: null,
+            error: errorPayload,
+        };
+    }
+    // Extract node config
+    const nodeConfig = (taskDef.node ?? {});
+    const entry = nodeConfig.entry;
+    if (!entry) {
+        log(verbose, `Missing node.entry in task.json for ${effectId}`);
+        const errorPayload = {
+            name: "Error",
+            message: `Missing node.entry in task definition for effect ${effectId}`,
+        };
+        await (0, commitEffectResult_1.commitEffectResult)({
+            runDir,
+            effectId,
+            invocationKey: record.invocationKey,
+            result: {
+                status: "error",
+                error: errorPayload,
+                startedAt: new Date().toISOString(),
+                finishedAt: new Date().toISOString(),
+            },
+        });
+        return {
+            effectId,
+            label,
+            status: "error",
+            exitCode: 1,
+            durationMs: 0,
+            stdoutRef: null,
+            stderrRef: null,
+            resultRef: null,
+            error: errorPayload,
+        };
+    }
+    const nodeArgs = nodeConfig.args ?? [];
+    const taskTimeout = nodeConfig.timeoutMs ?? timeout;
+    // Extract IO config
+    const ioConfig = (taskDef.io ?? {});
+    const inputRef = ioConfig.inputJsonPath ?? `tasks/${effectId}/inputs.json`;
+    const outputRef = ioConfig.outputJsonPath ?? `tasks/${effectId}/result.json`;
+    const stdoutRef = ioConfig.stdoutPath ?? `tasks/${effectId}/stdout.log`;
+    const stderrRef = ioConfig.stderrPath ?? `tasks/${effectId}/stderr.log`;
+    // Resolve paths relative to runDir
+    const inputAbs = resolveRelative(runDir, inputRef);
+    const outputAbs = resolveRelative(runDir, outputRef);
+    const stdoutAbs = resolveRelative(runDir, stdoutRef);
+    const stderrAbs = resolveRelative(runDir, stderrRef);
+    const entryAbs = resolveRelative(runDir, entry);
+    const cwdAbs = nodeConfig.cwd ? resolveRelative(runDir, nodeConfig.cwd) : runDir;
+    // Ensure directories exist
+    await Promise.all([
+        node_fs_1.promises.mkdir(path.dirname(inputAbs), { recursive: true }),
+        node_fs_1.promises.mkdir(path.dirname(outputAbs), { recursive: true }),
+        node_fs_1.promises.mkdir(path.dirname(stdoutAbs), { recursive: true }),
+        node_fs_1.promises.mkdir(path.dirname(stderrAbs), { recursive: true }),
+    ]);
+    // Stage inputs.json
+    const inputsRefField = taskDef.inputsRef;
+    if (inputsRefField) {
+        const sourceAbs = resolveRelative(runDir, inputsRefField);
+        try {
+            await node_fs_1.promises.copyFile(sourceAbs, inputAbs);
+        }
+        catch {
+            // If the source doesn't exist, write an empty object
+            await node_fs_1.promises.writeFile(inputAbs, "{}\n", "utf8");
+        }
+    }
+    else {
+        // Extract inline inputs or default to {}
+        const inputs = taskDef.inputs ?? {};
+        await node_fs_1.promises.writeFile(inputAbs, JSON.stringify(inputs) + "\n", "utf8");
+    }
+    // Build environment for the child process
+    const taskEnv = {
+        ...(nodeConfig.env ?? {}),
+        BABYSITTER_INPUT_JSON: inputAbs,
+        BABYSITTER_OUTPUT_JSON: outputAbs,
+        BABYSITTER_STDOUT_PATH: stdoutAbs,
+        BABYSITTER_STDERR_PATH: stderrAbs,
+        BABYSITTER_EFFECT_ID: effectId,
+    };
+    // Spawn the node process
+    const startedAt = new Date().toISOString();
+    const startMs = Date.now();
+    const spawnResult = await spawnNodeTask({
+        entry: entryAbs,
+        args: nodeArgs,
+        cwd: cwdAbs,
+        env: taskEnv,
+        stdoutPath: stdoutAbs,
+        stderrPath: stderrAbs,
+        timeout: taskTimeout,
+    });
+    const finishedAt = new Date().toISOString();
+    const durationMs = Date.now() - startMs;
+    // Write stdout and stderr to disk
+    await node_fs_1.promises.writeFile(stdoutAbs, spawnResult.stdout, "utf8");
+    await node_fs_1.promises.writeFile(stderrAbs, spawnResult.stderr, "utf8");
+    const stdoutRelRef = toRunRelative(runDir, stdoutAbs);
+    const stderrRelRef = toRunRelative(runDir, stderrAbs);
+    // Commit the result
+    if (spawnResult.exitCode === 0) {
+        // Read the output file produced by the task (if any)
+        let value = undefined;
+        try {
+            const outputContents = await node_fs_1.promises.readFile(outputAbs, "utf8");
+            const trimmed = outputContents.trim();
+            if (trimmed.length > 0) {
+                value = JSON.parse(trimmed);
+            }
+        }
+        catch {
+            // Output file may not exist; that is acceptable
+        }
+        const committed = await (0, commitEffectResult_1.commitEffectResult)({
+            runDir,
+            effectId,
+            invocationKey: record.invocationKey,
+            result: {
+                status: "ok",
+                value,
+                stdoutRef: stdoutRelRef,
+                stderrRef: stderrRelRef,
+                startedAt,
+                finishedAt,
+            },
+        });
+        log(verbose, `Posted result: ${effectId} (ok, ${durationMs}ms)`);
+        return {
+            effectId,
+            label,
+            status: "ok",
+            exitCode: spawnResult.exitCode,
+            durationMs,
+            stdoutRef: stdoutRelRef,
+            stderrRef: stderrRelRef,
+            resultRef: committed.resultRef ?? null,
+        };
+    }
+    else {
+        const errorPayload = {
+            name: "Error",
+            message: `Node task exited non-zero (exitCode=${spawnResult.exitCode})`,
+        };
+        const committed = await (0, commitEffectResult_1.commitEffectResult)({
+            runDir,
+            effectId,
+            invocationKey: record.invocationKey,
+            result: {
+                status: "error",
+                error: errorPayload,
+                stdoutRef: stdoutRelRef,
+                stderrRef: stderrRelRef,
+                startedAt,
+                finishedAt,
+            },
+        });
+        log(verbose, `Posted error: ${effectId} (exitCode=${spawnResult.exitCode}, ${durationMs}ms)`);
+        return {
+            effectId,
+            label,
+            status: "error",
+            exitCode: spawnResult.exitCode,
+            durationMs,
+            stdoutRef: stdoutRelRef,
+            stderrRef: stderrRelRef,
+            resultRef: committed.resultRef ?? null,
+            error: errorPayload,
+        };
+    }
+}
+async function runExecuteTasks(options) {
+    const { runDir, verbose, dryRun, } = options;
+    const maxTasks = options.maxTasks ?? 3;
+    const kind = options.kind ?? "node";
+    const config = (0, defaults_1.getConfig)();
+    const timeout = options.timeout ?? config.nodeTaskTimeout;
+    log(verbose, `Scanning for pending ${kind} tasks in ${runDir} (maxTasks=${maxTasks})`);
+    // Build the effect index from journal
+    const effectIndex = await (0, effectIndex_1.buildEffectIndex)({ runDir });
+    const pendingEffects = effectIndex.listPendingEffects();
+    if (pendingEffects.length === 0) {
+        log(verbose, "No pending effects found");
+        return {
+            action: "none",
+            count: 0,
+            reason: "no-pending-effects",
+            tasks: [],
+        };
+    }
+    // Filter by kind
+    const matchingEffects = pendingEffects.filter((record) => record.kind?.toLowerCase() === kind.toLowerCase());
+    if (matchingEffects.length === 0) {
+        log(verbose, `No pending effects matching kind="${kind}"`);
+        return {
+            action: "none",
+            count: 0,
+            reason: "no-matching-tasks",
+            tasks: [],
+        };
+    }
+    // Slice to maxTasks
+    const tasksToExecute = matchingEffects.slice(0, maxTasks);
+    log(verbose, `Found ${matchingEffects.length} matching tasks, executing ${tasksToExecute.length}`);
+    if (dryRun) {
+        const dryRunTasks = tasksToExecute.map((record) => ({
+            effectId: record.effectId,
+            label: record.label ?? null,
+            status: "ok",
+            exitCode: 0,
+            durationMs: 0,
+            stdoutRef: null,
+            stderrRef: null,
+            resultRef: null,
+        }));
+        return {
+            action: "none",
+            count: tasksToExecute.length,
+            reason: "dry-run",
+            tasks: dryRunTasks,
+        };
+    }
+    // Execute tasks sequentially
+    const taskSummaries = [];
+    for (const record of tasksToExecute) {
+        const summary = await executeOneTask(runDir, record, timeout, verbose);
+        taskSummaries.push(summary);
+    }
+    return {
+        action: "executed-tasks",
+        count: taskSummaries.length,
+        reason: "auto-runnable-tasks",
+        tasks: taskSummaries,
+    };
+}

package/dist/cli/commands/runIterate.d.ts

@@ -15,20 +15,24 @@ export interface RunIterateOptions {
     iteration?: number;
     verbose?: boolean;
     json?: boolean;
+    pluginRoot?: string;
 }
 export interface RunIterateResult {
     iteration: number;
+    iterationCount: number;
     status: "executed" | "waiting" | "completed" | "failed" | "none";
     action?: string;
     reason?: string;
     count?: number;
     until?: number;
     nextActions?: EffectAction[];
-    completionSecret?: string;
+    completionProof?: string;
     metadata?: {
         runId: string;
         processId: string;
         hookStatus?: string;
+        discoveredSkills?: string[];
+        discoveredAgents?: string[];
     };
 }
 export declare function runIterate(options: RunIterateOptions): Promise<RunIterateResult>;

package/dist/cli/commands/runIterate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runIterate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/runIterate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,YAAY,EAAE,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAgJtF"}
+{"version":3,"file":"runIterate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/runIterate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKxD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,YAAY,EAAE,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC5B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC7B,CAAC;CACH;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA+JtF"}

package/dist/cli/commands/runIterate.js

@@ -47,17 +47,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runIterate = runIterate;
 const path = __importStar(require("path"));
 const runFiles_1 = require("../../storage/runFiles");
+const journal_1 = require("../../storage/journal");
+const stateCache_1 = require("../../runtime/replay/stateCache");
 const runtime_1 = require("../../runtime/hooks/runtime");
 const orchestrateIteration_1 = require("../../runtime/orchestrateIteration");
-const completionSecret_1 = require("../completionSecret");
+const completionProof_1 = require("../completionProof");
+const skill_1 = require("./skill");
 async function runIterate(options) {
     const { runDir, verbose } = options;
     // Read run metadata
     const metadata = await (0, runFiles_1.readRunMetadata)(runDir);
     const runId = metadata.runId;
-    // Determine iteration number
-    // TODO: Read from state.json or journal
-    const iteration = options.iteration ?? 1;
+    // Determine iteration number from state cache or journal
+    const iterationCount = await detectIterationCount(runDir);
+    const iteration = options.iteration ?? (iterationCount + 1);
     const projectRoot = path.dirname(path.dirname(path.dirname(runDir)));
     if (verbose) {
         console.error(`[run:iterate] Starting iteration ${iteration} for run ${runId}`);
@@ -66,7 +69,7 @@ async function runIterate(options) {
     // This is what creates EFFECT_REQUESTED entries that hooks can observe via task:list.
     const iterationResult = await (0, orchestrateIteration_1.orchestrateIteration)({ runDir });
     if (iterationResult.status === "completed") {
-        const completionSecret = (0, completionSecret_1.resolveCompletionSecret)(metadata);
+        const completionProof = (0, completionProof_1.resolveCompletionProof)(metadata);
         await (0, runtime_1.callRuntimeHook)("on-iteration-end", {
             runId,
             iteration,
@@ -77,10 +80,11 @@ async function runIterate(options) {
         }, { cwd: projectRoot, logger: verbose ? ((msg) => console.error(msg)) : undefined });
         return {
             iteration,
+            iterationCount,
             status: "completed",
             action: "none",
             reason: "completed",
-            completionSecret,
+            completionProof,
             metadata: { runId, processId: metadata.processId, hookStatus: "executed" },
         };
     }
@@ -95,6 +99,7 @@ async function runIterate(options) {
         }, { cwd: projectRoot, logger: verbose ? ((msg) => console.error(msg)) : undefined });
         return {
             iteration,
+            iterationCount,
             status: "failed",
             action: "none",
             reason: "failed",
@@ -155,6 +160,7 @@ async function runIterate(options) {
     // Return result
     const result = {
         iteration,
+        iterationCount,
         status,
         action,
         reason,
@@ -167,8 +173,71 @@ async function runIterate(options) {
             hookStatus: hookResult.executedHooks?.length > 0 ? "executed" : "none",
         },
     };
+    // Discover available skills and agents
+    const pluginRoot = options.pluginRoot;
+    if (pluginRoot && result.metadata) {
+        try {
+            const discoverResult = await (0, skill_1.discoverSkillsInternal)({ pluginRoot, runId });
+            result.metadata.discoveredSkills = discoverResult.skills.map(s => s.name);
+            result.metadata.discoveredAgents = discoverResult.agents.map(a => a.name);
+        }
+        catch {
+            // Non-fatal
+        }
+    }
     return result;
 }
+/**
+ * Detect the current iteration count from state cache or journal.
+ *
+ * The iteration count represents how many iterations have been completed so far.
+ * This is used to determine the next iteration number when --iteration is not specified.
+ *
+ * Strategy:
+ * 1. Read from state.json (stateCache snapshot) if available - uses stateVersion
+ *    which tracks the journal sequence number
+ * 2. Fall back to counting RUN_ITERATION events in the journal
+ * 3. Return 0 if neither is available (fresh run)
+ */
+async function detectIterationCount(runDir) {
+    // Strategy 1: Read from state cache
+    try {
+        const stateCache = await (0, stateCache_1.readStateCache)(runDir);
+        if (stateCache && typeof stateCache.stateVersion === "number" && stateCache.stateVersion > 0) {
+            // stateVersion tracks journal sequence, which correlates to iteration progress
+            // We derive iteration count from the number of completed iteration cycles
+            // Each iteration typically produces multiple journal events, so we use
+            // RUN_ITERATION event count as the more accurate measure
+            const iterationCountFromJournal = await countIterationsFromJournal(runDir);
+            if (iterationCountFromJournal > 0) {
+                return iterationCountFromJournal;
+            }
+            // If no RUN_ITERATION events but we have state, estimate from stateVersion
+            // This provides backward compatibility for runs that don't log RUN_ITERATION
+            return Math.max(0, Math.floor(stateCache.stateVersion / 2));
+        }
+    }
+    catch {
+        // State cache not available, fall through to journal
+    }
+    // Strategy 2: Count RUN_ITERATION events in journal
+    try {
+        return await countIterationsFromJournal(runDir);
+    }
+    catch {
+        // Journal not available
+    }
+    // Strategy 3: Default to 0 for fresh runs
+    return 0;
+}
+/**
+ * Count the number of RUN_ITERATION events in the journal.
+ * Each RUN_ITERATION event represents one completed iteration.
+ */
+async function countIterationsFromJournal(runDir) {
+    const events = await (0, journal_1.loadJournal)(runDir);
+    return events.filter((event) => event.type === "RUN_ITERATION").length;
+}
 function parseHookDecision(output) {
     const record = parseMaybeJsonRecord(output);
     if (!record)

package/dist/cli/commands/session.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Session management CLI commands.
+ * Replaces bash logic from babysitter plugin shell scripts.
+ */
+/**
+ * Parsed arguments for session commands.
+ */
+export interface SessionCommandArgs {
+    sessionId?: string;
+    stateDir?: string;
+    maxIterations?: number;
+    runId?: string;
+    prompt?: string;
+    iteration?: number;
+    lastIterationAt?: string;
+    iterationTimes?: string;
+    delete?: boolean;
+    json: boolean;
+    runsDir?: string;
+}
+/**
+ * Handle session:init command.
+ * Initializes a new session state file.
+ */
+export declare function handleSessionInit(args: SessionCommandArgs): Promise<number>;
+/**
+ * Handle session:associate command.
+ * Associates a session with a run ID.
+ */
+export declare function handleSessionAssociate(args: SessionCommandArgs): Promise<number>;
+/**
+ * Handle session:resume command.
+ * Resumes an existing run in a new session.
+ */
+export declare function handleSessionResume(args: SessionCommandArgs): Promise<number>;
+/**
+ * Handle session:state command.
+ * Reads and returns session state.
+ */
+export declare function handleSessionState(args: SessionCommandArgs): Promise<number>;
+/**
+ * Handle session:update command.
+ * Updates session state fields.
+ */
+export declare function handleSessionUpdate(args: SessionCommandArgs): Promise<number>;
+/**
+ * Handle session:check-iteration command.
+ * Checks if iteration should continue based on timing and limits.
+ */
+export declare function handleSessionCheckIteration(args: SessionCommandArgs): Promise<number>;
+export interface SessionLastMessageArgs {
+    transcriptPath: string;
+    json: boolean;
+}
+export interface SessionLastMessageResult {
+    found: boolean;
+    text: string | null;
+    hasPromise: boolean;
+    promiseValue: string | null;
+    error?: string;
+}
+/**
+ * Parse a JSONL transcript file and extract the last assistant text message.
+ * Also detects <promise>...</promise> tags in the text.
+ */
+export declare function parseTranscriptLastAssistantMessage(content: string): {
+    found: boolean;
+    text: string | null;
+};
+/**
+ * Extract content from first <promise>...</promise> tag.
+ * Trims whitespace and collapses internal whitespace to single spaces.
+ */
+export declare function extractPromiseTag(text: string): string | null;
+export declare function handleSessionLastMessage(args: SessionLastMessageArgs): number;
+export interface SessionIterationMessageArgs {
+    runId?: string;
+    iteration?: number;
+    runsDir: string;
+    pluginRoot?: string;
+    json: boolean;
+}
+export interface SessionIterationMessageResult {
+    systemMessage: string;
+    runState: string | null;
+    completionProof: string | null;
+    pendingKinds: string | null;
+    skillContext: string | null;
+    iteration: number;
+}
+/**
+ * Handle session:iteration-message command.
+ * Generates the formatted system message for the next babysitter iteration.
+ * Replaces ~22 lines of bash branching + skill-context-resolver call in babysitter-stop-hook.sh.
+ */
+export declare function handleSessionIterationMessage(args: SessionIterationMessageArgs): Promise<number>;
+//# sourceMappingURL=session.d.ts.map

package/dist/cli/commands/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAuBH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CA0GjF;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoGtF;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CA0InF;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAmElF;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwGnF;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAyG3F;AAID,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,MAAM,GAAG;IACpE,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAoDA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI7D;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,sBAAsB,GAC3B,MAAM,CA+CR;AAID,MAAM,WAAW,2BAA2B;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,6BAA6B;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAcD;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,2BAA2B,GAChC,OAAO,CAAC,MAAM,CAAC,CA4GjB"}