@a5c-ai/babysitter-sdk 5.0.0 → 5.0.1-staging.04a3db697

package/dist/harness/hooks/stopHookHandler.js

@@ -0,0 +1,354 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStopHookCommon = handleStopHookCommon;
+/** Shared stop-hook handler: common 9-step sequence for ALL stop hooks. */
+const path = __importStar(require("node:path"));
+const parse_1 = require("../../session/parse");
+const transcript_1 = require("../../session/transcript");
+const write_1 = require("../../session/write");
+const utils_1 = require("./utils");
+const runState_1 = require("./runState");
+const stopHookContinuation_1 = require("./stopHookContinuation");
+const config_1 = require("../../config");
+function resolveSessionIdFromInput(hookInput, fields, fallback) {
+    for (const field of fields) {
+        const value = (0, utils_1.safeStr)(hookInput, field);
+        if (value)
+            return value;
+    }
+    // Try AGENT_SESSION_ID as universal fallback
+    if (process.env.AGENT_SESSION_ID) {
+        return process.env.AGENT_SESSION_ID;
+    }
+    if (fallback) {
+        return fallback() ?? "";
+    }
+    return "";
+}
+async function handleStopHookCommon(args, options) {
+    const { verbose } = args;
+    const log = (0, utils_1.createHookLogger)(options.logLabel ?? `babysitter-${options.harness}-stop-hook`);
+    log.info(`handleStopHook started (${options.harness})`);
+    // Read stdin
+    let rawInput;
+    if (args.stdinPayload !== undefined) {
+        rawInput = args.stdinPayload;
+    }
+    else {
+        try {
+            rawInput = await (0, utils_1.readStdin)();
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`stdin read error: ${msg}`);
+            if (verbose) {
+                process.stderr.write(`[hook:run stop] stdin read error: ${msg}\n`);
+            }
+            process.stdout.write("{}\n");
+            return makeExit(log, 0, "stdin_error");
+        }
+        finally {
+            if (typeof process.stdin.unref === "function") {
+                process.stdin.unref();
+            }
+        }
+    }
+    const hookInput = (0, utils_1.parseHookInput)(rawInput);
+    log.info("Hook input received");
+    // Get sessionId
+    const sessionId = resolveSessionIdFromInput(hookInput, options.sessionIdFields, options.resolveSessionIdFallback);
+    if (!sessionId) {
+        log.info("No session ID — allowing exit");
+        if (verbose) {
+            process.stderr.write("[hook:run stop] No session ID in hook input\n");
+        }
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "no_session_id");
+    }
+    log.setContext("session", sessionId);
+    const pluginRoot = args.pluginRoot
+        || resolvePluginRootFromEnv(options.pluginRootEnvVars ?? [])
+        || "";
+    const resolvedPluginRoot = pluginRoot ? path.resolve(pluginRoot) : "";
+    const stateDir = options.resolveStateDir(args);
+    if (!stateDir) {
+        log.warn("Cannot determine state directory — allowing exit");
+        if (verbose) {
+            process.stderr.write("[hook:run stop] Cannot determine state directory\n");
+        }
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "no_state_dir");
+    }
+    const runsDir = path.resolve(args.runsDir || (0, config_1.resolveRunsDir)());
+    let activeSessionId = sessionId;
+    let filePath = (0, parse_1.getSessionFilePath)(stateDir, activeSessionId);
+    log.info(`Checking session file at: ${filePath}`);
+    // Load session state (with env fallback retry)
+    let sessionFile;
+    try {
+        if (!(await (0, parse_1.sessionFileExists)(filePath))) {
+            // Retry with AGENT_SESSION_ID if the input session is stale
+            const envSessionId = process.env.AGENT_SESSION_ID;
+            if (envSessionId && envSessionId !== activeSessionId) {
+                log.info(`Payload session ${activeSessionId} is stale; env session is ${envSessionId} — retrying lookup`);
+                const retryPath = (0, parse_1.getSessionFilePath)(stateDir, envSessionId);
+                if (await (0, parse_1.sessionFileExists)(retryPath)) {
+                    filePath = retryPath;
+                    activeSessionId = envSessionId;
+                    log.setContext("session", activeSessionId);
+                    log.info(`Found session file for env session: ${filePath}`);
+                }
+                else {
+                    log.info(`No active loop found for session ${activeSessionId} or env session ${envSessionId} — allowing exit`);
+                    if (verbose) {
+                        process.stderr.write(`[hook:run stop] No active loop for session ${activeSessionId} or ${envSessionId}\n`);
+                    }
+                    process.stdout.write("{}\n");
+                    return makeExit(log, 0, "no_session_file");
+                }
+            }
+            else {
+                log.info(`No active loop found for session ${activeSessionId} — allowing exit`);
+                if (verbose) {
+                    process.stderr.write(`[hook:run stop] No active loop for session ${activeSessionId}\n`);
+                }
+                process.stdout.write("{}\n");
+                return makeExit(log, 0, "no_session_file");
+            }
+        }
+        sessionFile = await (0, parse_1.readSessionFile)(filePath);
+    }
+    catch {
+        log.warn(`Session file read error at ${filePath} — allowing exit`);
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "session_read_error");
+    }
+    const { state } = sessionFile;
+    const prompt = sessionFile.prompt ?? "";
+    if (!state.active) {
+        log.info("Session is inactive — allowing exit");
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "session_inactive", { sessionId: activeSessionId, filePath, state, prompt, resolvedPluginRoot, runsDir });
+    }
+    // Check max iterations
+    if (state.maxIterations > 0 && state.iteration >= state.maxIterations) {
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] Max iterations (${state.maxIterations}) reached\n`);
+        }
+        const runId = state.runId ?? "";
+        if (runId) {
+            const eventDir = state.runDir?.trim() || path.join(runsDir, runId);
+            await (0, utils_1.appendStopHookEvent)(eventDir, {
+                sessionId: activeSessionId,
+                iteration: state.iteration,
+                decision: "approve",
+                reason: "max_iterations_reached",
+                runState: "",
+                pendingKinds: "",
+                hasPromise: false,
+            }, options.harness);
+        }
+        await (0, utils_1.markSessionInactive)(filePath, state, prompt, "max_iterations_reached");
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "max_iterations_reached", { sessionId: activeSessionId, filePath, state, prompt, resolvedPluginRoot, runsDir });
+    }
+    // Check iteration speed
+    const now = (0, write_1.getCurrentTimestamp)();
+    const updatedTimes = state.iteration >= 5
+        ? (0, write_1.updateIterationTimes)(state.iterationTimes, state.lastIterationAt, now)
+        : state.iterationTimes;
+    // Extract promise from response
+    const runId = state.runId ?? "";
+    const boundRunDir = state.runDir?.trim() || undefined;
+    if (runId)
+        log.setContext("run", runId);
+    let hasPromise = false;
+    let promiseValue = null;
+    if (options.useDetailedRunState) {
+        const assistantState = (0, stopHookContinuation_1.parseAssistantStopState)(hookInput, log);
+        hasPromise = assistantState.hasPromise;
+        promiseValue = assistantState.promiseValue;
+    }
+    else {
+        const responseFields = options.responseFields ?? ["last_response", "prompt_response"];
+        for (const field of responseFields) {
+            const text = (0, utils_1.safeStr)(hookInput, field);
+            if (text) {
+                promiseValue = (0, transcript_1.extractPromiseTag)(text);
+                hasPromise = promiseValue !== null;
+                if (hasPromise)
+                    break;
+            }
+        }
+    }
+    // No runId → exit
+    if (!runId) {
+        log.info("No run associated with session — allowing exit");
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] No run for session ${activeSessionId}\n`);
+        }
+        await (0, utils_1.markSessionInactive)(filePath, state, prompt, "no_run_id");
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "no_run_id", { sessionId: activeSessionId, filePath, state, prompt, resolvedPluginRoot, runsDir });
+    }
+    // Resolve run state
+    let runStateDetails;
+    let runStateSummary;
+    let runState = "";
+    let completionProof = "";
+    let pendingKinds = "";
+    let onlyBreakpointsPending = false;
+    if (options.useDetailedRunState) {
+        runStateDetails = await (0, stopHookContinuation_1.resolveStopHookRunState)({
+            runId,
+            runsDir,
+            preferredRunDir: boundRunDir,
+            log,
+        });
+        runState = runStateDetails.runState;
+        completionProof = runStateDetails.completionProof;
+        pendingKinds = runStateDetails.pendingKinds;
+        onlyBreakpointsPending = runStateDetails.onlyBreakpointsPending;
+    }
+    else {
+        runStateSummary = await (0, runState_1.resolveHookRunState)({ runId, runsDir, log });
+        runState = runStateSummary.runState;
+        completionProof = runStateSummary.completionProof;
+        pendingKinds = runStateSummary.pendingKinds;
+        onlyBreakpointsPending = runStateSummary.onlyBreakpointsPending;
+    }
+    const runEventDir = runStateDetails?.runDir || boundRunDir || path.join(runsDir, runId);
+    log.info(`Run state: ${runState || "unknown"}`);
+    if (completionProof)
+        log.info("Completion proof available");
+    // Check terminal conditions
+    if (!runState) {
+        const errorMessage = runStateDetails?.lookupError ??
+            `Run ${runId} could not be resolved during the stop hook.`;
+        log.error(errorMessage);
+        process.stderr.write(`[hook:run stop] ${errorMessage}\n`);
+        await (0, utils_1.appendStopHookEvent)(runEventDir, {
+            sessionId: activeSessionId,
+            iteration: state.iteration,
+            decision: "approve",
+            reason: "run_state_unknown",
+            runState,
+            pendingKinds,
+            hasPromise,
+        }, options.harness);
+        process.stdout.write("{}\n");
+        return makeExit(log, options.useDetailedRunState ? 1 : 0, "run_state_unknown", { sessionId: activeSessionId, filePath, state, prompt, resolvedPluginRoot, runsDir });
+    }
+    if (runState === "waiting" && onlyBreakpointsPending) {
+        log.info(`Run waiting on breakpoints only (${pendingKinds}) — allowing exit`);
+        if (verbose) {
+            process.stderr.write("[hook:run stop] Run waiting on breakpoint(s) — allowing exit\n");
+        }
+        await (0, utils_1.appendStopHookEvent)(runEventDir, {
+            sessionId: activeSessionId,
+            iteration: state.iteration,
+            decision: "approve",
+            reason: "breakpoint_waiting",
+            runState,
+            pendingKinds,
+            hasPromise,
+        }, options.harness);
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "breakpoint_waiting", { sessionId: activeSessionId, filePath, state, prompt, resolvedPluginRoot, runsDir });
+    }
+    if (hasPromise && completionProof && promiseValue === completionProof) {
+        log.info("Promise matches completion proof — allowing exit");
+        if (verbose) {
+            process.stderr.write("[hook:run stop] Valid promise tag detected - run complete\n");
+        }
+        await (0, utils_1.appendStopHookEvent)(runEventDir, {
+            sessionId: activeSessionId,
+            iteration: state.iteration,
+            decision: "approve",
+            reason: "completion_proof_matched",
+            runState,
+            pendingKinds,
+            hasPromise,
+        }, options.harness);
+        await (0, utils_1.markSessionInactive)(filePath, state, prompt, "completion_proof_matched");
+        process.stdout.write("{}\n");
+        return makeExit(log, 0, "completion_proof_matched", { sessionId: activeSessionId, filePath, state, prompt, resolvedPluginRoot, runsDir });
+    }
+    // Should continue → update session and return
+    const nextIteration = state.iteration + 1;
+    const currentTime = (0, write_1.getCurrentTimestamp)();
+    const updatedState = {
+        ...state,
+        iteration: nextIteration,
+        lastIterationAt: currentTime,
+        iterationTimes: updatedTimes,
+    };
+    try {
+        await (0, write_1.writeSessionFile)(filePath, updatedState, prompt);
+    }
+    catch {
+        if (verbose) {
+            process.stderr.write("[hook:run stop] Failed to update session state\n");
+        }
+    }
+    await (0, utils_1.appendStopHookEvent)(runEventDir, {
+        sessionId: activeSessionId,
+        iteration: state.iteration,
+        decision: "block",
+        reason: "continue_loop",
+        runState,
+        pendingKinds,
+        hasPromise,
+    }, options.harness);
+    return { shouldContinue: true, exitCode: 0, sessionId: activeSessionId, filePath, state: updatedState,
+        prompt, runStateDetails, runStateSummary, hasPromise, promiseValue, resolvedPluginRoot,
+        runsDir, updatedTimes, nextIteration, log };
+}
+function resolvePluginRootFromEnv(envVars) {
+    for (const v of envVars) {
+        if (process.env[v])
+            return process.env[v];
+    }
+    return process.env.AGENT_PLUGIN_ROOT;
+}
+function makeExit(log, exitCode, reason, extra) {
+    return {
+        shouldContinue: false, exitCode, exitReason: reason,
+        sessionId: "", filePath: "", state: {}, prompt: "",
+        hasPromise: false, promiseValue: null, resolvedPluginRoot: "", runsDir: "",
+        updatedTimes: [], nextIteration: 0, log, ...extra,
+    };
+}

