@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/cli/commands/harness/resumeRun.js

@@ -0,0 +1,341 @@
+"use strict";
+/**
+ * resume-run command handler.
+ * Uses an agentic Pi session to discover existing runs, present them to the
+ * user, assess state, and resume orchestration via handleHarnessCreateRun.
+ */
+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.handleHarnessResumeRun = handleHarnessResumeRun;
+const path = __importStar(require("node:path"));
+const typebox_1 = require("@sinclair/typebox");
+const agent_core_1 = require("@a5c-ai/agent-core");
+const agent_core_2 = require("@a5c-ai/agent-core");
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const createRun_1 = require("./createRun");
+const utils_1 = require("../../../harness/internal/createRun/utils");
+const resumeState_1 = require("../../../harness/internal/createRun/resumeState");
+function errorResult(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+    };
+}
+// ---------------------------------------------------------------------------
+// System prompt
+// ---------------------------------------------------------------------------
+function buildResumeSystemPrompt(runsDir, runIdHint) {
+    const parts = [
+        "You are an assistant that helps users find and resume babysitter orchestration runs.",
+        "",
+        "## Your workflow",
+        "",
+        "1. **Discover runs** -- call `babysitter_list_runs` to list recent runs.",
+        runIdHint
+            ? `2. The user has requested run ID "${runIdHint}". Call \`babysitter_assess_run\` with that run ID to inspect it.`
+            : "2. Present the runs to the user. If there are multiple, use `AskUserQuestion` to let them pick one.",
+        "3. **Assess** the selected run by calling `babysitter_assess_run` with the run ID.",
+        "4. Show the user the run's state (status, pending effects, journal summary).",
+        "5. If the run is resumable (not completed), call `babysitter_resume_run` to resume it.",
+        "6. If the run is already completed, tell the user and stop.",
+        "",
+        "## Important rules",
+        "",
+        "- Always call `babysitter_list_runs` first to see what's available.",
+        "- Use `AskUserQuestion` for interactive selection when there are multiple runs.",
+        "- You may also use read, grep, bash and other tools to inspect run files in " + runsDir + " if more detail is needed.",
+        "- Call `babysitter_resume_run` exactly once when ready to resume.",
+        "- Do NOT attempt to modify run files yourself -- only use the provided resume tool.",
+    ];
+    return parts.join("\n");
+}
+function buildResumeUserPrompt(runIdHint) {
+    if (runIdHint) {
+        return `Resume the run with ID "${runIdHint}". Assess it and proceed.`;
+    }
+    return "Help me find and resume a babysitter run. Start by listing the available runs.";
+}
+// ---------------------------------------------------------------------------
+// Main handler
+// ---------------------------------------------------------------------------
+async function handleHarnessResumeRun(args) {
+    const { json, verbose, interactive = true, } = args;
+    const runsDir = args.runsDir ?? (0, babysitter_sdk_1.resolveRunsDir)({ cwd: args.workspace ?? process.cwd() });
+    const outputMode = args.outputMode;
+    const writeVerbose = (message) => {
+        (0, utils_1.writeVerboseLine)(verbose, json, message, outputMode);
+    };
+    const writeVerboseData = (label, value, maxChars) => {
+        (0, utils_1.writeVerboseBlock)(verbose, json, label, value, maxChars, outputMode);
+    };
+    // Track whether the agent has triggered a resume (set by the resume tool).
+    let resumeTriggered = false;
+    let resumeExitCode = 0;
+    // -----------------------------------------------------------------
+    // Define domain-specific tools
+    // -----------------------------------------------------------------
+    const customTools = [
+        {
+            name: "babysitter_list_runs",
+            label: "List Runs",
+            description: "List recent runs in the runs directory with status and metadata. " +
+                "Returns up to 20 runs sorted by most recent first.",
+            parameters: typebox_1.Type.Object({
+                statusFilter: typebox_1.Type.Optional(typebox_1.Type.String({ description: "Optional status filter: created, in-progress, waiting, failed, completed" })),
+            }),
+            execute: async (_toolCallId, params) => {
+                writeVerboseData("resume tool babysitter_list_runs", params);
+                try {
+                    let runs = await (0, resumeState_1.discoverRuns)(runsDir);
+                    if (params.statusFilter) {
+                        runs = runs.filter((r) => r.status === params.statusFilter);
+                    }
+                    if (runs.length === 0) {
+                        return (0, utils_1.formatToolResult)({ runs: [], runsDir }, "No runs found.");
+                    }
+                    const summary = runs.map((r) => ({
+                        runId: r.runId,
+                        processId: r.processId,
+                        status: r.status,
+                        createdAt: r.createdAt,
+                        prompt: r.prompt
+                            ? r.prompt.length > 80 ? r.prompt.slice(0, 77) + "..." : r.prompt
+                            : undefined,
+                        effects: `${r.resolvedEffects}/${r.totalEffects} resolved`,
+                        pendingEffects: r.pendingEffects,
+                    }));
+                    return (0, utils_1.formatToolResult)({ count: runs.length, runs: summary }, `Found ${runs.length} run(s).`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return errorResult(`Failed to list runs: ${msg}`);
+                }
+            },
+        },
+        {
+            name: "babysitter_assess_run",
+            label: "Assess Run",
+            description: "Get detailed state assessment for a specific run by ID. " +
+                "Returns status, effects, journal summary, and entrypoint info.",
+            parameters: typebox_1.Type.Object({
+                runId: typebox_1.Type.String({ description: "The run ID (or prefix) to assess" }),
+            }),
+            execute: async (_toolCallId, params) => {
+                writeVerboseData("resume tool babysitter_assess_run", params);
+                const runDir = (0, babysitter_sdk_1.resolveExistingRunDir)(params.runId, {
+                    cwd: args.workspace ?? process.cwd(),
+                    override: runsDir,
+                });
+                try {
+                    const assessment = await (0, resumeState_1.assessRun)(runDir);
+                    return (0, utils_1.formatToolResult)({
+                        runId: assessment.run.runId,
+                        processId: assessment.run.processId,
+                        status: assessment.run.status,
+                        createdAt: assessment.run.createdAt,
+                        prompt: assessment.run.prompt,
+                        totalEffects: assessment.run.totalEffects,
+                        resolvedEffects: assessment.run.resolvedEffects,
+                        pendingEffects: assessment.run.pendingEffects,
+                        journalEvents: assessment.journalLength,
+                        lastEvent: assessment.lastEvent,
+                        entrypoint: assessment.run.entrypoint,
+                        runDir: assessment.run.runDir,
+                        resumable: assessment.run.status !== "completed",
+                    }, `Run ${assessment.run.runId} assessed.`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return errorResult(`Failed to assess run "${params.runId}": ${msg}`);
+                }
+            },
+        },
+        {
+            name: "babysitter_resume_run",
+            label: "Resume Run",
+            description: "Resume orchestration for a specific run. Call this exactly once " +
+                "after assessing the run and confirming it should be resumed.",
+            parameters: typebox_1.Type.Object({
+                runId: typebox_1.Type.String({ description: "The run ID to resume" }),
+            }),
+            execute: async (_toolCallId, params) => {
+                writeVerboseData("resume tool babysitter_resume_run", params);
+                if (resumeTriggered) {
+                    return errorResult("Resume has already been triggered for this session.");
+                }
+                const runDir = (0, babysitter_sdk_1.resolveExistingRunDir)(params.runId, {
+                    cwd: args.workspace ?? process.cwd(),
+                    override: runsDir,
+                });
+                try {
+                    const assessment = await (0, resumeState_1.assessRun)(runDir);
+                    const selectedRun = assessment.run;
+                    if (selectedRun.status === "completed") {
+                        return (0, utils_1.formatToolResult)({ runId: selectedRun.runId, status: "completed" }, "Run is already completed. Nothing to resume.");
+                    }
+                    resumeTriggered = true;
+                    if (!json && outputMode !== "tui") {
+                        process.stderr.write(`${utils_1.MAGENTA}Resuming run ${utils_1.BOLD}${selectedRun.runId}${utils_1.RESET}${utils_1.MAGENTA}...${utils_1.RESET}\n\n`);
+                    }
+                    // Resolve the process entry path
+                    const entryImportPath = selectedRun.entrypoint.importPath;
+                    const processPath = path.isAbsolute(entryImportPath)
+                        ? entryImportPath
+                        : path.resolve(entryImportPath);
+                    resumeExitCode = await (0, createRun_1.handleHarnessCreateRun)({
+                        processPath,
+                        prompt: selectedRun.prompt,
+                        harness: args.harness,
+                        workspace: args.workspace,
+                        model: args.model,
+                        maxIterations: args.maxIterations,
+                        runsDir: args.runsDir,
+                        json: args.json,
+                        verbose: args.verbose,
+                        interactive: args.interactive,
+                        existingRunId: selectedRun.runId,
+                        existingRunDir: selectedRun.runDir,
+                        outputMode,
+                    });
+                    return (0, utils_1.formatToolResult)({ runId: selectedRun.runId, exitCode: resumeExitCode }, resumeExitCode === 0
+                        ? "Run resumed successfully."
+                        : `Run resume completed with exit code ${resumeExitCode}.`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return errorResult(`Failed to resume run "${params.runId}": ${msg}`);
+                }
+            },
+        },
+    ];
+    // -----------------------------------------------------------------
+    // Build agentic tools (read/write/edit/grep/bash/etc.)
+    // -----------------------------------------------------------------
+    const agenticTools = (0, agent_core_2.createAgentCoreToolDefinitions)({
+        workspace: args.workspace ?? process.cwd(),
+        interactive: interactive,
+        askUserQuestionHandler: interactive
+            ? undefined // Let the default AskUserQuestion handler work
+            : undefined,
+    });
+    const mergedCustomTools = [...customTools, ...agenticTools];
+    writeVerbose(`[resume setup] runsDir=${runsDir} workspace=${path.resolve(args.workspace ?? process.cwd())} model=${args.model ?? "(default)"}`);
+    writeVerboseData("resume tools", mergedCustomTools.map((tool) => ({
+        name: tool.name,
+        label: tool.label,
+    })));
+    // -----------------------------------------------------------------
+    // Create Pi session
+    // -----------------------------------------------------------------
+    const systemPrompt = buildResumeSystemPrompt(runsDir, args.runId);
+    const userPrompt = buildResumeUserPrompt(args.runId);
+    writeVerboseData("resume system prompt", systemPrompt);
+    writeVerboseData("resume user prompt", userPrompt);
+    let session = null;
+    try {
+        session = (0, agent_core_1.createAgentCoreSession)({
+            workspace: args.workspace,
+            model: args.model,
+            thinkingLevel: "low",
+            toolsMode: "coding",
+            customTools: mergedCustomTools,
+            systemPrompt,
+            isolated: true,
+            ephemeral: true,
+        });
+        await session.initialize();
+        // Subscribe to stream text output to stderr in non-JSON mode
+        let unsubscribe = null;
+        if (!json && outputMode !== "tui") {
+            process.stderr.write(`\n${utils_1.BOLD}${utils_1.MAGENTA}Run Discovery${utils_1.RESET} ${utils_1.DIM}Agent is searching for runs...${utils_1.RESET}\n\n`);
+            unsubscribe = session.subscribe((event) => {
+                if (event.type === "text_delta") {
+                    const text = event.text;
+                    if (text)
+                        process.stderr.write(text);
+                }
+            });
+        }
+        // Prompt the agent
+        const result = await session.prompt(userPrompt, 300_000);
+        if (unsubscribe)
+            unsubscribe();
+        if (!json && outputMode !== "tui")
+            process.stderr.write("\n");
+        writeVerboseData("resume agent result", {
+            success: result.success,
+            outputPreview: result.output.length > 500
+                ? result.output.slice(0, 497) + "..."
+                : result.output,
+            resumeTriggered,
+        });
+        if (!result.success && !resumeTriggered) {
+            if (json) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "Resume agent failed", details: result.output }) + "\n");
+            }
+            else if (outputMode !== "tui") {
+                process.stderr.write(`${utils_1.RED}Resume agent failed:${utils_1.RESET} ${result.output}\n`);
+            }
+            return 1;
+        }
+        // If the agent never triggered resume, it decided not to (e.g., no runs or user quit)
+        if (!resumeTriggered) {
+            if (json) {
+                process.stdout.write(JSON.stringify({ ok: true, resumed: false, message: "No run was resumed" }) + "\n");
+            }
+            return 0;
+        }
+        return resumeExitCode;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (json) {
+            process.stdout.write(JSON.stringify({ ok: false, error: "Resume session failed", details: message }) + "\n");
+        }
+        else if (outputMode !== "tui") {
+            process.stderr.write(`${utils_1.RED}Error:${utils_1.RESET} ${message}\n`);
+        }
+        return 1;
+    }
+    finally {
+        if (session) {
+            try {
+                session.dispose();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * GAP-JSON-004: Streaming JSONL CLI Mode (stdin/stdout).
+ *
+ * Reads JSONL requests from stdin, dispatches to API functions, writes
+ * JSONL responses to stdout. Enables programmatic control from any
+ * language via process pipes — no HTTP, no WebSocket.
+ */
+import type { ApiResult } from "../../api/runs";
+interface ParsedRequest {
+    id: string;
+    method: string;
+    params: Record<string, unknown>;
+}
+interface ParseError {
+    id: null;
+    error: {
+        code: string;
+        message: string;
+    };
+}
+interface StreamOptions {
+    stdin: NodeJS.ReadableStream;
+    stdout: NodeJS.WritableStream;
+}
+export declare const SUPPORTED_METHODS: readonly ["run.create", "run.iterate", "run.status", "run.events", "effect.commit", "effect.list", "effect.show", "effect.cancel", "effect.batchCommit", "breakpoint.list", "breakpoint.show", "breakpoint.respond", "breakpoint.listRules", "breakpoint.addRule", "breakpoint.removeRule", "breakpoint.evaluateAutoApproval", "event.subscribe", "event.unsubscribe", "shutdown"];
+export declare function parseJsonlRequest(line: string): ParsedRequest | ParseError;
+export declare function formatJsonlResponse(id: string | null, result: ApiResult<unknown>): string;
+export declare function dispatchJsonlMethod(method: string, params: Record<string, unknown>, defaults: {
+    runsDir: string;
+}): Promise<ApiResult<unknown>>;
+export declare function handleJsonlInteractive(args: {
+    runsDir: string;
+}, streamOpts?: StreamOptions): Promise<number>;
+export {};
+//# sourceMappingURL=jsonlInteractive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonlInteractive.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/jsonlInteractive.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA8BH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD,UAAU,aAAa;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,UAAU,UAAU;IAClB,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C;AAED,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B;AAID,eAAO,MAAM,iBAAiB,oXAoBpB,CAAC;AAIX,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,UAAU,CAyC1E;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,MAAM,CAWzF;AAID,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,QAAQ,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAC5B,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAoJ7B;AAMD,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EACzB,UAAU,CAAC,EAAE,aAAa,GACzB,OAAO,CAAC,MAAM,CAAC,CAqFjB"}

package/dist/cli/commands/jsonlInteractive.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * GAP-JSON-004: Streaming JSONL CLI Mode (stdin/stdout).
+ *
+ * Reads JSONL requests from stdin, dispatches to API functions, writes
+ * JSONL responses to stdout. Enables programmatic control from any
+ * language via process pipes — no HTTP, no WebSocket.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_METHODS = void 0;
+exports.parseJsonlRequest = parseJsonlRequest;
+exports.formatJsonlResponse = formatJsonlResponse;
+exports.dispatchJsonlMethod = dispatchJsonlMethod;
+exports.handleJsonlInteractive = handleJsonlInteractive;
+const node_readline_1 = require("node:readline");
+const runs_1 = require("../../api/runs");
+const effects_1 = require("../../api/effects");
+const breakpoints_1 = require("../../api/breakpoints");
+const eventStream_1 = require("../../api/eventStream");
+// ── Supported methods ──────────────────────────────────────────────────────
+exports.SUPPORTED_METHODS = [
+    "run.create",
+    "run.iterate",
+    "run.status",
+    "run.events",
+    "effect.commit",
+    "effect.list",
+    "effect.show",
+    "effect.cancel",
+    "effect.batchCommit",
+    "breakpoint.list",
+    "breakpoint.show",
+    "breakpoint.respond",
+    "breakpoint.listRules",
+    "breakpoint.addRule",
+    "breakpoint.removeRule",
+    "breakpoint.evaluateAutoApproval",
+    "event.subscribe",
+    "event.unsubscribe",
+    "shutdown",
+];
+// ── Pure functions ─────────────────────────────────────────────────────────
+function parseJsonlRequest(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return {
+            id: null,
+            error: { code: "INVALID_REQUEST", message: "Malformed JSON" },
+        };
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return {
+            id: null,
+            error: { code: "INVALID_REQUEST", message: "Request must be a JSON object" },
+        };
+    }
+    const obj = parsed;
+    if (obj.id === undefined || obj.id === null) {
+        return {
+            id: null,
+            error: { code: "INVALID_REQUEST", message: "Missing required field: id" },
+        };
+    }
+    if (typeof obj.method !== "string" || !obj.method) {
+        return {
+            id: null,
+            error: { code: "INVALID_REQUEST", message: "Missing required field: method" },
+        };
+    }
+    return {
+        id: String(obj.id),
+        method: obj.method,
+        params: (typeof obj.params === "object" && obj.params !== null && !Array.isArray(obj.params))
+            ? obj.params
+            : {},
+    };
+}
+function formatJsonlResponse(id, result) {
+    try {
+        if (result.ok) {
+            return JSON.stringify({ id, result: result.data });
+        }
+        else {
+            return JSON.stringify({ id, error: result.error });
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return JSON.stringify({ id, error: { code: "SERIALIZATION_ERROR", message: msg } });
+    }
+}
+// ── Dispatch table ─────────────────────────────────────────────────────────
+async function dispatchJsonlMethod(method, params, defaults) {
+    try {
+        const p = params;
+        const runsDir = (typeof p.runsDir === "string" ? p.runsDir : defaults.runsDir);
+        switch (method) {
+            // ── Run lifecycle ──
+            case "run.create":
+                return (0, runs_1.apiCreateRun)({
+                    processId: p.processId,
+                    entrypoint: p.entrypoint,
+                    runsDir,
+                    inputs: p.inputs,
+                    prompt: p.prompt,
+                });
+            case "run.iterate":
+                return (0, runs_1.apiIterate)({ runDir: p.runDir });
+            case "run.status":
+                return (0, runs_1.apiRunStatus)({ runId: p.runId, runsDir });
+            case "run.events":
+                return (0, runs_1.apiRunEvents)({
+                    runId: p.runId,
+                    runsDir,
+                    limit: typeof p.limit === "number" ? p.limit : undefined,
+                    filterType: typeof p.filterType === "string" ? p.filterType : undefined,
+                });
+            // ── Effect dispatch ──
+            case "effect.commit":
+                return (0, runs_1.apiCommitEffect)({
+                    runDir: p.runDir,
+                    effectId: p.effectId,
+                    result: p.result,
+                });
+            case "effect.list":
+                return (0, effects_1.apiListEffects)({
+                    runDir: p.runDir,
+                    filter: p.filter,
+                });
+            case "effect.show":
+                return (0, effects_1.apiShowEffect)({
+                    runDir: p.runDir,
+                    effectId: p.effectId,
+                });
+            case "effect.cancel":
+                return (0, effects_1.apiCancelEffect)({
+                    runDir: p.runDir,
+                    effectId: p.effectId,
+                    reason: p.reason,
+                });
+            case "effect.batchCommit":
+                return (0, effects_1.apiBatchCommitEffects)({
+                    runDir: p.runDir,
+                    effects: p.effects,
+                });
+            // ── Breakpoint interaction ──
+            case "breakpoint.list":
+                return (0, breakpoints_1.apiListBreakpoints)({ runDir: p.runDir });
+            case "breakpoint.show":
+                return (0, breakpoints_1.apiShowBreakpoint)({
+                    runDir: p.runDir,
+                    effectId: p.effectId,
+                });
+            case "breakpoint.respond":
+                return (0, breakpoints_1.apiRespondToBreakpoint)({
+                    runDir: p.runDir,
+                    effectId: p.effectId,
+                    approved: p.approved,
+                    response: p.response,
+                    feedback: p.feedback,
+                    option: p.option,
+                    respondedBy: p.respondedBy,
+                });
+            case "breakpoint.listRules":
+                return (0, breakpoints_1.apiListAutoApprovalRules)({ rulesPath: p.rulesPath });
+            case "breakpoint.addRule":
+                return (0, breakpoints_1.apiAddAutoApprovalRule)({
+                    pattern: p.pattern,
+                    action: p.action,
+                    createdBy: p.createdBy,
+                    id: p.id,
+                    source: p.source,
+                    note: p.note,
+                    rulesPath: p.rulesPath,
+                });
+            case "breakpoint.removeRule":
+                return (0, breakpoints_1.apiRemoveAutoApprovalRule)({
+                    ruleId: p.ruleId,
+                    rulesPath: p.rulesPath,
+                });
+            case "breakpoint.evaluateAutoApproval":
+                return (0, breakpoints_1.apiEvaluateAutoApproval)({
+                    breakpointId: p.breakpointId,
+                    tags: p.tags,
+                    expert: p.expert,
+                    rulesPath: p.rulesPath,
+                    autoApproveAfterN: p.autoApproveAfterN,
+                    consecutiveApprovals: p.consecutiveApprovals,
+                });
+            // ── Event streaming ──
+            case "event.subscribe": {
+                const subResult = await (0, eventStream_1.apiSubscribeRunEvents)({
+                    runId: p.runId,
+                    runsDir,
+                    afterSeq: typeof p.afterSeq === "number" ? p.afterSeq : undefined,
+                    pollIntervalMs: typeof p.pollIntervalMs === "number" ? p.pollIntervalMs : undefined,
+                    onEvent: () => {
+                        // Events are consumed via polling; JSONL doesn't push events
+                    },
+                });
+                return subResult;
+            }
+            case "event.unsubscribe":
+                return (0, eventStream_1.apiUnsubscribeRunEvents)({
+                    subscriptionId: p.subscriptionId,
+                });
+            // ── Control ──
+            case "shutdown":
+                (0, eventStream_1.closeAllSubscriptions)();
+                return { ok: true, data: { ok: true } };
+            default:
+                return {
+                    ok: false,
+                    error: { code: "UNKNOWN_METHOD", message: `Unknown method: ${method}` },
+                };
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: { code: "INTERNAL_ERROR", message: msg } };
+    }
+}
+// ── Main handler ───────────────────────────────────────────────────────────
+const MAX_PENDING_QUEUE = 100;
+async function handleJsonlInteractive(args, streamOpts) {
+    const stdin = streamOpts?.stdin ?? process.stdin;
+    const stdout = streamOpts?.stdout ?? process.stdout;
+    const writeLine = (line) => {
+        return stdout.write(line + "\n");
+    };
+    // Emit ready notification
+    writeLine(JSON.stringify({
+        jsonl: "ready",
+        version: 1,
+        methods: [...exports.SUPPORTED_METHODS],
+    }));
+    const rl = (0, node_readline_1.createInterface)({
+        input: stdin,
+        crlfDelay: Infinity,
+    });
+    let shutdownRequested = false;
+    let activeCount = 0;
+    const pending = new Set();
+    const processLine = async (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        const parsed = parseJsonlRequest(trimmed);
+        if ("error" in parsed) {
+            writeLine(formatJsonlResponse(parsed.id, {
+                ok: false,
+                error: parsed.error,
+            }));
+            return;
+        }
+        try {
+            const result = await dispatchJsonlMethod(parsed.method, parsed.params, {
+                runsDir: args.runsDir,
+            });
+            writeLine(formatJsonlResponse(parsed.id, result));
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            writeLine(formatJsonlResponse(parsed.id, {
+                ok: false,
+                error: { code: "INTERNAL_ERROR", message: msg },
+            }));
+        }
+        if (parsed.method === "shutdown") {
+            shutdownRequested = true;
+            rl.close();
+        }
+    };
+    return new Promise((resolve) => {
+        rl.on("line", (line) => {
+            if (shutdownRequested)
+                return;
+            activeCount++;
+            const promise = processLine(line).finally(() => {
+                activeCount--;
+                pending.delete(promise);
+                if (activeCount < MAX_PENDING_QUEUE) {
+                    rl.resume();
+                }
+            });
+            pending.add(promise);
+            // Backpressure: pause stdin when too many pending
+            if (activeCount >= MAX_PENDING_QUEUE) {
+                rl.pause();
+            }
+        });
+        rl.on("close", () => {
+            // Wait for all pending requests to complete
+            void Promise.allSettled([...pending]).then(() => {
+                resolve(0);
+            });
+        });
+    });
+}