@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/apps/daemon/dist/session/prompt.js

@@ -2,7 +2,10 @@ import { decryptJson } from "../../../../packages/shared/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { getRuntime } from "../runtime.js";
 import { activePromptRequests, completedPromptRequests, sessions, sessionTurns } from "../state.js";
+import { handleGatewayTurnTerminal } from "../gateway/runtime.js";
+import { maybePromoteMemory, prepareMemoryContext, writeTurnMemory } from "../memory/manager.js";
 import { attachClaimedTurn, claimSessionTurn, releaseSessionTurn, sendCommandResponse, sendReliable } from "../relay/send.js";
+import { settleScheduleTurnTerminal } from "../schedule/runner.js";
 import { emitEvent, runtimeEventToPayload } from "./events.js";
 import { replaceAuthoritativeTranscript, resumeSession, usesAuthoritativeTranscript } from "./lifecycle.js";
 import { encryptedSessionMetadata, sessionFallbackFromCommand } from "./metadata.js";
@@ -22,14 +25,19 @@ export async function handlePrompt(ws, config, command) {
     }
     if (activePromptRequests.has(command.requestId))
         return;
-    const session = sessions.get(command.sessionId);
+    const fallback = await sessionFallbackFromCommand(config, command);
+    let session = sessions.get(command.sessionId);
     if (!session) {
-        const resumed = await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), false);
+        const resumed = await resumeSession(ws, config, command.sessionId, command.requestId, fallback, false);
         if (!resumed)
             return;
         await handlePrompt(ws, config, command);
         return;
     }
