@xenosystem/agent-interface-host 0.1.3

package/dist/runtime/RuntimeTimelineProjection.js

@@ -0,0 +1,705 @@
+const UNKNOWN_REQUEST_ID = '__unknown_request__';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function readRawString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function readBoolean(record, key) {
+    const value = record[key];
+    return typeof value === 'boolean' ? value : undefined;
+}
+function readNumber(record, key) {
+    const value = record[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (typeof item !== 'string')
+            continue;
+        const trimmed = item.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+function readTokenUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    const input = readNumber(value, 'input');
+    const output = readNumber(value, 'output');
+    const total = readNumber(value, 'total');
+    if (input === undefined || output === undefined || total === undefined)
+        return undefined;
+    return { input, output, total };
+}
+function parseTimestampMs(timestamp) {
+    if (!timestamp)
+        return undefined;
+    const parsed = Date.parse(timestamp);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function readNestedPayload(record) {
+    return isRecord(record.event) ? record.event : record;
+}
+function normalizeRuntimeEvent(input, index) {
+    if (!isRecord(input))
+        return null;
+    const payload = readNestedPayload(input);
+    const type = readString(input, 'type') || readString(payload, 'type');
+    if (!type)
+        return null;
+    const sequence = readNumber(input, 'sequence') ?? readNumber(payload, 'sequence') ?? index + 1;
+    const timestamp = readString(input, 'timestamp') || readString(payload, 'timestamp');
+    const id = readString(input, 'id') || readString(payload, 'id') || `runtime-event-${sequence}-${index}`;
+    const requestId = readString(input, 'requestId') || readString(payload, 'requestId') || UNKNOWN_REQUEST_ID;
+    return {
+        id,
+        sequence,
+        timestamp,
+        timestampMs: parseTimestampMs(timestamp),
+        conversationId: readString(input, 'conversationId') || readString(payload, 'conversationId'),
+        workspaceId: readString(input, 'workspaceId') || readString(payload, 'workspaceId'),
+        teamId: readString(input, 'teamId') || readString(payload, 'teamId'),
+        agentId: readString(input, 'agentId') || readString(payload, 'agentId'),
+        requestId,
+        parentRunId: readString(input, 'parentRunId') || readString(payload, 'parentRunId'),
+        subagentRunId: readString(input, 'subagentRunId') || readString(payload, 'subagentRunId'),
+        providerKind: readString(input, 'providerKind') || readString(payload, 'providerKind'),
+        providerId: readString(input, 'providerId') || readString(payload, 'providerId'),
+        source: readString(input, 'source') || readString(payload, 'source'),
+        type,
+        schemaVersion: readString(input, 'schemaVersion') || readString(payload, 'schemaVersion'),
+        redactionState: readString(input, 'redactionState') || readString(payload, 'redactionState'),
+        payload,
+    };
+}
+function sortEvents(events) {
+    return events.slice().sort((a, b) => (a.sequence - b.sequence
+        || (a.timestampMs ?? Number.POSITIVE_INFINITY) - (b.timestampMs ?? Number.POSITIVE_INFINITY)
+        || a.id.localeCompare(b.id)));
+}
+function ensureRequest(state, event) {
+    const existing = state.requests.get(event.requestId);
+    if (existing)
+        return existing;
+    const request = {
+        requestId: event.requestId,
+        conversationId: event.conversationId,
+        parentRunId: event.parentRunId,
+        subagentRunId: event.subagentRunId,
+        status: 'unknown',
+        text: '',
+        textEventIds: [],
+        toolIds: [],
+        modelWaitEventIds: [],
+        eventIds: [],
+    };
+    state.requests.set(event.requestId, request);
+    return request;
+}
+function eventToolName(event) {
+    return readString(event.payload, 'toolName')
+        || readString(event.payload, 'tool')
+        || readString(event.payload, 'name')
+        || readString(event.payload, 'title')
+        || readString(event.payload, 'kind');
+}
+function eventToolCallId(event) {
+    return readString(event.payload, 'toolCallId')
+        || readString(event.payload, 'tool_call_id');
+}
+function toolKeyFor(event, fallbackToolName = 'unknown') {
+    const toolCallId = eventToolCallId(event);
+    if (toolCallId)
+        return `${event.requestId}:${toolCallId}`;
+    return `${event.requestId}:${eventToolName(event) || fallbackToolName}:${event.sequence}`;
+}
+function findLatestRunningTool(state, event, toolName) {
+    const normalized = (toolName || '').toLowerCase();
+    const candidates = Array.from(state.tools.values())
+        .filter((tool) => tool.requestId === event.requestId)
+        .filter((tool) => tool.status === 'running')
+        .filter((tool) => !normalized || tool.toolName.toLowerCase() === normalized)
+        .sort((a, b) => (Date.parse(b.startedAt || '') || 0) - (Date.parse(a.startedAt || '') || 0));
+    return candidates[0];
+}
+function ensureTool(state, event, status) {
+    const toolName = eventToolName(event) || 'unknown';
+    const directKey = toolKeyFor(event, toolName);
+    const existing = state.tools.get(directKey);
+    if (existing)
+        return existing;
+    const toolCallId = eventToolCallId(event);
+    if (!toolCallId && event.type === 'tool.completed') {
+        const running = findLatestRunningTool(state, event, toolName);
+        if (running)
+            return running;
+        state.orphanToolCompletionCount += 1;
+    }
+    const tool = {
+        id: directKey,
+        requestId: event.requestId,
+        toolCallId,
+        toolName,
+        status,
+        startedAt: status === 'running' ? event.timestamp : undefined,
+        eventIds: [],
+    };
+    state.tools.set(directKey, tool);
+    const request = ensureRequest(state, event);
+    if (!request.toolIds.includes(tool.id))
+        request.toolIds.push(tool.id);
+    return tool;
+}
+function attachToolEvent(tool, event) {
+    if (!tool.eventIds.includes(event.id))
+        tool.eventIds.push(event.id);
+}
+function readInputPreview(event) {
+    if ('inputPreview' in event.payload)
+        return event.payload.inputPreview;
+    if ('input' in event.payload)
+        return event.payload.input;
+    if ('params' in event.payload)
+        return event.payload.params;
+    return undefined;
+}
+function readOutputPreview(event) {
+    return readString(event.payload, 'outputPreview')
+        || readString(event.payload, 'output')
+        || readString(event.payload, 'result')
+        || readString(event.payload, 'summary')
+        || stringifyPreview(event.payload.rawOutput);
+}
+function stringifyPreview(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value).slice(0, 500);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizePermissionStatus(event) {
+    const raw = readString(event.payload, 'status') || readString(event.payload, 'decision');
+    if (raw === 'pending' || raw === 'granted' || raw === 'denied')
+        return raw;
+    const allowed = readBoolean(event.payload, 'allowed');
+    if (allowed === true)
+        return 'granted';
+    if (allowed === false)
+        return 'denied';
+    return 'unknown';
+}
+function normalizeAskUserStatus(event) {
+    const raw = readString(event.payload, 'status');
+    if (raw === 'pending' || raw === 'answered' || raw === 'cancelled')
+        return raw;
+    if (readString(event.payload, 'answer') || readString(event.payload, 'selectedOption'))
+        return 'answered';
+    return 'unknown';
+}
+function normalizeModelWaitStatus(event) {
+    if (event.type === 'hub.model.waiting')
+        return 'waiting';
+    if (event.type === 'hub.model.stalled')
+        return 'stalled';
+    if (event.type === 'hub.model.request.started')
+        return 'started';
+    if (event.type === 'hub.model.request.completed')
+        return 'completed';
+    if (event.type === 'hub.model.request.failed')
+        return 'failed';
+    const raw = readString(event.payload, 'status');
+    if (raw === 'started' || raw === 'waiting' || raw === 'completed' || raw === 'failed' || raw === 'stalled')
+        return raw;
+    return 'unknown';
+}
+function handleTurnEvent(state, event) {
+    const request = ensureRequest(state, event);
+    if (!request.eventIds.includes(event.id))
+        request.eventIds.push(event.id);
+    request.conversationId ||= event.conversationId;
+    request.parentRunId ||= event.parentRunId;
+    request.subagentRunId ||= event.subagentRunId;
+    if (event.type === 'turn.started') {
+        request.status = 'running';
+        request.startedAt = event.timestamp || request.startedAt;
+        request.model = readString(event.payload, 'model') || request.model;
+    }
+    else if (event.type === 'turn.completed') {
+        request.status = 'completed';
+        request.completedAt = event.timestamp || request.completedAt;
+        request.tokenUsage = readTokenUsage(event.payload.tokenUsage) || request.tokenUsage;
+        state.tokenUsage = request.tokenUsage || state.tokenUsage;
+    }
+    else if (event.type === 'turn.failed') {
+        request.status = 'failed';
+        request.failedAt = event.timestamp || request.failedAt;
+        request.error = readString(event.payload, 'error') || readString(event.payload, 'message') || request.error;
+    }
+    else if (event.type === 'turn.cancelled') {
+        request.status = 'cancelled';
+        request.completedAt = event.timestamp || request.completedAt;
+    }
+    if (event.type === 'turn.completed' || event.type === 'turn.failed' || event.type === 'turn.cancelled') {
+        closeRunningToolsForTerminalTurn(state, event);
+    }
+}
+function closeRunningToolsForTerminalTurn(state, event) {
+    for (const tool of state.tools.values()) {
+        if (tool.requestId !== event.requestId || tool.status !== 'running')
+            continue;
+        attachToolEvent(tool, event);
+        tool.status = 'failed';
+        tool.success = false;
+        tool.completedAt = event.timestamp || tool.completedAt;
+        tool.error = readString(event.payload, 'error')
+            || readString(event.payload, 'message')
+            || readString(event.payload, 'reason')
+            || 'Stopped before the tool completed.';
+    }
+}
+function handleTextEvent(state, event) {
+    const text = readRawString(event.payload, 'text') ?? readRawString(event.payload, 'delta');
+    if (text === undefined)
+        return;
+    const request = ensureRequest(state, event);
+    if (!request.eventIds.includes(event.id))
+        request.eventIds.push(event.id);
+    request.text += text;
+    request.textEventIds.push(event.id);
+    if (request.status === 'unknown')
+        request.status = 'running';
+}
+function handleToolEvent(state, event) {
+    const isStarted = event.type === 'tool.started';
+    const isCompleted = event.type === 'tool.completed';
+    const tool = ensureTool(state, event, isStarted ? 'running' : 'unknown');
+    attachToolEvent(tool, event);
+    if (isStarted) {
+        tool.status = 'running';
+        tool.startedAt = event.timestamp || tool.startedAt;
+        tool.input = readInputPreview(event) ?? tool.input;
+        tool.cwd = readString(event.payload, 'cwd') || tool.cwd;
+    }
+    if (isCompleted) {
+        const success = readBoolean(event.payload, 'success');
+        tool.status = success === false ? 'failed' : 'completed';
+        tool.success = success ?? true;
+        tool.completedAt = event.timestamp || tool.completedAt;
+        tool.durationMs = readNumber(event.payload, 'elapsedMs') ?? readNumber(event.payload, 'durationMs') ?? tool.durationMs;
+        tool.outputPreview = readOutputPreview(event) || tool.outputPreview;
+        tool.output = readString(event.payload, 'output') || readString(event.payload, 'result') || tool.output;
+        tool.error = readString(event.payload, 'error') || tool.error;
+    }
+}
+function handleAcpSessionEvent(state, event) {
+    const request = ensureRequest(state, event);
+    if (!request.eventIds.includes(event.id))
+        request.eventIds.push(event.id);
+    if (event.type === 'acp.session.started') {
+        request.status = 'running';
+        request.startedAt = event.timestamp || request.startedAt;
+        return;
+    }
+    if (event.type === 'acp.session.message.delta') {
+        handleTextEvent(state, event);
+        return;
+    }
+    if (event.type === 'acp.session.usage') {
+        const input = readNumber(event.payload, 'inputTokens') ?? 0;
+        const output = readNumber(event.payload, 'outputTokens') ?? 0;
+        const total = readNumber(event.payload, 'totalTokens') ?? input + output;
+        request.tokenUsage = { input, output, total };
+        state.tokenUsage = request.tokenUsage;
+        return;
+    }
+    if (event.type === 'acp.session.completed') {
+        request.status = 'completed';
+        request.completedAt = event.timestamp || request.completedAt;
+        closeRunningToolsForTerminalTurn(state, event);
+        return;
+    }
+    if (event.type === 'acp.session.cancelled') {
+        request.status = 'cancelled';
+        request.completedAt = event.timestamp || request.completedAt;
+        closeRunningToolsForTerminalTurn(state, event);
+        return;
+    }
+    if (event.type === 'acp.session.failed') {
+        request.status = 'failed';
+        request.failedAt = event.timestamp || request.failedAt;
+        request.error = readString(event.payload, 'error') || request.error;
+        closeRunningToolsForTerminalTurn(state, event);
+    }
+}
+function handleAcpToolEvent(state, event) {
+    const isStarted = event.type === 'acp.tool.started';
+    const isCompleted = event.type === 'acp.tool.completed';
+    const isFailed = event.type === 'acp.tool.failed';
+    const tool = ensureTool(state, event, isStarted ? 'running' : 'unknown');
+    attachToolEvent(tool, event);
+    tool.toolName = eventToolName(event) || tool.toolName || 'ACP Tool';
+    if (isStarted) {
+        tool.status = 'running';
+        tool.startedAt = event.timestamp || tool.startedAt;
+        tool.input = readInputPreview(event) ?? event.payload.rawInput ?? tool.input;
+        tool.outputPreview = readString(event.payload, 'title') || tool.outputPreview;
+        return;
+    }
+    if (event.type === 'acp.tool.updated') {
+        tool.status = tool.status === 'unknown' ? 'running' : tool.status;
+        tool.outputPreview = readOutputPreview(event) || tool.outputPreview;
+        return;
+    }
+    if (isCompleted || isFailed) {
+        tool.status = isFailed ? 'failed' : 'completed';
+        tool.success = !isFailed;
+        tool.completedAt = event.timestamp || tool.completedAt;
+        tool.outputPreview = readOutputPreview(event) || tool.outputPreview;
+        tool.output = readOutputPreview(event) || tool.output;
+        tool.error = readString(event.payload, 'error') || tool.error;
+    }
+}
+function handlePermissionEvent(state, event) {
+    const toolName = eventToolName(event);
+    const toolCallId = eventToolCallId(event);
+    const id = readString(event.payload, 'permissionId') || `${event.requestId}:permission:${toolCallId || event.sequence}`;
+    const permission = {
+        ...(state.permissions.get(id) || {
+            id,
+            requestId: event.requestId,
+            toolCallId,
+            toolName,
+            status: 'unknown',
+            startedAt: event.timestamp,
+        }),
+        status: normalizePermissionStatus(event),
+        reason: readString(event.payload, 'reason') || readString(event.payload, 'error'),
+        path: readString(event.payload, 'path'),
+        directory: readString(event.payload, 'directory'),
+        browserOrigin: readString(event.payload, 'browserOrigin'),
+        resolvedAt: event.timestamp,
+    };
+    state.permissions.set(id, permission);
+    const tool = toolCallId
+        ? state.tools.get(`${event.requestId}:${toolCallId}`)
+        : findLatestRunningTool(state, event, toolName);
+    if (tool) {
+        tool.permission = permission;
+        attachToolEvent(tool, event);
+        if (permission.status === 'denied') {
+            tool.status = 'failed';
+            tool.success = false;
+            tool.completedAt = event.timestamp || tool.completedAt;
+            tool.error = permission.reason || tool.error || 'Permission denied.';
+        }
+    }
+    else {
+        state.orphanPermissionCount += 1;
+    }
+}
+function handlePermissionProfileEvent(state, event) {
+    const request = ensureRequest(state, event);
+    const id = `${event.requestId}:permission-profile`;
+    const capabilities = isRecord(event.payload.capabilities) ? event.payload.capabilities : undefined;
+    const profile = {
+        id,
+        requestId: event.requestId,
+        profile: readString(event.payload, 'profile'),
+        sdkMode: readString(event.payload, 'sdkMode'),
+        ruleCount: readNumber(event.payload, 'ruleCount'),
+        allowedDirectoriesCount: readNumber(event.payload, 'allowedDirectoriesCount'),
+        approvalRulesCount: readNumber(event.payload, 'approvalRulesCount'),
+        capabilities,
+        selectedAt: event.timestamp,
+        eventId: event.id,
+    };
+    state.permissionProfiles.set(id, profile);
+    request.permissionProfile = profile;
+}
+function handleCheckpointEvent(state, event) {
+    const checkpointId = readString(event.payload, 'checkpointId');
+    if (!checkpointId)
+        return;
+    const checkpoint = {
+        id: `${event.requestId}:checkpoint:${checkpointId}`,
+        requestId: event.requestId,
+        checkpointId,
+        toolName: readString(event.payload, 'toolName'),
+        path: readString(event.payload, 'path'),
+        messageCount: readNumber(event.payload, 'messageCount'),
+        createdAt: event.timestamp,
+        eventId: event.id,
+    };
+    state.checkpoints.set(checkpoint.id, checkpoint);
+}
+/**
+ * `context.compacted` — the agent began continuing from a summary of its own history.
+ *
+ * ⚠️ Every field is optional except identity. The host builds this event from a request's
+ * `contextCompaction`, and a lane that reports compaction without token estimates is reporting
+ * something true; dropping the record because one number is absent would lose the boundary itself,
+ * which is the part no consumer can reconstruct.
+ */
+function handleCompactionEvent(state, event) {
+    const compaction = {
+        id: `${event.requestId}:compaction:${event.id}`,
+        requestId: event.requestId,
+        strategyVersion: readNumber(event.payload, 'strategyVersion'),
+        rawMessageCount: readNumber(event.payload, 'rawMessageCount'),
+        sentMessageCount: readNumber(event.payload, 'sentMessageCount'),
+        compactedMessageCount: readNumber(event.payload, 'compactedMessageCount'),
+        estimatedRawTokens: readNumber(event.payload, 'estimatedRawTokens'),
+        estimatedSentTokens: readNumber(event.payload, 'estimatedSentTokens'),
+        retainedAnchorCount: readNumber(event.payload, 'retainedAnchorCount'),
+        retainedArtifactCount: readNumber(event.payload, 'retainedArtifactCount'),
+        retainedGrantedDirectoryCount: readNumber(event.payload, 'retainedGrantedDirectoryCount'),
+        contextDigest: readString(event.payload, 'contextDigest'),
+        createdAt: event.timestamp,
+        eventId: event.id,
+    };
+    state.compactions.set(compaction.id, compaction);
+}
+function handleModelWaitEvent(state, event) {
+    const waitMs = readNumber(event.payload, 'waitMs');
+    const wait = {
+        id: `${event.requestId}:model-wait:${event.id}`,
+        requestId: event.requestId,
+        status: normalizeModelWaitStatus(event),
+        stage: readString(event.payload, 'stage'),
+        waitCategory: readString(event.payload, 'waitCategory'),
+        lifecycle: readString(event.payload, 'lifecycle'),
+        source: event.source,
+        message: readString(event.payload, 'message'),
+        error: readString(event.payload, 'error'),
+        waitMs,
+        timeoutMs: readNumber(event.payload, 'timeoutMs'),
+        warningMs: readNumber(event.payload, 'warningMs'),
+        hardTimeoutMs: readNumber(event.payload, 'hardTimeoutMs'),
+        activeToolCount: readNumber(event.payload, 'activeToolCount'),
+        lastToolName: readString(event.payload, 'lastToolName'),
+        lastToolCompletedAt: readString(event.payload, 'lastToolCompletedAt'),
+        lastToolCompletedSucceeded: readBoolean(event.payload, 'lastToolCompletedSucceeded'),
+        lastToolWasContextDiscovery: readBoolean(event.payload, 'lastToolWasContextDiscovery'),
+        postToolPlanningGraceEligible: readBoolean(event.payload, 'postToolPlanningGraceEligible'),
+        emittedAt: event.timestamp,
+        eventId: event.id,
+    };
+    state.modelWaits.set(wait.id, wait);
+    const request = ensureRequest(state, event);
+    if (!request.eventIds.includes(event.id))
+        request.eventIds.push(event.id);
+    if (!request.modelWaitEventIds.includes(event.id))
+        request.modelWaitEventIds.push(event.id);
+    if (waitMs !== undefined)
+        request.maxModelWaitMs = Math.max(request.maxModelWaitMs || 0, waitMs);
+    if (wait.status === 'stalled') {
+        request.modelStalledAt = event.timestamp || request.modelStalledAt;
+    }
+}
+function handleAskUserEvent(state, event) {
+    const toolCallId = eventToolCallId(event);
+    const id = readString(event.payload, 'askUserId') || readString(event.payload, 'requestId') || `${event.requestId}:ask-user:${toolCallId || event.sequence}`;
+    const askUser = {
+        ...(state.askUserRequests.get(id) || {
+            id,
+            requestId: event.requestId,
+            toolCallId,
+            options: [],
+            status: 'unknown',
+            startedAt: event.timestamp,
+        }),
+        question: readString(event.payload, 'question'),
+        options: readStringArray(event.payload.options),
+        answer: readString(event.payload, 'answer'),
+        selectedOption: readString(event.payload, 'selectedOption'),
+        status: normalizeAskUserStatus(event),
+        resolvedAt: event.timestamp,
+    };
+    state.askUserRequests.set(id, askUser);
+    const tool = toolCallId
+        ? state.tools.get(`${event.requestId}:${toolCallId}`)
+        : findLatestRunningTool(state, event, 'AskUser');
+    if (tool) {
+        tool.askUser = askUser;
+        attachToolEvent(tool, event);
+    }
+    else {
+        state.orphanAskUserCount += 1;
+    }
+}
+function applyEvent(state, event) {
+    state.events.push(event);
+    const request = ensureRequest(state, event);
+    if (!request.eventIds.includes(event.id))
+        request.eventIds.push(event.id);
+    if (event.type.startsWith('turn.')) {
+        handleTurnEvent(state, event);
+        return;
+    }
+    if (event.type === 'model.text.delta' || event.type === 'text.delta' || event.type === 'model.text.completed') {
+        handleTextEvent(state, event);
+        return;
+    }
+    if (event.type.startsWith('acp.session.') && event.type !== 'acp.session.permission.requested' && event.type !== 'acp.session.permission.decided') {
+        handleAcpSessionEvent(state, event);
+        return;
+    }
+    if (event.type.startsWith('acp.tool.')) {
+        handleAcpToolEvent(state, event);
+        return;
+    }
+    if (event.type === 'acp.session.permission.requested' || event.type === 'acp.session.permission.decided') {
+        handlePermissionEvent(state, event);
+        return;
+    }
+    if (event.type === 'tool.started' || event.type === 'tool.completed') {
+        handleToolEvent(state, event);
+        return;
+    }
+    if (event.type === 'tool.permission' || event.type === 'permission.requested' || event.type === 'permission.resolved') {
+        handlePermissionEvent(state, event);
+        return;
+    }
+    if (event.type === 'permission.profile.selected') {
+        handlePermissionProfileEvent(state, event);
+        return;
+    }
+    if (event.type === 'hub.checkpoint') {
+        handleCheckpointEvent(state, event);
+        return;
+    }
+    if (event.type === 'context.compacted') {
+        handleCompactionEvent(state, event);
+        return;
+    }
+    if (event.type.startsWith('hub.model.')) {
+        handleModelWaitEvent(state, event);
+        return;
+    }
+    if (event.type === 'ask_user.requested' || event.type === 'ask_user.answered' || event.type === 'ask_user.cancelled') {
+        handleAskUserEvent(state, event);
+    }
+}
+export function projectRuntimeTimeline(inputs) {
+    const seenIds = new Set();
+    const normalized = [];
+    let duplicateEventCount = 0;
+    inputs.forEach((input, index) => {
+        const event = normalizeRuntimeEvent(input, index);
+        if (!event)
+            return;
+        if (seenIds.has(event.id)) {
+            duplicateEventCount += 1;
+            return;
+        }
+        seenIds.add(event.id);
+        normalized.push(event);
+    });
+    const state = {
+        events: [],
+        requests: new Map(),
+        tools: new Map(),
+        permissions: new Map(),
+        permissionProfiles: new Map(),
+        checkpoints: new Map(),
+        compactions: new Map(),
+        modelWaits: new Map(),
+        askUserRequests: new Map(),
+        duplicateEventCount,
+        orphanToolCompletionCount: 0,
+        orphanPermissionCount: 0,
+        orphanAskUserCount: 0,
+    };
+    for (const event of sortEvents(normalized))
+        applyEvent(state, event);
+    const orderedEvents = state.events;
+    const requests = Array.from(state.requests.values())
+        .sort((a, b) => firstRequestSequence(a, orderedEvents) - firstRequestSequence(b, orderedEvents));
+    const tools = Array.from(state.tools.values())
+        .sort((a, b) => firstToolSequence(a, orderedEvents) - firstToolSequence(b, orderedEvents));
+    const permissions = Array.from(state.permissions.values());
+    const permissionProfiles = Array.from(state.permissionProfiles.values())
+        .sort((a, b) => firstProfileSequence(a, orderedEvents) - firstProfileSequence(b, orderedEvents));
+    const checkpoints = Array.from(state.checkpoints.values())
+        .sort((a, b) => firstCheckpointSequence(a, orderedEvents) - firstCheckpointSequence(b, orderedEvents));
+    const compactions = Array.from(state.compactions.values())
+        .sort((a, b) => firstCheckpointSequence(a, orderedEvents) - firstCheckpointSequence(b, orderedEvents));
+    const modelWaits = Array.from(state.modelWaits.values());
+    const maxModelWaitMs = modelWaits.reduce((max, wait) => Math.max(max, wait.waitMs || 0), 0);
+    const modelStallCount = modelWaits.filter((wait) => wait.status === 'stalled').length;
+    const askUserRequests = Array.from(state.askUserRequests.values());
+    const activeTools = tools.filter((tool) => tool.status === 'running');
+    const failedTools = tools.filter((tool) => tool.status === 'failed');
+    const last = orderedEvents[orderedEvents.length - 1];
+    return {
+        eventCount: orderedEvents.length,
+        orderedEvents,
+        requests,
+        tools,
+        activeTools,
+        failedTools,
+        permissions,
+        permissionProfiles,
+        checkpoints,
+        compactions,
+        modelWaits,
+        askUserRequests,
+        lastEventType: last?.type,
+        lastEventAt: last?.timestamp,
+        latestSequence: orderedEvents.reduce((max, event) => Math.max(max, event.sequence), 0),
+        tokenUsage: state.tokenUsage,
+        diagnostics: {
+            duplicateEventCount: state.duplicateEventCount,
+            orphanToolCompletionCount: state.orphanToolCompletionCount,
+            orphanPermissionCount: state.orphanPermissionCount,
+            orphanAskUserCount: state.orphanAskUserCount,
+            activeToolCount: activeTools.length,
+            failedToolCount: failedTools.length,
+            modelWaitCount: modelWaits.length,
+            modelStallCount,
+            maxModelWaitMs,
+        },
+    };
+}
+function firstRequestSequence(request, events) {
+    const event = events.find((candidate) => request.eventIds.includes(candidate.id));
+    return event?.sequence ?? Number.MAX_SAFE_INTEGER;
+}
+function firstToolSequence(tool, events) {
+    const event = events.find((candidate) => tool.eventIds.includes(candidate.id));
+    return event?.sequence ?? Number.MAX_SAFE_INTEGER;
+}
+function firstProfileSequence(profile, events) {
+    const event = events.find((candidate) => candidate.id === profile.eventId);
+    return event?.sequence ?? Number.MAX_SAFE_INTEGER;
+}
+/**
+ * Order any event-anchored record by where its event fell in the stream.
+ *
+ * ⚠️ Widened from `RuntimeTimelineCheckpoint` to a structural `{ eventId }` rather than copied
+ * for compactions. Two identical comparators drift; the second one is always the one nobody
+ * notices, because both look right in isolation.
+ */
+function firstCheckpointSequence(checkpoint, events) {
+    const event = events.find((candidate) => candidate.id === checkpoint.eventId);
+    return event?.sequence ?? Number.MAX_SAFE_INTEGER;
+}
+//# sourceMappingURL=RuntimeTimelineProjection.js.map