@zq-silk/yui 0.13.7 → 0.13.9

package/dist/run/agentRun.js

@@ -1,6 +1,5 @@
 import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { formatAgentRunReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
-import { prepareProviderRetryDispatch, validateAgentRunProviderRetry } from "./providerRetry.js";
 import { validateYieldReceipt } from "./yieldReceipt.js";
 import { validateAgentRunControlRequest } from "./runControlRequest.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
@@ -30,7 +29,7 @@ export function createAgentRun(id, taskId, roleName, mode, assignment, now, cont
         })
         : validateRunAssignment(assignment);
     return {
-        schemaVersion: 9,
+        schemaVersion: 10,
         id: requireSafeIdentity(id, "Agent run id"),
         taskId: requireSafeIdentity(taskId, "Task id"),
         roleName: requireSafeIdentity(roleName, "Role name"),
@@ -104,8 +103,8 @@ export function markAgentRunDelivered(run, now) {
     };
 }
 export function validateAgentRun(run) {
-    if (run.schemaVersion !== 9)
-        throw new Error("Agent run must use schemaVersion 9.");
+    if (run.schemaVersion !== 10)
+        throw new Error("Agent run must use schemaVersion 10.");
     validateTaskRecordReference({ taskId: run.taskId, localId: run.id }, "agentRun");
     requireSafeIdentity(run.roleName, "Role name");
     if (run.mode !== "new" && run.mode !== "resume") {
@@ -266,12 +265,6 @@ export function validateAgentRun(run) {
             }
         }
     }
