@harness-kernel/core 0.2.1 → 0.4.0

package/dist/{chunk-QEVKKJ7N.js → chunk-BLLQSHQI.js}

@@ -9,19 +9,26 @@ import {
   AgentWarnLog,
   ConsoleLogSink,
   HarnessLog,
+  annotateHarnessError,
+  normalizeHarnessError,
   normalizeHarnessLog,
   randomId,
+  sanitizeHarnessError,
   shouldWriteLog,
   summarizeValue
-} from "./chunk-Q44U2CMM.js";
+} from "./chunk-2NQ3JL7K.js";
 import {
   HarnessSandboxSession,
   NoopSandbox
-} from "./chunk-ZU6ADDET.js";
+} from "./chunk-IWHCNKHK.js";
 import {
   HarnessSessionStorage,
   MemorySessionStorage
 } from "./chunk-ONYDIU4X.js";
+import {
+  createToolErrorPayload,
+  createToolErrorResult
+} from "./chunk-NCSQEUQC.js";
 import {
   ContextReadyEvent,
   ErrorEvent,
@@ -31,7 +38,9 @@ import {
   ModeChangedEvent,
   ModelAfterEvent,
   ModelBeforeEvent,
+  RunAbortedEvent,
   RunEndEvent,
+  RunFailedEvent,
   RunStartEvent,
   SnapshotCreatedEvent,
   SnapshotDeletedEvent,
@@ -44,7 +53,7 @@ import {
   TurnEndEvent,
   TurnStartEvent,
   runtimeEventClasses
-} from "./chunk-JIJHGB6H.js";
+} from "./chunk-3QOAFCCZ.js";
 import {
   normalizeSchema
 } from "./chunk-OBKS4AJR.js";
@@ -59,21 +68,7 @@ import {
   systemRole,
   toolRole,
   userRole
-} from "./chunk-B4Q6CPYO.js";
-
-// src/logging/tool-errors.ts
-function createToolErrorPayload(input) {
-  return {
-    ok: false,
-    error: {
-      code: input.code,
-      message: input.message,
-      toolName: input.toolName,
-      invalidFields: input.invalidFields,
-      metadata: input.metadata
-    }
-  };
-}
+} from "./chunk-TCHZYK5Y.js";
 
 // src/logging/runtime-logs.ts
 var SessionCreatedLog = class extends HarnessLog {
@@ -100,8 +95,11 @@ var RunCompletedLog = class extends HarnessLog {
 var RunFailedLog = class extends HarnessLog {
   level = "error";
   category = "run";
-  message() {
-    return "run.failed";
+  levelFor(fields) {
+    return fields.error.severity === "warn" ? "warn" : "error";
+  }
+  message(fields) {
+    return `run.failed code=${fields.error.code}`;
   }
 };
 var TurnStartedLog = class extends HarnessLog {
@@ -135,8 +133,11 @@ var ContextBuildCompletedLog = class extends HarnessLog {
 var ContextProviderFailedLog = class extends HarnessLog {
   level = "error";
   category = "context";
+  levelFor(fields) {
+    return fields.error.severity === "warn" ? "warn" : "error";
+  }
   message(fields) {
-    return `context.provider.failed ${fields.providerType}`;
+    return `context.provider.failed ${fields.providerType} code=${fields.error.code}`;
   }
 };
 var ModelCallStartedLog = class extends HarnessLog {
@@ -156,8 +157,11 @@ var ModelCallCompletedLog = class extends HarnessLog {
 var ModelCallFailedLog = class extends HarnessLog {
   level = "error";
   category = "model";
+  levelFor(fields) {
+    return fields.error.severity === "warn" ? "warn" : "error";
+  }
   message(fields) {
-    return `model.failed model=${fields.model}`;
+    return `model.failed model=${fields.model} code=${fields.error.code}`;
   }
 };
 var ModelDeltaLog = class extends HarnessLog {
@@ -198,8 +202,11 @@ var ToolCompletedLog = class extends HarnessLog {
 var ToolFailedLog = class extends HarnessLog {
   level = "error";
   category = "tool";
+  levelFor(fields) {
+    return fields.error?.severity === "warn" ? "warn" : "error";
+  }
   message(fields) {
-    return `tool.failed ${fields.toolName}`;
+    return `tool.failed ${fields.toolName}${fields.error ? ` code=${fields.error.code}` : ""}`;
   }
 };
 var ToolApprovalRequestedLog = class extends HarnessLog {
@@ -244,7 +251,7 @@ var SandboxExecFailedLog = class extends HarnessLog {
   level = "error";
   category = "tool";
   message(fields) {
-    return `sandbox.exec.failed ${fields.sandboxId}`;
+    return `sandbox.exec.failed ${fields.sandboxId}${fields.error ? ` code=${fields.error.code}` : ""}`;
   }
 };
 var SandboxClosedLog = class extends HarnessLog {
@@ -300,7 +307,7 @@ var StorageWriteFailedLog = class extends HarnessLog {
   level = "error";
   category = "storage";
   message(fields) {
-    return `storage.write_failed ${fields.operation}`;
+    return `storage.write_failed ${fields.operation} code=${fields.error.code}`;
   }
 };
 
@@ -583,11 +590,11 @@ var SandboxManager = class {
     this.input.logOpened({ sandboxId: opened.id, workDir: opened.workDir });
     return this.session;
   }
-  async close() {
+  async close(input = { reason: "close" }) {
     const sandbox = this.session;
     this.session = void 0;
     if (!sandbox) return;
-    await sandbox.close?.();
+    await sandbox.close?.(input);
     this.input.logClosed({ sandboxId: sandbox.id });
   }
   wrap(base) {
@@ -622,8 +629,8 @@ var SandboxManager = class {
           throw error;
         }
       }
-      async close() {
-        await base.close?.();
+      async close(input2) {
+        await base.close?.(input2);
       }
     }();
   }
@@ -666,7 +673,6 @@ var RunStorageCoordinator = class {
     await this.write("save_transcript", (store) => store.saveTranscript(messages));
   }
   async saveMetrics(metrics) {
-    if (this.input.storage instanceof HarnessSessionStorage) return;
     await this.write("save_metrics", (store) => store.saveMetrics(metrics));
   }
   async saveSnapshot(snapshot) {
@@ -1175,6 +1181,9 @@ function ensureToolMetric(metrics, name) {
   metrics.tools[name] = metric;
   return metric;
 }
+function toolResultErrorCode(value) {
+  return value === "tool.args.invalid_schema" || value === "tool.approval.denied" || value === "sandbox.exec.failed" || value === "tool.failed" ? value : "tool.failed";
+}
 var ToolExecutor = class {
   constructor(input) {
     this.input = input;
@@ -1219,6 +1228,13 @@ var ToolExecutor = class {
     };
     const parsedArgs = safeParseWithSchema(input.tool.inputSchema, input.args);
     if (!parsedArgs.ok) {
+      const error = this.toolError({
+        error: parsedArgs.error,
+        code: "tool.args.invalid_schema",
+        message: "Tool arguments did not match schema.",
+        source: toolSource,
+        details: { invalidFields: parsedArgs.invalidFields }
+      });
       const result = this.structuredToolError({
         toolName: input.tool.name,
         code: "tool.args.invalid_schema",
@@ -1228,7 +1244,7 @@ var ToolExecutor = class {
       const durationMs = Math.round(performance.now() - start);
       metric.errorCount++;
       metric.totalDurationMs += durationMs;
-      metrics.errors.push(result.content);
+      metrics.errors.push(sanitizeHarnessError(error, this.input.errorPolicy));
       this.input.log(
         ToolInvalidSchemaLog,
         { toolName: input.tool.name, issues: parsedArgs.issues },
@@ -1238,6 +1254,7 @@ var ToolExecutor = class {
         { durationMs }
       );
       await this.input.addToolResultMessage(input.tool, result, id);
+      await this.emitToolError(error, toolEventOptions);
       await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result }, callerEventOptions);
       this.input.throwIfTurnHandoffRequested();
       return result;
@@ -1257,6 +1274,13 @@ var ToolExecutor = class {
       callerEventOptions
     );
     if (!approved) {
+      const error = this.toolError({
+        error: new Error(`Tool '${input.tool.name}' was denied by runner policy.`),
+        code: "tool.approval.denied",
+        message: `Tool '${input.tool.name}' was denied by runner policy.`,
+        source: toolSource,
+        severity: "warn"
+      });
       const denied = this.structuredToolError({
         toolName: input.tool.name,
         code: "tool.approval.denied",
@@ -1266,12 +1290,15 @@ var ToolExecutor = class {
       metric.errorCount++;
       const durationMs = Math.round(performance.now() - start);
       metric.totalDurationMs += durationMs;
+      metrics.errors.push(sanitizeHarnessError(error, this.input.errorPolicy));
       this.input.log(ToolFailedLog, {
         toolName: input.tool.name,
         durationMs,
+        error,
         result: summarizeValue(denied)
       }, toolSource, id, startEvent.id, { durationMs });
       await this.input.addToolResultMessage(input.tool, denied, id);
+      await this.emitToolError(error, toolEventOptions);
       await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result: denied }, callerEventOptions);
       this.input.throwIfTurnHandoffRequested();
       return denied;
@@ -1285,9 +1312,19 @@ var ToolExecutor = class {
       metric.totalDurationMs += durationMs;
       if (result.isError) metric.errorCount++;
       if (result.isError) {
+        const errorCode = toolResultErrorCode(result.metadata?.errorCode);
+        const error = this.toolError({
+          error: new Error(result.content || "Tool execution failed."),
+          code: errorCode,
+          message: result.content || "Tool execution failed.",
+          source: toolSource,
+          details: result.data
+        });
+        metrics.errors.push(sanitizeHarnessError(error, this.input.errorPolicy));
         this.input.log(ToolFailedLog, {
           toolName: input.tool.name,
           durationMs,
+          error,
           result: summarizeValue(result)
         }, toolSource, id, startEvent.id, { durationMs });
       } else {
@@ -1303,7 +1340,13 @@ var ToolExecutor = class {
       this.input.throwIfTurnHandoffRequested();
       return result;
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+      const normalized = this.toolError({
+        error,
+        code: "tool.failed",
+        message: "Tool execution failed.",
+        source: toolSource,
+        details: { toolName: input.tool.name }
+      });
       const result = this.structuredToolError({
         toolName: input.tool.name,
         code: "tool.failed",
@@ -1313,14 +1356,15 @@ var ToolExecutor = class {
       const durationMs = Math.round(performance.now() - start);
       metric.errorCount++;
       metric.totalDurationMs += durationMs;
-      metrics.errors.push(message);
+      metrics.errors.push(sanitizeHarnessError(normalized, this.input.errorPolicy));
       this.input.log(ToolFailedLog, {
         toolName: input.tool.name,
         durationMs,
-        error
+        error: normalized,
+        internalError: error
       }, toolSource, id, startEvent.id, { durationMs });
       await this.input.addToolResultMessage(input.tool, result, id);
-      await this.input.emitInternal(ErrorEvent, { message, details: error }, toolEventOptions);
+      await this.emitToolError(normalized, toolEventOptions);
       await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result }, callerEventOptions);
       this.input.throwIfTurnHandoffRequested();
       return result;
@@ -1329,21 +1373,7 @@ var ToolExecutor = class {
     }
   }
   structuredToolError(input) {
-    return {
-      content: input.message,
-      data: createToolErrorPayload({
-        code: input.code,
-        message: input.message,
-        toolName: input.toolName,
-        invalidFields: input.invalidFields
-      }),
-      isError: true,
-      metadata: {
-        errorCode: input.code,
-        ...input.invalidFields ? { invalidFields: input.invalidFields } : {},
-        ...input.metadata ?? {}
-      }
-    };
+    return createToolErrorResult(input);
   }
   ensureStructuredToolErrorResult(tool, result) {
     if (!result.isError || result.data !== void 0) return result;
@@ -1360,6 +1390,29 @@ var ToolExecutor = class {
       }
     };
   }
+  toolError(input) {
+    const normalized = normalizeHarnessError(input.error, {
+      code: input.code,
+      category: input.code === "tool.approval.denied" ? "approval" : input.code === "sandbox.exec.failed" ? "sandbox" : "tool",
+      severity: input.severity ?? (input.code === "tool.approval.denied" ? "warn" : "error"),
+      recoverable: true,
+      source: input.source,
+      message: input.message,
+      details: input.details
+    }, this.input.errorPolicy);
+    annotateHarnessError(input.error, normalized);
+    return normalized;
+  }
+  async emitToolError(error, options) {
+    const sanitized = sanitizeHarnessError(error, this.input.errorPolicy);
+    await this.input.emitInternal(ErrorEvent, {
+      error: sanitized,
+      message: sanitized.message,
+      code: sanitized.code,
+      recoverable: sanitized.recoverable,
+      details: sanitized.details
+    }, options);
+  }
   async approveTool(request, tool, args, eventOptions) {
     const policy = this.input.getToolApprovalMode() ?? "tool-default";
     if (policy === "auto") return this.recordApprovalResolution(request, "approved", eventOptions);
@@ -1520,6 +1573,20 @@ var SnapshotManager = class {
 };
 
 // src/runtime/model-pipeline.ts
+function retryDelayMs(attempt, backoffMs, maxBackoffMs) {
+  return Math.min(maxBackoffMs, backoffMs * 2 ** Math.max(0, attempt - 1));
+}
+function delay(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(new Error("Run aborted."));
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timeout);
+      reject(new Error("Run aborted."));
+    }, { once: true });
+  });
+}
 var ModelPipeline = class {
   constructor(input) {
     this.input = input;
@@ -1532,62 +1599,83 @@ var ModelPipeline = class {
     const model = this.input.getModel();
     const resolved = this.input.resolveModelProvider(model);
     const source = this.modelProviderSource(resolved);
-    try {
-      const modelStart = performance.now();
+    const modelStart = performance.now();
+    const retry = this.input.errorPolicy?.retry?.model;
+    const maxAttempts = Math.max(1, retry?.attempts ?? 1);
+    const backoffMs = Math.max(0, retry?.backoffMs ?? 250);
+    const maxBackoffMs = Math.max(backoffMs, retry?.maxBackoffMs ?? 5e3);
+    let result;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      let toolExecuted = false;
+      let providerEventEmitted = false;
       this.input.log(ModelCallStartedLog, { model, messageCount: messages.length }, source);
-      const result = await resolved.provider.run({
-        runId: this.input.getRunId(),
-        turnId: this.input.getTurnId(),
-        modeId: this.input.getModeId(),
-        modelRef: resolved.modelRef,
-        provider: resolved.namespace,
-        model: resolved.modelId,
-        systemPrompt,
-        messages,
-        roles: this.input.roles,
-        tools: input.tools,
-        maxTurns: input.mode.maxTurns ?? 20,
-        signal: input.options.signal,
-        prepareContext: () => this.prepareContext(input.mode, input.userMessage),
-        emit: async (eventClass, payload2, options) => {
-          const event = await this.input.emit(
-            eventClass,
-            payload2,
-            this.input.withEmitDefaults(source, void 0, void 0, options)
-          );
-          this.input.throwIfTurnHandoffRequested();
-          return event;
-        },
-        executeTool: (tool, args, callId) => this.input.executeTool(tool, args, callId, source)
-      });
-      const assistantMessage = await this.input.addAssistantMessage(result.content, {
-        usage: result.usage,
-        finishReason: result.finishReason
-      });
-      this.input.setFinalAnswer(result.content);
-      this.input.getMetrics().usage = result.usage;
-      await this.input.emitInternal(MessageEndEvent, { message: assistantMessage });
-      await this.input.markMessageEventCursor(assistantMessage.id);
-      this.input.log(ModelCallCompletedLog, {
-        model,
-        durationMs: Math.round(performance.now() - modelStart),
-        finishReason: result.finishReason
-      }, source);
-      await this.input.emitInternal(ModelAfterEvent, {
-        model,
-        content: result.content,
-        usage: result.usage,
-        finishReason: result.finishReason
-      });
-      this.input.throwIfTurnHandoffRequested();
-    } catch (error) {
-      if (this.input.isTurnHandoffSignal(error)) return;
-      const message = error instanceof Error ? error.message : String(error);
-      this.input.getMetrics().errors.push(message);
-      this.input.log(ModelCallFailedLog, { model, error }, source);
-      await this.input.emitInternal(ErrorEvent, { message, details: error });
-      throw error;
+      try {
+        result = await resolved.provider.run({
+          runId: this.input.getRunId(),
+          turnId: this.input.getTurnId(),
+          modeId: this.input.getModeId(),
+          modelRef: resolved.modelRef,
+          provider: resolved.namespace,
+          model: resolved.modelId,
+          systemPrompt,
+          messages,
+          roles: this.input.roles,
+          tools: input.tools,
+          maxTurns: input.mode.maxTurns ?? 20,
+          signal: input.options.signal,
+          prepareContext: () => this.prepareContext(input.mode, input.userMessage),
+          emit: async (eventClass, payload2, options) => {
+            providerEventEmitted = true;
+            const event = await this.input.emit(
+              eventClass,
+              payload2,
+              this.input.withEmitDefaults(source, void 0, void 0, options)
+            );
+            this.input.throwIfTurnHandoffRequested();
+            return event;
+          },
+          executeTool: async (tool, args, callId) => {
+            toolExecuted = true;
+            return this.input.executeTool(tool, args, callId, source);
+          }
+        });
+        break;
+      } catch (error) {
+        if (this.input.isTurnHandoffSignal(error)) return;
+        const normalized = normalizeHarnessError(error, {
+          category: "model",
+          severity: "error",
+          recoverable: false,
+          source
+        }, this.input.errorPolicy);
+        annotateHarnessError(error, normalized);
+        this.input.log(ModelCallFailedLog, { model, error: normalized, internalError: error, attempt }, source);
+        const canRetry = attempt < maxAttempts && normalized.category === "model" && !toolExecuted && !providerEventEmitted && input.options.signal?.aborted !== true;
+        if (!canRetry) throw error;
+        await delay(retryDelayMs(attempt, backoffMs, maxBackoffMs), input.options.signal);
+      }
     }
+    if (!result) throw new Error("Model provider did not return a result.");
+    const assistantMessage = await this.input.addAssistantMessage(result.content, {
+      usage: result.usage,
+      finishReason: result.finishReason
+    });
+    this.input.setFinalAnswer(result.content);
+    this.input.getMetrics().usage = result.usage;
+    await this.input.emitInternal(MessageEndEvent, { message: assistantMessage });
+    await this.input.markMessageEventCursor(assistantMessage.id);
+    this.input.log(ModelCallCompletedLog, {
+      model,
+      durationMs: Math.round(performance.now() - modelStart),
+      finishReason: result.finishReason
+    }, source);
+    await this.input.emitInternal(ModelAfterEvent, {
+      model,
+      content: result.content,
+      usage: result.usage,
+      finishReason: result.finishReason
+    });
+    this.input.throwIfTurnHandoffRequested();
   }
   modelProviderSource(resolved) {
     const id = modelProviderId(resolved.provider);
@@ -1776,7 +1864,16 @@ var AgentSessionRunner = class {
       mode: () => this.currentMode,
       openExistingRun: Boolean(options.initialRunId),
       logOpened: (fields) => this.log(RunStorageOpenedLog, fields),
-      logFailed: (fields) => this.log(StorageWriteFailedLog, fields)
+      logFailed: (fields) => {
+        const error = this.normalizeError(fields.error, {
+          code: "storage.write_failed",
+          category: "storage",
+          severity: "error",
+          recoverable: true,
+          details: { operation: fields.operation }
+        });
+        this.log(StorageWriteFailedLog, { operation: fields.operation, error, internalError: fields.error });
+      }
     });
     this.snapshotManager = new SnapshotManager({
       now: () => nowIso4(),
@@ -1870,13 +1967,28 @@ var AgentSessionRunner = class {
       logClosed: (fields) => this.log(SandboxClosedLog, fields),
       logExecStarted: (fields) => this.log(SandboxExecStartedLog, fields),
       logExecCompleted: (fields) => this.log(SandboxExecCompletedLog, fields),
-      logExecFailed: (fields) => this.log(SandboxExecFailedLog, fields)
+      logExecFailed: (fields) => {
+        const error = this.normalizeError(fields.error, {
+          code: "sandbox.exec.failed",
+          category: "sandbox",
+          severity: "error",
+          recoverable: true,
+          details: { sandboxId: fields.sandboxId, durationMs: fields.durationMs }
+        });
+        this.log(SandboxExecFailedLog, {
+          sandboxId: fields.sandboxId,
+          durationMs: fields.durationMs,
+          error,
+          internalError: fields.error
+        });
+      }
     });
     this.toolExecutor = new ToolExecutor({
       getMetrics: () => this.metrics,
       getCurrentMode: () => this.currentMode,
       getToolApprovalMode: () => this.getModeDefinition(this.currentMode).toolApproval,
       approveTool: this.options.approveTool,
+      errorPolicy: this.options.errorPolicy,
       ensureSandboxOpen: () => this.ensureSandboxOpen(),
       buildActionSession: (tool, source, correlationId, causationId) => this.buildActionSession(tool, source, correlationId, causationId),
       addToolCallMessage: (tool, args, toolCallId, source) => this.addToolCallMessage(tool, args, toolCallId, source),
@@ -1907,7 +2019,8 @@ var AgentSessionRunner = class {
       withEmitDefaults: (source, correlationId, causationId, eventOptions) => this.withEmitDefaults(source, correlationId, causationId, eventOptions),
       log: (logClass, fields, source, correlationId, causationId, overrides) => this.log(logClass, fields, source, correlationId, causationId, overrides),
       throwIfTurnHandoffRequested: () => this.throwIfTurnHandoffRequested(),
-      isTurnHandoffSignal: (error) => error instanceof TurnHandoffSignal
+      isTurnHandoffSignal: (error) => error instanceof TurnHandoffSignal,
+      errorPolicy: this.options.errorPolicy
     });
     this.state = this.createInitialState(this.agent);
     for (const eventClass of runtimeEventClasses) eventType(eventClass);
@@ -1945,6 +2058,14 @@ var AgentSessionRunner = class {
   hookDepth = 0;
   turnHandoffRequested = false;
   restoredFromRun = false;
+  normalizeError(error, context = {}) {
+    const normalized = normalizeHarnessError(error, context, this.options.errorPolicy);
+    annotateHarnessError(error, normalized);
+    return normalized;
+  }
+  publicError(error) {
+    return sanitizeHarnessError(error, this.options.errorPolicy);
+  }
   logSource(source) {
     if (!source) return { kind: "runtime" };
     return {
@@ -2008,8 +2129,8 @@ var AgentSessionRunner = class {
   async ensureSandboxOpen() {
     await this.sandboxManager.ensureOpen();
   }
-  async closeSandbox() {
-    await this.sandboxManager.close();
+  async closeSandbox(input = { reason: "close" }) {
+    await this.sandboxManager.close(input);
   }
   async closeStore() {
     await this.storageCoordinator.close();
@@ -2041,7 +2162,7 @@ var AgentSessionRunner = class {
   }
   async beginNewRun() {
     if (this.started || this.restoredFromRun) {
-      await this.closeSandbox();
+      await this.closeSandbox({ reason: "close" });
       this.runIdValue = randomId();
       await this.storageCoordinator.beginRun(this.runIdValue);
       this.started = false;
@@ -2053,12 +2174,12 @@ var AgentSessionRunner = class {
     this.turnHandoffRequested = false;
   }
   async run(message, options = {}) {
-    if (options.signal?.aborted) throw new Error("Run aborted.");
     await this.beginNewRun();
     this.runModelOverride = void 0;
     this.runModelOverride = this.normalizeModelOverride(options.model);
     let runStarted = false;
     try {
+      if (options.signal?.aborted) throw new Error("Run aborted.");
       await this.start();
       runStarted = true;
       this.pendingInputs.push({
@@ -2102,22 +2223,61 @@ var AgentSessionRunner = class {
         outputDir: this.storeRunDir()
       };
     } catch (error) {
-      this.log(RunFailedLog, { error });
+      const normalized = this.normalizeError(error, {
+        code: "run.failed",
+        category: "run",
+        severity: "fatal",
+        recoverable: false,
+        source: { kind: "runtime" }
+      });
+      const publicError = this.publicError(normalized);
+      this.finalizeMetrics();
+      this.metrics.errors.push(publicError);
+      await this.tryFailureWrite(() => this.storageCoordinator.saveTranscript(this.transcriptManager.allMessages));
+      await this.tryFailureWrite(() => this.emitInternal(ErrorEvent, {
+        error: publicError,
+        message: publicError.message,
+        code: publicError.code,
+        recoverable: publicError.recoverable,
+        details: publicError.details
+      }, { skipHooks: true }));
+      const terminalEvent = publicError.code === "run.aborted" ? RunAbortedEvent : RunFailedEvent;
+      await this.tryFailureWrite(() => this.emitInternal(terminalEvent, {
+        error: publicError,
+        metrics: cloneJSON4({ ...this.metrics, eventCount: this.eventRecorder.count + 1 }),
+        finalAnswer: this.finalAnswer || void 0
+      }, { skipHooks: true }));
+      this.contextRegistry.expireScope("run" /* Run */);
+      this.finalizeMetrics();
+      await this.tryFailureWrite(() => this.storageCoordinator.saveMetrics(this.metrics));
+      this.log(RunFailedLog, { error: normalized, internalError: error });
       throw error;
     } finally {
-      if (runStarted) await this.closeSandbox();
+      if (runStarted) await this.closeSandbox({ reason: "close" });
       this.runModelOverride = void 0;
     }
   }
   async prompt(message, options = {}) {
     return this.run(message, options);
   }
+  finalizeMetrics() {
+    this.metrics.completedAt = this.metrics.completedAt ?? nowIso4();
+    this.metrics.durationMs = this.startedAtPerf > 0 ? Math.round(performance.now() - this.startedAtPerf) : 0;
+    this.metrics.finalMode = this.currentMode;
+    this.metrics.eventCount = this.eventRecorder.count;
+  }
+  async tryFailureWrite(write) {
+    try {
+      await write();
+    } catch {
+    }
+  }
   async hydrate() {
     if (!this.restoredFromRun) return;
     await this.ensureStoreInitialized();
   }
-  async close() {
-    await this.closeSandbox();
+  async close(input = { reason: "close" }) {
+    await this.closeSandbox(input);
     await this.closeStore();
   }
   getTranscript(options) {
@@ -2602,7 +2762,11 @@ var AgentSessionRunner = class {
     this.log(ContextBuildStartedLog, { providerCount: activeBindings.length }, { kind: "runtime" });
     const providers = [];
     for (const binding of activeBindings) {
-      providers.push(await this.loadContextProvider(binding));
+      try {
+        providers.push(await this.loadContextProvider(binding));
+      } catch (error) {
+        if (!this.handleContextProviderFailure(binding, error)) throw error;
+      }
     }
     const dynamicEntries = this.dynamicContextEntriesFor(trigger);
     const contributions = [
@@ -2654,18 +2818,40 @@ var AgentSessionRunner = class {
         binding: summary,
         contributions: this.normalizeContextOutput(provider, output)
       };
-    } catch (error) {
-      this.log(
-        ContextProviderFailedLog,
-        { providerType: summary.type, error },
-        { kind: "context_provider", id: summary.type, name: summary.label },
-        this.currentTurnId
-      );
-      throw error;
     } finally {
       this.providerStack.pop();
     }
   }
+  handleContextProviderFailure(binding, error) {
+    let summary = { type: "unknown" };
+    let required = true;
+    try {
+      const { provider, options } = this.providerFromReference(binding, true);
+      summary = contextProviderSummary(provider, options);
+      required = isContextProviderBinding(binding) && typeof binding.required === "boolean" ? binding.required : provider.required ?? true;
+    } catch {
+    }
+    const modeFailure = this.getModeDefinition(this.currentMode).contextFailure;
+    const policyAllowsSkip = this.options.errorPolicy?.contextFailure === "warn-and-skip";
+    const skip = policyAllowsSkip && (required === false || modeFailure === "warn-and-skip");
+    const source = { kind: "context_provider", id: summary.type, name: summary.label };
+    const normalized = this.normalizeError(error, {
+      code: "context.provider.failed",
+      category: "context",
+      severity: skip ? "warn" : "error",
+      recoverable: skip,
+      source,
+      details: { providerType: summary.type }
+    });
+    this.log(
+      ContextProviderFailedLog,
+      { providerType: summary.type, error: normalized, internalError: error },
+      source,
+      this.currentTurnId
+    );
+    if (skip) this.metrics.errors.push(this.publicError(normalized));
+    return skip;
+  }
   normalizeContextContribution(input, context = {}) {
     if (typeof input === "string") {
       const role2 = this.resolveRole(context.defaultRole ?? systemRole);
@@ -3078,6 +3264,20 @@ var SessionEventHub = class {
         runId: record.runId,
         mode: String(payload2.modeId ?? record.modeId ?? "")
       });
+    } else if (record.type === RunFailedEvent.type) {
+      events.push({
+        type: "run.failed",
+        runId: record.runId,
+        error: payload2.error,
+        metrics: payload2.metrics
+      });
+    } else if (record.type === RunAbortedEvent.type) {
+      events.push({
+        type: "run.aborted",
+        runId: record.runId,
+        error: payload2.error,
+        metrics: payload2.metrics
+      });
     } else if (record.type === MessageDeltaEvent.type) {
       events.push({
         type: "assistant.delta",
@@ -3224,14 +3424,17 @@ var SessionQueue = class {
     if (!targetType) return "none";
     if (record.type === targetType) {
       this.pendingSendTriggers.shift();
-      return record.type === RunEndEvent.type ? "cleared" : "handoff";
+      return this.isTerminalRunEvent(record.type) ? "cleared" : "handoff";
     }
-    if (record.type === RunEndEvent.type) {
+    if (this.isTerminalRunEvent(record.type)) {
       this.pendingSendTriggers.shift();
       return "cleared";
     }
     return "none";
   }
+  isTerminalRunEvent(type) {
+    return type === RunEndEvent.type || type === RunFailedEvent.type || type === RunAbortedEvent.type;
+  }
 };
 
 // src/session/stream.ts
@@ -3358,9 +3561,19 @@ var SessionStatusTracker = class {
       this.currentTurnIdValue = void 0;
     } else if (record.type === RunEndEvent.type) {
       this.phaseValue = "completed" /* Completed */;
-    } else if (record.type === ErrorEvent.type) {
+    } else if (record.type === RunFailedEvent.type || record.type === RunAbortedEvent.type) {
       this.phaseValue = "error" /* Error */;
-      this.lastErrorValue = { message: String(payload2.message ?? "Unknown error") };
+      this.lastErrorValue = payload2.error;
+    } else if (record.type === ErrorEvent.type) {
+      const error = payload2.error;
+      this.lastErrorValue = error ?? {
+        code: "runtime.failed",
+        category: "runtime",
+        severity: "fatal",
+        recoverable: false,
+        message: String(payload2.message ?? "Unknown error")
+      };
+      if (!this.lastErrorValue.recoverable) this.phaseValue = "error" /* Error */;
     }
     if (record.turnId) this.currentTurnIdValue = record.turnId;
   }
@@ -3385,17 +3598,6 @@ function nowIso6() {
 function normalizeInput(input) {
   return typeof input === "string" ? { content: input } : input;
 }
-function toErrorShape(error) {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-      cause: error.cause
-    };
-  }
-  return { message: String(error) };
-}
 var HarnessSessionImpl = class {
   constructor(config, input) {
     this.config = config;
@@ -3424,7 +3626,8 @@ var HarnessSessionImpl = class {
       initialRunId: input.restoredSession?.latestRunId,
       resources: config.resources,
       approveTool: (request) => this.requestToolApproval(request),
-      logger: this.logger
+      logger: this.logger,
+      errorPolicy: config.errorPolicy
     });
     this.logger.emit(SessionCreatedLog, { sessionId: this.id }, { sessionId: this.id, source: { kind: "runtime" } });
     this.unsubscribeRunner = this.runner.subscribe((record) => {
@@ -3517,11 +3720,18 @@ var HarnessSessionImpl = class {
           await this.logger.flush();
           return sendResult;
         } catch (error) {
-          const shaped = toErrorShape(error);
+          const shaped = sanitizeHarnessError(normalizeHarnessError(error, {
+            code: "run.failed",
+            category: "run",
+            severity: "fatal",
+            recoverable: false,
+            source: { kind: "runtime" }
+          }, this.config.errorPolicy), this.config.errorPolicy);
           this.status.failRun(shaped);
           this.notify({ type: "error", error: shaped });
           this.notifyStatus();
           await this.logger.flush();
+          if (this.config.errorPolicy?.closeSessionOnFatal) await this.closeAfterFatal();
           throw error;
         } finally {
           unsubscribe();
@@ -3620,13 +3830,13 @@ var HarnessSessionImpl = class {
   waitForEvent(eventClass, options = {}) {
     return this.events.waitForEvent(eventClass, options);
   }
-  async close() {
+  async close(input = { reason: "close" }) {
     if (this.closed) return;
     this.closed = true;
     this.status.close();
     await this.cancelActiveRun("Session closed.");
     this.unsubscribeRunner();
-    await this.runner.close();
+    await this.runner.close(input);
     this.notifyStatus();
     this.events.clear();
     await this.logger.close();
@@ -3676,6 +3886,17 @@ var HarnessSessionImpl = class {
     this.activeAbort?.abort(reason);
     this.approvals.denyAll();
   }
+  async closeAfterFatal() {
+    if (this.closed) return;
+    this.closed = true;
+    this.status.close();
+    this.approvals.denyAll();
+    this.unsubscribeRunner();
+    await this.runner.close({ reason: "close" });
+    this.notifyStatus();
+    this.events.clear();
+    await this.logger.close();
+  }
 };
 async function createHarnessSession(config, options = {}) {
   const agent = await resolveAgent(config.agent);
@@ -3709,6 +3930,7 @@ function mergeConfig(base, overrides) {
     providers: overrides?.providers ?? base.providers,
     resources: overrides?.resources ?? base.resources,
     logging: overrides?.logging ?? base.logging,
+    errorPolicy: overrides?.errorPolicy ?? base.errorPolicy,
     storage: overrides?.storage ?? base.storage
   };
 }
@@ -3764,6 +3986,7 @@ var HarnessSessionStoreImpl = class {
   sessions = /* @__PURE__ */ new Map();
   unsubscriptions = /* @__PURE__ */ new Map();
   latestRunIds = /* @__PURE__ */ new Map();
+  sessionSandboxes = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   storage;
   closed = false;
@@ -3778,6 +4001,7 @@ var HarnessSessionStoreImpl = class {
     const config = mergeConfig({ ...this.config, storage: this.storage }, overrides);
     const stored = await this.storage.getSession(id);
     const session = await createHarnessSession(config, { sessionId: id, restoredSession: stored });
+    this.sessionSandboxes.set(id, config.sandbox);
     const status = session.getStatus();
     if (stored?.latestRunId) this.latestRunIds.set(id, stored.latestRunId);
     else this.latestRunIds.delete(id);
@@ -3794,6 +4018,7 @@ var HarnessSessionStoreImpl = class {
     this.unsubscriptions.set(id, session.on((event) => {
       if (event.type === "run.started") this.latestRunIds.set(id, event.runId);
       if (event.type === "run.completed") this.latestRunIds.set(id, event.result.runId);
+      if (event.type === "run.failed" || event.type === "run.aborted") this.latestRunIds.set(id, event.runId);
       if (event.type === "session.status") {
         void this.storage.touchSession({
           sessionId: id,
@@ -3830,17 +4055,26 @@ var HarnessSessionStoreImpl = class {
     }
     const session = this.sessions.get(sessionId);
     if (!session) return false;
-    this.sessions.delete(sessionId);
-    this.latestRunIds.delete(sessionId);
-    this.unsubscriptions.get(sessionId)?.();
-    this.unsubscriptions.delete(sessionId);
-    await session.close();
+    await this.closeTrackedSession(sessionId, session, { reason: "close" });
     return true;
   }
   async delete(sessionId) {
-    await this.close(sessionId);
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      await this.closeTrackedSession(sessionId, session, { reason: "delete" });
+    } else {
+      const stored = await this.storage.getSession(sessionId);
+      const sandbox = this.sessionSandboxes.get(sessionId) ?? this.config.sandbox;
+      if (stored || this.sessionSandboxes.has(sessionId)) {
+        await sandbox?.destroy?.({
+          sessionId,
+          agentKey: stored?.agentKey
+        });
+      }
+    }
     this.latestRunIds.delete(sessionId);
     const deleted = await this.storage.deleteSession(sessionId);
+    this.sessionSandboxes.delete(sessionId);
     if (deleted) this.notify({ type: "session.deleted", sessionId });
     return deleted;
   }
@@ -3883,6 +4117,13 @@ var HarnessSessionStoreImpl = class {
   notify(event) {
     for (const listener of this.listeners) void listener(event);
   }
+  async closeTrackedSession(sessionId, session, input) {
+    this.sessions.delete(sessionId);
+    this.latestRunIds.delete(sessionId);
+    this.unsubscriptions.get(sessionId)?.();
+    this.unsubscriptions.delete(sessionId);
+    await session.close(input);
+  }
 };
 async function createHarnessSessionStore(config) {
   const store = new HarnessSessionStoreImpl(config);
@@ -3891,7 +4132,6 @@ async function createHarnessSessionStore(config) {
 }
 
 export {
-  createToolErrorPayload,
   AgentSessionRunner,
   HarnessSessionPhase,
   HarnessSessionImpl,
@@ -3899,4 +4139,4 @@ export {
   HarnessSessionStoreImpl,
   createHarnessSessionStore
 };
-//# sourceMappingURL=chunk-QEVKKJ7N.js.map
+//# sourceMappingURL=chunk-BLLQSHQI.js.map