@pasko70/pibo 1.12.0 → 1.13.0

package/dist/core/session-router.js

@@ -7,6 +7,7 @@ import { runtimeSessionErrorDetails } from "./session-errors.js";
 import { createSubagentToolName } from "../subagents/tool.js";
 import { PiboRunRegistry } from "../runs/registry.js";
 import { PiboRunExecutionTimeoutError } from "../runs/lifecycle.js";
+import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
 import { createPiboSignalRegistry } from "../signals/registry.js";
 import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
 import { InMemoryPiboSessionStore, } from "../sessions/store.js";
@@ -86,6 +87,8 @@ function formatRunReminderMessage(notification) {
                 status: run.status,
                 toolName: run.toolName,
                 summary: run.summary,
+                resourceLimitReason: run.resources?.limitReason,
+                resourceUnit: run.resources?.unitName,
             })),
             timedOut: notification.timedOut.map((run) => ({
                 runId: run.runId,
@@ -202,6 +205,17 @@ export class PiboSessionRouter {
         this.runtimeRegistry = new RuntimeSessionRegistry({ cwd: options.cwd ?? getDefaultPiboWorkspace() });
         this.runRegistry = new PiboRunRegistry({ store: this.reliabilityStore });
         this.runRegistry.subscribe((event) => this.projectRunRegistryEvent(event));
+        const recoveredRuntimeState = options.recoverInterruptedRuntimeState
+            ? this.sessionStore.recoverInterruptedRuntimeState?.({
+                recoveredRuns: this.runRegistry.listRecoveredRuns(),
+            }) ?? []
+            : [];
+        for (const recovery of recoveredRuntimeState) {
+            const session = this.sessionStore.get(recovery.event.piboSessionId);
+            if (session)
+                this.signalRegistry.project({ type: "session_created", session });
+            this.signalRegistry.project({ type: "pibo_output", event: recovery.event });
+        }
         for (const run of this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })) {
             this.signalRegistry.project({ type: "run_changed", run, reason: "recovered" });
         }
@@ -863,8 +877,10 @@ export class PiboSessionRouter {
     }
     createRunToolController(parentPiboSessionId) {
         return {
-            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, timeoutMs, serviceWarning, execute }) => {
+            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, timeoutMs, serviceWarning, resources, execute }) => {
                 const admission = this.gatewayWorkAdmission.reserve(`yielded run ${toolName}`);
+                if (resources)
+                    resources.admission = admission.admission;
                 const reminderGeneration = this.runReminderGeneration(parentPiboSessionId);
                 let run;
                 try {
@@ -877,6 +893,7 @@ export class PiboSessionRouter {
                         maxAttempts,
                         timeoutMs,
                         serviceWarning,
+                        resources,
                     });
                 }
                 catch (error) {
@@ -886,15 +903,21 @@ export class PiboSessionRouter {
                 void (async () => {
                     try {
                         const result = await execute();
+                        if (resources)
+                            this.runRegistry.updateResources(run.runId, resources);
                         const completed = this.runRegistry.complete(run.runId, result);
                         if (completed)
                             this.handleTerminalRunReminder(parentPiboSessionId, completed.runId, reminderGeneration);
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
+                        if (resources)
+                            this.runRegistry.updateResources(run.runId, resources);
                         const terminalRun = error instanceof PiboRunExecutionTimeoutError
                             ? this.runRegistry.timeOut(run.runId, message, error.timeoutPhase)
-                            : this.runRegistry.fail(run.runId, message);
+                            : error instanceof PiboRunResourceLimitError
+                                ? this.runRegistry.resourceLimit(run.runId, message, error.resources)
+                                : this.runRegistry.fail(run.runId, message);
                         if (terminalRun)
                             this.handleTerminalRunReminder(parentPiboSessionId, terminalRun.runId, reminderGeneration);
                     }

package/dist/core/transcript-integrity.js

@@ -0,0 +1,431 @@
+import { sessionEntryToContextMessages, } from "@earendil-works/pi-coding-agent";
+export const PIBO_TRANSCRIPT_INTEGRITY_RESUME_MESSAGE_TYPE = "pibo-transcript-integrity-resume";
+export const PIBO_TRANSCRIPT_INTEGRITY_RESUME_PROMPT = "Continue the interrupted task autonomously from the repaired transcript. Do not rerun completed tools, wait for additional user input, or mention transcript repair unless it affects the result.";
+export const PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE = "pibo-transcript-integrity";
+const installedStates = new WeakMap();
+export class PiboTranscriptIntegrityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PiboTranscriptIntegrityError";
+    }
+}
+export function validatePiboTranscriptIntegrityMessages(messages) {
+    return validateProjectedMessages(messages.map((message) => ({ message })));
+}
+export function installPiboTranscriptIntegrity(session) {
+    const existing = installedStates.get(session);
+    if (existing)
+        return [...existing.reports];
+    const manager = session.sessionManager;
+    const state = {
+        session,
+        originalAppendMessage: manager.appendMessage.bind(manager),
+        restoredAssistants: new Map(),
+        reports: [],
+        continuationPending: false,
+        continuationInProgress: false,
+    };
+    installedStates.set(session, state);
+    manager.appendMessage = ((message) => appendMessageWithIntegrity(state, message));
+    patchProviderBoundary(state);
+    patchCompactionBoundaries(state);
+    reconcilePiboTranscriptIntegrity(session, "load");
+    return [...state.reports];
+}
+export function reconcilePiboTranscriptIntegrity(session, boundary) {
+    const state = installedStates.get(session);
+    if (!state)
+        throw new PiboTranscriptIntegrityError("Transcript integrity is not installed for this session");
+    const manager = session.sessionManager;
+    const activeEntries = manager.buildContextEntries();
+    const projected = projectEntries(activeEntries);
+    const [issue] = validateProjectedMessages(projected, manager.getEntries());
+    if (!issue)
+        return undefined;
+    const invalidEntry = issue.entryId ? manager.getEntry(issue.entryId) : undefined;
+    if (!invalidEntry) {
+        return quarantineRuntimeTranscript(state, boundary, issue);
+    }
+    const invalidEntryIndex = activeEntries.findIndex((entry) => entry.id === invalidEntry.id);
+    const removedEntryIds = invalidEntryIndex >= 0
+        ? activeEntries.slice(invalidEntryIndex).map((entry) => entry.id)
+        : [invalidEntry.id];
+    const resultMessage = isToolResultMessageEntry(invalidEntry) ? invalidEntry.message : undefined;
+    const authoritativeAssistant = resultMessage
+        ? uniqueAuthoritativeAssistant(manager.getEntries(), issue.toolCallId)
+        : undefined;
+    let report;
+    branchTo(manager, invalidEntry.parentId);
+    if (authoritativeAssistant && resultMessage && (issue.relation === "orphan_result" || issue.relation === "wrong_branch_result")) {
+        const repairId = manager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, repairMetadata({
+            boundary,
+            relation: issue.relation,
+            action: "restored_pair",
+            toolCallIds: assistantToolCalls(authoritativeAssistant.message).map((call) => call.id),
+            removedEntryIds,
+            restoredEntryIds: [authoritativeAssistant.id, invalidEntry.id],
+            phase: "journal_started",
+        }));
+        const restoredAssistantEntryId = state.originalAppendMessage(authoritativeAssistant.message);
+        rememberRestoredAssistant(state, authoritativeAssistant.message, restoredAssistantEntryId);
+        const restoredResultEntryId = state.originalAppendMessage(resultMessage);
+        manager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, {
+            repairId,
+            phase: "journal_committed",
+            restoredAssistantEntryId,
+            restoredResultEntryId,
+        });
+        report = {
+            repairId,
+            boundary,
+            relation: issue.relation,
+            action: "restored_pair",
+            toolCallIds: assistantToolCalls(authoritativeAssistant.message).map((call) => call.id),
+            removedEntryIds,
+            restoredEntryIds: [authoritativeAssistant.id, invalidEntry.id],
+            continuationRequired: boundary === "load",
+        };
+    }
+    else {
+        const repairId = manager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, repairMetadata({
+            boundary,
+            relation: issue.relation,
+            action: "quarantined_tail",
+            toolCallIds: [issue.toolCallId],
+            removedEntryIds,
+            restoredEntryIds: [],
+            phase: "quarantined",
+        }));
+        report = {
+            repairId,
+            boundary,
+            relation: issue.relation,
+            action: "quarantined_tail",
+            toolCallIds: [issue.toolCallId],
+            removedEntryIds,
+            restoredEntryIds: [],
+            continuationRequired: boundary === "load",
+        };
+    }
+    syncAgentTranscript(session);
+    assertSessionTranscriptValid(session, boundary);
+    recordReport(state, report);
+    return report;
+}
+export function claimPiboTranscriptIntegrityContinuation(session) {
+    const state = installedStates.get(session);
+    if (!state || !state.continuationPending || state.continuationInProgress)
+        return [];
+    const reports = state.reports.filter((report) => report.continuationRequired);
+    if (reports.length === 0) {
+        state.continuationPending = false;
+        return [];
+    }
+    state.continuationPending = false;
+    state.continuationInProgress = true;
+    session.sessionManager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, {
+        phase: "continuation_started",
+        repairIds: reports.map((report) => report.repairId),
+    });
+    return reports;
+}
+export function settlePiboTranscriptIntegrityContinuation(session, outcome, error) {
+    const state = installedStates.get(session);
+    if (!state?.continuationInProgress)
+        return;
+    state.continuationInProgress = false;
+    session.sessionManager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, {
+        phase: `continuation_${outcome}`,
+        ...(error ? { errorClass: error instanceof Error ? error.name : "Error" } : {}),
+    });
+}
+function patchProviderBoundary(state) {
+    const agent = state.session.agent;
+    const previous = agent.transformContext?.bind(agent);
+    const repairedProviderMessages = async (signal) => {
+        const repaired = state.session.sessionManager.buildSessionContext().messages;
+        if (!previous)
+            return repaired;
+        const transformed = await previous(repaired, signal);
+        return validatePiboTranscriptIntegrityMessages(transformed).length === 0 ? transformed : repaired;
+    };
+    agent.transformContext = async (messages, signal) => {
+        const transformed = previous ? await previous(messages, signal) : messages;
+        const durableRepair = reconcilePiboTranscriptIntegrity(state.session, "before_provider");
+        if (durableRepair)
+            return repairedProviderMessages(signal);
+        const [runtimeIssue] = validatePiboTranscriptIntegrityMessages(transformed);
+        if (!runtimeIssue)
+            return transformed;
+        quarantineRuntimeTranscript(state, "before_provider", runtimeIssue);
+        return repairedProviderMessages(signal);
+    };
+}
+function patchCompactionBoundaries(state) {
+    const session = state.session;
+    const originalCompact = session.compact.bind(session);
+    session.compact = (async (...args) => {
+        reconcilePiboTranscriptIntegrity(session, "before_compaction");
+        const result = await originalCompact(...args);
+        reconcilePiboTranscriptIntegrity(session, "after_compaction");
+        return result;
+    });
+}
+function appendMessageWithIntegrity(state, message) {
+    if (isAssistantMessage(message)) {
+        const restoredEntryId = restoredAssistantEntryId(state, message);
+        return restoredEntryId ?? state.originalAppendMessage(message);
+    }
+    if (!isToolResultMessage(message))
+        return state.originalAppendMessage(message);
+    const activeMessages = state.session.sessionManager.buildSessionContext().messages;
+    if (activeToolCall(activeMessages, message.toolCallId))
+        return state.originalAppendMessage(message);
+    const authoritativeAssistant = uniqueAssistantMessage(state.session.agent.state.messages, message.toolCallId);
+    if (authoritativeAssistant) {
+        const toolCallIds = assistantToolCalls(authoritativeAssistant).map((call) => call.id);
+        const repairId = state.session.sessionManager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, repairMetadata({
+            boundary: "persistence",
+            relation: "orphan_result",
+            action: "restored_pair",
+            toolCallIds,
+            removedEntryIds: [],
+            restoredEntryIds: [],
+            phase: "journal_started",
+        }));
+        const assistantEntryId = state.originalAppendMessage(authoritativeAssistant);
+        rememberRestoredAssistant(state, authoritativeAssistant, assistantEntryId);
+        const resultEntryId = state.originalAppendMessage(message);
+        state.session.sessionManager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, {
+            repairId,
+            phase: "journal_committed",
+            assistantEntryId,
+            resultEntryId,
+        });
+        recordReport(state, {
+            repairId,
+            boundary: "persistence",
+            relation: "orphan_result",
+            action: "restored_pair",
+            toolCallIds,
+            removedEntryIds: [],
+            restoredEntryIds: [assistantEntryId, resultEntryId],
+            continuationRequired: false,
+        });
+        return resultEntryId;
+    }
+    const repairId = state.session.sessionManager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, repairMetadata({
+        boundary: "persistence",
+        relation: "orphan_result",
+        action: "quarantined_runtime_result",
+        toolCallIds: [message.toolCallId],
+        removedEntryIds: [],
+        restoredEntryIds: [],
+        phase: "quarantined",
+    }));
+    recordReport(state, {
+        repairId,
+        boundary: "persistence",
+        relation: "orphan_result",
+        action: "quarantined_runtime_result",
+        toolCallIds: [message.toolCallId],
+        removedEntryIds: [],
+        restoredEntryIds: [],
+        continuationRequired: false,
+    });
+    syncAgentTranscript(state.session);
+    return repairId;
+}
+function quarantineRuntimeTranscript(state, boundary, issue) {
+    const repairId = state.session.sessionManager.appendCustomEntry(PIBO_TRANSCRIPT_INTEGRITY_ENTRY_TYPE, repairMetadata({
+        boundary,
+        relation: issue.relation,
+        action: "quarantined_runtime_result",
+        toolCallIds: [issue.toolCallId],
+        removedEntryIds: [],
+        restoredEntryIds: [],
+        phase: "quarantined",
+    }));
+    const report = {
+        repairId,
+        boundary,
+        relation: issue.relation,
+        action: "quarantined_runtime_result",
+        toolCallIds: [issue.toolCallId],
+        removedEntryIds: [],
+        restoredEntryIds: [],
+        continuationRequired: boundary === "load",
+    };
+    syncAgentTranscript(state.session);
+    recordReport(state, report);
+    return report;
+}
+function validateProjectedMessages(projected, allEntries = []) {
+    const calls = new Map();
+    const results = new Map();
+    const issues = [];
+    const allCalls = allAssistantCallIds(allEntries);
+    for (let messageIndex = 0; messageIndex < projected.length; messageIndex += 1) {
+        const { message, entry } = projected[messageIndex];
+        if (isAssistantMessage(message)) {
+            for (const call of assistantToolCalls(message)) {
+                const existing = calls.get(call.id);
+                if (existing) {
+                    issues.push({ relation: "duplicate_call", toolCallId: call.id, toolName: call.name, messageIndex, entryId: entry?.id });
+                    continue;
+                }
+                calls.set(call.id, { name: call.name, messageIndex });
+            }
+            continue;
+        }
+        if (!isToolResultMessage(message))
+            continue;
+        if (results.has(message.toolCallId)) {
+            issues.push({ relation: "duplicate_result", toolCallId: message.toolCallId, toolName: message.toolName, messageIndex, entryId: entry?.id });
+            continue;
+        }
+        results.set(message.toolCallId, messageIndex);
+        const call = calls.get(message.toolCallId);
+        if (!call) {
+            issues.push({
+                relation: allCalls.has(message.toolCallId) ? "wrong_branch_result" : "orphan_result",
+                toolCallId: message.toolCallId,
+                toolName: message.toolName,
+                messageIndex,
+                entryId: entry?.id,
+            });
+            continue;
+        }
+        if (call.name !== message.toolName) {
+            issues.push({
+                relation: "tool_name_mismatch",
+                toolCallId: message.toolCallId,
+                toolName: message.toolName,
+                expectedToolName: call.name,
+                messageIndex,
+                entryId: entry?.id,
+            });
+        }
+    }
+    return issues;
+}
+function projectEntries(entries) {
+    return entries.flatMap((entry) => sessionEntryToContextMessages(entry).map((message) => ({ entry, message })));
+}
+function allAssistantCallIds(entries) {
+    const ids = new Set();
+    for (const entry of entries) {
+        if (!isAssistantMessageEntry(entry))
+            continue;
+        for (const call of assistantToolCalls(entry.message))
+            ids.add(call.id);
+    }
+    return ids;
+}
+function uniqueAuthoritativeAssistant(entries, toolCallId) {
+    const candidates = entries.filter((entry) => isAssistantMessageEntry(entry) && assistantToolCalls(entry.message).some((call) => call.id === toolCallId));
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
+function uniqueAssistantMessage(messages, toolCallId) {
+    const candidates = messages.filter((message) => isAssistantMessage(message) && assistantToolCalls(message).some((call) => call.id === toolCallId));
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
+function activeToolCall(messages, toolCallId) {
+    for (const message of messages) {
+        if (!isAssistantMessage(message))
+            continue;
+        const call = assistantToolCalls(message).find((candidate) => candidate.id === toolCallId);
+        if (call)
+            return call;
+    }
+    return undefined;
+}
+function assistantToolCalls(message) {
+    if (!isAssistantMessage(message))
+        return [];
+    return message.content.flatMap((part) => {
+        if (!part || typeof part !== "object")
+            return [];
+        const candidate = part;
+        return candidate.type === "toolCall" && typeof candidate.id === "string" && typeof candidate.name === "string"
+            ? [{ type: "toolCall", id: candidate.id, name: candidate.name, arguments: candidate.arguments }]
+            : [];
+    });
+}
+function isAssistantMessage(message) {
+    return Boolean(message && typeof message === "object" && message.role === "assistant" && Array.isArray(message.content));
+}
+function isToolResultMessage(message) {
+    return Boolean(message
+        && typeof message === "object"
+        && message.role === "toolResult"
+        && typeof message.toolCallId === "string"
+        && typeof message.toolName === "string");
+}
+function isAssistantMessageEntry(entry) {
+    return entry.type === "message" && isAssistantMessage(entry.message);
+}
+function isToolResultMessageEntry(entry) {
+    return entry.type === "message" && isToolResultMessage(entry.message);
+}
+function branchTo(manager, parentId) {
+    if (parentId)
+        manager.branch(parentId);
+    else
+        manager.resetLeaf();
+}
+function syncAgentTranscript(session) {
+    session.agent.state.messages = session.sessionManager.buildSessionContext().messages;
+}
+function assertSessionTranscriptValid(session, boundary) {
+    const issues = validateProjectedMessages(projectEntries(session.sessionManager.buildContextEntries()), session.sessionManager.getEntries());
+    if (issues.length === 0)
+        return;
+    const issue = issues[0];
+    throw new PiboTranscriptIntegrityError(`Transcript integrity repair failed at ${boundary}: ${issue.relation} for tool call ${issue.toolCallId}`);
+}
+function rememberRestoredAssistant(state, message, entryId) {
+    const fingerprint = assistantFingerprint(message);
+    for (const call of assistantToolCalls(message))
+        state.restoredAssistants.set(call.id, { entryId, fingerprint });
+}
+function restoredAssistantEntryId(state, message) {
+    const calls = assistantToolCalls(message);
+    if (calls.length === 0)
+        return undefined;
+    const fingerprint = assistantFingerprint(message);
+    const restored = calls.map((call) => state.restoredAssistants.get(call.id));
+    if (restored.some((item) => !item || item.fingerprint !== fingerprint))
+        return undefined;
+    const entryIds = new Set(restored.map((item) => item.entryId));
+    return entryIds.size === 1 ? restored[0].entryId : undefined;
+}
+function assistantFingerprint(message) {
+    return JSON.stringify({
+        content: message.content,
+        api: message.api,
+        provider: message.provider,
+        model: message.model,
+        responseId: message.responseId,
+        timestamp: message.timestamp,
+    });
+}
+function repairMetadata(input) {
+    return {
+        version: 1,
+        boundary: input.boundary,
+        relation: input.relation,
+        action: input.action,
+        phase: input.phase,
+        toolCallIds: input.toolCallIds,
+        removedEntryIds: input.removedEntryIds,
+        restoredEntryIds: input.restoredEntryIds,
+        removedCount: input.removedEntryIds.length,
+        restoredCount: input.restoredEntryIds.length,
+    };
+}
+function recordReport(state, report) {
+    state.reports.push(report);
+    if (report.continuationRequired)
+        state.continuationPending = true;
+}

package/dist/data/pibo-store.js

@@ -39,6 +39,8 @@ export class PiboDataStore {
         this.telemetry = new TelemetryStore(this.db);
     }
     transaction(action) {
+        if (this.db.isTransaction)
+            return action();
         this.db.exec("BEGIN IMMEDIATE");
         try {
             const result = action();

package/dist/data/telemetry.js

@@ -86,6 +86,154 @@ export class TelemetryStore {
 		`).all(turnId);
         return rows.map(toolCallFromRow);
     }
+    listActiveTurns() {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_turns
+			WHERE status IN ('queued', 'running')
+			ORDER BY queued_at ASC, created_at ASC
+		`).all();
+        return rows.map(turnFromRow);
+    }
+    recoverInterruptedTurns(input = {}) {
+        const at = input.at ?? new Date().toISOString();
+        return this.transaction(() => this.listActiveTurns().map((turn) => {
+            const outcome = input.resolveOutcome?.(turn) ?? {
+                status: "aborted",
+                summary: "Turn was interrupted by gateway restart.",
+            };
+            const phaseStatus = outcome.status;
+            const providerStatus = outcome.status;
+            const toolStatus = outcome.status;
+            const phaseName = outcome.status === "timeout"
+                ? "timeout"
+                : outcome.status === "error"
+                    ? "error"
+                    : "abort";
+            for (const phase of this.listOpenPhasesForTurn(turn.turnId)) {
+                this.finishPhase(phase.phaseId, {
+                    status: phaseStatus,
+                    endedAt: at,
+                    lastProgressAt: at,
+                    summary: outcome.summary,
+                });
+            }
+            for (const request of this.listActiveProviderRequestsForTurn(turn.turnId)) {
+                this.upsertProviderRequest({
+                    providerRequestId: request.providerRequestId,
+                    piboSessionId: request.piboSessionId,
+                    rootSessionId: request.rootSessionId,
+                    roomId: request.roomId,
+                    turnId: request.turnId,
+                    phaseId: request.phaseId,
+                    provider: request.provider,
+                    api: request.api,
+                    model: request.model,
+                    transport: request.transport,
+                    serviceTier: request.serviceTier,
+                    status: providerStatus,
+                    responseHeadersAt: request.responseHeadersAt,
+                    firstByteAt: request.firstByteAt,
+                    lastRawEventAt: request.lastRawEventAt,
+                    lastNormalizedEventAt: request.lastNormalizedEventAt,
+                    completedAt: at,
+                    httpStatus: request.httpStatus,
+                    upstreamResponseId: request.upstreamResponseId,
+                    rawEventCount: request.rawEventCount,
+                    normalizedEventCount: request.normalizedEventCount,
+                    parseErrorCount: request.parseErrorCount,
+                    unknownEventCount: request.unknownEventCount,
+                    bytesReceived: request.bytesReceived,
+                    eventTypeCounts: request.eventTypeCounts,
+                    eventStreamId: request.eventStreamId,
+                    eventId: request.eventId,
+                    payloadRef: request.payloadRef,
+                    errorCategory: "runtime_restart",
+                    errorMessage: outcome.summary,
+                    captureMode: request.captureMode,
+                    retentionClass: request.retentionClass,
+                    updatedAt: at,
+                });
+            }
+            for (const toolCall of this.listActiveToolCallsForTurn(turn.turnId)) {
+                const executionEndedAt = toolCall.executionStartedAt ? at : toolCall.executionEndedAt;
+                this.upsertToolCall({
+                    toolCallId: toolCall.toolCallId,
+                    piboSessionId: toolCall.piboSessionId,
+                    rootSessionId: toolCall.rootSessionId,
+                    roomId: toolCall.roomId,
+                    turnId: toolCall.turnId,
+                    providerRequestId: toolCall.providerRequestId,
+                    providerItemId: toolCall.providerItemId,
+                    outputIndex: toolCall.outputIndex,
+                    toolName: toolCall.toolName,
+                    status: toolStatus,
+                    argsStartedAt: toolCall.argsStartedAt,
+                    firstDeltaAt: toolCall.firstDeltaAt,
+                    lastDeltaAt: toolCall.lastDeltaAt,
+                    argsCompletedAt: toolCall.argsCompletedAt,
+                    executionStartedAt: toolCall.executionStartedAt,
+                    executionEndedAt,
+                    durationMs: toolCall.executionStartedAt && executionEndedAt
+                        ? Math.max(0, Date.parse(executionEndedAt) - Date.parse(toolCall.executionStartedAt))
+                        : toolCall.durationMs,
+                    argsBytes: toolCall.argsBytes,
+                    parseStatus: toolCall.parseStatus,
+                    safeArgKeys: toolCall.safeArgKeys,
+                    eventStreamId: toolCall.eventStreamId,
+                    eventId: toolCall.eventId,
+                    payloadRef: toolCall.payloadRef,
+                    runId: toolCall.runId,
+                    errorCategory: "runtime_restart",
+                    errorMessage: outcome.summary,
+                    retentionClass: toolCall.retentionClass,
+                    updatedAt: at,
+                });
+            }
+            this.upsertPhase({
+                phaseId: `${turn.turnId}:runtime_restart`,
+                turnId: turn.turnId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                name: phaseName,
+                status: phaseStatus,
+                startedAt: at,
+                endedAt: at,
+                lastProgressAt: at,
+                eventId: turn.eventId,
+                runId: turn.runId,
+                summary: outcome.summary,
+                retentionClass: turn.retentionClass,
+                updatedAt: at,
+            });
+            const recovered = this.upsertTurn({
+                turnId: turn.turnId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                inputEventId: turn.inputEventId,
+                eventId: turn.eventId,
+                eventStreamId: turn.eventStreamId,
+                payloadRef: turn.payloadRef,
+                runId: turn.runId,
+                source: turn.source,
+                status: outcome.status,
+                currentPhase: phaseName,
+                queuedAt: turn.queuedAt,
+                startedAt: turn.startedAt,
+                completedAt: at,
+                lastProgressAt: at,
+                queuedBehind: turn.queuedBehind,
+                queueDepth: 0,
+                summary: outcome.summary,
+                retentionClass: turn.retentionClass,
+                createdAt: turn.createdAt,
+                updatedAt: at,
+                metadata: turn.metadata,
+            });
+            return { turn: recovered, outcome };
+        }));
+    }
     listProviderEventsPage(providerRequestId, input = {}) {
         return listTelemetryProviderEventsPage(this.db, providerRequestId, input);
     }