@a5c-ai/babysitter-sdk 0.0.175 → 0.0.176-staging.83d08ece

package/dist/harness/geminiCli.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Gemini CLI harness adapter.
+ *
+ * Centralizes all Gemini CLI-specific behaviors:
+ *   - Session ID resolution (GEMINI_SESSION_ID env var or hook stdin)
+ *   - State directory conventions (.a5c/state/ by default)
+ *   - Extension path resolution (GEMINI_EXTENSION_PATH or script-relative)
+ *   - Session binding (run:create → state file with run association)
+ *   - AfterAgent hook handler (deny/approve decision — equivalent to Stop hook)
+ *   - SessionStart hook handler (baseline state file creation)
+ *
+ * Gemini CLI Hook Protocol:
+ *   - Input:  JSON via stdin
+ *   - Output: JSON via stdout (plain text MUST NOT appear on stdout)
+ *   - Stderr: debug/log output only
+ *   - Exit 0: success, stdout parsed as JSON
+ *   - Exit 2: system block (stderr used as rejection reason)
+ *
+ * AfterAgent hook output:
+ *   - `{}` or `{"decision":"allow"}` → allow session to exit normally
+ *   - `{"decision":"block","reason":"...","systemMessage":"..."}` → continue loop
+ *   - `{"decision":"deny","systemMessage":"..."}` → deny/retry (newer Gemini CLI)
+ *
+ * Gemini CLI environment variables available in hooks:
+ *   - GEMINI_SESSION_ID  — unique ID for the current Gemini CLI session
+ *   - GEMINI_PROJECT_DIR — absolute path to the project root
+ *   - GEMINI_CWD         — current working directory
+ */
+import type { HarnessAdapter } from "./types";
+export declare function createGeminiCliAdapter(): HarnessAdapter;
+//# sourceMappingURL=geminiCli.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geminiCli.d.ts","sourceRoot":"","sources":["../../src/harness/geminiCli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAsBH,OAAO,KAAK,EACV,cAAc,EAIf,MAAM,SAAS,CAAC;AAuuBjB,wBAAgB,sBAAsB,IAAI,cAAc,CAkEvD"}

package/dist/harness/geminiCli.js

