@sema-agent/core 7.23.1 → 7.23.3

package/dist/core/runner/resume-preflight.js

@@ -4,6 +4,7 @@ import { hasDestroy } from "../remote-env.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { describeSuppliedValue } from "./decide-continuation.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
+import { asThrownError } from "../thrown-value.js";
 const RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS = 10_000;
 export async function resumePreflight(input) {
     const { token, cp, resumeSignal, recheckGovernanceWindow, store, runner, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
@@ -40,7 +41,7 @@ export async function resumePreflight(input) {
                 abortEnds: true,
                 onBadTimeout: (badErr) => {
                     try {
-                        runner.deps.onError?.(badErr instanceof Error ? badErr : new Error(String(badErr)), { phase: "hook", sessionId: cp.sessionId });
+                        runner.deps.onError?.(asThrownError(badErr), { phase: "hook", sessionId: cp.sessionId });
                     }
                     catch {
                     }
@@ -57,7 +58,7 @@ export async function resumePreflight(input) {
         catch (preflightErr) {
             if (preflightErr instanceof CheckpointError)
                 throw preflightErr;
-            const err = preflightErr instanceof Error ? preflightErr : new Error(String(preflightErr));
+            const err = asThrownError(preflightErr);
             try {
                 runner.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
             }

package/dist/core/runner/run-git-lane.js

@@ -1,5 +1,6 @@
 import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
 import { wrapGitFrame } from "./git-leg-delivery.js";
+import { thrownText } from "../thrown-value.js";
 export function runGitLane(input) {
     const { prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner } = input;
     prepared.gitStatusRef.reassert = async () => {
@@ -34,7 +35,7 @@ export function runGitLane(input) {
             }
             catch (mirrorErr) {
                 try {
-                    runner.deps.onError?.(new Error(`git announcement mirror write failed (frame delivered; next leg re-announces): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`), { phase: "degraded", sessionId: prepared.sessionId });
+                    runner.deps.onError?.(new Error(`git announcement mirror write failed (frame delivered; next leg re-announces): ${thrownText(mirrorErr)}`), { phase: "degraded", sessionId: prepared.sessionId });
                 }
                 catch {
                 }
@@ -43,7 +44,7 @@ export function runGitLane(input) {
         catch (err) {
             ref.announced = { kind: use.kind, hash: use.hash, pending: true };
             try {
-                runner.deps.onError?.(new Error(`git status frame re-assert append failed (pending; retried at the next boundary): ${err instanceof Error ? err.message : String(err)}`), { phase: "degraded", sessionId: prepared.sessionId });
+                runner.deps.onError?.(new Error(`git status frame re-assert append failed (pending; retried at the next boundary): ${thrownText(err)}`), { phase: "degraded", sessionId: prepared.sessionId });
             }
             catch {
             }
@@ -64,7 +65,7 @@ export function runGitLane(input) {
         catch (mirrorErr) {
             prepared.gitStatusRef.mirrorOwed = owed;
             try {
-                runner.deps.onError?.(new Error(`git announcement mirror write failed (frame delivered; retried at the next serialization point): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`), { phase: "degraded", sessionId: prepared.sessionId });
+                runner.deps.onError?.(new Error(`git announcement mirror write failed (frame delivered; retried at the next serialization point): ${thrownText(mirrorErr)}`), { phase: "degraded", sessionId: prepared.sessionId });
             }
             catch {
             }

package/dist/core/runner/run-leg.js

@@ -29,6 +29,7 @@ import { toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
 import { announceListingTruncation } from "../skill-listing-budget.js";
 import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
 import { flushOwedAnnouncedSnapshot } from "./announce-once-ledger.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 export async function runLeg(input) {
     const { spec, queue, prepared, resume, rs, isDelegatedChild, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
     let final;
@@ -164,7 +165,7 @@ export async function runLeg(input) {
                                         : { ...(seat.value?.additionalContext !== undefined && seat.value.additionalContext !== "" ? { context: seat.value.additionalContext } : {}) };
                             }
                             catch (hookErr) {
-                                const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                                const err = asThrownError(hookErr);
                                 try {
                                     runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
                                 }
@@ -301,7 +302,7 @@ export async function runLeg(input) {
                     }
                 }
                 catch (hookErr) {
-                    const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                    const err = asThrownError(hookErr);
                     try {
                         runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
                     }
@@ -691,7 +692,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         res = await tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal);
     }
     catch (err) {
-        const execError = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        const execError = `Error: ${thrownText(err)}`;
         const marks = (() => {
             if (err === null || typeof err !== "object")
                 return undefined;

package/dist/core/runner/run-recovery-lanes.js

@@ -9,6 +9,7 @@ import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFi
 import { gitRestateOption } from "./git-leg-delivery.js";
 import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 export function runRecoveryLanes(input) {
     const { spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner } = input;
     const runForcedCompactionPass = async (lane, turnSignal) => {
@@ -108,8 +109,8 @@ export function runRecoveryLanes(input) {
                 return false;
             }
             compactionBreaker.failures += 1;
-            runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "compaction", sessionId: prepared.sessionId });
-            const msg = String(err instanceof Error ? err.message : err);
+            runner.deps.onError?.(asThrownError(err), { phase: "compaction", sessionId: prepared.sessionId });
+            const msg = thrownText(err);
             queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
             return false;
         }

package/dist/core/runner/run-settle-and-teardown.js

@@ -20,6 +20,7 @@ import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
+import { asThrownError } from "../thrown-value.js";
 export async function runSettleAndTeardown(input) {
     const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
     try {
@@ -204,7 +205,7 @@ export async function runSettleAndTeardown(input) {
             }
             catch (err) {
                 try {
-                    runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                    runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
                 }
                 catch {
                 }

package/dist/core/runner/run-stop-and-final-verify.js

@@ -1,5 +1,6 @@
 import { openSystemReminder } from "../reminder-mint.js";
 import { formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { asThrownError } from "../thrown-value.js";
 const STOP_HOOK_BLOCK_CAP = 8;
 export function runStopAndFinalVerify(input) {
     const { spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner } = input;
@@ -120,7 +121,7 @@ export function runStopAndFinalVerify(input) {
                 result = stopSeat.value;
             }
             catch (err) {
-                runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
                 return [];
             }
             const messages = [];

package/dist/core/runner/run-telemetry-and-budget-seats.js

@@ -6,6 +6,7 @@ import { emitTrace } from "../trace.js";
 import { resolveMaxTurns } from "./clock-and-limits.js";
 import { resolveOutputRetries } from "./synthetic-tools.js";
 import { cacheFamilyOf } from "./usage-accounting.js";
+import { asThrownError } from "../thrown-value.js";
 export function runTelemetryAndBudgetSeats(input) {
     const { spec, prepared, resume, stats, taskIdRef, entryTracer, modelCatalog, runSourceTaskId, rs, runner, sessions } = input;
     prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) });
@@ -66,7 +67,7 @@ export function runTelemetryAndBudgetSeats(input) {
     rs.telemetry.taskStartMonotonic = performance.now();
     const discloseNoteTaskRunFailure = (err) => {
         try {
-            runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId: prepared.sessionId });
+            runner.deps.onError?.(asThrownError(err), { phase: "config", sessionId: prepared.sessionId });
         }
         catch {
         }

package/dist/core/runner/run-terminal-adoption.js

@@ -10,6 +10,7 @@ import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions }
 import { gitRestateOption } from "./git-leg-delivery.js";
 import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { reconciledToolEndBody } from "./tool-end-body.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 export async function runTerminalAdoption(input) {
     const { spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions, undrainedUserAtEnd, userInputLostAtEnd, final, abortedLive, userInterruptedLive, runner, sessions, next } = input;
     let { threw } = input;
@@ -48,7 +49,7 @@ export async function runTerminalAdoption(input) {
             reconcileComplete = true;
         }
         catch (reconcileErr) {
-            runner.deps.onError?.(reconcileErr instanceof Error ? reconcileErr : new Error(String(reconcileErr)), {
+            runner.deps.onError?.(asThrownError(reconcileErr), {
                 phase: "interrupt-reconcile",
                 sessionId: prepared.sessionId,
             });
@@ -57,7 +58,7 @@ export async function runTerminalAdoption(input) {
             await prepared.harness.flushQueuedSessionWrites();
         }
         catch (flushErr) {
-            runner.deps.onError?.(flushErr instanceof Error ? flushErr : new Error(String(flushErr)), {
+            runner.deps.onError?.(asThrownError(flushErr), {
                 phase: "interrupt-reconcile",
                 sessionId: prepared.sessionId,
             });
@@ -69,7 +70,7 @@ export async function runTerminalAdoption(input) {
             emitCommitted(entryId, "user");
         }
         catch (markerErr) {
-            runner.deps.onError?.(markerErr instanceof Error ? markerErr : new Error(String(markerErr)), {
+            runner.deps.onError?.(asThrownError(markerErr), {
                 phase: "interrupt-reconcile",
                 sessionId: prepared.sessionId,
             });
@@ -96,7 +97,7 @@ export async function runTerminalAdoption(input) {
                     carriedContinuation += 1;
             }
             catch (parkErr) {
-                runner.deps.onError?.(parkErr instanceof Error ? parkErr : new Error(String(parkErr)), {
+                runner.deps.onError?.(asThrownError(parkErr), {
                     phase: "config",
                     sessionId: prepared.sessionId,
                 });
@@ -161,7 +162,7 @@ async function finish(spec, prepared, opts, runner, sessions) {
             comp = finishComp;
         }
         catch (err) {
-            const failMsg = String(err instanceof Error ? err.message : err);
+            const failMsg = thrownText(err);
             const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
             emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, () => ({
                 kind: "compaction.failed",

package/dist/core/runner/run-turn-boundary.js

@@ -17,6 +17,7 @@ import { gitRestateOption } from "./git-leg-delivery.js";
 import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
 import { contextUsageSections } from "../../prompt-assembly/section-usage.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 export function createTurnBoundary(input) {
@@ -49,7 +50,7 @@ export function createTurnBoundary(input) {
                         if (answer === GOVERNANCE_READ_STALLED) {
                             void windowRead.catch((lateErr) => {
                                 try {
-                                    runnerHooks.onError?.(lateErr instanceof Error ? lateErr : new Error(String(lateErr)), { phase: "config", sessionId: prepared.sessionId });
+                                    runnerHooks.onError?.(asThrownError(lateErr), { phase: "config", sessionId: prepared.sessionId });
                                 }
                                 catch {
                                 }
@@ -71,7 +72,7 @@ export function createTurnBoundary(input) {
                     }
                 }
                 catch (govErr) {
-                    rs.limits.platformTerminal = govErr instanceof Error ? govErr : new Error(String(govErr));
+                    rs.limits.platformTerminal = asThrownError(govErr);
                     void prepared.harness.abort();
                     prepared.abortController.abort();
                     return undefined;
@@ -479,7 +480,7 @@ export function createTurnBoundary(input) {
                 }
                 catch (err) {
                     try {
-                        runnerHooks.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                        runnerHooks.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
                     }
                     catch {
                     }
@@ -689,7 +690,7 @@ export function createTurnBoundary(input) {
             else if (!prepared.abortController.signal.aborted) {
                 compactionBreaker.failures += 1;
                 runnerHooks.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
-                const msg = String(err instanceof Error ? err.message : err);
+                const msg = thrownText(err);
                 const failReason = msg.length > 512 ? `${msg.slice(0, 512)}…` : msg;
                 emitTrace(rs.telemetry.tracer, () => ({
                     kind: "compaction.failed",

package/dist/core/runner/runtask.js

@@ -56,6 +56,7 @@ import { runCompactionMachinery } from "./run-compaction-machinery.js";
 import { runStopAndFinalVerify } from "./run-stop-and-final-verify.js";
 import { runRecoveryLanes } from "./run-recovery-lanes.js";
 import { runGitLane } from "./run-git-lane.js";
+import { thrownText } from "../thrown-value.js";
 export class Runner {
     deps;
     sessions;
@@ -83,7 +84,7 @@ export class Runner {
                         version: 1,
                         sessionId: context.sessionId,
                         phase: context.phase,
-                        reason: (sinkErr instanceof Error ? sinkErr.message : String(sinkErr)).slice(0, 256),
+                        reason: (thrownText(sinkErr)).slice(0, 256),
                         ts: Date.now(),
                     }));
                 }

package/dist/core/runner/stream-settle-backstop.js

@@ -6,6 +6,7 @@ import { createSafeNotifier } from "../safe-notify.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { emitTrace } from "../trace.js";
 import { deliverDelegationLifecycle } from "../types.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 export function streamSettleBackstop(input) {
     const { spec, resume, queue, taskIdRef, entryTracer, runStartedAt, live, runner, sessions, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
     const onRunRejected = async (err) => {
@@ -21,8 +22,8 @@ export function streamSettleBackstop(input) {
             }
             catch (reopenErr) {
                 parentConstraintRegistry.delete(resume.cp.token);
-                const original = err instanceof Error ? err : new Error(String(err));
-                const reopenMsg = reopenErr instanceof Error ? reopenErr.message : String(reopenErr);
+                const original = asThrownError(err);
+                const reopenMsg = thrownText(reopenErr);
                 const definitive = errorCodeOf(reopenErr) === "checkpoint.reopen_failed";
                 reopenStateUnknown = !definitive;
                 err = Object.assign(new Error(definitive
@@ -47,7 +48,7 @@ export function streamSettleBackstop(input) {
         }
         if (live.resultValue !== undefined) {
             try {
-                runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId: live.resultValue.sessionId });
+                runner.deps.onError?.(asThrownError(err), { phase: "config", sessionId: live.resultValue.sessionId });
             }
             catch {
             }
@@ -68,7 +69,7 @@ export function streamSettleBackstop(input) {
             taskId: taskIdRef.current ?? "unknown",
             sessionId: taskIdRef.sessionId ?? "unknown",
             ...(taskIdRef.runId !== undefined ? { runId: taskIdRef.runId } : {}),
-            terminal: { kind: "failed", ...(code !== undefined ? { code } : {}), message: err instanceof Error ? err.message : String(err) },
+            terminal: { kind: "failed", ...(code !== undefined ? { code } : {}), message: thrownText(err) },
             result: "",
             ...(remoteEnvFailure !== undefined ? { remoteEnvFailures: remoteEnvFailure } : {}),
             ...(taskIdRef.effectiveMemoryScopes !== undefined ? { effectiveMemoryScopes: taskIdRef.effectiveMemoryScopes } : {}),

package/dist/core/runner/stream-steer-verb.js

@@ -7,6 +7,7 @@ import { isSystemInjectionPriority, SYSTEM_INJECTION_PRIORITIES } from "../task-
 import { deliverEngineNotice } from "../types.js";
 import { inlineUntrusted, sanitizeUntrustedText } from "../untrusted-text.js";
 import { nextHumanInputSeq, sameAcceptedSteerInput } from "./steer-admission.js";
+import { asThrownError } from "../thrown-value.js";
 export function streamSteerVerb(input) {
     const { spec, internals, queue, acceptedSteerInputs, live, ready, orTimeout, readyTimeoutMs: READY_TIMEOUT_MS, steeringError, runner } = input;
     let steerChain = Promise.resolve();
@@ -111,7 +112,7 @@ export function streamSteerVerb(input) {
                     catch (hookErr) {
                         if (hookErr instanceof Error && hookErr.code === "steering.blocked_by_hook")
                             throw hookErr;
-                        const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                        const err = asThrownError(hookErr);
                         try {
                             runner.deps.onError?.(err, { phase: "hook", sessionId: h.sessionId });
                         }

package/dist/core/runner/strict-output-schema.js

@@ -1,3 +1,4 @@
+import { thrownText } from "../thrown-value.js";
 const STRICT_KEYWORDS = new Set([
     "$schema",
     "type",
@@ -298,6 +299,6 @@ function compileUncached(schema) {
         return { modelSchema: schema, strict: false, fallbackReason: derived.reason };
     }
     catch (err) {
-        return { modelSchema: schema, strict: false, fallbackReason: `derivation_error: ${err instanceof Error ? err.message : String(err)}` };
+        return { modelSchema: schema, strict: false, fallbackReason: `derivation_error: ${thrownText(err)}` };
     }
 }

package/dist/core/runner/teardown-bounded.js

@@ -1,3 +1,4 @@
+import { asThrownError } from "../thrown-value.js";
 export const TEARDOWN_LEG_MAX_MS = 15_000;
 let teardownLegBudgetMs = TEARDOWN_LEG_MAX_MS;
 export function setTeardownLegBudgetForTests(ms) {
@@ -24,7 +25,7 @@ export async function settleTeardownLeg(leg, label, report) {
     }
     catch (e) {
         try {
-            report?.(e instanceof Error ? e : new Error(String(e)));
+            report?.(asThrownError(e));
         }
         catch {
         }

package/dist/core/safe-notify.js

@@ -1,3 +1,4 @@
+import { thrownText } from "./thrown-value.js";
 function containedError(thrown) {
     try {
         if (thrown instanceof Error && typeof thrown.message === "string")
@@ -13,7 +14,7 @@ export function safeErrorMessage(error) {
         const m = error?.message;
         if (typeof m === "string")
             return m;
-        return String(error);
+        return thrownText(error);
     }
     catch {
         return "a failure whose message could not be read";

package/dist/core/skills-directory.js

@@ -2,6 +2,7 @@ import { readFileSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import { physicalPathOf } from "./physical-path.js";
 import { isSkillSpecifierEnforced, parseSkillToolEntry } from "./skill-tool-specifier.js";
+import { thrownText } from "./thrown-value.js";
 const SKILL_FILE = "SKILL.md";
 const RESOURCE_DIRS = ["assets", "references", "scripts"];
 const NAME_MAX_CHARS = 64;
@@ -282,7 +283,7 @@ function isDecodableText(bytes) {
     return Buffer.byteLength(decoded, "utf8") === bytes.byteLength;
 }
 function errText(err) {
-    return err instanceof Error ? err.message : String(err);
+    return thrownText(err);
 }
 const ALL_TOOLS_WILDCARD = "*";
 function splitToolNames(declared) {

package/dist/core/strategy-store.js

@@ -1,4 +1,5 @@
 import { termSet } from "./memory-vector.js";
+import { thrownText } from "./thrown-value.js";
 function invalidKnob(message, code) {
     const e = new Error(message);
     e.code = code;
@@ -244,7 +245,7 @@ export async function seedStrategies(store, scope, entries) {
             await store.save(s);
         }
         catch (err) {
-            return { written, failedAt: { id: s.id, error: String(err.message ?? err) } };
+            return { written, failedAt: { id: s.id, error: thrownText(err) } };
         }
         written++;
     }

package/dist/core/task-registry-agent.js

@@ -7,6 +7,7 @@ import { delimitUntrusted } from "./untrusted-text.js";
 import { boundedRedactedSummary } from "./untrusted-egress.js";
 import { mintCompletionId, commitCompletionIdIfEmpty, clipTaskOutput, assertOwnership, sleepPollStep, alreadyTerminalStopNote, canAccess, normalizeAgentName, closestName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR, } from "./task-registry-shared.js";
 import { buildToolResultRef, OFFLOAD_TOOL_NAME, toolResultProvenanceOf } from "./tool-result-store.js";
+import { thrownLabel } from "./thrown-value.js";
 export function activeDelegationHandlesLane(core, scope, rootSessionId) {
     const out = [];
     for (const h of core.handles.values()) {
@@ -140,7 +141,7 @@ export function durableAgentWriteLane(handle, patch, clear) {
                     poison("handle collision (foreign durable row left untouched)");
                     return;
                 }
-                shutdownDebug(`durable-agents write failed for ${lane.record.handle} (attempt ${attempt + 1}/3)`, { error: String(e) });
+                shutdownDebug(`durable-agents write failed for ${lane.record.handle} (attempt ${attempt + 1}/3)`, { error: thrownLabel(e) });
             }
         }
         lane.flushFailed = true;

package/dist/core/task-registry-monitor.js

@@ -1,6 +1,7 @@
 import { delimitUntrusted } from "./untrusted-text.js";
 import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, MONITOR_SPILL_CAP_CHARS, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, renderSpoolBody, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
 import { buildToolResultRef, OFFLOAD_TOOL_NAME, toolResultProvenanceOf } from "./tool-result-store.js";
+import { thrownText } from "./thrown-value.js";
 export function registerMonitorLane(core, input) {
     assertOwnership(input, "registerMonitor");
     const id = core.mintTaskId("monitor");
@@ -289,7 +290,7 @@ export function startMonitorWatcherLane(core, id) {
             if (++pollFailures <= MAX_RETRYABLE_POLL_FAILURES)
                 return;
             handle.status = "failed";
-            terminal("failed", `monitor watcher crashed (${e instanceof Error ? e.message : String(e)}); watch ended.${pendingSuppressionNote()}`, pendingFinalLines([]));
+            terminal("failed", `monitor watcher crashed (${thrownText(e)}); watch ended.${pendingSuppressionNote()}`, pendingFinalLines([]));
         }
         finally {
             ticking = false;

package/dist/core/task-registry-workflow.js

@@ -1,5 +1,6 @@
 import { boundedRedactedSummary } from "./untrusted-egress.js";
 import { delimitUntrusted } from "./untrusted-text.js";
+import { thrownText } from "./thrown-value.js";
 import { assertOwnership, canAccessWorkflowRun, formatWorkflowRun, sleepPollStep, } from "./task-registry-shared.js";
 export function registerWorkflowLane(core, input) {
     assertOwnership(input, "registerWorkflow");
@@ -37,7 +38,7 @@ export function registerWorkflowLane(core, input) {
     }, (err) => {
         if (handle.status !== "cancelled")
             handle.status = "failed";
-        handle.error = boundedRedactedSummary(err instanceof Error ? err.message : String(err), 500);
+        handle.error = boundedRedactedSummary(thrownText(err), 500);
         const rejectedRun = err !== null && (typeof err === "object" || typeof err === "function")
             ? err.workflowRun
             : undefined;

package/dist/core/task-registry.js

@@ -13,6 +13,7 @@ export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
 import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, noteBackgroundAgentActivityLane, reapStaleSessionBackgroundAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, recordBackgroundAgentOrgAdmissionLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, backgroundAgentCycleSeqLane, activeDelegationHandlesLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
 import { toolFace } from "./tool-catalog-entries.js";
+import { thrownText } from "./thrown-value.js";
 export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
 const BLOCK_MAX_TIMEOUT_MS = 600_000;
@@ -498,7 +499,7 @@ export class TaskRegistry {
             }
         }
         catch (err) {
-            shutdownDebug("session reap: kill threw", { kind, id: handle.id, shellId: handle.shellId, error: err instanceof Error ? err.message : String(err) });
+            shutdownDebug("session reap: kill threw", { kind, id: handle.id, shellId: handle.shellId, error: thrownText(err) });
         }
     }
     reapSessionBackground(sessionId, scope) {
@@ -764,7 +765,7 @@ export class TaskRegistry {
                     ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
                     ...(handle.outputFile !== undefined ? { output_file: handle.outputFile } : {}),
                     status: "failed",
-                    summary: `${terminalTaskSummary("bash", (handle.description ?? "background command").slice(0, 200), "failed")} — lost its background process (poll failed: ${e instanceof Error ? e.message : String(e)}); no further output will arrive.${bashMirrorGapNote(handle)}`,
+                    summary: `${terminalTaskSummary("bash", (handle.description ?? "background command").slice(0, 200), "failed")} — lost its background process (poll failed: ${thrownText(e)}); no further output will arrive.${bashMirrorGapNote(handle)}`,
                     ...(crashedResult.length > 0 ? { result: crashedResult } : {}),
                     ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
                 }));

package/dist/core/thrown-value.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Turning a value that was THROWN at us into text — the ONE rule, for the whole engine.
+ *
+ * The idiom this replaces is `err instanceof Error ? err.message : String(err)` (and its template-literal
+ * twin, `` `${err}` ``). Both spell a PARTIAL function on the non-Error arm: `String` calls the value's own
+ * `toString` / `Symbol.toPrimitive`, so it throws on a value that has neither (a null-prototype object) and
+ * on one whose own hook throws. The thrower is not ours — a deployment hook, a plugin callback, a model-
+ * supplied tool body may reject with any value at all — so the rendering step was the one step that could
+ * destroy the report it exists to produce. Where the render sat inside a promise rejection handler, the
+ * resulting `TypeError` was an unhandled rejection and took the whole process down: a caller's choice of
+ * rejection value decided whether the engine stayed alive.
+ *
+ * Totality is therefore the contract, and it is met the same way the engine's structural describer already
+ * meets it: the value is never asked to say what it is. Three arms, in this order, chosen so that the
+ * dominant shapes keep their EXACT previous bytes and only the shapes that used to be useless or fatal move:
+ *  - a thrown STRING is its own message (a bare `throw "…"`), returned verbatim — the describer would quote
+ *    it, which is right when rejecting a config value and wrong when relaying a message someone threw;
+ *  - an ERROR hands over `message` verbatim — no cap, no one-lining, no quoting. This is the arm nearly all
+ *    production traffic takes, and the text on it is byte-for-byte what the old idiom produced;
+ *  - anything else is DESCRIBED structurally, by the one describer, which guards every read it makes.
+ *
+ * Empty is a legitimate answer: `new Error("")` returns `""`, exactly as `err.message` did, because callers
+ * fold that into their own wording (`… || "unknown"`). Two callers want something else and have their own
+ * face for it: {@link thrownLabel} when the previous text was `String(err)` (which names the error CLASS),
+ * and `describeThrown` when the text must be non-empty and contained for a model-facing frame.
+ */
+export declare function thrownText(err: unknown): string;
+/**
+ * The LABELLED face of the same rule: what `String(err)` used to produce, made total.
+ *
+ * `String` on an Error does not yield its message — it yields `"TypeError: boom"`, the class AND the message
+ * (and just `"TypeError"` when the message is empty). Sites that spelled a bare `String(err)` were therefore
+ * saying something the message-only face cannot say, and at least one of them is load-bearing rather than
+ * decorative: a stuck-detector keyed its signature on this text, so collapsing two distinct error classes
+ * with equal messages into one string would have changed when a run gets abandoned. Preserving those bytes
+ * is the whole reason this face exists as well as {@link thrownText}.
+ *
+ * Fidelity is obtained by calling `String` itself rather than reassembling `name` and `message` by hand —
+ * the spelling rules for an empty name or an empty message live in `Error.prototype.toString`, and a second
+ * copy of them here would be a second rule to keep in step. It is called INSIDE the guard, so a subclass
+ * whose own `toString`/`name`/`message` misbehaves falls back to the structural description instead of
+ * escaping. Non-Errors never reach `String` at all; they go to {@link thrownText}, which is the fix.
+ */
+export declare function thrownLabel(err: unknown): string;
+/**
+ * The same rule for callers that need an `Error` OBJECT rather than text — the normalizing half of
+ * `err instanceof Error ? err : new Error(String(err))`, which carries the identical defect on the identical
+ * arm and appears wherever an unknown rejection has to be handed to a seat typed `Error` (a deployment's
+ * error lane, a promise `reject`, a report callback).
+ *
+ * An `Error` of THIS realm is passed through by IDENTITY — same object, same stack, same own properties — so
+ * the arm that carries nearly all traffic is unchanged in every observable way, not merely in its message.
+ * A cross-realm Error is WRAPPED rather than passed through, which is what the old idiom did too: the seat's
+ * type says `Error`, and an object that fails `instanceof` here would break the first consumer that trusts
+ * it. Its message survives the wrap, because the new message is the {@link thrownLabel} of the original —
+ * the same text `String(err)` produced.
+ *
+ * The original value is deliberately NOT attached as `cause`: `cause` chains are walked elsewhere to
+ * attribute error codes, so attaching one here would let an arbitrary thrown object start supplying codes
+ * to readers that never saw it before. Preserving it is a worthwhile change on its own terms and belongs
+ * with those readers, not smuggled in by a rendering fix.
+ */
+export declare function asThrownError(err: unknown): Error;
+/**
+ * Read ONE member of an untrusted value, once, and hand back an inert snapshot.
+ *
+ * Inspecting a thrown value is attacker-reachable in the same way coercing it is: any property can be an
+ * accessor that throws, or one that answers differently on a second read. Sites that need a member — a
+ * shell error's `exitCode`, a refusal's `code`, a transport error's `cause` — were each wrapping their own
+ * `try`, and a guard written per SITE is coarse: one hostile member took the readable ones down with it,
+ * so a report lost an exit code it had already read because a later `stdout` threw.
+ *
+ * One guarded read, per member, is the finer and the smaller rule: the caller keeps what it could read and
+ * loses only what it could not, and nothing it holds afterwards can run the value's code again. The result
+ * is `undefined` for BOTH "absent" and "unreadable" — deliberately, because a caller that must tell those
+ * apart is asking a question an untrusted value is not obliged to answer; what it does instead is fall back
+ * to describing the value, which {@link thrownText} already does totally.
+ */
+export declare function readMember(value: unknown, key: string): unknown;

package/dist/core/thrown-value.js

@@ -0,0 +1,56 @@
+import { describeRejectedValue } from "./tool-search-setting.js";
+function isErrorLike(value) {
+    try {
+        if (value instanceof Error)
+            return true;
+        return Object.prototype.toString.call(value) === "[object Error]";
+    }
+    catch {
+        return false;
+    }
+}
+export function thrownText(err) {
+    try {
+        if (typeof err === "string")
+            return err;
+        if (isErrorLike(err)) {
+            const message = err.message;
+            if (typeof message === "string")
+                return message;
+        }
+    }
+    catch {
+    }
+    return describeRejectedValue(err);
+}
+export function thrownLabel(err) {
+    try {
+        if (isErrorLike(err)) {
+            const label = String(err);
+            if (label !== "")
+                return label;
+        }
+    }
+    catch {
+    }
+    return thrownText(err);
+}
+export function asThrownError(err) {
+    try {
+        if (err instanceof Error)
+            return err;
+    }
+    catch {
+    }
+    return new Error(thrownLabel(err));
+}
+export function readMember(value, key) {
+    try {
+        if (value === null || value === undefined)
+            return undefined;
+        return value[key];
+    }
+    catch {
+        return undefined;
+    }
+}