@grackle-ai/common 0.132.0 → 0.132.1

package/dist/ahp-mapper.test.js

@@ -0,0 +1,624 @@
+/**
+ * Tests for `mapAgentEvent` — AgentEvent → AHP SessionAction mapping.
+ *
+ * Each test covers one AgentEvent type and verifies:
+ * 1. Correct AHP action(s) are produced
+ * 2. Mapper context is updated correctly
+ * 3. Mapping notes have the right disposition
+ */
+import { describe, it, expect } from "vitest";
+import { ActionType } from "@grackle-ai/ahp";
+import { mapAgentEvent } from "./ahp-mapper.js";
+// ─── Helpers ────────────────────────────────────────────────────────
+function makeContext(overrides) {
+    return {
+        turnId: undefined,
+        openToolCalls: [],
+        partCounter: 0,
+        eventIndex: 0,
+        metaAccumulator: {},
+        ...overrides,
+    };
+}
+function makeEvent(type, overrides) {
+    return {
+        type,
+        content: overrides?.content,
+        toolCallId: overrides?.toolCallId,
+        turnId: overrides?.turnId,
+        diagnostic: overrides?.diagnostic,
+    };
+}
+function assertActionType(actions, expectedType, index = 0) {
+    const action = actions[index];
+    expect(action.type).toBe(expectedType);
+    return action;
+}
+// ─── turn_started ──────────────────────────────────────────────────
+describe("turn_started", () => {
+    it("maps to SessionTurnStarted with userMessage", () => {
+        const context = makeContext();
+        const event = makeEvent("turn_started", {
+            turnId: "turn-abc",
+            content: JSON.stringify({ user_message: "Hello world" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(1);
+        const action = assertActionType(result.actions, ActionType.SessionTurnStarted);
+        expect(action.turnId).toBe("turn-abc");
+        expect(action.userMessage.text).toBe("Hello world");
+        expect(context.turnId).toBe("turn-abc");
+        expect(context.openToolCalls).toEqual([]);
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("uses generated turnId when none provided", () => {
+        const context = makeContext();
+        const event = makeEvent("turn_started", {
+            content: JSON.stringify({ user_message: "Prompt" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(1);
+        const action = assertActionType(result.actions, ActionType.SessionTurnStarted);
+        expect(action.turnId).toBe("turn-0");
+        expect(context.turnId).toBe("turn-0");
+    });
+    it("resets openToolCalls on new turn", () => {
+        const context = makeContext({ openToolCalls: ["old-tc-1", "old-tc-2"] });
+        const event = makeEvent("turn_started", {
+            turnId: "turn-new",
+            content: JSON.stringify({ user_message: "New turn" }),
+        });
+        mapAgentEvent(event, 0, context);
+        expect(context.openToolCalls).toEqual([]);
+    });
+});
+// ─── turn_complete ─────────────────────────────────────────────────
+describe("turn_complete", () => {
+    it("maps to SessionTurnComplete when turn is active", () => {
+        const context = makeContext({ turnId: "turn-abc" });
+        const event = makeEvent("turn_complete", { turnId: "turn-abc" });
+        const result = mapAgentEvent(event, 1, context);
+        expect(result.actions.length).toBe(1);
+        assertActionType(result.actions, ActionType.SessionTurnComplete);
+        expect(context.turnId).toBeUndefined();
+        expect(context.openToolCalls).toEqual([]);
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("drops when no active turn", () => {
+        const context = makeContext();
+        const event = makeEvent("turn_complete");
+        const result = mapAgentEvent(event, 1, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+});
+// ─── input_needed ──────────────────────────────────────────────────
+describe("input_needed", () => {
+    it("drops as advisory only", () => {
+        const context = makeContext();
+        const event = makeEvent("input_needed");
+        const result = mapAgentEvent(event, 2, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+        expect(result.note?.detail).toContain("Advisory event");
+    });
+});
+// ─── text ──────────────────────────────────────────────────────────
+describe("text", () => {
+    it("maps to SessionResponsePart(markdown) with turn", () => {
+        const context = makeContext({ turnId: "turn-abc", partCounter: 5 });
+        const event = makeEvent("text", { content: "Hello there" });
+        const result = mapAgentEvent(event, 3, context);
+        expect(result.actions.length).toBe(1);
+        const action = assertActionType(result.actions, ActionType.SessionResponsePart);
+        expect(action.part.kind).toBe("markdown");
+        expect(action.part.id).toBe("part-5");
+        expect(action.part.content).toBe("Hello there");
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("drops when no active turn", () => {
+        const context = makeContext();
+        const event = makeEvent("text", { content: "Hello" });
+        const result = mapAgentEvent(event, 3, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+});
+// ─── tool_use ──────────────────────────────────────────────────────
+describe("tool_use", () => {
+    it("maps to SessionToolCallStart + SessionToolCallReady", () => {
+        const context = makeContext({ turnId: "turn-abc", partCounter: 10 });
+        const event = makeEvent("tool_use", {
+            toolCallId: "tc-xyz",
+            content: JSON.stringify({
+                tool_name: "read_file",
+                display_name: "Read File",
+            }),
+        });
+        const result = mapAgentEvent(event, 4, context);
+        expect(result.actions.length).toBe(2);
+        const start = assertActionType(result.actions, ActionType.SessionToolCallStart);
+        expect(start.toolCallId).toBe("tc-xyz");
+        expect(start.toolName).toBe("read_file");
+        expect(start.displayName).toBe("Read File");
+        const ready = assertActionType(result.actions, ActionType.SessionToolCallReady, 1);
+        expect(ready.toolCallId).toBe("tc-xyz");
+        expect(ready.confirmed).toBe("not-needed");
+        expect(context.openToolCalls).toEqual(["tc-xyz"]);
+        expect(result.note ? 1 : 0).toBe(1);
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("generates toolCallId when none provided", () => {
+        const context = makeContext({ turnId: "turn-abc", partCounter: 10 });
+        const event = makeEvent("tool_use", {
+            content: JSON.stringify({ tool_name: "shell" }),
+        });
+        mapAgentEvent(event, 4, context);
+        expect(context.openToolCalls).toEqual(["tc-10"]);
+    });
+    it("drops when no active turn", () => {
+        const context = makeContext();
+        const event = makeEvent("tool_use", { content: "{}" });
+        const result = mapAgentEvent(event, 4, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+});
+// ─── tool_result ───────────────────────────────────────────────────
+describe("tool_result", () => {
+    it("pairs by toolCallId and maps to SessionToolCallComplete", () => {
+        const context = makeContext({
+            turnId: "turn-abc",
+            openToolCalls: ["tc-xyz"],
+        });
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-xyz",
+            content: JSON.stringify({ is_ok: true, content: "file contents here" }),
+        });
+        const result = mapAgentEvent(event, 5, context);
+        // Successful result produces: Complete + systemNotification
+        expect(result.actions.length).toBe(2);
+        const complete = assertActionType(result.actions, ActionType.SessionToolCallComplete);
+        expect(complete.toolCallId).toBe("tc-xyz");
+        expect(complete.result.success).toBe(true);
+        // First-class toolCallId (HR3) is used; matched id is removed from LIFO stack
+        expect(context.openToolCalls).toEqual([]);
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("pairs by LIFO stack when no toolCallId", () => {
+        const context = makeContext({
+            turnId: "turn-abc",
+            openToolCalls: ["tc-first", "tc-last"],
+        });
+        const event = makeEvent("tool_result", {
+            content: JSON.stringify({ is_ok: true, content: "result" }),
+        });
+        mapAgentEvent(event, 5, context);
+        // Should pop "tc-last" (LIFO)
+        expect(context.openToolCalls).toEqual(["tc-first"]);
+    });
+    it("drops when no matching tool call", () => {
+        const context = makeContext({ turnId: "turn-abc", openToolCalls: [] });
+        const event = makeEvent("tool_result", { content: "{}" });
+        const result = mapAgentEvent(event, 5, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+    it("adds system notification for successful result", () => {
+        const context = makeContext({
+            turnId: "turn-abc",
+            openToolCalls: ["tc-xyz"],
+        });
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-xyz",
+            content: "Success: file written",
+        });
+        const result = mapAgentEvent(event, 5, context);
+        expect(result.actions.length).toBe(2);
+        expect(result.note).toBeDefined();
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("drops when no active turn", () => {
+        const context = makeContext({ openToolCalls: ["tc-xyz"] });
+        const event = makeEvent("tool_result", { toolCallId: "tc-xyz", content: "{}" });
+        const result = mapAgentEvent(event, 5, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+});
+// ─── usage ─────────────────────────────────────────────────────────
+describe("usage", () => {
+    it("carries cost_millicents into metaAccumulator", () => {
+        const context = makeContext({
+            metaAccumulator: { costMillicents: 100 },
+        });
+        const event = makeEvent("usage", {
+            content: JSON.stringify({ cost_millicents: 50 }),
+        });
+        const result = mapAgentEvent(event, 6, context);
+        expect(context.metaAccumulator.costMillicents).toBe(150);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("carried");
+    });
+    it("ignores non-finite cost_millicents", () => {
+        const context = makeContext();
+        const event = makeEvent("usage", {
+            content: JSON.stringify({ cost_millicents: NaN }),
+        });
+        mapAgentEvent(event, 6, context);
+        expect(context.metaAccumulator.costMillicents).toBeUndefined();
+    });
+    it("handles zero cost_millicents without breaking accumulator", () => {
+        const context = makeContext({ metaAccumulator: { costMillicents: 100 } });
+        const event = makeEvent("usage", {
+            content: JSON.stringify({ cost_millicents: 0 }),
+        });
+        mapAgentEvent(event, 6, context);
+        // 0 is a valid (non-null) cost — accumulator should be 100 + 0 = 100
+        expect(context.metaAccumulator.costMillicents).toBe(100);
+    });
+});
+// ─── error ─────────────────────────────────────────────────────────
+describe("error", () => {
+    it("maps to SessionError when in-turn", () => {
+        const context = makeContext({ turnId: "turn-abc" });
+        const event = makeEvent("error", { content: "Something went wrong" });
+        const result = mapAgentEvent(event, 7, context);
+        expect(result.actions.length).toBe(1);
+        const action = assertActionType(result.actions, ActionType.SessionError);
+        expect(action.turnId).toBe("turn-abc");
+        expect(action.error.message).toBe("Something went wrong");
+        expect(result.note?.disposition).toBe("mapped");
+        // context.turnId must be cleared so subsequent events aren't mapped to the defunct turn
+        expect(context.turnId).toBeUndefined();
+    });
+    it("clears context.turnId so subsequent text events are dropped after in-turn error", () => {
+        const context = makeContext({ turnId: "turn-abc" });
+        mapAgentEvent(makeEvent("error", { content: "Oops" }), 7, context);
+        const textResult = mapAgentEvent(makeEvent("text", { content: "After error" }), 8, context);
+        expect(textResult.actions.length).toBe(0);
+        expect(textResult.note?.disposition).toBe("dropped");
+    });
+    it("maps to SessionCreationFailed when pre-turn", () => {
+        const context = makeContext();
+        const event = makeEvent("error", { content: "Init failed" });
+        const result = mapAgentEvent(event, 7, context);
+        expect(result.actions.length).toBe(1);
+        const action = assertActionType(result.actions, ActionType.SessionCreationFailed);
+        expect(action.error.message).toBe("Init failed");
+        expect(result.note?.disposition).toBe("mapped");
+    });
+});
+// ─── status ────────────────────────────────────────────────────────
+describe("status", () => {
+    it("maps failed to SessionError when in-turn", () => {
+        const context = makeContext({ turnId: "turn-abc" });
+        const event = makeEvent("status", { content: "failed" });
+        const result = mapAgentEvent(event, 8, context);
+        expect(result.actions.length).toBe(1);
+        assertActionType(result.actions, ActionType.SessionError);
+        expect(context.turnId).toBeUndefined();
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("maps failed to SessionCreationFailed when pre-turn", () => {
+        const context = makeContext();
+        const event = makeEvent("status", { content: "failed" });
+        const result = mapAgentEvent(event, 8, context);
+        expect(result.actions.length).toBe(1);
+        assertActionType(result.actions, ActionType.SessionCreationFailed);
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("maps killed to SessionError when in-turn", () => {
+        const context = makeContext({ turnId: "turn-abc", openToolCalls: ["tc-1"] });
+        const event = makeEvent("status", { content: "killed" });
+        const result = mapAgentEvent(event, 9, context);
+        expect(result.actions.length).toBe(1);
+        assertActionType(result.actions, ActionType.SessionError);
+        expect(context.turnId).toBeUndefined();
+        expect(context.openToolCalls).toEqual([]);
+    });
+    it("drops killed when no active turn", () => {
+        const context = makeContext();
+        const event = makeEvent("status", { content: "killed" });
+        const result = mapAgentEvent(event, 9, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+    it("drops completed/waiting_input/running", () => {
+        for (const status of ["completed", "waiting_input", "running"]) {
+            const context = makeContext({ turnId: "turn-abc" });
+            const event = makeEvent("status", { content: status });
+            const result = mapAgentEvent(event, 10, context);
+            expect(result.actions.length).toBe(0);
+            expect(result.note?.disposition).toBe("dropped");
+        }
+    });
+});
+// ─── system ────────────────────────────────────────────────────────
+describe("system", () => {
+    it("maps non-diagnostic system to SessionResponsePart(systemNotification)", () => {
+        const context = makeContext({ turnId: "turn-abc", partCounter: 20 });
+        const event = makeEvent("system", { content: "Subagent completed" });
+        const result = mapAgentEvent(event, 11, context);
+        expect(result.actions.length).toBe(1);
+        const action = assertActionType(result.actions, ActionType.SessionResponsePart);
+        expect(action.part.kind).toBe("systemNotification");
+        expect(action.part.content).toBe("Subagent completed");
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("drops diagnostic system events", () => {
+        const context = makeContext();
+        const event = makeEvent("system", {
+            diagnostic: true,
+            content: JSON.stringify({ level: "info", msg: "diagnostic" }),
+        });
+        const result = mapAgentEvent(event, 12, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("carried");
+        expect(result.note?.detail).toContain("diagnostic");
+    });
+    it("drops non-diagnostic system when no active turn", () => {
+        const context = makeContext();
+        const event = makeEvent("system", { content: "Subagent completed" });
+        const result = mapAgentEvent(event, 11, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+});
+// ─── runtime_session_id ────────────────────────────────────────────
+describe("runtime_session_id", () => {
+    it("carries content into metaAccumulator", () => {
+        const context = makeContext();
+        const event = makeEvent("runtime_session_id", { content: "runtime-abc-123" });
+        const result = mapAgentEvent(event, 13, context);
+        expect(context.metaAccumulator.runtimeSessionId).toBe("runtime-abc-123");
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("carried");
+    });
+    it("drops when no content", () => {
+        const context = makeContext();
+        const event = makeEvent("runtime_session_id");
+        const result = mapAgentEvent(event, 13, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+});
+// ─── Unknown event types ──────────────────────────────────────────
+describe("unknown event types", () => {
+    it("drops unrecognized event types", () => {
+        const context = makeContext();
+        const event = makeEvent("unknown_weird_type");
+        const result = mapAgentEvent(event, 100, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+        expect(result.note?.detail).toContain("Unrecognized event type");
+    });
+});
+// ─── Context mutation tests ────────────────────────────────────────
+describe("context mutation", () => {
+    it("partCounter increments across multiple text events", () => {
+        const context = makeContext({ turnId: "turn-abc", partCounter: 0 });
+        const r1 = mapAgentEvent(makeEvent("text", { content: "A" }), 0, context);
+        const r2 = mapAgentEvent(makeEvent("text", { content: "B" }), 1, context);
+        expect(r1.actions[0]).toMatchObject({ part: { id: "part-0" } });
+        expect(r2.actions[0]).toMatchObject({ part: { id: "part-1" } });
+    });
+    it("metaAccumulator persists across events", () => {
+        const context = makeContext({ metaAccumulator: {} });
+        mapAgentEvent(makeEvent("usage", { content: JSON.stringify({ cost_millicents: 10 }) }), 0, context);
+        mapAgentEvent(makeEvent("usage", { content: JSON.stringify({ cost_millicents: 20 }) }), 1, context);
+        expect(context.metaAccumulator.costMillicents).toBe(30);
+    });
+});
+// ─── Branch-coverage supplement ────────────────────────────────────
+//
+// The tests above cover the headline mappings. This block fills in the
+// remaining branches (parse fallbacks, ternary "else" arms, missing-field
+// paths) so v8 coverage hits the per-package `branches` floor in
+// rigs/heft-rig/coverage-thresholds.json.
+describe("branch coverage", () => {
+    it("turn_started with non-JSON content uses raw content as userMessage", () => {
+        const context = makeContext();
+        const event = makeEvent("turn_started", { content: "just a plain string", turnId: "t1" });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.userMessage.text).toBe("just a plain string");
+    });
+    it("turn_started with empty content yields empty userMessage text", () => {
+        const context = makeContext();
+        const event = makeEvent("turn_started", { turnId: "t1" });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.userMessage.text).toBe("");
+    });
+    it("text with no content emits empty markdown part", () => {
+        const context = makeContext({ turnId: "t1", partCounter: 0 });
+        const event = makeEvent("text");
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.part.content).toBe("");
+    });
+    it("tool_use with non-JSON content falls back to unknown_tool / generated invocation", () => {
+        const context = makeContext({ turnId: "t1", partCounter: 0 });
+        const event = makeEvent("tool_use", { content: "not json" });
+        const result = mapAgentEvent(event, 0, context);
+        const start = result.actions[0];
+        const ready = result.actions[1];
+        expect(start.toolName).toBe("unknown_tool");
+        expect(start.displayName).toBe("unknown_tool");
+        expect(ready.invocationMessage).toBe("Running unknown_tool");
+    });
+    it("tool_use accepts `name` field when `tool_name` is absent", () => {
+        const context = makeContext({ turnId: "t1", partCounter: 0 });
+        const event = makeEvent("tool_use", { content: JSON.stringify({ name: "shell" }) });
+        const result = mapAgentEvent(event, 0, context);
+        const start = result.actions[0];
+        expect(start.toolName).toBe("shell");
+    });
+    it("tool_use falls back to toolName when display_name is absent", () => {
+        const context = makeContext({ turnId: "t1", partCounter: 0 });
+        const event = makeEvent("tool_use", { content: JSON.stringify({ tool_name: "edit" }) });
+        const result = mapAgentEvent(event, 0, context);
+        const start = result.actions[0];
+        expect(start.displayName).toBe("edit");
+    });
+    it("tool_use uses provided invocation_message when present", () => {
+        const context = makeContext({ turnId: "t1", partCounter: 0 });
+        const event = makeEvent("tool_use", {
+            content: JSON.stringify({ tool_name: "shell", invocation_message: "running shell `ls`" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        const ready = result.actions[1];
+        expect(ready.invocationMessage).toBe("running shell `ls`");
+    });
+    it("tool_result with is_ok:false emits failure result with error", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-1",
+            content: JSON.stringify({ is_ok: false, past_tense_message: "failed to read" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.result.success).toBe(false);
+        expect(action.result.content).toBeUndefined();
+        expect(action.result.error?.message).toBe("failed to read");
+        // No system notification on failure
+        expect(result.actions.length).toBe(1);
+    });
+    it("tool_result accepts `success` field when `is_ok` is absent", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-1",
+            content: JSON.stringify({ success: false, content: "nope" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.result.success).toBe(false);
+    });
+    it("tool_result defaults to success=true when neither is_ok nor success present", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-1",
+            content: JSON.stringify({ content: "ok" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.result.success).toBe(true);
+    });
+    it("tool_result with non-JSON content keeps default success=true", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const event = makeEvent("tool_result", { toolCallId: "tc-1", content: "raw text result" });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.result.success).toBe(true);
+        expect(action.result.pastTenseMessage).toBe("raw text result");
+    });
+    it("tool_result with no content emits no system notification", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const event = makeEvent("tool_result", { toolCallId: "tc-1" });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(1);
+    });
+    it("tool_result with content > 200 chars truncates the system notification", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const longText = "x".repeat(250);
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-1",
+            content: JSON.stringify({ is_ok: true, content: longText }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        const notification = result.actions[1];
+        expect(notification.part.content.length).toBe(203); // 200 chars + "..."
+        expect(notification.part.content.endsWith("...")).toBe(true);
+    });
+    it("usage with null cost_millicents leaves accumulator untouched", () => {
+        const context = makeContext({ metaAccumulator: { costMillicents: 50 } });
+        const event = makeEvent("usage", { content: JSON.stringify({ cost_millicents: null }) });
+        mapAgentEvent(event, 0, context);
+        expect(context.metaAccumulator.costMillicents).toBe(50);
+    });
+    it("usage with no parsed content leaves accumulator untouched", () => {
+        const context = makeContext({ metaAccumulator: { costMillicents: 50 } });
+        const event = makeEvent("usage");
+        mapAgentEvent(event, 0, context);
+        expect(context.metaAccumulator.costMillicents).toBe(50);
+    });
+    it("error with no content falls back to 'Unknown error'", () => {
+        const context = makeContext({ turnId: "t1" });
+        const event = makeEvent("error");
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.error.message).toBe("Unknown error");
+    });
+    it("status with unknown content is dropped", () => {
+        const context = makeContext({ turnId: "t1" });
+        const event = makeEvent("status", { content: "made_up_status" });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+        expect(result.note?.detail).toContain("unrecognized");
+    });
+    it("status with no content is dropped (empty default branch)", () => {
+        const context = makeContext({ turnId: "t1" });
+        const event = makeEvent("status");
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+    it("status terminated maps to SessionError when in-turn", () => {
+        const context = makeContext({ turnId: "t1", openToolCalls: ["tc-1"] });
+        const event = makeEvent("status", { content: "terminated" });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(1);
+        const action = result.actions[0];
+        expect(action.type).toBe(ActionType.SessionError);
+        expect(context.turnId).toBeUndefined();
+        expect(context.openToolCalls).toEqual([]);
+    });
+    it("status terminated drops when no active turn", () => {
+        const context = makeContext();
+        const event = makeEvent("status", { content: "terminated" });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("dropped");
+    });
+    it("system diagnostic via parsed `span`/`trace`/`level` keys is carried (not mapped)", () => {
+        const context = makeContext({ turnId: "t1" });
+        const event = makeEvent("system", {
+            content: JSON.stringify({ span: "x", trace: "y" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(0);
+        expect(result.note?.disposition).toBe("carried");
+    });
+    it("system with diagnostic-looking keys but also `text` is treated as user-visible", () => {
+        const context = makeContext({ turnId: "t1" });
+        const event = makeEvent("system", {
+            content: JSON.stringify({ span: "x", text: "user-visible content" }),
+        });
+        const result = mapAgentEvent(event, 0, context);
+        expect(result.actions.length).toBe(1);
+        expect(result.note?.disposition).toBe("mapped");
+    });
+    it("tool_result with explicit toolCallId splices from middle of LIFO stack", () => {
+        const context = makeContext({
+            turnId: "t1",
+            openToolCalls: ["tc-old", "tc-target", "tc-newer"],
+        });
+        const event = makeEvent("tool_result", {
+            toolCallId: "tc-target",
+            content: JSON.stringify({ is_ok: true, content: "done" }),
+        });
+        mapAgentEvent(event, 0, context);
+        // Splice removed "tc-target" from the middle, preserving order
+        expect(context.openToolCalls).toEqual(["tc-old", "tc-newer"]);
+    });
+    it("text uses event.turnId when context.turnId is unset", () => {
+        const context = makeContext();
+        const event = makeEvent("text", { content: "hi", turnId: "from-event" });
+        const result = mapAgentEvent(event, 0, context);
+        const action = result.actions[0];
+        expect(action.turnId).toBe("from-event");
+    });
+});
+//# sourceMappingURL=ahp-mapper.test.js.map