@wjarka/cezarion 0.15.1 → 0.16.0

package/dist/core/omp-ui-mapper.js

@@ -0,0 +1,882 @@
+import { toolDisplay } from './tool-display.js';
+/** Early `subagent_event` buffer bounds (spec § Sub-agents and the Agents drawer). */
+const PENDING_SUBAGENT_EVENTS_PER_ID = 200;
+const PENDING_SUBAGENT_IDS = 8;
+const SUBAGENT_DROP_MESSAGE = 'omp: sub-agent events dropped before lifecycle';
+/** A failure before admission never gets a `prompt_result`, so its id is never released: bound it. */
+const FAILED_PROMPTS_KEPT = 32;
+const EMPTY_LANE = {
+    textBlock: 0,
+    startedItems: new Set(),
+    endedItems: new Set(),
+    textByItem: new Map(),
+};
+export function createOmpUiState() {
+    return {
+        sessionStarted: false,
+        sessionId: null,
+        turnSeq: 0,
+        turnId: null,
+        turnPromptId: null,
+        turnPromptAdmitted: false,
+        stopReason: 'end_turn',
+        turnUsage: null,
+        turnCostUsd: null,
+        sessionUsage: null,
+        sessionCostUsd: null,
+        latchedProviderError: null,
+        ...EMPTY_LANE,
+        tools: new Map(),
+        subagents: new Map(),
+        pendingSubagentEvents: new Map(),
+        batchCalls: new Set(),
+        childLanes: new Map(),
+        subagentDropReported: false,
+        failedPrompts: new Set(),
+    };
+}
+/**
+ * Same as `pi-ui-mapper.ts` `piTurnStarted`, plus the id of the `prompt` that opens the turn
+ * (the runner's; omitted when OMP's own activity opened it).
+ */
+export function ompTurnStarted(state, promptId) {
+    const turnSeq = state.turnSeq + 1;
+    const turnId = `turn_${turnSeq}`;
+    return {
+        events: [{ type: 'turn.started', turnId }],
+        state: {
+            ...state,
+            turnSeq,
+            turnId,
+            turnPromptId: promptId ?? null,
+            turnPromptAdmitted: false,
+            stopReason: 'end_turn',
+            textBlock: 0,
+        },
+    };
+}
+/** The frame answers the `prompt` that opened the turn in flight (ids are the runner's). */
+function opensTurn(value, state) {
+    const id = string(value.id);
+    return state.turnId !== null && id !== undefined && id === state.turnPromptId;
+}
+/**
+ * Which frame can end a turn (rpc.md § Yield vs settled): `session_settled` when the session
+ * went quiet, or a prompt OMP finished without invoking the agent — a `prompt_result` with
+ * `agentInvoked: false`, or the prompt's own success response carrying `data.agentInvoked:
+ * false` (no `prompt_result` follows that one). `agent_end` is never a boundary. A `local`
+ * boundary ends the turn only for the prompt that opened it: a steer answered locally, or
+ * failing after admission (`RpcPromptResults.fail`), leaves the running turn alone.
+ */
+export function ompTurnBoundary(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.type === 'session_settled')
+        return 'settled';
+    if (value.type === 'prompt_result' && value.agentInvoked === false)
+        return 'local';
+    if (value.type === 'response' &&
+        value.command === 'prompt' &&
+        value.success === true &&
+        isRecord(value.data) &&
+        value.data.agentInvoked === false) {
+        return 'local';
+    }
+    return null;
+}
+/** Same rule as `pi-ui-mapper.ts` `mapActivity`: activity after the turn ended re-opens one. */
+function mapActivity(value, state, map) {
+    if (state.turnId)
+        return map(value, state);
+    const started = ompTurnStarted(state);
+    const mapped = map(value, started.state);
+    if (mapped.events.length === 0)
+        return { events: [], state };
+    return { events: [...started.events, ...mapped.events], state: mapped.state };
+}
+function isMessageUpdateActivity(value) {
+    const update = isRecord(value.assistantMessageEvent) ? value.assistantMessageEvent : undefined;
+    const type = update ? string(update.type) : undefined;
+    return type?.startsWith('text_') === true || type?.startsWith('thinking_') === true;
+}
+function isAssistantMessageEnd(value) {
+    return isRecord(value.message) && string(value.message.role) === 'assistant';
+}
+function isToolStart(value) {
+    return Boolean(string(value.toolCallId) && string(value.toolName));
+}
+export function mapOmpRpcMessage(value, state) {
+    if (!isRecord(value) || typeof value.type !== 'string')
+        return { events: [], state };
+    if (value.type === 'response')
+        return mapResponse(value, state);
+    switch (value.type) {
+        case 'message_update':
+            return isMessageUpdateActivity(value)
+                ? mapActivity(value, state, mapMessageUpdate)
+                : mapMessageUpdate(value, state);
+        case 'message_end':
+            return isAssistantMessageEnd(value)
+                ? mapActivity(value, state, mapMessageEnd)
+                : mapMessageEnd(value, state);
+        case 'tool_execution_start':
+            return isToolStart(value) ? mapActivity(value, state, mapToolStart) : mapToolStart(value, state);
+        case 'tool_execution_update':
+            return mapActivity(value, state, mapToolUpdate);
+        case 'tool_execution_end':
+            return mapActivity(value, state, mapToolEnd);
+        case 'session_settled':
+            return completeTurn(state.stopReason, state);
+        case 'prompt_result':
+            return mapPromptResult(value, state);
+        case 'subagent_lifecycle':
+            return isRecord(value.payload) ? mapSubagentLifecycle(value.payload, state) : { events: [], state };
+        case 'subagent_event':
+            return isRecord(value.payload) ? mapSubagentEvent(value.payload, state) : { events: [], state };
+        case 'extension_error': {
+            const message = string(value.error) ?? string(value.message) ?? 'omp extension error';
+            return { events: [{ type: 'session.error', message, fatal: false }], state };
+        }
+        case 'notice': {
+            if (value.level !== 'error')
+                return { events: [], state };
+            const message = string(value.message) ?? 'omp error notice';
+            return { events: [{ type: 'session.error', message, fatal: false }], state };
+        }
+        // `agent_end` (any `yielded`), `ready`, `queue_update`, `auto_*`, `cache_warming_*`, and the
+        // unsolicited startup frames `extension_ui_request`, `advisor_cost_changed`,
+        // `available_commands_update` (recorded from the real v18.4.11 binary) carry nothing here.
+        default:
+            return { events: [], state };
+    }
+}
+function mapResponse(value, state) {
+    const command = string(value.command);
+    if (command === 'get_state' && value.success === true && isRecord(value.data)) {
+        const sessionId = string(value.data.sessionId);
+        if (sessionId && !state.sessionStarted) {
+            const model = isRecord(value.data.model) ? string(value.data.model.id) : undefined;
+            return {
+                events: [{ type: 'session.started', sessionId, backend: 'omp', ...(model ? { model } : {}) }],
+                state: { ...state, sessionStarted: true, sessionId },
+            };
+        }
+        return { events: [], state };
+    }
+    if (command === 'prompt') {
+        if (value.success === false) {
+            // rpc.md § Request/Response Correlation: a prompt that fails before admission gets only
+            // this error response — no `prompt_result` follows — so it is reported here. A failure
+            // after admission sends this response after the success ack, AND a `prompt_result`,
+            // whose error is then skipped. The opening prompt failing before its ack ends the turn
+            // (Ruling 10); a steer failing leaves it running.
+            const id = string(value.id);
+            let failedPrompts = state.failedPrompts;
+            if (id) {
+                const kept = [...failedPrompts, id].slice(-FAILED_PROMPTS_KEPT);
+                failedPrompts = new Set(kept);
+            }
+            const error = { type: 'session.error', message: `omp: prompt failed: ${rpcError(value)}`, fatal: false };
+            if (opensTurn(value, state) && !state.turnPromptAdmitted) {
+                const completed = completeTurn('error', state);
+                return { events: [error, ...completed.events], state: { ...completed.state, failedPrompts } };
+            }
+            return { events: [error], state: { ...state, failedPrompts } };
+        }
+        if (value.success !== true || !opensTurn(value, state))
+            return { events: [], state };
+        const admitted = { ...state, turnPromptAdmitted: true };
+        return ompTurnBoundary(value) === 'local' ? completeTurn(state.stopReason, admitted) : { events: [], state: admitted };
+    }
+    // `set_*` failures are configuration notes for the runner (v1), not session errors.
+    if (value.success === false && !command?.startsWith('set_')) {
+        return { events: [{ type: 'session.error', message: rpcError(value), fatal: false }], state };
+    }
+    return { events: [], state };
+}
+function mapPromptResult(value, state) {
+    // An agent-invoked prompt yields here, but the turn runs on until `session_settled`.
+    if (ompTurnBoundary(value) !== 'local')
+        return { events: [], state };
+    const status = string(value.status);
+    const id = string(value.id);
+    // Only the prompt that opened the turn ends it; a steer's local completion does not.
+    const ends = opensTurn(value, state);
+    const end = (reason, next) => ends ? completeTurn(reason, next) : { events: [], state: next };
+    if (status === 'error' && id && state.failedPrompts.has(id)) {
+        // Its failure response already reported the error; this frame only ends the turn.
+        const failedPrompts = new Set(state.failedPrompts);
+        failedPrompts.delete(id);
+        return end('error', { ...state, failedPrompts });
+    }
+    if (status === 'error') {
+        const error = isRecord(value.error) ? value.error : {};
+        const message = ompProviderErrorMessage({
+            provider: error.provider,
+            model: error.model,
+            errorMessage: error.message,
+        });
+        const completed = end('error', state);
+        return { events: [{ type: 'session.error', message, fatal: false }, ...completed.events], state: completed.state };
+    }
+    return end(status === 'aborted' ? 'cancelled' : state.stopReason, state);
+}
+/* ------------------------------------------------------------------ */
+/* Text and reasoning — same wire as pi-ui-mapper.ts (rpc.md, v18.4.11) */
+/* ------------------------------------------------------------------ */
+/** Parent ids are `<turnId>_text_…`, child ids `<rowId>/text_…` (see `ItemScope`). */
+const LANE_ITEM = /[_/](text|reasoning)_\d+_\d+$/;
+function laneOf(state) {
+    return {
+        textBlock: state.textBlock,
+        startedItems: state.startedItems,
+        endedItems: state.endedItems,
+        textByItem: state.textByItem,
+    };
+}
+function withChildLane(state, rowId, lane) {
+    const childLanes = new Map(state.childLanes);
+    childLanes.set(rowId, lane);
+    return { ...state, childLanes };
+}
+/** Same wire as pi-ui-mapper.ts `mapMessageUpdate` (rpc.md, v18.4.11), for one lane. */
+function laneTextUpdate(update, lane, scope) {
+    const updateType = string(update.type);
+    const contentIndex = number(update.contentIndex) ?? 0;
+    const field = updateType?.startsWith('thinking_') ? 'reasoning' : updateType?.startsWith('text_') ? 'text' : null;
+    if (!updateType || !field)
+        return { events: [], lane };
+    const itemId = `${scope.textPrefix}${field}_${contentIndex}_${lane.textBlock}`;
+    const events = [];
+    let { startedItems, textByItem, endedItems } = lane;
+    const makeItem = (text) => withParent(field === 'text' ? { kind: 'message', id: itemId, role: 'assistant', text } : { kind: 'reasoning', id: itemId, text }, scope);
+    const delta = string(update.delta);
+    if (!startedItems.has(itemId)) {
+        if (delta === undefined && !updateType.endsWith('_end'))
+            return { events: [], lane };
+        events.push({ type: 'item.started', item: makeItem('') });
+        startedItems = new Set(startedItems).add(itemId);
+    }
+    if (delta !== undefined) {
+        events.push({ type: 'item.delta', itemId, field, delta });
+        const next = new Map(textByItem);
+        next.set(itemId, `${next.get(itemId) ?? ''}${delta}`);
+        textByItem = next;
+    }
+    if (updateType.endsWith('_end')) {
+        const text = string(update.content) ?? textByItem.get(itemId) ?? '';
+        events.push({ type: 'item.completed', item: makeItem(text) });
+        endedItems = new Set(endedItems).add(itemId);
+    }
+    return { events, lane: { ...lane, startedItems, textByItem, endedItems } };
+}
+/** Same as pi-ui-mapper.ts `closeOpenPiText`, for one lane. */
+function closeLaneText(lane, scope) {
+    const events = [];
+    let endedItems = lane.endedItems;
+    for (const id of lane.startedItems) {
+        if (endedItems.has(id))
+            continue;
+        const kind = LANE_ITEM.exec(id)?.[1];
+        if (!kind)
+            continue;
+        const text = lane.textByItem.get(id) ?? '';
+        events.push({
+            type: 'item.completed',
+            item: withParent(kind === 'text' ? { kind: 'message', id, role: 'assistant', text } : { kind: 'reasoning', id, text }, scope),
+        });
+        endedItems = new Set(endedItems).add(id);
+    }
+    return { events, lane: { ...lane, endedItems, textBlock: lane.textBlock + 1 } };
+}
+function parentScope(state) {
+    return { textPrefix: `${state.turnId ?? 'turn_0'}_`, toolPrefix: '' };
+}
+function childScope(rowId) {
+    return { textPrefix: `${rowId}/`, toolPrefix: `${rowId}/`, parentItemId: rowId };
+}
+function withParent(item, scope) {
+    return scope.parentItemId === undefined ? item : { ...item, parentItemId: scope.parentItemId };
+}
+function closeParentText(state) {
+    const closed = closeLaneText(laneOf(state), parentScope(state));
+    return { events: closed.events, state: { ...state, ...closed.lane } };
+}
+/** Same wire as pi-ui-mapper.ts `mapMessageUpdate` (rpc.md, v18.4.11). */
+function mapMessageUpdate(value, state) {
+    const update = isRecord(value.assistantMessageEvent) ? value.assistantMessageEvent : undefined;
+    const updateType = update ? string(update.type) : undefined;
+    if (!update || !updateType || !state.turnId)
+        return { events: [], state };
+    if (updateType === 'done') {
+        return { events: [], state: { ...state, stopReason: mapOmpMessageStopReason(string(update.reason)) } };
+    }
+    if (updateType === 'error') {
+        const reason = string(update.reason) === 'aborted' ? 'cancelled' : 'error';
+        const error = isRecord(update.error) ? string(update.error.errorMessage) : undefined;
+        return {
+            events: [],
+            state: { ...state, stopReason: reason, latchedProviderError: error ?? `omp model ${reason}` },
+        };
+    }
+    const mapped = laneTextUpdate(update, laneOf(state), parentScope(state));
+    return { events: mapped.events, state: { ...state, ...mapped.lane } };
+}
+/** Same wire as pi-ui-mapper.ts `mapMessageEnd` (rpc.md, v18.4.11). */
+function mapMessageEnd(value, state) {
+    const message = isRecord(value.message) ? value.message : undefined;
+    if (!message || string(message.role) !== 'assistant')
+        return { events: [], state };
+    const closed = closeParentText(state);
+    state = closed.state;
+    const events = [...closed.events];
+    const accounted = accountUsage(ompMessageUsage(value), state);
+    events.push(...accounted.events);
+    state = accounted.state;
+    // Latch the failed attempt, clear on a successful one (#316): `agent_end {yielded:false}`
+    // follows a failed attempt OMP is about to retry, and a recovered retry must stay silent.
+    if (string(message.stopReason) === 'error') {
+        state = { ...state, latchedProviderError: ompProviderErrorMessage(message) };
+    }
+    else {
+        state = { ...state, latchedProviderError: null };
+    }
+    state = { ...state, stopReason: mapOmpMessageStopReason(string(message.stopReason)) };
+    return { events, state };
+}
+/** Same as pi-ui-mapper.ts `mapPiMessageStopReason`. */
+function mapOmpMessageStopReason(reason) {
+    if (reason === 'error')
+        return 'error';
+    if (reason === 'aborted')
+        return 'cancelled';
+    if (reason === 'length')
+        return 'max_tokens';
+    return 'end_turn';
+}
+/* ------------------------------------------------------------------ */
+/* Tools                                                                */
+/* ------------------------------------------------------------------ */
+/** `toolDisplay` plus the OMP-only shapes: `todo` is the plan tool and a batch `task` is a plain card. */
+function ompToolDisplay(name, args) {
+    if (name === 'todo')
+        return { toolKind: 'plan', title: 'Update plan' };
+    if (name === 'task' && isRecord(args) && Array.isArray(args.tasks)) {
+        // The drawer lists one synthetic row per sub-agent; the card itself must not be a row too.
+        return { toolKind: 'other', title: `Task batch · ${args.tasks.length} agent${args.tasks.length === 1 ? '' : 's'}` };
+    }
+    // The single form has no `description`; its `task` text is the row's label.
+    const display = name === 'task' && isRecord(args) && args.description === undefined
+        ? toolDisplay(name, { description: args.task })
+        : toolDisplay(name, args);
+    return { toolKind: display.toolKind, title: display.title };
+}
+function mapToolStart(value, state) {
+    const callId = string(value.toolCallId);
+    const name = string(value.toolName);
+    if (!callId || !name)
+        return { events: [], state };
+    const closed = closeParentText(state);
+    state = closed.state;
+    const started = toolStarted(callId, name, value.args, parentScope(state), state);
+    let batchCalls = state.batchCalls;
+    if (name === 'task' && isRecord(value.args) && Array.isArray(value.args.tasks)) {
+        batchCalls = new Set(batchCalls).add(callId);
+    }
+    return { events: [...closed.events, ...started.events], state: { ...started.state, batchCalls } };
+}
+function toolStarted(callId, name, args, scope, state) {
+    const display = ompToolDisplay(name, args);
+    const item = withParent({
+        kind: 'tool',
+        id: `${scope.toolPrefix}${callId}`,
+        name,
+        toolKind: display.toolKind,
+        title: display.title,
+        status: 'running',
+        input: args,
+    }, scope);
+    const tools = new Map(state.tools);
+    tools.set(item.id, item);
+    return { events: [{ type: 'item.started', item }], state: { ...state, tools } };
+}
+function mapToolUpdate(value, state) {
+    return toolUpdated(value, '', state);
+}
+function toolUpdated(value, toolPrefix, state) {
+    const callId = string(value.toolCallId);
+    const id = callId ? `${toolPrefix}${callId}` : undefined;
+    const previous = id ? state.tools.get(id) : undefined;
+    if (!id || !previous)
+        return { events: [], state };
+    const output = contentText(isRecord(value.partialResult) ? value.partialResult.content : undefined);
+    if (output === undefined)
+        return { events: [], state };
+    const item = { ...previous, output };
+    const tools = new Map(state.tools);
+    tools.set(id, item);
+    return { events: [{ type: 'item.updated', item }], state: { ...state, tools } };
+}
+function mapToolEnd(value, state) {
+    return toolEnded(value, parentScope(state), state, true);
+}
+function toolEnded(value, scope, state, publishPlan) {
+    const callId = string(value.toolCallId);
+    const id = callId ? `${scope.toolPrefix}${callId}` : undefined;
+    const previous = id ? state.tools.get(id) : undefined;
+    if (!id || !previous)
+        return { events: [], state };
+    const result = isRecord(value.result) ? value.result : {};
+    const output = contentText(result.content);
+    const isError = value.isError === true || result.isError === true;
+    // A single-form `task` row is its sub-agent's: in RPC OMP runs `task` asynchronously by
+    // default, so the result can arrive while the agent still runs, and an aborted agent's result
+    // can still read as success. Its lifecycle status wins over a successful result.
+    const agent = scope.toolPrefix === '' ? singleFormSubagent(state, id) : undefined;
+    if (agent)
+        state = withSubagent(state, agent[0], { ...agent[1], ended: true });
+    const status = isError ? 'failed' : agent ? agent[1].status : 'completed';
+    const item = {
+        ...previous,
+        status,
+        ...(isError ? { error: output ?? 'omp tool failed' } : output !== undefined ? { output } : {}),
+    };
+    const diffs = isError ? undefined : ompToolDiffs(previous.name, previous.input, result);
+    if (diffs) {
+        item.diffs = diffs;
+        // Hashline edits carry the path only in `{input}` text; the result names it.
+        if (previous.name.toLowerCase() === 'edit' && !argsPath(previous.input)) {
+            item.title = diffs.length === 1 ? `Edit ${diffs[0].path}` : `Edit ${diffs.length} files`;
+        }
+    }
+    const tools = new Map(state.tools);
+    tools.set(id, item);
+    const events = [{ type: status === 'running' ? 'item.updated' : 'item.completed', item }];
+    // A sub-agent's todo list is its own; it never replaces the session's plan dock.
+    const plan = publishPlan && !isError ? ompToolPlan(previous.name, result) : undefined;
+    if (plan)
+        events.push({ type: 'plan.updated', entries: plan });
+    return { events, state: { ...state, tools } };
+}
+/**
+ * Diffs for an `edit`/`write` call. OMP's default `edit.mode` is `hashline` (args `{input}`), so
+ * the change lives in the result `details` (`path`/`oldText`/`newText`, or `perFileResults[]` for
+ * several files — `src/edit/index.ts` `aggregateDetails`, v18.4.11). Falls back to replace-mode
+ * args and `write` content, the same reading as pi-ui-mapper.ts `toolDiffs`.
+ */
+function ompToolDiffs(name, args, result) {
+    const key = name.toLowerCase();
+    if (key !== 'edit' && key !== 'write')
+        return undefined;
+    const details = isRecord(result.details) ? result.details : undefined;
+    if (details) {
+        const files = Array.isArray(details.perFileResults) ? details.perFileResults : [details];
+        const diffs = files.flatMap((file) => {
+            const diff = isRecord(file) ? detailDiff(file) : undefined;
+            return diff ? [diff] : [];
+        });
+        if (diffs.length > 0)
+            return diffs;
+    }
+    return argsDiffs(key, args);
+}
+function detailDiff(file) {
+    const path = string(file.path);
+    const oldText = string(file.oldText);
+    const newText = string(file.newText);
+    if (!path || (oldText === undefined && newText === undefined))
+        return undefined;
+    return { path, oldText: oldText ?? null, ...(newText !== undefined ? { newText } : {}) };
+}
+/** The path keys `toolDisplay` titles an edit from. */
+function argsPath(input) {
+    if (!isRecord(input))
+        return undefined;
+    return string(input.path) ?? string(input.file_path) ?? string(input.filePath);
+}
+/** Same reading as pi-ui-mapper.ts `toolDiffs`. */
+function argsDiffs(key, input) {
+    if (!isRecord(input))
+        return undefined;
+    const path = argsPath(input);
+    if (!path)
+        return undefined;
+    const oldText = string(input.oldText) ?? string(input.old_string) ?? (key === 'write' ? null : undefined);
+    const newText = string(input.newText) ?? string(input.new_string) ?? string(input.content);
+    if (oldText === undefined && newText === undefined)
+        return undefined;
+    return [{ path, oldText: oldText ?? null, ...(newText !== undefined ? { newText } : {}) }];
+}
+const TODO_STATUS = {
+    pending: 'pending',
+    in_progress: 'in_progress',
+    completed: 'completed',
+    abandoned: 'cancelled',
+    // A blocked task is still to do; the plan vocabulary has no "blocked".
+    blocked: 'pending',
+};
+/**
+ * The whole plan from a state-changing `todo` result: `details.phases[].tasks[]` holds the full
+ * list after the op (`src/tools/todo.ts` `committedTodoPhases`, v18.4.11). `view` is a read.
+ */
+function ompToolPlan(name, result) {
+    if (name !== 'todo' || !isRecord(result.details))
+        return undefined;
+    const { op, phases } = result.details;
+    if (op === 'view' || !Array.isArray(phases))
+        return undefined;
+    const entries = [];
+    for (const phase of phases) {
+        if (!isRecord(phase) || !Array.isArray(phase.tasks))
+            continue;
+        for (const task of phase.tasks) {
+            if (!isRecord(task))
+                continue;
+            const content = string(task.content);
+            const status = TODO_STATUS[string(task.status) ?? ''];
+            if (content && status)
+                entries.push({ content, status });
+        }
+    }
+    return entries;
+}
+/* ------------------------------------------------------------------ */
+/* Sub-agents                                                           */
+/* ------------------------------------------------------------------ */
+function lifecycleStatus(status) {
+    if (status === 'completed')
+        return 'completed';
+    if (status === 'failed' || status === 'aborted')
+        return 'failed';
+    return 'running';
+}
+/** The batch entry this sub-agent runs: by `name` (OMP derives the id from it), else by index. */
+function batchTask(parent, id, index) {
+    const tasks = isRecord(parent?.input) && Array.isArray(parent.input.tasks) ? parent.input.tasks : [];
+    const byName = tasks.find((task) => isRecord(task) && string(task.name) === id);
+    if (isRecord(byName))
+        return byName;
+    const byIndex = index !== undefined ? tasks[index] : undefined;
+    return isRecord(byIndex) ? byIndex : undefined;
+}
+function mapSubagentLifecycle(payload, state) {
+    const id = string(payload.id);
+    if (!id)
+        return { events: [], state };
+    const status = lifecycleStatus(string(payload.status));
+    const events = [];
+    const parentToolCallId = string(payload.parentToolCallId) ?? '';
+    let entry = state.subagents.get(id);
+    // v18.4.11 `AgentOutputManager.allocate` keeps ids unique within one session, but a
+    // `new_session` in the same process starts a fresh allocator. A `started` frame naming
+    // another parent call is a new agent: rebind the id so its events cannot reach the old row.
+    if (entry && string(payload.status) === 'started' && parentToolCallId && entry.parentToolCallId !== parentToolCallId) {
+        entry = undefined;
+    }
+    if (!entry) {
+        const parent = parentToolCallId ? state.tools.get(parentToolCallId) : undefined;
+        // A single-form call IS the sub-agent's row; a batch call (or an unknown parent) gets one
+        // synthetic `task` row per sub-agent so the drawer counts agents, not calls.
+        const single = parent !== undefined && !state.batchCalls.has(parentToolCallId);
+        const rowId = single ? parentToolCallId : `${parentToolCallId || 'omp-subagent'}#${id}`;
+        entry = { rowId, parentToolCallId, status, ended: false };
+        state = withSubagent(state, id, entry);
+        if (!single) {
+            const agent = string(payload.agent);
+            const task = batchTask(parent, id, number(payload.index));
+            const taskText = task ? string(task.task) : undefined;
+            const label = string(payload.description) ?? taskText ?? agent ?? id;
+            const item = {
+                kind: 'tool',
+                id: rowId,
+                name: 'task',
+                toolKind: 'task',
+                title: toolDisplay('task', { description: label }).title,
+                status: 'running',
+                input: { ...(agent ? { agent } : {}), ...(taskText ? { task: taskText } : {}) },
+            };
+            const tools = new Map(state.tools);
+            tools.set(rowId, item);
+            state = { ...state, tools };
+            events.push({ type: 'item.started', item });
+        }
+    }
+    // Replay what arrived before this frame named the parent, ahead of any terminal close.
+    const buffered = state.pendingSubagentEvents.get(id);
+    if (buffered) {
+        const pendingSubagentEvents = new Map(state.pendingSubagentEvents);
+        pendingSubagentEvents.delete(id);
+        state = { ...state, pendingSubagentEvents };
+        for (const event of buffered) {
+            const mapped = mapChildEvent(event, entry.rowId, state);
+            state = mapped.state;
+            events.push(...mapped.events);
+        }
+    }
+    if (status !== 'running') {
+        // An aborted agent leaves its last block open; it ends with the agent, not the turn.
+        const lane = state.childLanes.get(entry.rowId);
+        if (lane) {
+            const closed = closeLaneText(lane, childScope(entry.rowId));
+            events.push(...closed.events);
+            state = withChildLane(state, entry.rowId, closed.lane);
+        }
+    }
+    if (entry.status !== status) {
+        entry = { ...entry, status };
+        state = withSubagent(state, id, entry);
+    }
+    // A batch row is the agent's own; a single-form row is the `task` call, which follows the
+    // lifecycle only once its result has arrived (`toolEnded` reads `status` up to then).
+    const single = entry.rowId === entry.parentToolCallId;
+    const row = !single || (entry.ended && status !== 'running') ? state.tools.get(entry.rowId) : undefined;
+    if (row && row.status !== status && (!single || row.status === 'running')) {
+        const item = { ...row, status };
+        const tools = new Map(state.tools);
+        tools.set(row.id, item);
+        state = { ...state, tools };
+        events.push({ type: status === 'running' ? 'item.updated' : 'item.completed', item });
+    }
+    return { events, state };
+}
+/** The sub-agent whose single-form `task` call is row `rowId`, with its id. */
+function singleFormSubagent(state, rowId) {
+    for (const [id, entry] of state.subagents) {
+        if (entry.rowId === rowId && entry.parentToolCallId === rowId)
+            return [id, entry];
+    }
+    return undefined;
+}
+function withSubagent(state, id, entry) {
+    const subagents = new Map(state.subagents);
+    subagents.set(id, entry);
+    return { ...state, subagents };
+}
+function mapSubagentEvent(payload, state) {
+    const id = string(payload.id);
+    if (!id || !isRecord(payload.event))
+        return { events: [], state };
+    // Account on receipt, before the presentation buffer. Replaying or dropping visual
+    // frames must neither duplicate nor discard spend (hearsay-tools/cezarion#833).
+    const accounted = accountUsage(ompMessageUsage({ type: 'subagent_event', payload }), state);
+    const mapped = mapSubagentVisualEvent(id, payload.event, accounted.state);
+    return { events: [...accounted.events, ...mapped.events], state: mapped.state };
+}
+function mapSubagentVisualEvent(id, event, state) {
+    const entry = state.subagents.get(id);
+    if (entry)
+        return mapChildEvent(event, entry.rowId, state);
+    // Only the lifecycle frame names the parent call: hold the event until it arrives.
+    const buffered = state.pendingSubagentEvents.get(id);
+    const full = buffered
+        ? buffered.length >= PENDING_SUBAGENT_EVENTS_PER_ID
+        : state.pendingSubagentEvents.size >= PENDING_SUBAGENT_IDS;
+    if (full) {
+        if (state.subagentDropReported)
+            return { events: [], state };
+        return {
+            events: [{ type: 'session.error', message: SUBAGENT_DROP_MESSAGE, fatal: false }],
+            state: { ...state, subagentDropReported: true },
+        };
+    }
+    const pendingSubagentEvents = new Map(state.pendingSubagentEvents);
+    pendingSubagentEvents.set(id, [...(buffered ?? []), event]);
+    return { events: [], state: { ...state, pendingSubagentEvents } };
+}
+/**
+ * One sub-agent's `AgentSessionEvent`, nested under its row. It never ends the parent turn,
+ * never writes parent text or plan: a child `agent_end` only closes the child's own open
+ * text. Usage is accounted on receipt, outside this replayable presentation path.
+ */
+function mapChildEvent(event, rowId, state) {
+    if (!isRecord(event) || typeof event.type !== 'string')
+        return { events: [], state };
+    const scope = childScope(rowId);
+    const lane = state.childLanes.get(rowId) ?? EMPTY_LANE;
+    switch (event.type) {
+        case 'message_update': {
+            if (!isRecord(event.assistantMessageEvent))
+                return { events: [], state };
+            const mapped = laneTextUpdate(event.assistantMessageEvent, lane, scope);
+            return { events: mapped.events, state: withChildLane(state, rowId, mapped.lane) };
+        }
+        case 'message_end':
+        case 'agent_end': {
+            if (event.type === 'message_end' && !isAssistantMessageEnd(event))
+                return { events: [], state };
+            const closed = closeLaneText(lane, scope);
+            return { events: closed.events, state: withChildLane(state, rowId, closed.lane) };
+        }
+        case 'tool_execution_start': {
+            const callId = string(event.toolCallId);
+            const name = string(event.toolName);
+            if (!callId || !name)
+                return { events: [], state };
+            const closed = closeLaneText(lane, scope);
+            const started = toolStarted(callId, name, event.args, scope, withChildLane(state, rowId, closed.lane));
+            return { events: [...closed.events, ...started.events], state: started.state };
+        }
+        case 'tool_execution_update':
+            return toolUpdated(event, scope.toolPrefix, state);
+        case 'tool_execution_end':
+            return toolEnded(event, scope, state, false);
+        default:
+            return { events: [], state };
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Turn end, usage and errors                                           */
+/* ------------------------------------------------------------------ */
+/** Same as pi-ui-mapper.ts `completeTurn`, also closing every sub-agent's open text. */
+function completeTurn(reason, state) {
+    if (!state.turnId)
+        return { events: [], state };
+    const turnId = state.turnId;
+    const closed = closeParentText(state);
+    state = closed.state;
+    const events = [...closed.events];
+    for (const [rowId, lane] of state.childLanes) {
+        const child = closeLaneText(lane, childScope(rowId));
+        events.push(...child.events);
+        state = withChildLane(state, rowId, child.lane);
+    }
+    const flushed = ompFlushProviderError(state);
+    state = flushed.state;
+    const event = { type: 'turn.completed', turnId, stopReason: reason };
+    if (state.turnUsage)
+        event.usage = state.turnUsage;
+    if (state.turnCostUsd !== null)
+        event.costUsd = state.turnCostUsd;
+    return {
+        events: [...events, ...flushed.events, event],
+        state: { ...state, turnId: null, turnPromptId: null, turnPromptAdmitted: false, turnUsage: null, turnCostUsd: null },
+    };
+}
+/** Same as pi-ui-mapper.ts `piFlushProviderError`: release the latch as `session.error` (#256). */
+export function ompFlushProviderError(state) {
+    if (!state.latchedProviderError)
+        return { events: [], state };
+    return {
+        events: [{ type: 'session.error', message: state.latchedProviderError, fatal: false }],
+        state: { ...state, latchedProviderError: null },
+    };
+}
+/** Same as pi-ui-mapper.ts `piProviderErrorMessage`, prefixed `omp:`. */
+export function ompProviderErrorMessage(message) {
+    const detail = ompProviderErrorDetail(message);
+    const provider = string(message.provider);
+    const model = string(message.model);
+    const who = provider && model ? `${provider}/${model}` : (provider ?? model);
+    if (who && detail)
+        return `omp: ${who} request failed: ${detail}`;
+    if (who)
+        return `omp: ${who} request failed`;
+    if (detail)
+        return `omp: provider request failed: ${detail}`;
+    return 'omp: provider request failed';
+}
+/** Same as pi-ui-mapper.ts `piProviderErrorDetail`. */
+function ompProviderErrorDetail(message) {
+    if (Array.isArray(message.diagnostics)) {
+        for (const diagnostic of message.diagnostics) {
+            if (!isRecord(diagnostic) || string(diagnostic.type) !== 'provider_transport_failure')
+                continue;
+            const error = isRecord(diagnostic.error) ? string(diagnostic.error.message) : undefined;
+            if (error)
+                return error;
+        }
+    }
+    return string(message.errorMessage);
+}
+/** Read the same native per-message report for both v1 and v2, including child envelopes. */
+export function ompMessageUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (value.type === 'subagent_event') {
+        if (!isRecord(value.payload) || !string(value.payload.id) || !isRecord(value.payload.event))
+            return undefined;
+        value = value.payload.event;
+    }
+    if (!isRecord(value) || value.type !== 'message_end' || !isRecord(value.message) || value.message.role !== 'assistant')
+        return undefined;
+    return usageEvent(value.message.usage);
+}
+function sumUsage(previous, next) {
+    return {
+        input: (previous?.input ?? 0) + next.input,
+        output: (previous?.output ?? 0) + next.output,
+        total: (previous?.total ?? 0) + (next.total ?? 0),
+        ...(previous?.cacheRead !== undefined || next.cacheRead !== undefined
+            ? { cacheRead: (previous?.cacheRead ?? 0) + (next.cacheRead ?? 0) } : {}),
+        ...(previous?.cacheWrite !== undefined || next.cacheWrite !== undefined
+            ? { cacheWrite: (previous?.cacheWrite ?? 0) + (next.cacheWrite ?? 0) } : {}),
+    };
+}
+function accountUsage(report, state) {
+    if (!report)
+        return { events: [], state };
+    const sessionUsage = sumUsage(state.sessionUsage, report.usage);
+    const sessionCostUsd = report.costUsd === undefined ? state.sessionCostUsd : (state.sessionCostUsd ?? 0) + report.costUsd;
+    return {
+        events: [{ type: 'usage.updated', usage: sessionUsage, ...(sessionCostUsd !== null ? { costUsd: sessionCostUsd } : {}) }],
+        state: {
+            ...state, sessionUsage, sessionCostUsd,
+            ...(state.turnId ? {
+                turnUsage: sumUsage(state.turnUsage, report.usage),
+                turnCostUsd: report.costUsd === undefined ? state.turnCostUsd : (state.turnCostUsd ?? 0) + report.costUsd,
+            } : {}),
+        },
+    };
+}
+/** Native OMP message usage is an increment; the public usage.updated event is cumulative. */
+function usageEvent(value) {
+    if (!isRecord(value))
+        return undefined;
+    const input = number(value.input) ?? 0;
+    const output = number(value.output) ?? 0;
+    const cacheRead = number(value.cacheRead);
+    const cacheWrite = number(value.cacheWrite);
+    const total = number(value.totalTokens) ?? input + output + (cacheRead ?? 0) + (cacheWrite ?? 0);
+    const cost = isRecord(value.cost) ? number(value.cost.total) : undefined;
+    if (total <= 0 && !(cost !== undefined && cost > 0))
+        return undefined;
+    return {
+        type: 'usage.updated',
+        usage: {
+            input,
+            output,
+            total,
+            ...(cacheRead !== undefined ? { cacheRead } : {}),
+            ...(cacheWrite !== undefined ? { cacheWrite } : {}),
+        },
+        ...(cost !== undefined && cost >= 0 ? { costUsd: cost } : {}),
+    };
+}
+/** OMP's failure response carries `error` as a string (rpc.md § Responses). */
+function rpcError(value) {
+    if (typeof value.error === 'string')
+        return value.error;
+    const error = isRecord(value.error) ? value.error : undefined;
+    return string(error?.message) ?? string(value.message) ?? `omp RPC command ${string(value.command) ?? 'unknown'} failed`;
+}
+/** Same as pi-ui-mapper.ts `contentText`. */
+function contentText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = value
+        .map((part) => (isRecord(part) && part.type === 'text' ? string(part.text) : undefined))
+        .filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join('\n') : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function string(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=omp-ui-mapper.js.map