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

package/dist/api/breakpoints.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * GAP-JSON-003: JSON Breakpoint Interaction API.
+ *
+ * Typed API wrappers for listing, showing, and responding to breakpoint effects,
+ * plus auto-approval rule management. All functions return ApiResult envelopes
+ * and never throw.
+ */
+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.apiListBreakpoints = apiListBreakpoints;
+exports.apiShowBreakpoint = apiShowBreakpoint;
+exports.apiRespondToBreakpoint = apiRespondToBreakpoint;
+exports.apiListAutoApprovalRules = apiListAutoApprovalRules;
+exports.apiAddAutoApprovalRule = apiAddAutoApprovalRule;
+exports.apiRemoveAutoApprovalRule = apiRemoveAutoApprovalRule;
+exports.apiEvaluateAutoApproval = apiEvaluateAutoApproval;
+const crypto = __importStar(require("node:crypto"));
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const utils_1 = require("./utils");
+// ── Internal helpers ───────────────────────────────────────────────────────
+function isBreakpointEffect(info) {
+    return info.kind === "breakpoint" || info.taskId === "__sdk.breakpoint";
+}
+// ── API functions ──────────────────────────────────────────────────────────
+async function apiListBreakpoints(input) {
+    try {
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        const events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+        const effectMap = (0, utils_1.buildBaseEffectMap)(events);
+        const breakpoints = [];
+        for (const info of effectMap.values()) {
+            if (!isBreakpointEffect(info))
+                continue;
+            if (info.lifecycle !== "requested")
+                continue;
+            // Read task definition to extract breakpoint-specific fields
+            let taskDef;
+            try {
+                taskDef = await (0, babysitter_sdk_1.readTaskDefinition)(input.runDir, info.effectId);
+            }
+            catch {
+                // task.json may not exist
+            }
+            const td = taskDef;
+            breakpoints.push({
+                effectId: info.effectId,
+                breakpointId: td?.breakpointId,
+                title: td?.title,
+                tags: Array.isArray(td?.tags) ? td.tags : undefined,
+                expert: td?.expert,
+                strategy: td?.strategy,
+                autoApproval: td?.autoApproval,
+                requestedAt: info.requestedAt,
+            });
+        }
+        return (0, utils_1.ok)({ breakpoints });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiShowBreakpoint(input) {
+    try {
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!input.effectId) {
+            return (0, utils_1.fail)("INVALID_INPUT", "effectId must be a non-empty string");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        const events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+        const effectMap = (0, utils_1.buildBaseEffectMap)(events);
+        const info = effectMap.get(input.effectId);
+        if (!info) {
+            return (0, utils_1.fail)("EFFECT_NOT_FOUND", `Effect not found: ${input.effectId}`);
+        }
+        if (!isBreakpointEffect(info)) {
+            return (0, utils_1.fail)("EFFECT_NOT_BREAKPOINT", `Effect ${input.effectId} is not a breakpoint (kind=${info.kind})`);
+        }
+        // Read task definition
+        let taskDef;
+        try {
+            taskDef = await (0, babysitter_sdk_1.readTaskDefinition)(input.runDir, input.effectId);
+        }
+        catch {
+            // task.json may not exist
+        }
+        // Read result if resolved
+        let resultData = undefined;
+        if (info.lifecycle === "resolved") {
+            try {
+                const storedResult = await (0, babysitter_sdk_1.readTaskResult)(input.runDir, input.effectId);
+                resultData = storedResult ?? undefined;
+            }
+            catch {
+                // result.json may be missing/corrupt
+            }
+        }
+        const td = taskDef;
+        const output = {
+            effectId: info.effectId,
+            status: info.lifecycle,
+            breakpointId: td?.breakpointId,
+            title: td?.title,
+            description: td?.description,
+            tags: Array.isArray(td?.tags) ? td.tags : undefined,
+            expert: td?.expert,
+            strategy: td?.strategy,
+            previousFeedback: td?.previousFeedback,
+            attempt: typeof td?.attempt === "number" ? td.attempt : undefined,
+            options: td?.options,
+            autoApproval: td?.autoApproval,
+            result: resultData,
+            requestedAt: info.requestedAt,
+            resolvedAt: info.resolvedAt,
+        };
+        return (0, utils_1.ok)(output);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiRespondToBreakpoint(input) {
+    try {
+        // Validate input
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!input.effectId) {
+            return (0, utils_1.fail)("INVALID_INPUT", "effectId must be a non-empty string");
+        }
+        if (input.approved === false && (!input.feedback || input.feedback.trim() === "")) {
+            return (0, utils_1.fail)("INVALID_INPUT", "feedback is required when rejecting a breakpoint (approved=false)");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        return await (0, babysitter_sdk_1.withRunLock)(input.runDir, "api:respondToBreakpoint", async () => {
+            const events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+            const effectMap = (0, utils_1.buildBaseEffectMap)(events);
+            const info = effectMap.get(input.effectId);
+            if (!info) {
+                return (0, utils_1.fail)("EFFECT_NOT_FOUND", `Effect not found: ${input.effectId}`);
+            }
+            if (!isBreakpointEffect(info)) {
+                return (0, utils_1.fail)("EFFECT_NOT_BREAKPOINT", `Effect ${input.effectId} is not a breakpoint (kind=${info.kind})`);
+            }
+            if (info.lifecycle !== "requested") {
+                return (0, utils_1.fail)("EFFECT_NOT_PENDING", `Breakpoint ${input.effectId} is not pending (status=${info.lifecycle})`);
+            }
+            const taskId = info.taskId ?? `task-${input.effectId}`;
+            const invocationKey = info.invocationKey ?? `key-${input.effectId}`;
+            // Build breakpoint result value
+            const breakpointResult = {
+                approved: input.approved,
+            };
+            if (input.response !== undefined)
+                breakpointResult.response = input.response;
+            if (input.feedback !== undefined)
+                breakpointResult.feedback = input.feedback;
+            if (input.option !== undefined)
+                breakpointResult.option = input.option;
+            if (input.respondedBy !== undefined)
+                breakpointResult.respondedBy = input.respondedBy;
+            const { resultRef } = await (0, babysitter_sdk_1.serializeAndWriteTaskResult)({
+                runDir: input.runDir,
+                effectId: input.effectId,
+                taskId,
+                invocationKey,
+                payload: {
+                    status: "ok",
+                    result: breakpointResult,
+                },
+            });
+            await (0, babysitter_sdk_1.appendEvent)({
+                runDir: input.runDir,
+                eventType: "EFFECT_RESOLVED",
+                event: {
+                    effectId: input.effectId,
+                    status: "ok",
+                    resultRef,
+                },
+            });
+            // GAP-SEC-003: Fire on-permission-denied hook when breakpoint is denied
+            if (!input.approved) {
+                const td = await (0, babysitter_sdk_1.readTaskDefinition)(input.runDir, input.effectId).catch(() => undefined);
+                const bpId = td?.breakpointId;
+                const kind = td?.kind;
+                (0, babysitter_sdk_1.callHook)({
+                    hookType: "on-permission-denied",
+                    payload: {
+                        hookType: "on-permission-denied",
+                        breakpointId: bpId ?? input.effectId,
+                        title: td?.title,
+                        kind: kind ?? "breakpoint",
+                        runId: input.runDir.split("/").pop(),
+                        effectId: input.effectId,
+                        respondedBy: input.respondedBy,
+                        feedback: input.feedback,
+                        timestamp: new Date().toISOString(),
+                    },
+                    cwd: input.runDir,
+                }).catch(() => { });
+            }
+            return (0, utils_1.ok)({ resultRef });
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiListAutoApprovalRules(input) {
+    try {
+        const rules = await (0, babysitter_sdk_1.readRules)(input?.rulesPath);
+        return (0, utils_1.ok)({ rules });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiAddAutoApprovalRule(input) {
+    try {
+        if (!input.pattern) {
+            return (0, utils_1.fail)("INVALID_INPUT", "pattern must be a non-empty string");
+        }
+        const validActions = ["auto-approve", "never-auto-approve"];
+        if (!validActions.includes(input.action)) {
+            return (0, utils_1.fail)("INVALID_INPUT", `action must be one of: ${validActions.join(", ")}`);
+        }
+        if (!input.createdBy) {
+            return (0, utils_1.fail)("INVALID_INPUT", "createdBy must be a non-empty string");
+        }
+        const rule = {
+            id: input.id ?? crypto.randomUUID(),
+            pattern: input.pattern,
+            action: input.action,
+            createdAt: new Date().toISOString(),
+            createdBy: input.createdBy,
+            source: input.source,
+            note: input.note,
+        };
+        const rules = await (0, babysitter_sdk_1.addRule)(rule, input.rulesPath);
+        return (0, utils_1.ok)({ rule, rules });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiRemoveAutoApprovalRule(input) {
+    try {
+        if (!input.ruleId) {
+            return (0, utils_1.fail)("INVALID_INPUT", "ruleId must be a non-empty string");
+        }
+        // Check if rule exists before removing
+        const existingRules = await (0, babysitter_sdk_1.readRules)(input.rulesPath);
+        const ruleExists = existingRules.some((r) => r.id === input.ruleId);
+        if (!ruleExists) {
+            return (0, utils_1.fail)("RULE_NOT_FOUND", `Rule not found: ${input.ruleId}`);
+        }
+        const rules = await (0, babysitter_sdk_1.removeRule)(input.ruleId, input.rulesPath);
+        return (0, utils_1.ok)({ rules });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiEvaluateAutoApproval(input) {
+    try {
+        if (!input.breakpointId) {
+            return (0, utils_1.fail)("INVALID_INPUT", "breakpointId must be a non-empty string");
+        }
+        const rules = await (0, babysitter_sdk_1.readRules)(input.rulesPath);
+        const result = (0, babysitter_sdk_1.evaluateAutoApproval)({
+            breakpointId: input.breakpointId,
+            tags: input.tags,
+            expert: input.expert,
+            rules,
+            profileConfig: input.profileConfig,
+            consecutiveApprovals: input.consecutiveApprovals,
+            autoApproveAfterN: input.autoApproveAfterN,
+        });
+        return (0, utils_1.ok)(result);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}

package/dist/api/effects.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GAP-JSON-002: Effect Dispatch and Response Protocol.
+ *
+ * Typed API wrappers for listing, showing, cancelling, and batch-committing
+ * effects.  All functions return ApiResult envelopes and never throw.
+ */
+import type { ApiResult } from "./runs";
+import type { ListEffectsInput, ListEffectsOutput, ShowEffectInput, ShowEffectOutput, CancelEffectInput, CancelEffectOutput, BatchCommitEffectsInput, BatchCommitEffectsOutput } from "./effectsTypes";
+export type { EffectStatusFilter, EffectStatusOutput, ListEffectsInput, ListEffectsOutput, ShowEffectInput, ShowEffectOutput, CancelEffectInput, CancelEffectOutput, BatchCommitEffectsInput, BatchCommitEffectResult, BatchCommitEffectsOutput, } from "./effectsTypes";
+export declare function apiListEffects(input: ListEffectsInput): Promise<ApiResult<ListEffectsOutput>>;
+export declare function apiShowEffect(input: ShowEffectInput): Promise<ApiResult<ShowEffectOutput>>;
+export declare function apiCancelEffect(input: CancelEffectInput): Promise<ApiResult<CancelEffectOutput>>;
+export declare function apiBatchCommitEffects(input: BatchCommitEffectsInput): Promise<ApiResult<BatchCommitEffectsOutput>>;
+//# sourceMappingURL=effects.d.ts.map

package/dist/api/effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.d.ts","sourceRoot":"","sources":["../../src/api/effects.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,KAAK,EAC8B,gBAAgB,EAAE,iBAAiB,EAC3E,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,kBAAkB,EACxE,uBAAuB,EAA2B,wBAAwB,EAC3E,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EACV,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,iBAAiB,EAC3E,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,kBAAkB,EACxE,uBAAuB,EAAE,uBAAuB,EAAE,wBAAwB,GAC3E,MAAM,gBAAgB,CAAC;AAyCxB,wBAAsB,cAAc,CAClC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,CAgDvC;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAuDtC;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC,CAsDxC;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,SAAS,CAAC,wBAAwB,CAAC,CAAC,CAwG9C"}

package/dist/api/effects.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * GAP-JSON-002: Effect Dispatch and Response Protocol.
+ *
+ * Typed API wrappers for listing, showing, cancelling, and batch-committing
+ * effects.  All functions return ApiResult envelopes and never throw.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiListEffects = apiListEffects;
+exports.apiShowEffect = apiShowEffect;
+exports.apiCancelEffect = apiCancelEffect;
+exports.apiBatchCommitEffects = apiBatchCommitEffects;
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const utils_1 = require("./utils");
+function toEffectStatus(base) {
+    if (base.lifecycle === "cancelled")
+        return "cancelled";
+    if (base.lifecycle === "resolved") {
+        return base.resolvedStatus === "error" ? "resolved_error" : "resolved_ok";
+    }
+    return "requested";
+}
+function buildEffectInfoMap(events) {
+    const baseMap = (0, utils_1.buildBaseEffectMap)(events);
+    const effects = new Map();
+    for (const [id, base] of baseMap) {
+        effects.set(id, {
+            effectId: base.effectId,
+            kind: base.kind,
+            taskId: base.taskId,
+            labels: base.labels,
+            status: toEffectStatus(base),
+            requestedAt: base.requestedAt,
+            resolvedAt: base.resolvedAt,
+        });
+    }
+    return effects;
+}
+// ── API functions ──────────────────────────────────────────────────────────
+async function apiListEffects(input) {
+    try {
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        const events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+        const effectMap = buildEffectInfoMap(events);
+        let effects = Array.from(effectMap.values());
+        // Apply filters
+        if (input.filter) {
+            if (input.filter.kind !== undefined) {
+                const kinds = Array.isArray(input.filter.kind) ? input.filter.kind : [input.filter.kind];
+                effects = effects.filter((e) => e.kind !== undefined && kinds.includes(e.kind));
+            }
+            if (input.filter.status !== undefined) {
+                const statusFilter = input.filter.status;
+                const validStatuses = ["requested", "resolved", "cancelled"];
+                if (!validStatuses.includes(statusFilter)) {
+                    return (0, utils_1.fail)("INVALID_INPUT", `Invalid status filter: ${statusFilter}. Must be one of: ${validStatuses.join(", ")}`);
+                }
+                effects = effects.filter((e) => {
+                    if (statusFilter === "requested")
+                        return e.status === "requested";
+                    if (statusFilter === "resolved")
+                        return e.status === "resolved_ok" || e.status === "resolved_error";
+                    if (statusFilter === "cancelled")
+                        return e.status === "cancelled";
+                    return true;
+                });
+            }
+        }
+        // Sort by effectId ascending
+        effects.sort((a, b) => a.effectId.localeCompare(b.effectId));
+        return (0, utils_1.ok)({
+            effects: effects.map((e) => ({
+                effectId: e.effectId,
+                kind: e.kind,
+                status: e.status,
+                taskId: e.taskId,
+                labels: e.labels,
+                requestedAt: e.requestedAt,
+                resolvedAt: e.resolvedAt,
+            })),
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiShowEffect(input) {
+    try {
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!input.effectId) {
+            return (0, utils_1.fail)("INVALID_INPUT", "effectId must be a non-empty string");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        const events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+        const effectMap = buildEffectInfoMap(events);
+        const info = effectMap.get(input.effectId);
+        if (!info) {
+            return (0, utils_1.fail)("EFFECT_NOT_FOUND", `Effect not found: ${input.effectId}`);
+        }
+        // Read task definition (may be missing if the task dir hasn't been created yet)
+        let taskDef = undefined;
+        try {
+            taskDef = await (0, babysitter_sdk_1.readTaskDefinition)(input.runDir, input.effectId);
+        }
+        catch {
+            // task.json may not exist yet for freshly-requested effects
+        }
+        // Read result if resolved
+        let resultData = null;
+        if (info.status === "resolved_ok" || info.status === "resolved_error") {
+            const storedResult = await (0, babysitter_sdk_1.readTaskResult)(input.runDir, input.effectId);
+            resultData = storedResult ?? null;
+        }
+        const output = {
+            effectId: info.effectId,
+            kind: info.kind,
+            status: info.status,
+            taskId: info.taskId,
+            labels: info.labels,
+            requestedAt: info.requestedAt,
+            resolvedAt: info.resolvedAt,
+            taskDefinition: taskDef,
+            result: resultData === null ? undefined : resultData,
+        };
+        // Include autoApproval for breakpoint effects
+        if (info.kind === "breakpoint" || info.taskId === "__sdk.breakpoint") {
+            if (taskDef && typeof taskDef === "object") {
+                const autoApproval = taskDef.autoApproval;
+                if (autoApproval !== undefined) {
+                    output.autoApproval = autoApproval;
+                }
+            }
+        }
+        return (0, utils_1.ok)(output);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiCancelEffect(input) {
+    try {
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!input.effectId) {
+            return (0, utils_1.fail)("INVALID_INPUT", "effectId must be a non-empty string");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        return await (0, babysitter_sdk_1.withRunLock)(input.runDir, "api:cancelEffect", async () => {
+            const events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+            const effectMap = buildEffectInfoMap(events);
+            const info = effectMap.get(input.effectId);
+            if (!info) {
+                return (0, utils_1.fail)("EFFECT_NOT_FOUND", `Effect not found: ${input.effectId}`);
+            }
+            if (info.status !== "requested") {
+                return (0, utils_1.fail)("EFFECT_NOT_PENDING", `Effect ${input.effectId} is not pending (status=${info.status})`);
+            }
+            // Extract taskId and invocationKey from the EFFECT_REQUESTED event
+            const requestedEvent = events.find((e) => e.type === "EFFECT_REQUESTED" && e.data.effectId === input.effectId);
+            const eventData = requestedEvent?.data;
+            const taskId = eventData?.taskId ?? `task-${input.effectId}`;
+            const invocationKey = eventData?.invocationKey ?? `key-${input.effectId}`;
+            const { resultRef } = await (0, babysitter_sdk_1.serializeAndWriteTaskResult)({
+                runDir: input.runDir,
+                effectId: input.effectId,
+                taskId,
+                invocationKey,
+                payload: {
+                    status: "cancelled",
+                    reason: input.reason,
+                    error: { name: "EffectCancelledError", message: input.reason ?? "Effect cancelled" },
+                    metadata: { cancelled: true, reason: input.reason },
+                },
+            });
+            await (0, babysitter_sdk_1.appendEvent)({
+                runDir: input.runDir,
+                eventType: "EFFECT_CANCELLED",
+                event: {
+                    effectId: input.effectId,
+                    reason: input.reason,
+                },
+            });
+            return (0, utils_1.ok)({ resultRef });
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function apiBatchCommitEffects(input) {
+    try {
+        if (!input.runDir) {
+            return (0, utils_1.fail)("INVALID_INPUT", "runDir must be a non-empty string");
+        }
+        if (!Array.isArray(input.effects)) {
+            return (0, utils_1.fail)("INVALID_INPUT", "effects must be an array");
+        }
+        if (input.effects.length === 0) {
+            return (0, utils_1.fail)("INVALID_INPUT", "effects array must not be empty");
+        }
+        if (!(await (0, utils_1.pathExists)(input.runDir))) {
+            return (0, utils_1.fail)("RUN_NOT_FOUND", `Run directory not found: ${input.runDir}`);
+        }
+        // Acquire lock once for the entire batch to ensure atomicity
+        return await (0, babysitter_sdk_1.withRunLock)(input.runDir, "api:batchCommitEffects", async () => {
+            // Load journal once for the entire batch
+            let events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+            const results = [];
+            for (const entry of input.effects) {
+                try {
+                    const requestedEvent = events.find((e) => e.type === "EFFECT_REQUESTED" && e.data.effectId === entry.effectId);
+                    if (!requestedEvent) {
+                        throw new Error(`Unknown effectId ${entry.effectId}`);
+                    }
+                    const eventData = requestedEvent.data;
+                    const taskId = eventData.taskId ?? `task-${entry.effectId}`;
+                    const invocationKey = eventData.invocationKey ?? `key-${entry.effectId}`;
+                    // Check if already resolved
+                    const alreadyResolved = events.some((e) => (e.type === "EFFECT_RESOLVED" || e.type === "EFFECT_CANCELLED") &&
+                        e.data.effectId === entry.effectId);
+                    if (alreadyResolved) {
+                        throw new Error(`Effect ${entry.effectId} is already resolved`);
+                    }
+                    const resultPayload = entry.result.status === "ok"
+                        ? {
+                            status: "ok",
+                            result: entry.result.value,
+                            stdout: entry.result.stdout,
+                            stderr: entry.result.stderr,
+                            stdoutRef: entry.result.stdoutRef,
+                            stderrRef: entry.result.stderrRef,
+                            startedAt: entry.result.startedAt,
+                            finishedAt: entry.result.finishedAt,
+                            metadata: entry.result.metadata,
+                        }
+                        : {
+                            status: "error",
+                            error: { name: "Error", message: entry.result.error ?? "Unknown error" },
+                            stdout: entry.result.stdout,
+                            stderr: entry.result.stderr,
+                            stdoutRef: entry.result.stdoutRef,
+                            stderrRef: entry.result.stderrRef,
+                            startedAt: entry.result.startedAt,
+                            finishedAt: entry.result.finishedAt,
+                            metadata: entry.result.metadata,
+                        };
+                    const { resultRef, stdoutRef, stderrRef } = await (0, babysitter_sdk_1.serializeAndWriteTaskResult)({
+                        runDir: input.runDir,
+                        effectId: entry.effectId,
+                        taskId,
+                        invocationKey,
+                        payload: resultPayload,
+                    });
+                    await (0, babysitter_sdk_1.appendEvent)({
+                        runDir: input.runDir,
+                        eventType: "EFFECT_RESOLVED",
+                        event: {
+                            effectId: entry.effectId,
+                            status: entry.result.status,
+                            resultRef,
+                            stdoutRef: stdoutRef ?? undefined,
+                            stderrRef: stderrRef ?? undefined,
+                            startedAt: resultPayload.startedAt,
+                            finishedAt: resultPayload.finishedAt,
+                        },
+                    });
+                    // Reload journal so subsequent effects in the batch see this resolution
+                    events = await (0, babysitter_sdk_1.loadJournal)(input.runDir);
+                    results.push({
+                        effectId: entry.effectId,
+                        ok: true,
+                        resultRef,
+                    });
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    results.push({
+                        effectId: entry.effectId,
+                        ok: false,
+                        error: msg,
+                    });
+                }
+            }
+            return (0, utils_1.ok)({ results });
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}