+    if (fallback?.tags && fallback.tags.length > 0) {
+        session = { ...session, tags: fallback.tags };
+        sessions.set(command.sessionId, session);
+    }
     if (!claimSessionTurn(command.sessionId, command.requestId, command.turnId, "prompt")) {
         await sendCommandResponse(ws, {
             type: "machine:error",
@@ -49,25 +57,69 @@ export async function handlePrompt(ws, config, command) {
         activePromptRequests.delete(command.requestId);
         releaseSessionTurn(command.sessionId, command.requestId);
     };
+    let phase = "decrypt-prompt";
     try {
         const prompt = await decryptJson(config.accountSecret, command.encryptedPrompt);
-        const text = prompt.type === "user_prompt" ? prompt.text : JSON.stringify(prompt);
+        const rawText = prompt.type === "user_prompt" ? prompt.text : JSON.stringify(prompt);
+        const promptAttachments = prompt.type === "user_prompt" ? normalizePromptAttachments(prompt.attachments) : [];
+        phase = "prepare-attachments";
+        const preparedPrompt = preparePromptAttachments(rawText, promptAttachments);
+        phase = "decrypt-memory-options";
+        const memoryOptions = await decryptMemoryOptions(config, command);
+        phase = "prepare-memory-context";
+        const memoryContext = memoryOptions
+            ? await prepareMemoryContext(memoryOptions, preparedPrompt.text)
+            : { text: preparedPrompt.text, used: [], options: undefined };
+        const text = memoryContext.text;
+        phase = "emit-submitted";
         await emitEvent(ws, config, command.sessionId, command.turnId, {
             type: "status",
             text: "Prompt submitted to runtime",
         });
+        if (memoryOptions) {
+            phase = "emit-memory-status";
+            await emitEvent(ws, config, command.sessionId, command.turnId, {
+                type: "status",
+                tag: "memory",
+                text: memoryOptions.mode === "off"
+                    ? "Memory mode off for this turn"
+                    : memoryContext.used.length > 0
+                        ? `Memory ${memoryOptions.mode} used: ${memoryContext.used.map((item) => `${item.path}:${item.citation.startLine}-${item.citation.endLine}`).join(", ")}`
+                        : `Memory ${memoryOptions.mode}: no relevant citations found`,
+            });
+            if (memoryContext.used.length > 0 && memoryOptions.mode !== "off") {
+                await emitEvent(ws, config, command.sessionId, command.turnId, {
+                    type: "memory_used",
+                    mode: memoryOptions.mode,
+                    projectKey: memoryOptions.projectKey,
+                    memories: memoryContext.used.map((item) => ({
+                        id: item.id,
+                        layer: item.layer,
+                        path: item.path,
+                        ...(item.title ? { title: item.title } : {}),
+                        citation: item.citation,
+                    })),
+                });
+            }
+        }
         const previousBackendSessionId = session.handle.backendSessionId;
+        const model = modelFromCommand(command.model) ?? session.model ?? session.handle.model;
+        phase = "start-turn";
         const turn = getRuntime(session.cwd).startTurn({
             handle: session.handle,
             text,
             mode: "prompt",
             permissionMode: command.permissionMode,
+            model,
+            attachments: preparedPrompt.runtimeAttachments,
             requestId: command.requestId,
             timeoutMs: command.timeoutMs,
         });
+        phase = "attach-turn";
         if (!attachClaimedTurn(command.sessionId, command.requestId, command.turnId, turn)) {
             throw new Error(`Session turn claim was lost before start: ${command.sessionId}`);
         }
+        phase = "audit-turn-start";
         await appendAudit({
             sessionId: command.sessionId,
             machineId: config.machineId,
@@ -78,13 +130,46 @@ export async function handlePrompt(ws, config, command) {
                 requestId: command.requestId,
                 turnId: command.turnId,
                 promptChars: text.length,
+                rawPromptChars: rawText.length,
+                attachmentCount: promptAttachments.length,
+                runtimeAttachmentCount: preparedPrompt.runtimeAttachments.length,
                 permissionMode: command.permissionMode ?? "approve-reads",
+                model,
+                memoryMode: memoryOptions?.mode,
+                usedMemories: memoryContext.used.map((item) => ({ path: item.path, citation: item.citation })),
             },
         });
+        let outputPreview = "";
+        phase = "stream-turn";
         for await (const event of turn.events) {
-            await emitEvent(ws, config, command.sessionId, command.turnId, runtimeEventToPayload(event));
+            const payload = runtimeEventToPayload(event);
+            if (payload.type === "text_delta" && payload.stream !== "thought") {
+                outputPreview = truncateOutputPreview(`${outputPreview}${payload.text}`, 4000);
+            }
+            await emitEvent(ws, config, command.sessionId, command.turnId, payload);
         }
+        phase = "await-turn-result";
         const result = await turn.result;
+        phase = "write-memory";
+        const dailyMemory = await writeTurnMemory(memoryOptions, {
+            promptText: rawText,
+            outputPreview,
+            requestId: command.requestId,
+            turnId: command.turnId,
+            status: result.status,
+        });
+        const promotedMemory = await maybePromoteMemory(memoryOptions, rawText);
+        if (dailyMemory || promotedMemory) {
+            await emitEvent(ws, config, command.sessionId, command.turnId, {
+                type: "status",
+                tag: "memory",
+                text: [
+                    dailyMemory ? `Memory daily write: ${dailyMemory.path}` : "",
+                    promotedMemory ? `Memory promoted: ${promotedMemory.path}` : "",
+                ].filter(Boolean).join(" · "),
+            });
+        }
+        phase = "refresh-runtime-metadata";
         const refreshedMetadata = session.handle.backendSessionId
             ? await encryptedSessionMetadata(config, command.sessionId, session, {
                 currentHead: result.currentHead,
@@ -106,6 +191,7 @@ export async function handlePrompt(ws, config, command) {
                 },
             });
         }
+        phase = "emit-terminal";
         await emitEvent(ws, config, command.sessionId, command.turnId, result.status === "failed"
             ? {
                 type: "done",
@@ -121,8 +207,10 @@ export async function handlePrompt(ws, config, command) {
                 currentHead: result.currentHead,
                 lastTurnId: result.lastTurnId,
             });
-        await refreshAuthoritativeTranscriptAfterTurn(ws, config, session, command.requestId, result.currentHead, result.lastTurnId);
+        phase = "refresh-authoritative-transcript";
+        await refreshAuthoritativeTranscriptAfterTurn(ws, config, session, command.requestId, result.currentHead, result.lastTurnId, result.status);
         releasePromptTurn();
+        phase = "send-turn-done";
         await sendReliable({
             type: "machine:turnDone",
             sessionId: command.sessionId,
@@ -133,6 +221,27 @@ export async function handlePrompt(ws, config, command) {
             error: result.status === "failed" ? result.error.message : undefined,
             encryptedMetadata: refreshedMetadata,
         }, ws);
+        phase = "terminal-hooks";
+        await handleGatewayTurnTerminal(config, {
+            sessionId: command.sessionId,
+            requestId: command.requestId,
+            turnId: command.turnId,
+            status: result.status,
+            stopReason: result.status === "failed" ? undefined : result.stopReason,
+            error: result.status === "failed" ? result.error.message : undefined,
+            outputPreview,
+        }).catch((error) => {
+            console.error(`Gateway terminal hook failed for ${command.turnId}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        await settleScheduleTurnTerminal({
+            requestId: command.requestId,
+            turnId: command.turnId,
+            status: result.status,
+            error: result.status === "failed" ? result.error.message : undefined,
+            outputPreview,
+        }).catch((error) => {
+            console.error(`Schedule terminal hook failed for ${command.turnId}: ${error instanceof Error ? error.message : String(error)}`);
+        });
         completedPromptRequests.set(command.requestId, {
             sessionId: command.sessionId,
             turnId: command.turnId,
@@ -152,10 +261,148 @@ export async function handlePrompt(ws, config, command) {
             },
         });
     }
+    catch (error) {
+        const response = promptFailureResponse(command, phase, error);
+        await appendAudit(promptFailureAuditEvent(config, command, phase, error)).catch((auditError) => {
+            console.error(`Prompt failure audit failed for ${command.turnId}: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
+        });
+        await sendCommandResponse(ws, response);
+    }
     finally {
         releasePromptTurn();
     }
 }
+export async function handleOptionResponse(ws, config, command) {
+    if (command.type !== "machine:optionResponse")
+        return;
+    const activeTurnId = sessionTurns.activeTurnId(command.sessionId);
+    const activeTurn = sessionTurns.activeTurn(command.sessionId);
+    if (!activeTurn || activeTurnId !== command.turnId) {
+        await sendCommandResponse(ws, {
+            type: "machine:error",
+            requestId: command.requestId,
+            sessionId: command.sessionId,
+            code: "OPTION_REQUEST_NOT_ACTIVE",
+            message: "No matching active turn is waiting for this option response",
+        });
+        return;
+    }
+    if (!activeTurn.respondOption) {
+        await sendCommandResponse(ws, {
+            type: "machine:error",
+            requestId: command.requestId,
+            sessionId: command.sessionId,
+            code: "OPTION_RESPONSE_UNSUPPORTED",
+            message: "This runtime does not support Happy Elves option responses",
+        });
+        return;
+    }
+    await activeTurn.respondOption({
+        optionRequestId: command.optionRequestId,
+        ...(command.selectedOptionId ? { selectedOptionId: command.selectedOptionId } : {}),
+        ...(command.text ? { text: command.text } : {}),
+    });
+    await emitEvent(ws, config, command.sessionId, command.turnId, {
+        type: "option_response",
+        optionRequestId: command.optionRequestId,
+        ...(command.selectedOptionId ? { selectedOptionId: command.selectedOptionId } : {}),
+        ...(command.text ? { text: command.text } : {}),
+    });
+    await sendCommandResponse(ws, {
+        type: "machine:optionResponded",
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        turnId: command.turnId,
+        optionRequestId: command.optionRequestId,
+    });
+}
+function modelFromCommand(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export function promptFailureResponse(command, phase, error) {
+    const code = promptFailureCode(phase, error);
+    return {
+        type: "machine:error",
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        code,
+        message: promptFailureMessage(code, error),
+    };
+}
+export function promptFailureAuditEvent(config, command, phase, error) {
+    const code = promptFailureCode(phase, error);
+    return {
+        sessionId: command.sessionId,
+        machineId: config.machineId,
+        actor: "system",
+        action: "turn.prompt.failed",
+        summary: `Failed to run prompt turn ${command.turnId}`,
+        evidence: {
+            requestId: command.requestId,
+            turnId: command.turnId,
+            code,
+            phase,
+            message: safeErrorMessage(error),
+        },
+    };
+}
+function promptFailureCode(phase, error) {
+    if (phase === "decrypt-prompt" && isCryptoOperationFailure(error))
+        return "PROMPT_DECRYPT_FAILED";
+    if (phase === "decrypt-memory-options" && isCryptoOperationFailure(error))
+        return "MEMORY_OPTIONS_DECRYPT_FAILED";
+    if (phase === "start-turn" || phase === "attach-turn")
+        return "TURN_START_FAILED";
+    if (phase === "stream-turn" || phase === "await-turn-result")
+        return "TURN_RUNTIME_FAILED";
+    if (phase === "refresh-runtime-metadata")
+        return "SESSION_METADATA_REFRESH_FAILED";
+    if (phase === "emit-submitted" || phase === "emit-memory-status" || phase === "emit-terminal")
+        return "SESSION_EVENT_EMIT_FAILED";
+    return "PROMPT_EXECUTION_FAILED";
+}
+function promptFailureMessage(code, error) {
+    if (code === "PROMPT_DECRYPT_FAILED") {
+        return "Failed to decrypt the prompt for this daemon. Re-pair the daemon with the correct account secret.";
+    }
+    if (code === "MEMORY_OPTIONS_DECRYPT_FAILED") {
+        return "Failed to decrypt memory options for this turn.";
+    }
+    return safeErrorMessage(error);
+}
+function isCryptoOperationFailure(error) {
+    const record = error && typeof error === "object" ? error : {};
+    const name = typeof record.name === "string" ? record.name : "";
+    const code = typeof record.code === "string" ? record.code : "";
+    const message = safeErrorMessage(error);
+    return name === "OperationError" ||
+        code === "ERR_OSSL_BAD_DECRYPT" ||
+        /operation-specific reason|decrypt|authentication tag|Unsupported state or unable to authenticate data/i.test(message);
+}
+function safeErrorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error);
+}
+async function decryptMemoryOptions(config, command) {
+    if (!command.encryptedMemoryOptions)
+        return undefined;
+    try {
+        const options = await decryptJson(config.accountSecret, command.encryptedMemoryOptions);
+        if (!options || typeof options.projectKey !== "string")
+            return undefined;
+        if (options.mode !== "off" && options.mode !== "readonly" && options.mode !== "readwrite")
+            return undefined;
+        return {
+            mode: options.mode,
+            projectKey: options.projectKey,
+            ...(typeof options.topN === "number" && options.topN > 0 ? { topN: options.topN } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 async function refreshAuthoritativeTranscriptAfterTurn(ws, config, session, requestId, currentHead, lastTurnId, status) {
     if (!usesAuthoritativeTranscript(session))
         return;
@@ -163,6 +410,8 @@ async function refreshAuthoritativeTranscriptAfterTurn(ws, config, session, requ
         const backfill = await replaceAuthoritativeTranscript(ws, config, session, undefined, {
             currentHead,
             lastTurnId,
+            replacementKind: "command",
+            requestId,
             ...(status ? { status } : {}),
         });
         sessions.set(session.sessionId, { ...session, historicalBackfill: {
@@ -221,6 +470,92 @@ export async function handleCancel(ws, config, command) {
             status: "cancelled",
             lastTurnId: turnId,
         }, ws);
+        await handleGatewayTurnTerminal(config, {
+            sessionId: command.sessionId,
+            requestId: command.requestId,
+            turnId,
+            status: "cancelled",
+            stopReason: command.reason,
+        }).catch((error) => {
+            console.error(`Gateway cancel hook failed for ${turnId}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        await settleScheduleTurnTerminal({
+            requestId: command.requestId,
+            turnId,
+            status: "cancelled",
+            error: command.reason,
+        }).catch((error) => {
+            console.error(`Schedule cancel hook failed for ${turnId}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+}
+function truncateOutputPreview(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return value.slice(value.length - maxChars);
+}
+function normalizePromptAttachments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((attachment) => {
+        if (!attachment ||
+            typeof attachment.id !== "string" ||
+            typeof attachment.name !== "string" ||
+            typeof attachment.mediaType !== "string" ||
+            typeof attachment.data !== "string" ||
+            typeof attachment.sizeBytes !== "number")
+            return [];
+        return [{
+                id: attachment.id,
+                name: attachment.name,
+                mediaType: attachment.mediaType,
+                sizeBytes: attachment.sizeBytes,
+                data: attachment.data,
+            }];
+    });
+}
+function preparePromptAttachments(text, attachments) {
+    const textBlocks = [];
+    const runtimeAttachments = [];
+    for (const attachment of attachments) {
+        const decodedText = decodeTextAttachment(attachment);
+        if (decodedText !== undefined) {
+            textBlocks.push([
+                `--- Attachment: ${attachment.name} (${attachment.mediaType}, ${attachment.sizeBytes} bytes) ---`,
+                decodedText,
+                "--- End attachment ---",
+            ].join("\n"));
+            continue;
+        }
+        runtimeAttachments.push({
+            name: attachment.name,
+            mediaType: attachment.mediaType,
+            sizeBytes: attachment.sizeBytes,
+            data: attachment.data,
+        });
+    }
+    return {
+        text: textBlocks.length > 0
+            ? `${text}\n\nAttached text files:\n\n${textBlocks.join("\n\n")}`
+            : text,
+        runtimeAttachments,
+    };
+}
+function decodeTextAttachment(attachment) {
+    const mediaType = attachment.mediaType.toLowerCase();
+    const textLike = mediaType.startsWith("text/") ||
+        mediaType.includes("json") ||
+        mediaType.includes("xml") ||
+        mediaType.includes("yaml") ||
+        mediaType.includes("csv") ||
+        /\.(txt|md|markdown|json|jsonl|yaml|yml|csv|tsv|log|xml|html|css|js|ts|tsx|jsx|vue|py|rb|go|rs|java|c|cc|cpp|h|hpp|sh|zsh|bash|ps1)$/iu.test(attachment.name);
+    if (!textLike)
+        return undefined;
+    try {
+        return Buffer.from(attachment.data, "base64").toString("utf8").slice(0, 64 * 1024);
+    }
+    catch {
+        return undefined;
     }
 }
 //# sourceMappingURL=prompt.js.map

package/apps/daemon/dist/session/reconcile.d.ts

@@ -0,0 +1,3 @@
+import type { MachineCommand } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+export declare function handleReconcileTurn(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;

package/apps/daemon/dist/session/reconcile.js

@@ -0,0 +1,235 @@
+import { appendAudit } from "../audit.js";
+import { handleGatewayTurnTerminal } from "../gateway/runtime.js";
+import { getRuntime } from "../runtime.js";
+import { sessions, sessionTurns } from "../state.js";
+import { sendCommandResponse } from "../relay/send.js";
+import { settleScheduleTurnTerminal } from "../schedule/runner.js";
+import { commandSessionMetadata } from "./metadata.js";
+export async function handleReconcileTurn(ws, config, command) {
+    if (command.type !== "machine:reconcileTurn")
+        return;
+    const activeClaim = sessionTurns.activeClaim(command.sessionId);
+    if (activeClaim && (!command.turnId || activeClaim.turnId === command.turnId)) {
+        await sendReconcileResult(ws, config, command, {
+            sessionId: command.sessionId,
+            turnId: activeClaim.turnId,
+            requestId: activeClaim.requestId,
+            status: "active",
+            reason: "Daemon still has an in-memory active turn claim",
+            evidence: { type: "in_memory", detail: activeClaim.source },
+        });
+        return;
+    }
+    const state = await sessionStateForReconcile(config, command);
+    if (!state) {
+        await sendReconcileResult(ws, config, command, {
+            sessionId: command.sessionId,
+            turnId: command.turnId,
+            requestId: command.activeRequestId,
+            providerTurnId: command.providerTurnId,
+            status: "uninspectable",
+            reason: "Session runtime handle is not loaded and no persisted provider handle was available",
+            evidence: { type: "missing", detail: "session-runtime-handle" },
+        });
+        return;
+    }
+    const runtime = getRuntime(state.cwd);
+    let inspection;
+    if (runtime.inspectTurn) {
+        inspection = await runtime.inspectTurn({
+            handle: state.handle,
+            turnId: command.turnId,
+            providerTurnId: command.providerTurnId,
+            requestId: command.activeRequestId,
+        });
+    }
+    else if (runtime.readHistoricalSessionEvents && state.handle.backendSessionId) {
+        try {
+            const events = await runtime.readHistoricalSessionEvents({
+                agent: state.agent,
+                cwd: state.cwd,
+                runtimeSessionId: state.handle.backendSessionId,
+                handle: state.handle,
+            });
+            inspection = inspectHistoricalEvents(events, {
+                turnId: command.turnId,
+                providerTurnId: command.providerTurnId,
+                fallbackProviderTurnId: state.handle.backendSessionId,
+            });
+        }
+        catch (error) {
+            inspection = {
+                status: "unknown",
+                providerTurnId: command.providerTurnId ?? state.handle.backendSessionId,
+                reason: error instanceof Error ? error.message : String(error),
+                evidence: "provider-history-error",
+            };
+        }
+    }
+    else {
+        inspection = {
+            status: "uninspectable",
+            providerTurnId: command.providerTurnId ?? state.handle.backendSessionId,
+            reason: "Runtime does not support inspectTurn or historical event reads",
+            evidence: "unsupported",
+        };
+    }
+    const result = reconcileResultFromInspection(command, inspection);
+    await appendAudit({
+        sessionId: command.sessionId,
+        machineId: config.machineId,
+        actor: "system",
+        action: "turn.reconcile",
+        summary: `Reconcile ${command.turnId ?? command.providerTurnId ?? "latest"}: ${result.status}`,
+        evidence: {
+            requestId: command.requestId,
+            turnId: command.turnId,
+            activeRequestId: command.activeRequestId,
+            providerTurnId: command.providerTurnId,
+            result,
+        },
+    });
+    await sendReconcileResult(ws, config, command, result);
+    if (result.status === "terminal" && result.terminalStatus && result.turnId) {
+        await settleTerminalSideEffects(config, result);
+    }
+}
+async function sendReconcileResult(ws, config, command, result) {
+    await sendCommandResponse(ws, {
+        type: "machine:turnReconciled",
+        requestId: command.requestId,
+        machineId: config.machineId,
+        result,
+    });
+}
+async function sessionStateForReconcile(config, command) {
+    const existing = sessions.get(command.sessionId);
+    if (existing)
+        return existing;
+    const metadata = await commandSessionMetadata(config, command.encryptedMetadata);
+    if (!metadata?.runtime)
+        return undefined;
+    const handle = handleFromMetadata(command.sessionId, metadata);
+    if (!handle)
+        return undefined;
+    return {
+        sessionId: command.sessionId,
+        agent: metadata.agent ?? handle.runtimeSessionName,
+        cwd: metadata.cwd || handle.cwd || process.cwd(),
+        name: metadata.name ?? command.sessionId,
+        handle,
+    };
+}
+function handleFromMetadata(sessionId, metadata) {
+    const runtime = metadata.runtime;
+    if (!runtime)
+        return undefined;
+    const runtimeSessionName = runtime.runtimeSessionName ?? metadata.agent;
+    if (!runtimeSessionName)
+        return undefined;
+    return {
+        sessionKey: sessionId,
+        backend: runtime.backend ?? "unknown",
+        runtimeSessionName,
+        cwd: metadata.cwd,
+        acpxRecordId: runtime.acpxRecordId,
+        backendSessionId: runtime.backendSessionId,
+        agentSessionId: runtime.agentSessionId,
+        externalProviderId: runtime.externalProviderId,
+        externalHandle: runtime.externalHandle,
+    };
+}
+function reconcileResultFromInspection(command, inspection) {
+    const base = {
+        sessionId: command.sessionId,
+        turnId: command.turnId,
+        requestId: command.activeRequestId,
+        providerTurnId: inspection.providerTurnId ?? command.providerTurnId,
+        evidence: evidenceFromInspection(inspection),
+    };
+    if (inspection.status === "terminal") {
+        return {
+            ...base,
+            status: "terminal",
+            terminalStatus: inspection.terminalStatus,
+            currentHead: inspection.currentHead,
+            lastTurnId: inspection.lastTurnId,
+            error: inspection.error,
+        };
+    }
+    return {
+        ...base,
+        status: inspection.status,
+        reason: inspection.status === "active" ? undefined : inspection.reason,
+    };
+}
+function evidenceFromInspection(inspection) {
+    if (inspection.evidence?.includes("history"))
+        return { type: "provider_history", detail: inspection.evidence };
+    if (inspection.evidence?.includes("unsupported"))
+        return { type: "unsupported", detail: inspection.evidence };
+    if (inspection.evidence?.includes("missing"))
+        return { type: "missing", detail: inspection.evidence };
+    if (inspection.evidence)
+        return { type: "provider_inspect", detail: inspection.evidence };
+    return undefined;
+}
+function inspectHistoricalEvents(events, input) {
+    const candidates = new Set([input.turnId, input.providerTurnId].filter((value) => typeof value === "string" && value.length > 0));
+    const providerTurnId = input.providerTurnId ?? input.fallbackProviderTurnId;
+    const relevant = candidates.size === 0
+        ? events
+        : events.filter((event) => {
+            if (candidates.has(event.turnId))
+                return true;
+            if (event.payload.type !== "done")
+                return false;
+            return Boolean((event.payload.currentHead && candidates.has(event.payload.currentHead)) ||
+                (event.payload.lastTurnId && candidates.has(event.payload.lastTurnId)));
+        });
+    if (relevant.length === 0) {
+        return {
+            status: "not_found",
+            providerTurnId,
+            reason: "No provider history event matched the requested turn",
+            evidence: "provider-history-empty",
+        };
+    }
+    const done = [...relevant].reverse().find((event) => event.payload.type === "done");
+    if (done?.payload.type === "done") {
+        return {
+            status: "terminal",
+            terminalStatus: done.payload.status,
+            currentHead: done.payload.currentHead,
+            lastTurnId: done.payload.lastTurnId ?? done.turnId,
+            providerTurnId: done.payload.lastTurnId ?? done.payload.currentHead ?? providerTurnId,
+            error: done.payload.error,
+            evidence: "provider-history-terminal",
+        };
+    }
+    return {
+        status: "active",
+        providerTurnId,
+        evidence: "provider-history-nonterminal-events",
+    };
+}
+async function settleTerminalSideEffects(config, result) {
+    await handleGatewayTurnTerminal(config, {
+        sessionId: result.sessionId,
+        requestId: result.requestId ?? result.turnId ?? "",
+        turnId: result.turnId ?? result.lastTurnId ?? "",
+        status: result.terminalStatus ?? "completed",
+        error: result.error,
+    }).catch((error) => {
+        console.error(`Gateway reconcile terminal hook failed for ${result.turnId}: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    await settleScheduleTurnTerminal({
+        requestId: result.requestId ?? result.turnId ?? "",
+        turnId: result.turnId ?? result.lastTurnId ?? "",
+        status: result.terminalStatus ?? "completed",
+        error: result.error,
+    }).catch((error) => {
+        console.error(`Schedule reconcile terminal hook failed for ${result.turnId}: ${error instanceof Error ? error.message : String(error)}`);
+    });
+}
+//# sourceMappingURL=reconcile.js.map