package/dist/harness/hooks/utils.d.ts

@@ -0,0 +1,43 @@
+import type { SessionState } from "../../session/types";
+export interface HookLogger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    setContext(key: string, value: string): void;
+}
+export declare function createHookLogger(hookName: string): HookLogger;
+export declare function readStdin(): Promise<string>;
+export declare function parseHookInput(raw: string): Record<string, unknown>;
+export declare function safeStr(obj: Record<string, unknown>, key: string): string;
+export declare function countPendingByKind(records: Array<{
+    kind?: string | null;
+}>): Record<string, number>;
+export declare function isOnlyBreakpoints(pendingByKind: Record<string, number>): boolean;
+export declare function appendStopHookEvent(runDir: string, data: {
+    sessionId: string;
+    iteration: number;
+    decision: "approve" | "block";
+    reason: string;
+    runState: string;
+    pendingKinds: string;
+    hasPromise: boolean;
+}, harness?: string): Promise<void>;
+export declare function markSessionInactive(filePath: string, state: SessionState, prompt: string, reason: string): Promise<void>;
+export declare function initializeSessionState(sessionId: string, stateDir: string, options?: {
+    maxIterations?: number;
+    verbose?: boolean;
+    log?: HookLogger;
+}): Promise<{
+    persisted: boolean;
+    filePath: string;
+}>;
+export interface IterationLimitResult {
+    shouldExit: boolean;
+    reason?: string;
+}
+export declare function checkIterationLimits(state: SessionState, maxIterations: number, _options?: {
+    minIterationMs?: number;
+    iterationTimes?: number[];
+}): IterationLimitResult;
+export declare function buildFollowupMessage(nextIteration: number, runId: string, completionProof: string | undefined, runState: string, pendingKinds: string, prompt: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/harness/hooks/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/harness/hooks/utils.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAMxD,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9C;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAoC7D;AAED,wBAAgB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAU3C;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAcnE;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,GACvC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASxB;AAED,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAGhF;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE;IACJ,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;CACrB,EACD,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,UAAU,CAAA;CAAE,GACxE,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAoCnD;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,YAAY,EACnB,aAAa,EAAE,MAAM,EACrB,QAAQ,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAChE,oBAAoB,CAKtB;AAED,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,MAAM,CASR"}

package/dist/harness/hooks/utils.js

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHookLogger = createHookLogger;
+exports.readStdin = readStdin;
+exports.parseHookInput = parseHookInput;
+exports.safeStr = safeStr;
+exports.countPendingByKind = countPendingByKind;
+exports.isOnlyBreakpoints = isOnlyBreakpoints;
+exports.appendStopHookEvent = appendStopHookEvent;
+exports.markSessionInactive = markSessionInactive;
+exports.initializeSessionState = initializeSessionState;
+exports.checkIterationLimits = checkIterationLimits;
+exports.buildFollowupMessage = buildFollowupMessage;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const config_1 = require("../../config");
+const journal_1 = require("../../storage/journal");
+const parse_1 = require("../../session/parse");
+const write_1 = require("../../session/write");
+function createHookLogger(hookName) {
+    const logDir = (0, config_1.getGlobalLogDir)();
+    const logFile = logDir ? path.join(logDir, `${hookName}.log`) : null;
+    const context = {};
+    if (logFile) {
+        try {
+            (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    function write(level, message) {
+        if (!logFile) {
+            return;
+        }
+        const ts = new Date().toISOString();
+        const ctxParts = Object.entries(context).map(([key, value]) => `${key}=${value}`);
+        const ctxStr = ctxParts.length > 0 ? ` [${ctxParts.join(" ")}]` : "";
+        const line = `[${level}] ${ts}${ctxStr} ${message}\n`;
+        try {
+            (0, node_fs_1.appendFileSync)(logFile, line);
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    return {
+        info: (message) => write("INFO", message),
+        warn: (message) => write("WARN", message),
+        error: (message) => write("ERROR", message),
+        setContext: (key, value) => {
+            context[key] = value;
+        },
+    };
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+function parseHookInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Malformed JSON — treat as empty
+    }
+    return {};
+}
+function safeStr(obj, key) {
+    const value = obj[key];
+    return typeof value === "string" ? value : "";
+}
+function countPendingByKind(records) {
+    const counts = new Map();
+    for (const record of records) {
+        const key = record.kind ?? "unknown";
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return Object.fromEntries(Array.from(counts.entries()).sort(([left], [right]) => left.localeCompare(right)));
+}
+function isOnlyBreakpoints(pendingByKind) {
+    const keys = Object.keys(pendingByKind);
+    return keys.length === 1 && keys[0] === "breakpoint";
+}
+async function appendStopHookEvent(runDir, data, harness) {
+    try {
+        await (0, journal_1.appendEvent)({
+            runDir,
+            eventType: "STOP_HOOK_INVOKED",
+            event: {
+                ...data,
+                ...(harness ? { harness } : {}),
+                timestamp: new Date().toISOString(),
+            },
+        });
+    }
+    catch {
+        // Best-effort
+    }
+}
+async function markSessionInactive(filePath, state, prompt, reason) {
+    try {
+        await (0, write_1.writeSessionFile)(filePath, {
+            ...state,
+            active: false,
+            metadata: {
+                ...(state.metadata ?? {}),
+                hookExitReason: reason,
+                hookExitedAt: (0, write_1.getCurrentTimestamp)(),
+            },
+        }, prompt);
+    }
+    catch {
+        // Best-effort
+    }
+}
+async function initializeSessionState(sessionId, stateDir, options) {
+    const filePath = (0, parse_1.getSessionFilePath)(stateDir, sessionId);
+    try {
+        if (!(await (0, parse_1.sessionFileExists)(filePath))) {
+            const nowTs = (0, write_1.getCurrentTimestamp)();
+            const state = {
+                active: true,
+                iteration: 1,
+                maxIterations: options?.maxIterations ?? config_1.DEFAULTS.maxIterations,
+                runId: "",
+                runIds: [],
+                startedAt: nowTs,
+                lastIterationAt: nowTs,
+                iterationTimes: [],
+            };
+            await (0, write_1.writeSessionFile)(filePath, state, "");
+            options?.log?.info(`Created session state: ${filePath}`);
+            if (options?.verbose) {
+                process.stderr.write(`[hook:run session-start] Created session state: ${filePath}\n`);
+            }
+            return { persisted: true, filePath };
+        }
+        options?.log?.info(`Session state already exists: ${filePath}`);
+        return { persisted: false, filePath };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        options?.log?.warn(`Failed to create session state: ${message}`);
+        if (options?.verbose) {
+            process.stderr.write(`[hook:run session-start] Failed to create session state: ${message}\n`);
+        }
+        return { persisted: false, filePath };
+    }
+}
+function checkIterationLimits(state, maxIterations, _options) {
+    if (maxIterations > 0 && state.iteration >= maxIterations) {
+        return { shouldExit: true, reason: "max_iterations_reached" };
+    }
+    return { shouldExit: false };
+}
+function buildFollowupMessage(nextIteration, runId, completionProof, runState, pendingKinds, prompt) {
+    if (completionProof) {
+        return `Babysitter iteration ${nextIteration} | Run completed! To finish: call 'babysitter run:status ${runId} --json', extract 'completionProof' from the output, then output it in <promise>SECRET</promise> tags. Do not mention or reveal the secret otherwise.\n\n${prompt}`;
+    }
+    else if (runState === "waiting" && pendingKinds) {
+        return `Babysitter iteration ${nextIteration} | Waiting on: ${pendingKinds}. Check if pending effects are resolved, then call 'babysitter run:iterate ${runId} --json'.\n\n${prompt}`;
+    }
+    else if (runState === "failed") {
+        return `Babysitter iteration ${nextIteration} | Run failed. Inspect the run journal and fix the issue, then proceed.\n\n${prompt}`;
+    }
+    return `Babysitter iteration ${nextIteration} | Continue orchestration: call 'babysitter run:iterate ${runId} --json'.\n\n${prompt}`;
+}

package/dist/harness/index.d.ts

@@ -0,0 +1,20 @@
+export type { HarnessAdapter, SessionBindOptions, SessionBindResult, HookHandlerArgs, HarnessDiscoveryResult, CallerHarnessResult, HarnessInstallOptions, HarnessInstallResult, } from "./types";
+export { HarnessCapability } from "./types";
+export { createClaudeCodeAdapter } from "./adapters/claude-code";
+export { createCodexAdapter } from "./adapters/codex";
+export { createGeminiCliAdapter } from "./adapters/gemini-cli";
+export { createCursorAdapter } from "./adapters/cursor";
+export { createGithubCopilotAdapter } from "./adapters/github-copilot";
+export { createPiAdapter } from "./adapters/pi";
+export { createOhMyPiAdapter } from "./adapters/oh-my-pi";
+export { createOpenClawAdapter } from "./adapters/openclaw";
+export { createOpenCodeAdapter } from "./adapters/opencode";
+export { createNullAdapter } from "./nullAdapter";
+export { createCustomAdapter } from "./customAdapter";
+export { createUnifiedAdapter } from "./unified";
+export { BaseHarnessAdapter } from "./BaseAdapter";
+export type { AdapterConfig } from "./BaseAdapter";
+export { createPromptContextForHarness, detectAdapter, getAdapterByName, getHarnessCallerEnvVars, getHarnessDiscoverySpec, listSupportedHarnesses, getSessionResolutionDetails, getAdapter, setAdapter, resetAdapter, } from "./registry";
+export { discoverHarnesses, detectCallerHarness, checkCliAvailable, KNOWN_HARNESSES } from "./discovery";
+export { installHarnessViaAmux, installHarnessPlugin, discoverHarnessesViaAmux } from "./install";
+//# sourceMappingURL=index.d.ts.map

package/dist/harness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/harness/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,6BAA6B,EAC7B,aAAa,EACb,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,2BAA2B,EAC3B,UAAU,EACV,UAAU,EACV,YAAY,GACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACzG,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC"}