@@ -0,0 +1,705 @@
+"use strict";
+/**
+ * Gemini CLI harness adapter.
+ *
+ * Centralizes all Gemini CLI-specific behaviors:
+ *   - Session ID resolution (GEMINI_SESSION_ID env var or hook stdin)
+ *   - State directory conventions (.a5c/state/ by default)
+ *   - Extension path resolution (GEMINI_EXTENSION_PATH or script-relative)
+ *   - Session binding (run:create → state file with run association)
+ *   - AfterAgent hook handler (deny/approve decision — equivalent to Stop hook)
+ *   - SessionStart hook handler (baseline state file creation)
+ *
+ * Gemini CLI Hook Protocol:
+ *   - Input:  JSON via stdin
+ *   - Output: JSON via stdout (plain text MUST NOT appear on stdout)
+ *   - Stderr: debug/log output only
+ *   - Exit 0: success, stdout parsed as JSON
+ *   - Exit 2: system block (stderr used as rejection reason)
+ *
+ * AfterAgent hook output:
+ *   - `{}` or `{"decision":"allow"}` → allow session to exit normally
+ *   - `{"decision":"block","reason":"...","systemMessage":"..."}` → continue loop
+ *   - `{"decision":"deny","systemMessage":"..."}` → deny/retry (newer Gemini CLI)
+ *
+ * Gemini CLI environment variables available in hooks:
+ *   - GEMINI_SESSION_ID  — unique ID for the current Gemini CLI session
+ *   - GEMINI_PROJECT_DIR — absolute path to the project root
+ *   - GEMINI_CWD         — current working directory
+ */
+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.createGeminiCliAdapter = createGeminiCliAdapter;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const journal_1 = require("../storage/journal");
+const runFiles_1 = require("../storage/runFiles");
+const effectIndex_1 = require("../runtime/replay/effectIndex");
+const completionProof_1 = require("../cli/completionProof");
+const session_1 = require("../session");
+const session_2 = require("../cli/commands/session");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const HARNESS_NAME = "gemini-cli";
+/** Default state directory for Gemini CLI sessions */
+const DEFAULT_STATE_DIR = ".a5c/state";
+function createHookLogger(hookName) {
+    const logDir = process.env.BABYSITTER_LOG_DIR || ".a5c/logs";
+    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(([k, v]) => `${k}=${v}`);
+        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: (msg) => write("INFO", msg),
+        warn: (msg) => write("WARN", msg),
+        error: (msg) => write("ERROR", msg),
+        setContext: (key, value) => {
+            context[key] = value;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Journal event helper
+// ---------------------------------------------------------------------------
+async function appendStopHookEvent(runDir, data) {
+    try {
+        await (0, journal_1.appendEvent)({
+            runDir,
+            eventType: "STOP_HOOK_INVOKED",
+            event: {
+                ...data,
+                harness: HARNESS_NAME,
+                timestamp: new Date().toISOString(),
+            },
+        });
+    }
+    catch {
+        // Best-effort: don't fail the hook if journal write fails
+    }
+}
+// ---------------------------------------------------------------------------
+// Stdin reader
+// ---------------------------------------------------------------------------
+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 val = obj[key];
+    return typeof val === "string" ? val : "";
+}
+// ---------------------------------------------------------------------------
+// Pending-by-kind helper
+// ---------------------------------------------------------------------------
+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(([a], [b]) => a.localeCompare(b)));
+}
+// ---------------------------------------------------------------------------
+// Cleanup helper
+// ---------------------------------------------------------------------------
+async function cleanupSession(filePath) {
+    try {
+        await (0, session_1.deleteSessionFile)(filePath);
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+// ---------------------------------------------------------------------------
+// State directory resolution
+// ---------------------------------------------------------------------------
+function resolveStateDirInternal(args) {
+    if (args.stateDir)
+        return path.resolve(args.stateDir);
+    if (args.pluginRoot) {
+        return path.resolve(args.pluginRoot, "state");
+    }
+    // Check Gemini CLI extension path env var
+    const extensionPath = process.env.GEMINI_EXTENSION_PATH ||
+        process.env.BABYSITTER_EXTENSION_PATH;
+    if (extensionPath) {
+        return path.resolve(extensionPath, "state");
+    }
+    // Default: project-relative .a5c/state/
+    return path.resolve(DEFAULT_STATE_DIR);
+}
+// ---------------------------------------------------------------------------
+// AfterAgent (Stop) hook handler
+// ---------------------------------------------------------------------------
+async function handleAfterAgentHookImpl(args) {
+    const { verbose } = args;
+    const log = createHookLogger("babysitter-after-agent-hook");
+    log.info("handleAfterAgentHook started");
+    // 1. Read hook input JSON from stdin
+    let rawInput;
+    try {
+        rawInput = await readStdin();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`stdin read error: ${msg}`);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    finally {
+        if (typeof process.stdin.unref === "function") {
+            process.stdin.unref();
+        }
+    }
+    const hookInput = parseHookInput(rawInput);
+    log.info("Hook input received");
+    // 2. Resolve session ID from hook input or env var
+    const sessionId = safeStr(hookInput, "session_id") ||
+        process.env.GEMINI_SESSION_ID ||
+        "";
+    if (!sessionId) {
+        log.info("No session ID in hook input — allowing exit");
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    log.setContext("session", sessionId);
+    log.info(`Session ID: ${sessionId}`);
+    // 3. Resolve state directory
+    const stateDir = resolveStateDirInternal(args);
+    const runsDir = args.runsDir || ".a5c/runs";
+    log.info(`Resolved stateDir: ${stateDir}`);
+    // 4. Read session state file
+    let filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    log.info(`Checking session file at: ${filePath}`);
+    let sessionFile;
+    try {
+        if (!(await (0, session_1.sessionFileExists)(filePath))) {
+            // Fallback: check .a5c/state/ directory
+            const fallbackPath = (0, session_1.getSessionFilePath)(path.resolve(DEFAULT_STATE_DIR), sessionId);
+            log.info(`Primary state file not found, trying fallback: ${fallbackPath}`);
+            if (await (0, session_1.sessionFileExists)(fallbackPath)) {
+                filePath = fallbackPath;
+                log.info(`Found session file at fallback path: ${filePath}`);
+            }
+            else {
+                log.info(`No active babysitter loop for session ${sessionId} — allowing exit`);
+                process.stdout.write("{}\n");
+                return 0;
+            }
+        }
+        sessionFile = await (0, session_1.readSessionFile)(filePath);
+    }
+    catch {
+        log.warn(`Session file read error at ${filePath} — allowing exit`);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    const { state } = sessionFile;
+    const prompt = sessionFile.prompt ?? "";
+    // 5. Check max iterations
+    if (state.maxIterations > 0 && state.iteration >= state.maxIterations) {
+        if (verbose) {
+            process.stderr.write(`[hook:run after-agent] Max iterations (${state.maxIterations}) reached\n`);
+        }
+        if (state.runId) {
+            await appendStopHookEvent(path.join(runsDir, state.runId), {
+                sessionId,
+                iteration: state.iteration,
+                decision: "approve",
+                reason: "max_iterations_reached",
+                runState: "",
+                pendingKinds: "",
+                hasPromise: false,
+            });
+        }
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 6. Check iteration timing (runaway loop detection)
+    const now = (0, session_1.getCurrentTimestamp)();
+    const updatedTimes = state.iteration >= 5
+        ? (0, session_1.updateIterationTimes)(state.iterationTimes, state.lastIterationAt, now)
+        : state.iterationTimes;
+    if ((0, session_1.isIterationTooFast)(updatedTimes)) {
+        if (verbose) {
+            process.stderr.write(`[hook:run after-agent] Iteration too fast\n`);
+        }
+        if (state.runId) {
+            await appendStopHookEvent(path.join(runsDir, state.runId), {
+                sessionId,
+                iteration: state.iteration,
+                decision: "approve",
+                reason: "iteration_too_fast",
+                runState: "",
+                pendingKinds: "",
+                hasPromise: false,
+            });
+        }
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    const iteration = state.iteration;
+    const maxIterations = state.maxIterations;
+    const runId = state.runId ?? "";
+    if (runId)
+        log.setContext("run", runId);
+    // 7. Extract last assistant message text for completion proof check
+    // Gemini CLI provides prompt_response directly in the hook input
+    const promptResponse = safeStr(hookInput, "prompt_response");
+    let hasPromise = false;
+    let promiseValue = null;
+    if (promptResponse) {
+        promiseValue = (0, session_2.extractPromiseTag)(promptResponse);
+        hasPromise = promiseValue !== null;
+        log.info(`prompt_response extracted (${promptResponse.length} chars)`);
+    }
+    // Fallback: check transcript_path if prompt_response is missing
+    if (!hasPromise) {
+        const transcriptPath = safeStr(hookInput, "transcript_path");
+        if (transcriptPath) {
+            const resolvedTranscript = path.resolve(transcriptPath);
+            if ((0, node_fs_1.existsSync)(resolvedTranscript)) {
+                try {
+                    const { readFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
+                    const content = readFileSync(resolvedTranscript, "utf-8");
+                    // Simple extraction: look for <promise>...</promise> anywhere
+                    promiseValue = (0, session_2.extractPromiseTag)(content);
+                    hasPromise = promiseValue !== null;
+                    log.info("Checked transcript for promise tag");
+                }
+                catch {
+                    log.warn(`Transcript read error: ${transcriptPath}`);
+                }
+            }
+        }
+    }
+    // 8. If no run is bound, allow exit
+    if (!runId) {
+        log.info("No run associated with session — allowing exit");
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 9. Get run state and completion proof
+    let runState = "";
+    let completionProof = "";
+    let pendingKinds = "";
+    try {
+        let runDir = path.isAbsolute(runId)
+            ? runId
+            : path.join(runsDir, runId);
+        // Fallback: search alternative locations
+        if (!(0, node_fs_1.existsSync)(path.join(runDir, "run.json")) &&
+            !path.isAbsolute(runId)) {
+            const alternatives = [
+                path.join(".a5c", ".a5c", "runs", runId),
+                path.join(".a5c", "runs", runId),
+            ];
+            for (const alt of alternatives) {
+                const resolved = path.resolve(alt);
+                if (resolved !== path.resolve(runDir) &&
+                    (0, node_fs_1.existsSync)(path.join(resolved, "run.json"))) {
+                    log.info(`Run not found at ${runDir}, using fallback: ${resolved}`);
+                    runDir = resolved;
+                    break;
+                }
+            }
+        }
+        const metadata = await (0, runFiles_1.readRunMetadata)(runDir);
+        const journal = await (0, journal_1.loadJournal)(runDir);
+        const index = await (0, effectIndex_1.buildEffectIndex)({ runDir, events: journal });
+        const hasCompleted = journal.some((e) => e.type === "RUN_COMPLETED");
+        const hasFailed = journal.some((e) => e.type === "RUN_FAILED");
+        const pendingRecords = index.listPendingEffects();
+        const pendingByKind = countPendingByKind(pendingRecords);
+        const kindKeys = Object.keys(pendingByKind);
+        if (kindKeys.length > 0) {
+            pendingKinds = kindKeys.join(", ");
+        }
+        if (hasCompleted) {
+            runState = "completed";
+            completionProof = (0, completionProof_1.resolveCompletionProof)(metadata);
+        }
+        else if (hasFailed) {
+            runState = "failed";
+        }
+        else if (pendingRecords.length > 0) {
+            runState = "waiting";
+        }
+        else {
+            runState = "created";
+        }
+    }
+    catch {
+        runState = "";
+    }
+    log.info(`Run state: ${runState || "unknown"}`);
+    if (completionProof)
+        log.info("Completion proof available");
+    if (!runState) {
+        log.warn(`Run state unknown for ${runId} — allowing exit`);
+        if (runId) {
+            await appendStopHookEvent(path.join(runsDir, runId), {
+                sessionId,
+                iteration: state.iteration,
+                decision: "approve",
+                reason: "run_state_unknown",
+                runState,
+                pendingKinds,
+                hasPromise,
+            });
+        }
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 10. Check completion proof match
+    if (hasPromise && completionProof && promiseValue === completionProof) {
+        log.info("Promise matches completion proof — allowing exit");
+        if (verbose) {
+            process.stderr.write(`[hook:run after-agent] Valid promise tag detected — run complete\n`);
+        }
+        if (runId) {
+            await appendStopHookEvent(path.join(runsDir, runId), {
+                sessionId,
+                iteration: state.iteration,
+                decision: "approve",
+                reason: "completion_proof_matched",
+                runState,
+                pendingKinds,
+                hasPromise,
+            });
+        }
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 11. Not complete — continue the loop
+    const nextIteration = iteration + 1;
+    const currentTime = (0, session_1.getCurrentTimestamp)();
+    const updatedState = {
+        ...state,
+        iteration: nextIteration,
+        lastIterationAt: currentTime,
+        iterationTimes: updatedTimes,
+    };
+    try {
+        await (0, session_1.writeSessionFile)(filePath, updatedState, prompt);
+    }
+    catch {
+        log.warn("Failed to update session state");
+    }
+    // 12. Build reason (re-injected as next turn prompt) and systemMessage (shown to user)
+    let iterationContext;
+    if (completionProof) {
+        iterationContext = `Babysitter iteration ${nextIteration} | Run completed! To finish: call 'babysitter run:status .a5c/runs/${runId} --json', extract 'completionProof' from the output, then output it in <promise>SECRET</promise> tags. Do not mention or reveal the secret otherwise.`;
+    }
+    else if (runState === "waiting" && pendingKinds) {
+        iterationContext = `Babysitter iteration ${nextIteration} | Waiting on: ${pendingKinds}. Check if pending effects are resolved, then call 'babysitter run:iterate .a5c/runs/${runId} --json'.`;
+    }
+    else if (runState === "failed") {
+        iterationContext = `Babysitter iteration ${nextIteration} | Run failed. Inspect the run journal and fix the issue, then proceed.`;
+    }
+    else {
+        iterationContext = `Babysitter iteration ${nextIteration} | Continue orchestration: call 'babysitter run:iterate .a5c/runs/${runId} --json'.`;
+    }
+    const reason = `${iterationContext}\n\n${prompt}`;
+    let systemMessage;
+    if (completionProof) {
+        systemMessage = `🔄 Babysitter iteration ${nextIteration}/${maxIterations} | Run completed! Extract promise tag to finish.`;
+    }
+    else if (runState === "waiting" && pendingKinds) {
+        systemMessage = `🔄 Babysitter iteration ${nextIteration}/${maxIterations} | Waiting on: ${pendingKinds}`;
+    }
+    else if (runState === "failed") {
+        systemMessage = `🔄 Babysitter iteration ${nextIteration}/${maxIterations} | Failed — check run state`;
+    }
+    else {
+        systemMessage = `🔄 Babysitter iteration ${nextIteration}/${maxIterations} [${runState}]`;
+    }
+    // Output: block decision (continue loop)
+    // Using "block" decision with reason re-injected as next prompt context.
+    // Gemini CLI honors this to start a new turn with the reason as prompt context.
+    const output = {
+        decision: "block",
+        reason,
+        systemMessage,
+    };
+    if (runId) {
+        await appendStopHookEvent(path.join(runsDir, runId), {
+            sessionId,
+            iteration: state.iteration,
+            decision: "block",
+            reason: "continue_loop",
+            runState,
+            pendingKinds,
+            hasPromise,
+        });
+    }
+    log.info(`Decision: block (iteration=${nextIteration}, maxIterations=${maxIterations})`);
+    if (verbose) {
+        process.stderr.write(`[hook:run after-agent] Blocking, iteration=${nextIteration} maxIterations=${maxIterations}\n`);
+    }
+    process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// SessionStart hook handler
+// ---------------------------------------------------------------------------
+async function handleSessionStartHookImpl(args) {
+    const { verbose } = args;
+    const log = createHookLogger("babysitter-session-start-hook");
+    log.info("handleSessionStartHook started (gemini-cli)");
+    // 1. Read hook input JSON from stdin
+    let rawInput;
+    try {
+        rawInput = await readStdin();
+    }
+    catch {
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    finally {
+        if (typeof process.stdin.unref === "function") {
+            process.stdin.unref();
+        }
+    }
+    const hookInput = parseHookInput(rawInput);
+    // 2. Resolve session ID
+    const sessionId = safeStr(hookInput, "session_id") ||
+        process.env.GEMINI_SESSION_ID ||
+        "";
+    if (!sessionId) {
+        log.info("No session ID in hook input — skipping state file creation");
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    log.setContext("session", sessionId);
+    log.info(`Session ID: ${sessionId}`);
+    // 3. Resolve state directory and create baseline session file
+    const stateDir = resolveStateDirInternal(args);
+    log.info(`Resolved stateDir: ${stateDir}`);
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    try {
+        if (!(await (0, session_1.sessionFileExists)(filePath))) {
+            const nowTs = (0, session_1.getCurrentTimestamp)();
+            const state = {
+                active: true,
+                iteration: 1,
+                maxIterations: 256,
+                runId: "",
+                startedAt: nowTs,
+                lastIterationAt: nowTs,
+                iterationTimes: [],
+            };
+            await (0, session_1.writeSessionFile)(filePath, state, "");
+            log.info(`Created session state: ${filePath}`);
+            if (verbose) {
+                process.stderr.write(`[hook:run session-start] Created session state: ${filePath}\n`);
+            }
+        }
+        else {
+            log.info(`Session state already exists: ${filePath}`);
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Failed to create session state: ${msg}`);
+        if (verbose) {
+            process.stderr.write(`[hook:run session-start] Failed to create session state: ${msg}\n`);
+        }
+    }
+    // 4. Output empty object (no additional context to inject at session start)
+    process.stdout.write("{}\n");
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Session binding (run:create flow)
+// ---------------------------------------------------------------------------
+async function bindSessionImpl(opts) {
+    const { sessionId, runId, maxIterations = 256, prompt, verbose } = opts;
+    // Resolve state directory
+    const stateDir = resolveStateDirInternal({
+        stateDir: opts.stateDir,
+        pluginRoot: opts.pluginRoot,
+    });
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    // Check for existing session (prevent re-entrant runs)
+    if (await (0, session_1.sessionFileExists)(filePath)) {
+        try {
+            const existing = await (0, session_1.readSessionFile)(filePath);
+            if (existing.state.runId && existing.state.runId !== runId) {
+                return {
+                    harness: HARNESS_NAME,
+                    sessionId,
+                    stateFile: filePath,
+                    error: `Session already associated with run: ${existing.state.runId}`,
+                };
+            }
+            // Update existing session with run ID
+            await (0, session_1.updateSessionState)(filePath, { runId, active: true }, { state: existing.state, prompt: existing.prompt });
+            if (verbose) {
+                process.stderr.write(`[run:create] Updated existing session ${sessionId} with run ${runId}\n`);
+            }
+            return { harness: HARNESS_NAME, sessionId, stateFile: filePath };
+        }
+        catch {
+            // Corrupted state file — overwrite
+        }
+    }
+    // Create new session state with run associated
+    const nowTs = (0, session_1.getCurrentTimestamp)();
+    const state = {
+        active: true,
+        iteration: 1,
+        maxIterations,
+        runId,
+        startedAt: nowTs,
+        lastIterationAt: nowTs,
+        iterationTimes: [],
+    };
+    try {
+        await (0, session_1.writeSessionFile)(filePath, state, prompt);
+    }
+    catch (e) {
+        return {
+            harness: HARNESS_NAME,
+            sessionId,
+            error: `Failed to write session state: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+    if (verbose) {
+        process.stderr.write(`[run:create] Session ${sessionId} initialized and bound to run ${runId}\n`);
+    }
+    return { harness: HARNESS_NAME, sessionId, stateFile: filePath };
+}
+// ---------------------------------------------------------------------------
+// Adapter factory
+// ---------------------------------------------------------------------------
+function createGeminiCliAdapter() {
+    return {
+        name: HARNESS_NAME,
+        isActive() {
+            return !!(process.env.GEMINI_SESSION_ID ||
+                process.env.GEMINI_PROJECT_DIR ||
+                process.env.GEMINI_CWD);
+        },
+        resolveSessionId(parsed) {
+            if (parsed.sessionId)
+                return parsed.sessionId;
+            if (process.env.GEMINI_SESSION_ID)
+                return process.env.GEMINI_SESSION_ID;
+            return undefined;
+        },
+        resolveStateDir(args) {
+            return resolveStateDirInternal(args);
+        },
+        resolvePluginRoot(args) {
+            const root = args.pluginRoot ||
+                process.env.GEMINI_EXTENSION_PATH ||
+                process.env.BABYSITTER_EXTENSION_PATH;
+            return root ? path.resolve(root) : undefined;
+        },
+        bindSession(opts) {
+            return bindSessionImpl(opts);
+        },
+        /**
+         * Handle the AfterAgent hook — the Gemini CLI equivalent of the Stop hook.
+         * Reads prompt_response (and optionally transcript_path) from stdin JSON,
+         * checks for the completion proof, and outputs block/approve decision.
+         */
+        handleStopHook(args) {
+            return handleAfterAgentHookImpl(args);
+        },
+        handleSessionStartHook(args) {
+            return handleSessionStartHookImpl(args);
+        },
+        findHookDispatcherPath(_startCwd) {
+            // Gemini CLI extensions don't use a hook dispatcher in the same way
+            const extensionPath = process.env.GEMINI_EXTENSION_PATH ||
+                process.env.BABYSITTER_EXTENSION_PATH;
+            if (extensionPath) {
+                const candidate = path.join(path.resolve(extensionPath), "hooks", "after-agent.sh");
+                if ((0, node_fs_1.existsSync)(candidate))
+                    return candidate;
+            }
+            return null;
+        },
+    };
+}

package/dist/harness/index.d.ts

@@ -1,5 +1,6 @@
 export type { HarnessAdapter, SessionBindOptions, SessionBindResult, HookHandlerArgs, } from "./types";
 export { createClaudeCodeAdapter } from "./claudeCode";
+export { createGeminiCliAdapter } from "./geminiCli";
 export { createNullAdapter } from "./nullAdapter";
 export { detectAdapter, getAdapterByName, listSupportedHarnesses, getAdapter, setAdapter, resetAdapter, } from "./registry";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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,GAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,sBAAsB,EACtB,UAAU,EACV,UAAU,EACV,YAAY,GACb,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/harness/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,GAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,sBAAsB,EACtB,UAAU,EACV,UAAU,EACV,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/harness/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetAdapter = exports.setAdapter = exports.getAdapter = exports.listSupportedHarnesses = exports.getAdapterByName = exports.detectAdapter = exports.createNullAdapter = exports.createClaudeCodeAdapter = void 0;
+exports.resetAdapter = exports.setAdapter = exports.getAdapter = exports.listSupportedHarnesses = exports.getAdapterByName = exports.detectAdapter = exports.createNullAdapter = exports.createGeminiCliAdapter = exports.createClaudeCodeAdapter = void 0;
 var claudeCode_1 = require("./claudeCode");
 Object.defineProperty(exports, "createClaudeCodeAdapter", { enumerable: true, get: function () { return claudeCode_1.createClaudeCodeAdapter; } });
+var geminiCli_1 = require("./geminiCli");
+Object.defineProperty(exports, "createGeminiCliAdapter", { enumerable: true, get: function () { return geminiCli_1.createGeminiCliAdapter; } });
 var nullAdapter_1 = require("./nullAdapter");
 Object.defineProperty(exports, "createNullAdapter", { enumerable: true, get: function () { return nullAdapter_1.createNullAdapter; } });
 var registry_1 = require("./registry");

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

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/harness/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAgB9C;;;GAGG;AACH,wBAAgB,aAAa,IAAI,cAAc,CAK9C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAKpE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAQD;;GAEG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAK3C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/harness/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAkB9C;;;GAGG;AACH,wBAAgB,aAAa,IAAI,cAAc,CAK9C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAKpE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAQD;;GAEG;AACH,wBAAgB,UAAU,IAAI,cAAc,CAK3C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC"}

package/dist/harness/registry.js

@@ -14,12 +14,14 @@ exports.getAdapter = getAdapter;
 exports.setAdapter = setAdapter;
 exports.resetAdapter = resetAdapter;
 const claudeCode_1 = require("./claudeCode");
+const geminiCli_1 = require("./geminiCli");
 const nullAdapter_1 = require("./nullAdapter");
 // ---------------------------------------------------------------------------
 // Registry of known adapters (ordered by priority)
 // ---------------------------------------------------------------------------
 const knownAdapters = [
     (0, claudeCode_1.createClaudeCodeAdapter)(),
+    (0, geminiCli_1.createGeminiCliAdapter)(),
 ];
 // ---------------------------------------------------------------------------
 // Auto-detection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a5c-ai/babysitter-sdk",
-  "version": "0.0.175",
+  "version": "0.0.176-staging.83d08ece",
   "description": "Storage and run-registry primitives for event-sourced babysitter workflows.",
   "license": "UNLICENSED",
   "type": "commonjs",