-    if (run.providerRetry !== undefined) {
-        validateAgentRunProviderRetry(run.providerRetry);
-        if (run.status !== "active") {
-            throw new Error("A terminal Agent run cannot carry a providerRetry projection.");
-        }
-    }
     if (run.controlRequest !== undefined) {
         validateAgentRunControlRequest(run.controlRequest);
         if (run.status !== "active") {
@@ -304,60 +297,17 @@ function finishAgentRun(run, status, summary, now) {
         updatedAt: timestamp,
         endedAt: timestamp
     };
-    // A terminal Run no longer waits for a retry; the projection is cleared so
-    // old and new readers agree the Run is settled.
-    if (terminal.providerRetry !== undefined) {
-        delete terminal.providerRetry;
-    }
     if (terminal.controlRequest !== undefined)
         delete terminal.controlRequest;
     return terminal;
 }
-/**
- * Attaches (or advances) the Issue 04 in-place retry projection on an active
- * Run. The Run stays `active`; only the projection changes.
- */
-export function withProviderRetry(run, retry) {
-    if (run.status !== "active") {
-        throw new Error(`Cannot schedule provider retry on a terminal Agent run: ${run.id}.`);
-    }
-    return validateAgentRun({ ...run, providerRetry: retry });
-}
-/**
- * Reopens an active retry-waiting Run for another in-place attempt on its
- * original Native Session. The original Run transport/acceptance timestamps
- * remain historical facts; the new delivery receipt and `dispatching` retry
- * state make the delivery path send only the short continuation envelope.
- */
-export function reopenRunForProviderRetry(run, receiptId, now, mode = "resume") {
-    if (run.status !== "active" || run.providerRetry === undefined) {
-        throw new Error(`Agent run is not waiting for a provider retry: ${run.id}.`);
-    }
-    const timestamp = now.toISOString();
-    const { providerRetry, ...rest } = run;
-    return validateAgentRun({
-        ...rest,
-        mode,
-        deliveryReceiptId: receiptId,
-        updatedAt: timestamp,
-        providerRetry: prepareProviderRetryDispatch(providerRetry, receiptId, now)
-    });
-}
-/** Any exact correlated provider progress ends the active consecutive-failure episode. */
-export function clearProviderRetryOnProgress(run) {
-    if (run.providerRetry === undefined)
-        return run;
-    const { providerRetry: _providerRetry, ...rest } = run;
-    return validateAgentRun(rest);
-}
 export function agentRunDeliveryReceiptId(run) {
     return run.deliveryReceiptId
         ?? run.controlRequest?.receiptId
-        ?? run.providerRetry?.lastRetryReceiptId
         ?? formatAgentRunReceiptId(run.taskId, run.id);
 }
 export function withAgentRunControlRequest(run, request, now) {
-    if (run.status !== "active" || run.providerRetry !== undefined) {
+    if (run.status !== "active") {
         throw new Error(`Agent run cannot accept a control request: ${run.id}.`);
     }
     return validateAgentRun({

package/dist/runtime/agentDriver.js

@@ -233,6 +233,7 @@ export class AgentDriverRegistry {
         }
         if (typeof input.runtime.nativeSessionId !== "function"
             || typeof input.runtime.nativeTurnId !== "function"
+            || typeof input.runtime.mapError !== "function"
             || typeof input.runtime.mapHook !== "function"
             || typeof input.runtime.classifyHook !== "function"
             || (input.runtime.observer !== undefined
@@ -249,6 +250,7 @@ export class AgentDriverRegistry {
             runtime: Object.freeze({
                 nativeSessionId: input.runtime.nativeSessionId,
                 nativeTurnId: input.runtime.nativeTurnId,
+                mapError: input.runtime.mapError,
                 mapHook: input.runtime.mapHook,
                 classifyHook: input.runtime.classifyHook,
                 ...(input.runtime.observer === undefined

package/dist/runtime/agentError.js

@@ -0,0 +1,114 @@
+/**
+ * Provider-neutral Agent failure facts.
+ *
+ * Drivers recognize provider-native failures. Core persists the resulting
+ * facts and routes them to an Agent; it does not attach a recovery policy.
+ * `unknown` is the required fallback and the complete native payload is always
+ * retained in `raw`.
+ */
+export const AGENT_ERROR_CATEGORIES = Object.freeze([
+    "availability",
+    "rate-limit",
+    "transport",
+    "access",
+    "invalid-request",
+    "context",
+    "session",
+    "runtime",
+    "conflict",
+    "cancelled",
+    "unknown"
+]);
+export function standardAgentError(input) {
+    const classification = input.classification ?? UNKNOWN_AGENT_ERROR_CLASSIFICATION;
+    const retryAfterMs = input.retryAfterMs;
+    if (retryAfterMs !== undefined
+        && (!Number.isSafeInteger(retryAfterMs) || retryAfterMs < 0)) {
+        throw new Error("Agent error retryAfterMs must be a non-negative safe integer.");
+    }
+    return Object.freeze({
+        source: input.source,
+        phase: input.phase,
+        category: classification.category,
+        code: requiredErrorText(classification.code, "Agent error code"),
+        message: requiredErrorText(input.message, "Agent error message"),
+        raw: requiredErrorText(input.raw, "Agent error raw payload"),
+        inputDisposition: input.inputDisposition
+            ?? classification.inputDisposition
+            ?? "unknown",
+        sessionDisposition: input.sessionDisposition
+            ?? classification.sessionDisposition
+            ?? "unknown",
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs })
+    });
+}
+export const UNKNOWN_AGENT_ERROR_CLASSIFICATION = Object.freeze({
+    category: "unknown",
+    code: "unknown"
+});
+export function isAgentErrorCategory(value) {
+    return typeof value === "string"
+        && AGENT_ERROR_CATEGORIES.includes(value);
+}
+export function isStandardAgentError(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const error = value;
+    return ["provider", "driver", "host", "yui"].includes(error.source ?? "")
+        && [
+            "host-start",
+            "session-start",
+            "session-restore",
+            "turn-submit",
+            "turn-execute",
+            "turn-reconcile",
+            "host-stop"
+        ].includes(error.phase ?? "")
+        && isAgentErrorCategory(error.category)
+        && isErrorText(error.code)
+        && isErrorText(error.message)
+        && isErrorText(error.raw)
+        && ["accepted", "not-accepted", "unknown"].includes(error.inputDisposition ?? "")
+        && ["recoverable", "unrecoverable", "unknown"].includes(error.sessionDisposition ?? "")
+        && (error.retryAfterMs === undefined
+            || (Number.isSafeInteger(error.retryAfterMs) && error.retryAfterMs >= 0));
+}
+export function serializeAgentErrorRaw(value) {
+    if (typeof value === "string")
+        return requiredErrorText(value, "Agent error raw payload");
+    if (value === undefined)
+        return "Agent operation failed without an error payload.";
+    try {
+        const seen = new WeakSet();
+        const serialized = JSON.stringify(value, (_key, member) => {
+            if (typeof member === "bigint")
+                return member.toString();
+            if (member !== null && typeof member === "object") {
+                if (seen.has(member))
+                    return "[Circular]";
+                seen.add(member);
+                if (member instanceof Error) {
+                    return Object.fromEntries(Object.getOwnPropertyNames(member).map((name) => [
+                        name,
+                        member[name]
+                    ]));
+                }
+            }
+            return member;
+        });
+        return serialized === undefined
+            ? String(value)
+            : requiredErrorText(serialized, "Agent error raw payload");
+    }
+    catch {
+        return requiredErrorText(String(value), "Agent error raw payload");
+    }
+}
+function isErrorText(value) {
+    return typeof value === "string" && value.trim().length > 0 && !value.includes("\0");
+}
+function requiredErrorText(value, label) {
+    if (!isErrorText(value))
+        throw new Error(`${label} is required.`);
+    return value;
+}

package/dist/runtime/agentHost.js

@@ -16,7 +16,8 @@ import { validateRuntimeProcessExitObservation } from "./processExitObservation.
 import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox } from "./processExitOutbox.js";
 import { readRuntimeStopReceipt, removeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
 import { AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS } from "./runtimeDeadlines.js";
-export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v2";
+import { serializeAgentErrorRaw } from "./agentError.js";
+export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v3";
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
 const CODEX_CLIENT_STABLE_MS = 5_000;
 const MAX_CONSECUTIVE_CODEX_DISCONNECTS = 3;
@@ -146,7 +147,7 @@ export async function runAgentHost(input) {
                 schemaVersion: 1,
                 adapterId: "codex",
                 transport: "codex-app-server-proxy",
-                kind: "ensure",
+                kind: "restore",
                 mode: "resume",
                 nativeSessionId: disconnectedSession.nativeSessionId,
                 ...(previousControl.sessionTitle === undefined
@@ -351,7 +352,7 @@ export async function runAgentHost(input) {
             throw new Error("Agent Host still owns an unsettled Provider Turn.");
         }
         const requestedAuthority = validateProviderAuthorityFence(providerControl.authority);
-        const replacesCurrentConversation = session !== undefined && providerControl.kind === "new";
+        const replacesCurrentConversation = session !== undefined && providerControl.kind === "start";
         if (replacesCurrentConversation) {
             throw new Error("Agent Host cannot replace a live Provider Session; stop it before starting a fresh Session.");
         }
@@ -364,9 +365,6 @@ export async function runAgentHost(input) {
         updateSnapshot(hostSnapshot("starting", {
             launchId: next.launchId,
             adapterId: providerControl.adapterId,
-            ...(providerControl.initialTurn === undefined
-                ? {}
-                : { attemptId: providerControl.initialTurn.attemptId }),
             ...(session === undefined ? {} : {
                 processInstanceId: session.processInstanceId,
                 nativeSessionId: session.nativeSessionId,
@@ -374,8 +372,6 @@ export async function runAgentHost(input) {
             }),
             ...authorityFields()
         }));
-        let providerAcceptedAttemptId;
-        let durableInitialTurn;
         try {
             if (session !== undefined) {
                 if (session.adapterId !== providerControl.adapterId
@@ -390,7 +386,7 @@ export async function runAgentHost(input) {
                 conversationRecoverability = providerControl.adapterId === "codex"
                     ? "recoverable"
                     : "unknown";
-                if (providerControl.kind === "ensure" && providerControl.ownedTurn !== undefined) {
+                if (providerControl.kind === "restore" && providerControl.ownedTurn !== undefined) {
                     activeTurnPayload = next;
                     activeTurnAttemptId = providerControl.ownedTurn.attemptId;
                     activeNativeTurnId = providerControl.ownedTurn.turnId;
@@ -416,58 +412,24 @@ export async function runAgentHost(input) {
                 recoverability: conversationRecoverability,
                 observedAt: new Date().toISOString()
             });
-            let receipt;
-            if (providerControl.initialTurn !== undefined) {
-                durableInitialTurn = hostTurnControlParams(next, session.nativeSessionId, requestedAuthority, providerControl.initialTurn.attemptId);
-                await beginDurableProviderTurn(input.home, durableInitialTurn);
-                activeTurnPayload = next;
-                activeTurnAttemptId = providerControl.initialTurn.attemptId;
-                activeNativeTurnId = undefined;
-                try {
-                    receipt = await session.submitTurn(providerControl.initialTurn);
-                    providerAcceptedAttemptId = receipt.attemptId;
-                    activeNativeTurnId = receipt.nativeTurnId;
-                }
-                catch (error) {
-                    await resolveProviderTurnSubmission(input.home, durableInitialTurn, error);
-                    throw error;
-                }
-            }
-            if (receipt !== undefined) {
-                conversationRecoverability = "recoverable";
-                try {
-                    await publishStructuredProviderAccepted({
-                        home: input.home,
-                        environment: next.environment,
-                        activationId: activationId ?? next.launchId,
-                        receipt
-                    });
-                }
-                catch (error) {
-                    await resolveProviderTurnSubmission(input.home, durableInitialTurn, new ProviderDeliveryUnknownError(`Provider accepted input but its durable acknowledgement could not be confirmed: ${errorText(error)}`, receipt.attemptId));
-                    throw error;
-                }
-            }
-            const ensuredOwnedTurn = providerControl.kind === "ensure"
+            const restoredOwnedTurn = providerControl.kind === "restore"
                 ? providerControl.ownedTurn
                 : undefined;
-            const providerState = receipt !== undefined || ensuredOwnedTurn !== undefined
+            const providerState = restoredOwnedTurn !== undefined
                 ? "ready"
                 : session.activeTurnId === undefined ? "idle" : "busy";
             updateSnapshot(hostSnapshot(providerState, {
                 launchId: next.launchId,
                 adapterId: providerControl.adapterId,
                 processInstanceId: session.processInstanceId,
-                nativeSessionId: receipt?.nativeSessionId ?? session.nativeSessionId,
-                conversationId: receipt?.conversationId ?? session.conversationId,
-                ...(receipt !== undefined
-                    ? { attemptId: receipt.attemptId, nativeTurnId: receipt.nativeTurnId }
-                    : ensuredOwnedTurn === undefined
-                        ? {}
-                        : {
-                            attemptId: ensuredOwnedTurn.attemptId,
-                            nativeTurnId: ensuredOwnedTurn.turnId
-                        }),
+                nativeSessionId: session.nativeSessionId,
+                conversationId: session.conversationId,
+                ...(restoredOwnedTurn === undefined
+                    ? {}
+                    : {
+                        attemptId: restoredOwnedTurn.attemptId,
+                        nativeTurnId: restoredOwnedTurn.turnId
+                    }),
                 ...authorityFields()
             }));
             return snapshot;
@@ -488,33 +450,21 @@ export async function runAgentHost(input) {
                 conversationRecoverability = "unknown";
                 authority = undefined;
             }
-            const deliveryUnknown = error instanceof ProviderDeliveryUnknownError
-                || providerAcceptedAttemptId !== undefined;
-            const state = deliveryUnknown
-                ? "delivery-unknown"
-                : error instanceof ProviderTurnBusyError
-                    ? "busy"
-                    : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
+            const state = error instanceof ProviderTurnBusyError
+                ? "busy"
+                : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
             updateSnapshot(hostSnapshot(state, {
                 launchId: next.launchId,
                 adapterId: providerControl.adapterId,
                 processInstanceId: session?.processInstanceId,
                 nativeSessionId: session?.nativeSessionId ?? providerControl.nativeSessionId,
                 conversationId: session?.conversationId ?? providerControl.nativeSessionId,
-                ...(providerControl.initialTurn === undefined
-                    ? {}
-                    : { attemptId: providerControl.initialTurn.attemptId }),
                 ...authorityFields(),
                 detail: errorText(error)
             }));
-            if (state !== "delivery-unknown") {
-                activeTurnPayload = undefined;
-                activeTurnAttemptId = undefined;
-                activeNativeTurnId = undefined;
-            }
-            if (deliveryUnknown && !(error instanceof ProviderDeliveryUnknownError)) {
-                throw new ProviderDeliveryUnknownError(`Provider accepted input but its durable acknowledgement could not be confirmed: ${errorText(error)}`, providerAcceptedAttemptId);
-            }
+            activeTurnPayload = undefined;
+            activeTurnAttemptId = undefined;
+            activeNativeTurnId = undefined;
             throw error;
         }
     };
@@ -536,9 +486,15 @@ export async function runAgentHost(input) {
             throw new Error("Agent Host rejected a stale Provider writer fence.");
         }
         if (activeTurnPayload !== undefined || snapshot.state === "settling") {
-            throw new Error("Agent Host still owns an unsettled Provider Turn.");
+            throw new ProviderTurnBusyError("Agent Host still owns an unsettled Provider Turn.", request.turn.attemptId, activeNativeTurnId);
         }
-        activeTurnPayload = sessionPayload;
+        activeTurnPayload = {
+            ...sessionPayload,
+            environment: {
+                ...sessionPayload.environment,
+                YUI_RUN_ID: request.runId
+            }
+        };
         activeTurnAttemptId = request.turn.attemptId;
         activeNativeTurnId = undefined;
         updateSnapshot(hostSnapshot("starting", {
@@ -550,17 +506,26 @@ export async function runAgentHost(input) {
             attemptId: request.turn.attemptId,
             ...authorityFields()
         }));
+        const durableTurn = hostTurnControlParams(sessionPayload, session.nativeSessionId, request.authority, request.turn.attemptId, request.runId);
+        await beginDurableProviderTurn(input.home, durableTurn);
         let providerAccepted = false;
         try {
             const receipt = await session.submitTurn(request.turn);
             providerAccepted = true;
             activeNativeTurnId = receipt.nativeTurnId;
-            await publishStructuredProviderAccepted({
-                home: input.home,
-                environment: sessionPayload.environment,
-                activationId: activationId ?? sessionPayload.launchId,
-                receipt
-            });
+            try {
+                await publishStructuredProviderAccepted({
+                    home: input.home,
+                    environment: sessionPayload.environment,
+                    activationId: activationId ?? sessionPayload.launchId,
+                    receipt
+                });
+            }
+            catch (error) {
+                const unknown = new ProviderDeliveryUnknownError(`Provider accepted input but its durable acknowledgement could not be confirmed: ${errorText(error)}`, request.turn.attemptId);
+                await resolveProviderTurnSubmission(input.home, durableTurn, unknown);
+                throw unknown;
+            }
             updateSnapshot(hostSnapshot("ready", {
                 launchId: request.launchId,
                 adapterId: session.adapterId,
@@ -574,6 +539,9 @@ export async function runAgentHost(input) {
             return snapshot;
         }
         catch (error) {
+            if (!providerAccepted) {
+                await resolveProviderTurnSubmission(input.home, durableTurn, error);
+            }
             const deliveryUnknown = error instanceof ProviderDeliveryUnknownError || providerAccepted;
             const state = deliveryUnknown
                 ? "delivery-unknown"
@@ -684,6 +652,7 @@ export async function runAgentHost(input) {
                 type: "submit-turn",
                 launchId: currentPayload.launchId,
                 nativeSessionId: currentSession.nativeSessionId,
+                runId: requiredEnvironment(currentPayload.environment.YUI_RUN_ID, "Run id"),
                 authority: currentAuthority,
                 turn: {
                     attemptId,
@@ -902,8 +871,10 @@ export async function openAgentHostControl(home, payload, snapshot, dispatch) {
                 }
                 catch (error) {
                     const current = snapshot();
-                    socket.end(`${JSON.stringify(controlResult("rejected", validateSnapshot({
+                    const busy = error instanceof ProviderTurnBusyError;
+                    socket.end(`${JSON.stringify(controlResult(busy ? "accepted" : "rejected", validateSnapshot({
                         ...current,
+                        ...(busy ? { state: "busy" } : {}),
                         detail: errorText(error),
                         updatedAt: new Date().toISOString()
                     })))}\n`);
@@ -951,6 +922,7 @@ function validateControl(control) {
     if (control.type === "submit-turn") {
         validateLaunchId(control.launchId);
         validateIdentity(control.nativeSessionId, "native Session id");
+        validateIdentity(control.runId, "Run id");
         validateProviderAuthorityFence(control.authority);
         validateIdentity(control.turn.attemptId, "Provider input attempt id");
         if (typeof control.turn.boundedText !== "string"
@@ -1056,12 +1028,12 @@ async function delay(milliseconds) {
         timer.unref();
     });
 }
-function hostTurnControlParams(payload, nativeSessionId, authority, attemptId) {
+function hostTurnControlParams(payload, nativeSessionId, authority, attemptId, runId = requiredEnvironment(payload.environment.YUI_RUN_ID, "Run id")) {
     const environment = payload.environment;
     return Object.freeze({
         taskId: requiredEnvironment(environment.YUI_TASK_ID, "Task id"),
         roleName: requiredEnvironment(environment.YUI_ROLE, "Role name"),
-        runId: requiredEnvironment(environment.YUI_RUN_ID, "Run id"),
+        runId: requiredEnvironment(runId, "Run id"),
         agentId: requiredEnvironment(environment.YUI_AGENT_ID, "Agent id"),
         launchId: payload.launchId,
         nativeSessionId: requiredEnvironment(nativeSessionId, "native Session id"),
@@ -1120,6 +1092,7 @@ async function resolveProviderTurnSubmission(home, durableTurn, error) {
             ? "delivery-unknown"
             : "rejected",
         reason: errorText(error),
+        raw: serializeAgentErrorRaw(error),
         observedAt: new Date().toISOString()
     };
     try {

package/dist/runtime/builtinAgentDrivers.js

@@ -1,6 +1,7 @@
 import { AgentDriverRegistry } from "./agentDriver.js";
 import { claudeTranscriptObserver, codexTranscriptObserver, transcriptObserverSource } from "./builtinTranscriptObserver.js";
-import { parseClaudeError } from "./providerErrorCodes.js";
+import { mapClaudeAgentError, mapCodexAgentError } from "./builtinAgentErrorMappers.js";
+import { serializeAgentErrorRaw, standardAgentError } from "./agentError.js";
 export const CODEX_DRIVER_ID = "openai/codex";
 export const CLAUDE_CODE_DRIVER_ID = "anthropic/claude-code";
 export function builtinDriverIdForAdapter(adapterId) {
@@ -77,6 +78,7 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
         runtime: Object.freeze({
             nativeSessionId: ({ payload }) => (optionalIdentityFrom(payload, ["session_id"])),
             nativeTurnId: ({ payload }) => (optionalIdentityFrom(payload, ["prompt_id", "turn_id"])),
+            mapError: mapClaudeAgentError,
             mapHook: ({ hookEventName, payload, occurrenceId }) => (mapClaudeHook(hookEventName, payload, occurrenceId)),
             classifyHook: ({ hookEventName, payload }) => Object.freeze({
                 ...(hookEventName === "SessionStart" && payload.source === "startup"
@@ -133,6 +135,7 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
         runtime: Object.freeze({
             nativeSessionId: ({ payload }) => (optionalIdentityFrom(payload, ["session_id"])),
             nativeTurnId: ({ payload }) => (optionalIdentityFrom(payload, ["turn_id", "prompt_id"])),
+            mapError: mapCodexAgentError,
             mapHook: ({ hookEventName, payload, occurrenceId }) => (mapCodexHook(hookEventName, payload, occurrenceId)),
             classifyHook: ({ hookEventName, payload }) => Object.freeze({
                 ...(hookEventName === "SessionStart"
@@ -237,7 +240,10 @@ function mapClaudeHook(name, payload, occurrenceId) {
         case "StopFailure":
             return mapped("turn.failed", claudeFailure(payload));
         case "SessionEnd":
-            return [mapped("session.ended"), mapped("activation.ended")];
+            // Native CLI exit ends this local Provider attachment, not the
+            // resumable Conversation. Durable Session end is an explicit Yui
+            // mutation or a Provider fact that the Conversation is unrecoverable.
+            return mapped("activation.ended");
         default:
             throw new Error(`Claude Code Driver does not support Hook event: ${name}.`);
     }
@@ -291,7 +297,7 @@ function mapCodexHook(name, payload, occurrenceId) {
         case "Stop":
             return mapped("turn.completed", optionalSummary(payload));
         case "SessionEnd":
-            return [mapped("session.ended"), mapped("activation.ended")];
+            return mapped("activation.ended");
         default:
             throw new Error(`Codex Driver does not support Hook event: ${name}.`);
     }
@@ -376,7 +382,8 @@ function claudeFailure(payload) {
     const code = firstIdentity(payload, ["error"], "Claude StopFailure error");
     const details = optionalText(payload.error_details);
     const lastOutput = optionalText(payload.last_assistant_message);
-    const parsed = parseClaudeError(code, details);
+    const raw = serializeAgentErrorRaw(payload);
+    const classification = mapClaudeAgentError({ message: code, raw });
     const retryAfterMs = typeof payload.retry_after_ms === "number"
         && Number.isSafeInteger(payload.retry_after_ms)
         && payload.retry_after_ms > 0
@@ -384,14 +391,19 @@ function claudeFailure(payload) {
         : undefined;
     return {
         failure: {
-            ...(parsed.code !== "unknown" ? { errorCode: parsed.code } : {}),
-            code,
-            ...(details === undefined ? {} : { details }),
+            error: standardAgentError({
+                source: "provider",
+                phase: "turn-execute",
+                classification,
+                message: code,
+                raw,
+                inputDisposition: "accepted",
+                ...(retryAfterMs === undefined ? {} : { retryAfterMs })
+            }),
             ...(lastOutput === undefined ? {} : { lastOutput }),
             ...(payload.run_terminal === true || payload.unrecoverable === true
                 ? { runTerminal: true }
-                : {}),
-            ...(retryAfterMs === undefined ? {} : { retryAfterMs })
+                : {})
         },
         summary: [
             "Agent turn failed.",