@sema-agent/core 7.23.1 → 7.23.3

package/dist/core/memory-engine/session-incarnation.js

@@ -1,4 +1,5 @@
 import { sessionRecordBindsIncarnation, usableSessionIncarnation } from "./layout.js";
+import { thrownText } from "../thrown-value.js";
 export function createSessionIncarnationSeat(input) {
     const { resolve, onIncident } = input;
     let faultAnnounced = false;
@@ -24,7 +25,7 @@ export function createSessionIncarnationSeat(input) {
         catch (err) {
             if (!faultAnnounced) {
                 faultAnnounced = true;
-                disclose("memory.session_incarnation_unreadable", `the session incarnation resolver threw (${err instanceof Error ? err.message : String(err)}) — this run cannot tell one occupant of a session id from the next, so every durable session record binds by id alone (the conservative reading, and the behavior of a deployment that wires no resolver)`);
+                disclose("memory.session_incarnation_unreadable", `the session incarnation resolver threw (${thrownText(err)}) — this run cannot tell one occupant of a session id from the next, so every durable session record binds by id alone (the conservative reading, and the behavior of a deployment that wires no resolver)`);
             }
             return undefined;
         }

package/dist/core/memory.js

@@ -3,6 +3,7 @@ import { parseScopeKey } from "./memory-engine/scope-contract.js";
 import { termSet } from "./memory-vector.js";
 import { attrEscape } from "./task-notification.js";
 import { sanitizeUntrustedText, ENGINE_AUTHORITY_ENVELOPE_TAGS } from "./untrusted-text.js";
+import { thrownText } from "./thrown-value.js";
 export function supportsConsolidation(store) {
     return (typeof store.searchScored === "function" &&
         typeof store.update === "function" &&
@@ -27,7 +28,7 @@ export class MemoryProjectionError extends Error {
     committed = true;
     path;
     constructor(path, cause) {
-        const detail = cause instanceof Error ? cause.message : String(cause);
+        const detail = thrownText(cause);
         super(`memory.projection_failed: the note IS durably committed — only the derived projection ${path} could not be rewritten: ${detail}. ` +
             `Do not retry the write (it would store the note twice); the projection is rebuilt by the next mutation of this scope.`, cause !== undefined ? { cause } : undefined);
         this.name = "MemoryProjectionError";

package/dist/core/oracle-isolation.js

@@ -1,5 +1,6 @@
 import { isRemoteExecutionEnv, isIsolated } from "./remote-env.js";
 import { canonicalizeTarget, pathFamilyOf } from "../tools/fs/safety.js";
+import { thrownText } from "./thrown-value.js";
 function probeCommand(canonOraclePath) {
     const q = `'${canonOraclePath.replace(/'/g, `'\\''`)}'`;
     return `touch -- ${q}/.oracle-isolation-probe 2>/dev/null`;
@@ -19,7 +20,7 @@ export async function assertOracleIsolation(workerEnv, grader, opts) {
             workerId = workerEnv.workspaceHandle().sandboxId;
         }
         catch (e) {
-            return { protected: false, isolationClass, reason: `workspaceHandle() threw during identity check: ${String(e?.message ?? e)}` };
+            return { protected: false, isolationClass, reason: `workspaceHandle() threw during identity check: ${thrownText(e)}` };
         }
         if (graderId === workerId) {
             return { protected: false, isolationClass, reason: `grader and worker share sandboxId "${graderId}" (no isolation)` };
@@ -39,7 +40,7 @@ export async function assertOracleIsolation(workerEnv, grader, opts) {
             writable = res.ok && res.value.exitCode === 0;
         }
         catch (e) {
-            return { protected: false, isolationClass, reason: `isolation probe threw for "${oraclePath}": ${String(e?.message ?? e)}` };
+            return { protected: false, isolationClass, reason: `isolation probe threw for "${oraclePath}": ${thrownText(e)}` };
         }
         if (writable) {
             return { protected: false, isolationClass, reason: `oracle path "${oraclePath}" is WRITABLE from the worker env (probe wrote it)` };

package/dist/core/permission-rule-store.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { canonicalize } from "./canonical-json.js";
 import { escapeForDisclosure, isRuleBehavior, isRuleLive, parseRuleText } from "./permission-rule-model.js";
+import { thrownText } from "./thrown-value.js";
 export function sameRuleOwner(a, b) {
     return a.kind === "principal" ? b.kind === "principal" && a.principal === b.principal : b.kind === "local-owner";
 }
@@ -473,7 +474,7 @@ export async function removePersistedRule(opts) {
     }
 }
 export function errText(err) {
-    return err instanceof Error ? err.message : String(err);
+    return thrownText(err);
 }
 export const EMPTY_DURABLE_RULE_PARTITION = {
     list: async () => ({ rules: [], tombstones: [], rev: 0 }),

package/dist/core/runner/announce-once-ledger.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { redactSecrets } from "../untrusted-egress.js";
 import { inlineUntrusted } from "../untrusted-text.js";
+import { thrownText } from "../thrown-value.js";
 export const ANNOUNCE_ONCE_MAX_DIGESTS = 200;
 const DROPPED_TOOL_MODEL_LANE = "mcp_dropped_tools";
 export function announceDigest(lane, text) {
@@ -9,7 +10,7 @@ export function announceDigest(lane, text) {
 export function warningDigest(err) {
     const e = err;
     const code = typeof e?.code === "string" ? e.code : "";
-    const message = err instanceof Error ? err.message : String(err);
+    const message = thrownText(err);
     return announceDigest(code, redactSecrets(message));
 }
 export function droppedToolDigest(d) {

package/dist/core/runner/compaction-seams.js

@@ -1,4 +1,5 @@
 import { hookSeatExpiredError, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
+import { asThrownError } from "../thrown-value.js";
 export function seamCCompactionOptions(runner, prepared) {
     if (!runner.deps.summaryProvider)
         return undefined;
@@ -42,7 +43,7 @@ export function compactionHookOptions(runner, spec, sessionId, trigger, identity
                         return r;
                     }
                     catch (err) {
-                        report(err instanceof Error ? err : new Error(String(err)));
+                        report(asThrownError(err));
                         return undefined;
                     }
                 },
@@ -63,7 +64,7 @@ export function compactionHookOptions(runner, spec, sessionId, trigger, identity
                     }
                     catch (err) {
                         try {
-                            runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
+                            runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId });
                         }
                         catch {
                         }

package/dist/core/runner/gate-exit.d.ts

@@ -246,6 +246,11 @@ export interface GatePass {
      *  leaves the call's boundary UNKNOWN: the allow layer (a stored allow rule, the read-only reader) must
      *  not clear the surviving ask — a person confirms it. Writer: the fold. Reader: the lanes' mandate. */
     probeUnanswered?: true;
+    /** borrowed-mutable — the probe ANSWERED and reported that the read boundary DECLINED to judge where this
+     *  command reads ({@link import("../tool-spec.js").ReversibilityVerdict.boundaryDeclined}). The member above's
+     *  twin on the answered side, and narrower: the ask stays ordinary for every ANSWERER, and only the allow
+     *  layer's read-only-command arm stands down. Writer: the fold. Reader: that arm, and nothing else. */
+    probeBoundaryDeclined?: true;
     /** borrowed-mutable — the write-protection judge covered this call and its table MATCHED: the allow
      *  layer must not clear the surviving ask, a live decider still may. Writer: the fold's fourth tighten,
      *  on BOTH its arms. Reader: the lanes' mandate. */

package/dist/core/runner/git-leg-delivery.js

@@ -2,6 +2,7 @@ import { gitFrameContextVisible, normalizeGitAnnouncement } from "../../internal
 import { mintSystemReminder } from "../reminder-mint.js";
 import { sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
 import { branchCarriesVisiblePositiveGitFrame, newestEngineGitFrame } from "./git-status-frame.js";
+import { asThrownError } from "../thrown-value.js";
 export function wrapGitFrame(body, mark) {
     return mintSystemReminder(sanitizeUntrustedText(body, SHELLED_BODY_ENVELOPE_TAGS), mark);
 }
@@ -42,7 +43,7 @@ export async function resolveGitLegDelivery(prepared, cpMirror, report) {
     }
     catch (err) {
         pending = true;
-        report(err instanceof Error ? err : new Error(String(err)));
+        report(asThrownError(err));
     }
     if (prior !== undefined && !pending && prior.entryId !== undefined) {
         try {
@@ -52,7 +53,7 @@ export async function resolveGitLegDelivery(prepared, cpMirror, report) {
         }
         catch (err) {
             pending = true;
-            report(err instanceof Error ? err : new Error(String(err)));
+            report(asThrownError(err));
         }
     }
     if (prior !== undefined)
@@ -66,7 +67,7 @@ export async function resolveGitLegDelivery(prepared, cpMirror, report) {
             }
             catch (err) {
                 mustDisown = true;
-                report(err instanceof Error ? err : new Error(String(err)));
+                report(asThrownError(err));
             }
             return mustDisown ? frame.body : undefined;
         }

package/dist/core/runner/git-status-frame.js

@@ -4,6 +4,7 @@ import { inlineUntrusted } from "../untrusted-text.js";
 import { openSystemReminder } from "../reminder-mint.js";
 import { engineRegionCovers, protectGitFrame } from "../context-guard.js";
 import { gitFrameContextVisible } from "../../internal/harness.js";
+import { thrownText } from "../thrown-value.js";
 export const GIT_STATUS_FRAME_FORMAT_VERSION = 1;
 export const GIT_STATUS_FRAME_PREAMBLE = "This is the git status observed while preparing this request. When the visible snapshot changes it will be re-sent in a later message — the most recent git status frame supersedes earlier ones.";
 export const GIT_STATUS_UNAVAILABLE_BODY = "Git status is currently unavailable; the most recent git status frame above may be stale.";
@@ -104,7 +105,7 @@ export async function probeGitStatusLane(args) {
             }
         }
         catch (err) {
-            onDegrade(err instanceof Error ? err.message : String(err));
+            onDegrade(thrownText(err));
         }
     }
     else if (envFacts.isGitRepo === false) {

package/dist/core/runner/mcp-redial.js

@@ -1,4 +1,5 @@
 import { deliverEngineNotice } from "../types.js";
+import { thrownText } from "../thrown-value.js";
 export function applyMcpRosterDelta(input, delta) {
     const { toolFaceSnapshot, withFaces, remoteToolOffload, foldProtocolAxes, toolEffects, axisExplicitNegatives, roster } = input;
     const excludedSet = new Set(toolFaceSnapshot.exclude ?? []);
@@ -24,7 +25,7 @@ export function applyMcpRosterDelta(input, delta) {
     catch (foldErr) {
         restoreDomain(toolEffects, priorDomainEffects);
         restoreDomain(axisExplicitNegatives, priorDomainNegatives);
-        return { applied: false, foldError: foldErr instanceof Error ? foldErr.message : String(foldErr) };
+        return { applied: false, foldError: thrownText(foldErr) };
     }
     roster.replaceDomain(delta.prefix, withFaces(pushable, delta.server).map((t) => remoteToolOffload(t)), { source: "mcp", mountedBy: "optional", origin: { peer: delta.server } });
     return { applied: true, pushed: pushable.length, excluded };

package/dist/core/runner/memory-consolidation-driver.js

@@ -3,6 +3,7 @@ import { expandTiers, roleModelIfSet } from "../roles.js";
 import { isAliasModelId, openAiCompatChatSeat } from "../memory-engine/distiller.js";
 import { runMemoryConsolidationDriver } from "../memory-engine/consolidation-driver.js";
 import { recommendationUnconsumed } from "../memory-engine/consolidation.js";
+import { asThrownError } from "../thrown-value.js";
 function seatRefusal(message) {
     const e = new Error(message);
     e.code = "config.memory_consolidation_driver";
@@ -74,7 +75,7 @@ export function autoRunConsolidationFromRecommendation(args) {
         }
         catch (err) {
             try {
-                onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "memory", sessionId });
+                onError?.(asThrownError(err), { phase: "memory", sessionId });
             }
             catch {
             }

package/dist/core/runner/permission-rule-lanes.js

@@ -5,6 +5,7 @@ import { isAbsolutePathForm } from "../../tools/fs/safety.js";
 import { effectivePathTargetOf } from "../effective-path-target.js";
 import { declaredPathTargetOf, protectivePathTargetOf } from "../tool-registry.js";
 import { orgRuleVerdictFor } from "../permission-rule-org.js";
+import { thrownText } from "../thrown-value.js";
 export const PERSISTED_RULE_TOOL = "Bash";
 const HANDOFF_BOUND = 256;
 export function inheritedAskRuleEvidence(provider) {
@@ -97,7 +98,7 @@ export function createPermissionRuleLanes(cfg) {
                     resolution = (await hand(req.toolCallId)).org;
                 }
                 catch (err) {
-                    return { status: "unavailable", disclosures: [`the permission-rule store threw while resolving the org partition: ${err instanceof Error ? err.message : String(err)}`] };
+                    return { status: "unavailable", disclosures: [`the permission-rule store threw while resolving the org partition: ${thrownText(err)}`] };
                 }
                 if (resolution.status === "unavailable" || resolution.status === "ungoverned") {
                     return { status: "unavailable", disclosures: resolution.status === "ungoverned" ? ["the store reports no org partition while the provider declares one — unreadable governance, never an empty one"] : resolution.disclosures };
@@ -124,7 +125,7 @@ export function createPermissionRuleLanes(cfg) {
                     view = await claim(req.toolCallId);
                 }
                 catch (err) {
-                    cfg.onDisclosure(err instanceof Error ? err.message : String(err));
+                    cfg.onDisclosure(thrownText(err));
                     return { unreadable: true };
                 }
                 if (view.unreadable !== undefined) {

package/dist/core/runner/prepare-artifact.js

@@ -7,6 +7,7 @@ import { inlineUntrusted } from "../untrusted-text.js";
 import { physicalPathOfExisting } from "../physical-path.js";
 import { pathFamilyOf, resolveKey, violationDetails, violationText, withinAnyRoot } from "../../tools/fs/safety.js";
 import { createArtifactTool } from "../../tools/artifact/artifact-tool.js";
+import { thrownText } from "../thrown-value.js";
 export function prepareArtifact(input) {
     const { deps, runId, taskId, sessionId, agentName, onAsk, executionEnv, rootCanonical, additionalRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, roster, firstPartyOffload, envHandToolNames } = input;
     const host = deps.artifactHost;
@@ -35,7 +36,7 @@ export function prepareArtifact(input) {
         host.onMount?.(runId);
     }
     catch (err) {
-        return refuse(`artifactHost.onMount threw: ${err instanceof Error ? err.message : String(err)}`);
+        return refuse(`artifactHost.onMount threw: ${thrownText(err)}`);
     }
     const readLocalFile = async (path, maxBytes, signal) => {
         if (rootCanonical === undefined)

package/dist/core/runner/prepare-ask-lane.js

@@ -4,6 +4,7 @@ import { advertisedWritableRootsSeat, isLiveApproverSeat, resolveAsk } from "../
 import { composeCallSignal, raceAbort } from "./abort-race.js";
 import { gateAskCarry, lateAskSettlementObserver } from "./denial-limit-arms.js";
 import { consumeInheritedAskGrant } from "./inherited-ask-grants.js";
+import { asThrownError } from "../thrown-value.js";
 function createDenyObserverNotifier(hooks, hookTimeoutMs, signal, report) {
     if (hooks?.permissionDenied === undefined)
         return undefined;
@@ -124,7 +125,7 @@ export function prepareAskLane(input) {
     const notifyPermissionDenied = createDenyObserverNotifier(hooks, hookTimeoutMs, abortController.signal, notifyOwnHookCrash);
     const notifyHookError = (err) => {
         try {
-            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
+            deps.onError?.(asThrownError(err), { phase: "hook", sessionId });
         }
         catch {
         }

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -20,6 +20,7 @@ import { derivedRouteFallsBack } from "./derived-route-fallback.js";
 import { CLASSIFIER_ATTEMPT_SUFFIX, CLASSIFIER_THINK_SEAT, announceClassifierRoleDefaulted, classifierLadderRungs, classifierReplyAsksAgain, classifierReplyFailure, classifierReplyVerdictText, classifierRoundObserver, classifierRungSeat, classifierSeatModel } from "./classifier-ladder.js";
 import { REPORT_FINDINGS_TOOL_NAME, createReportBlockedTool, createReportFindingsTool } from "./synthetic-tools.js";
 import { RosterBuilder, callerMountSource } from "../tool-roster.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 function assembleParentCaptureState(o, i, ctl, ancestors) {
     const build = (optedOut, indeterminate) => ({
         optedOut: optedOut === true,
@@ -59,7 +60,7 @@ function screenAutoModeCap(caps, onError, sessionId) {
         record = snapshotRuntimeCaps(caps);
     }
     catch (err) {
-        onError?.(new Error(`runtimeCapsResolver's record threw while being read (${err instanceof Error ? err.message : String(err)}) — read as a resolver fault: every per-principal capability is DENIED for this run (auto mode is not armed; asks flow the original chain).`), { phase: "config", sessionId });
+        onError?.(new Error(`runtimeCapsResolver's record threw while being read (${thrownText(err)}) — read as a resolver fault: every per-principal capability is DENIED for this run (auto mode is not armed; asks flow the original chain).`), { phase: "config", sessionId });
         return { caps: { allowWorkflows: false, allowFork: false, autoMode: false }, faulted: true };
     }
     const { autoMode, autoModeDenySource } = record;
@@ -148,7 +149,7 @@ export async function prepareCapsAndWorkflow(input) {
             runtimeCaps = (await deps.runtimeCapsResolver(spec.principal)) ?? undefined;
         }
         catch (err) {
-            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            deps.onError?.(asThrownError(err), { phase: "config", sessionId });
             runtimeCaps = { allowWorkflows: false, allowFork: false, autoMode: false };
             runtimeCapsFaulted = true;
         }
@@ -165,7 +166,7 @@ export async function prepareCapsAndWorkflow(input) {
                 complianceDenies = resolveComplianceDenies(posture);
         }
         catch (err) {
-            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            deps.onError?.(asThrownError(err), { phase: "config", sessionId });
             complianceDenies = new Set(COMPLIANCE_CAPABILITIES);
             complianceDegraded = true;
         }

package/dist/core/runner/prepare-inherited-gate.js

@@ -5,6 +5,7 @@ import { createPreToolUseConstraintPolicy } from "../hooks.js";
 import { StubExecutionEnv } from "../stub-env.js";
 import { askApproverIdentity, durableMandateSourceOf } from "../tool-policy.js";
 import { attachRebuiltDenialTrackers, createDenialLimitStop } from "./denial-limit-arms.js";
+import { asThrownError } from "../thrown-value.js";
 export function prepareInheritedGate(input) {
     const { spec, deps, internals, resume, sessions, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, ownedEnv, lockedPreflight, toolFaceSnapshot, promptProfile, resolvedInteractionPosture, autoModeSeat, handsEnabled, reportUsage, harnessRef, skillScope, forwardEvent, subagentRetain, worktreeIsolation, requestReview, requestStopAfterTurn, enterPlanMode, reminderMark, reminderDisclosureCounts, fileHistoryEnabled, historyScope, historyRoot, historyFs, abortRun } = input;
     const liveInheritedGate = internals?.inheritedGate;
@@ -94,7 +95,7 @@ export function prepareInheritedGate(input) {
     const hookEnvSource = (ownedEnv ?? deps.executionEnv) != null ? executionEnv : undefined;
     const notifyOwnHookCrash = (err) => {
         try {
-            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
+            deps.onError?.(asThrownError(err), { phase: "hook", sessionId });
         }
         catch {
         }

package/dist/core/runner/prepare-memory-engine-session.js

@@ -6,6 +6,7 @@ import { deliverEngineNotice } from "../types.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { fileArgPath } from "../../tools/fs/safety.js";
 import { RosterBuilder } from "../tool-roster.js";
+import { thrownText } from "../thrown-value.js";
 export function prepareMemoryEngineSession(input) {
     const { memoryEngineSession, internals, memoryDelegationEvidence, externalContentTargetActive, lockedPreflight, mcp, sessionId, runId, deps, provenanceForChildrenRef, delegationSettlementRef, spec, envHandToolNames, roster, contentOriginWrapRef } = input;
     const tools = roster.tools;
@@ -167,7 +168,7 @@ export function prepareMemoryEngineSession(input) {
                                             recordSyncUnattestable(settlementSeat.controlDir, { sessionId: settlementSeat.sessionId, toolCallId, now: Date.now });
                                         }
                                         catch (err) {
-                                            const e = new Error(`delegated output withheld (fail-closed): the delegation delivered without a provable attestation and the settlement account could not record the fact (${err instanceof Error ? err.message : String(err)}) — repair the memory control plane or retry`);
+                                            const e = new Error(`delegated output withheld (fail-closed): the delegation delivered without a provable attestation and the settlement account could not record the fact (${thrownText(err)}) — repair the memory control plane or retry`);
                                             e.code = "memory.settlement_record_failed";
                                             throw e;
                                         }

package/dist/core/runner/prepare-memory.js

@@ -11,6 +11,7 @@ import { createMemoryEngineTools } from "../memory-engine/tools.js";
 import { assertScopeContractPlacement, parseScopeKey, resolveProjectId } from "../memory-engine/scope-contract.js";
 import { FileMemoryEngineBackend } from "../memory-engine/file-backend.js";
 import { writableRootOf } from "../memory-engine/types.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 let undeclaredCapturePostureAnnounced = false;
 export async function prepareMemory(input) {
     const { spec, deps, sessionId, taskRootPath, admissionCtx } = input;
@@ -108,7 +109,7 @@ export async function prepareMemory(input) {
                 catch (err) {
                     if (consumesProjectIdentity)
                         throw err;
-                    deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+                    deps.onError?.(asThrownError(err), { phase: "config", sessionId });
                 }
                 if (marker) {
                     identityKey = marker.projectId;
@@ -403,7 +404,7 @@ export async function prepareMemory(input) {
                         readReport = await readOther[0].harvest(readOther[1]);
                     }
                     catch (err) {
-                        readFailure = err instanceof Error ? err.message : String(err);
+                        readFailure = thrownText(err);
                     }
                     const merged = readReport !== undefined ? mergeHarvestReports(writeReport, readReport) : writeReport;
                     if (readFailure !== undefined)
@@ -548,7 +549,7 @@ export async function prepareMemory(input) {
                 }
                 catch (err) {
                     try {
-                        deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "memory", sessionId });
+                        deps.onError?.(asThrownError(err), { phase: "memory", sessionId });
                     }
                     catch {
                     }
@@ -700,7 +701,7 @@ export async function prepareMemory(input) {
                     err.code.startsWith("config.memory_capture"))) {
                 throw err;
             }
-            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "memory", sessionId });
+            deps.onError?.(asThrownError(err), { phase: "memory", sessionId });
             if (effectiveMemoryScopes === undefined) {
                 effectiveMemoryScopes = {
                     state: "memoryless",

package/dist/core/runner/prepare-policy-chain.js

@@ -15,6 +15,7 @@ import { headlessDenyAtFold, headlessDenyAtRecheck, inheritedAskCarry, judgeInhe
 import { askGrantShapeOf } from "./inherited-ask-grants.js";
 import { createPermissionRuleLanes, inheritedAskRuleEvidence, createRuleOffersOf } from "./permission-rule-lanes.js";
 import { createSessionRulePolicy } from "./session-rule-policy.js";
+import { thrownText } from "../thrown-value.js";
 export async function preparePolicyChain(input) {
     const { spec, deps, internals, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, lockedPreflight, tools, harnessTools, toolEffects, egressTools, irreversibilityTier, axisExplicitNegatives, shellGatedTools, envHandToolNames, handsCwdRef, readDenyMatcher, questionToolMounted, runtimeCaps, inheritedAncestorRules, inheritedParentConstraints, seedInheritedGate, hasSkillManifest, skillScope, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, autoModeDecider, stopForDenialLimit, delegation, abortController, now, ownSessionRulesRef } = input;
     const policy = lockedPreflight.toolPolicy;
@@ -300,7 +301,7 @@ export async function preparePolicyChain(input) {
             catch (err) {
                 return vetoed({
                     action: "deny",
-                    message: `inherited parent policy re-check of the approved edit errored for "${creq.toolName}": ${err instanceof Error ? err.message : String(err)}`,
+                    message: `inherited parent policy re-check of the approved edit errored for "${creq.toolName}": ${thrownText(err)}`,
                 });
             }
             if (re.action === "deny")
@@ -437,7 +438,7 @@ export async function preparePolicyChain(input) {
                     catch (err) {
                         return {
                             action: "deny",
-                            message: `inherited parent policy errored for "${creq.toolName}": ${err instanceof Error ? err.message : String(err)}`,
+                            message: `inherited parent policy errored for "${creq.toolName}": ${thrownText(err)}`,
                         };
                     }
                     if (decision.action !== "ask")

package/dist/core/runner/prepare-project-context.js

@@ -8,6 +8,7 @@ import { defineTool } from "../tools.js";
 import { SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, createSkillTool, normalizeSkills } from "./synthetic-tools.js";
 import { substitutedSkillLength } from "./skill-base-dir.js";
 import { RosterBuilder } from "../tool-roster.js";
+import { asThrownError } from "../thrown-value.js";
 export async function prepareProjectContext(input) {
     const { deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume, skillListingBudget } = input;
     const tools = roster.tools;
@@ -49,7 +50,7 @@ export async function prepareProjectContext(input) {
             }));
         }
         catch (err) {
-            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            deps.onError?.(asThrownError(err), { phase: "config", sessionId });
         }
         const projectMem = loaded !== null && typeof loaded === "object" ? loaded.content : loaded;
         const seededFiles = loaded !== null && typeof loaded === "object" ? loaded.seededFiles : undefined;
@@ -61,7 +62,7 @@ export async function prepareProjectContext(input) {
                 await seedContextFiles(seededFiles);
             }
             catch (err) {
-                deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+                deps.onError?.(asThrownError(err), { phase: "config", sessionId });
             }
         }
         if (projectMem != null && projectMem.trim()) {

package/dist/core/runner/prepare-protocol-tools.js

@@ -9,6 +9,7 @@ import { REFRESH_MCP_TOOLS_TOOL_NAME, toolFace } from "../tool-catalog-entries.j
 import { MCP_NAMESPACE, A2A_NAMESPACE } from "../protocol-table.js";
 import { mintNamespacePrefix } from "../protocol-naming.js";
 import { applyMcpToolFaces } from "./tool-face-overlay.js";
+import { thrownText } from "../thrown-value.js";
 export async function prepareProtocolTools(input) {
     const { lockedPreflight, spec, deps, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, abortController, rollback } = input;
     const overPeer = (lockedPreflight.mcp ?? []).find((s) => s.name.length > TOOL_WIRE_NAME_MAX_CHARS);
@@ -176,8 +177,8 @@ function mcpRevocationWiring(deps, runId) {
         isRevoked: (name) => ledger.isRevoked(name),
         onProbeFailure: (e) => deliverEngineNotice(deps.onNotice, {
             code: "mcp.revocation_probe_failed",
-            message: `the mcpRevocations.isRevoked probe threw — MCP dispatch fails OPEN (no server treated as revoked) until the probe recovers: ${e instanceof Error ? e.message : String(e)}`,
-            detail: { message: e instanceof Error ? e.message : String(e), runId },
+            message: `the mcpRevocations.isRevoked probe threw — MCP dispatch fails OPEN (no server treated as revoked) until the probe recovers: ${thrownText(e)}`,
+            detail: { message: thrownText(e), runId },
         }),
     };
 }

package/dist/core/runner/prepare-suspend-saga.js

@@ -5,6 +5,7 @@ import { raceSettlementAgainstSignal } from "./abort-race.js";
 import { placementValueOrAbsent } from "./checkpoint-scope.js";
 import { serializeAnnouncedListings } from "./announce-once-ledger.js";
 import { remoteEnvFailureNote, restoreWorkspaceWithRetry } from "./remote-env-retry.js";
+import { thrownText } from "../thrown-value.js";
 const PARK_COMPENSATION_TIMEOUT_MS = 30_000;
 export async function compensateUnparkedPause(remoteEnv, snapshotId, io) {
     const boundCtl = new AbortController();
@@ -40,7 +41,7 @@ export async function compensateUnparkedPause(remoteEnv, snapshotId, io) {
     if (raced.tag === "threw") {
         io.noteFailure(remoteEnvFailureNote(phase, raced.error instanceof RemoteExecutionError
             ? raced.error
-            : new RemoteExecutionError("unknown", `the pause compensation's ${phase} call threw: ${raced.error instanceof Error ? raced.error.message : String(raced.error)}`), phase === "resumeVM" ? restoreAttempts : 1));
+            : new RemoteExecutionError("unknown", `the pause compensation's ${phase} call threw: ${thrownText(raced.error)}`), phase === "resumeVM" ? restoreAttempts : 1));
         io.disclose(raced.error);
         return {
             ok: false,

package/dist/core/runner/prepare-task.js

@@ -80,6 +80,7 @@ import { catalogEntriesNamed, pathTargetOf } from "../tool-registry.js";
 import { AdvertisedWritableDirs } from "./advertised-writable-dirs.js";
 import { resolveTaskRootCanonical } from "./task-root-canonical.js";
 import { createStructuredProjector } from "./tool-output-projection.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 function warnCompactionWindowHazard(tracer, spec, model, compModel, hostTaskId) {
     if (compModel === undefined)
         return;
@@ -209,7 +210,7 @@ async function adoptReminderMark(session, sessionId, seedMark, spawnMark, onErro
             return await session.getReminderMark();
         }
         catch (err) {
-            onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            onError?.(asThrownError(err), { phase: "config", sessionId });
             return undefined;
         }
     })();
@@ -225,7 +226,7 @@ async function adoptReminderMark(session, sessionId, seedMark, spawnMark, onErro
             await session.appendReminderMark(reminderMark);
         }
         catch (err) {
-            onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            onError?.(asThrownError(err), { phase: "config", sessionId });
         }
     }
     return { reminderMark, reminderDisclosureCounts: {} };
@@ -246,7 +247,7 @@ function refuseRequireExistingWithoutSession(spec) {
     }
 }
 function validateInputFaultNotice(onError, sessionId) {
-    return ({ toolName, toolCallId, error }) => onError?.(new Error(`tool input pre-validation (validateInput) threw for ${toolName} (call ${toolCallId}) — read as no verdict; the call proceeded to the gate: ${error instanceof Error ? error.message : String(error)}`), { phase: "hook", sessionId });
+    return ({ toolName, toolCallId, error }) => onError?.(new Error(`tool input pre-validation (validateInput) threw for ${toolName} (call ${toolCallId}) — read as no verdict; the call proceeded to the gate: ${thrownText(error)}`), { phase: "hook", sessionId });
 }
 function refuseInvalidAutoModeSeat(spec) {
     if (spec.autoModeRequested !== undefined && spec.autoModeRequested !== true) {
@@ -350,7 +351,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         return physicalPathOf(resolveFsPath(p));
                     }
                     catch (err) {
-                        return failIsolation(`cannot canonicalize ${what} (${err instanceof Error ? err.message : String(err)}) — an unverifiable path is treated as not isolated`);
+                        return failIsolation(`cannot canonicalize ${what} (${thrownText(err)}) — an unverifiable path is treated as not isolated`);
                     }
                 };
                 if (deps.rootPath !== undefined || internals.parentCwd !== undefined) {
@@ -573,7 +574,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 await seedContextFiles(memorySeedFiles);
             }
             catch (err) {
-                deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+                deps.onError?.(asThrownError(err), { phase: "config", sessionId });
             }
         }
         const projectContext = await prepareProjectContext({ deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume, skillListingBudget: doors.skillListingBudget });

package/dist/core/runner/prepare-turn-wiring.js

@@ -10,6 +10,7 @@ import { applyContextShrinkToReadFileState, isReadDedupStubResult } from "../../
 import { resolveKey } from "../../tools/fs/safety.js";
 import { PROMPT_HASH_SALT } from "./prompt-hash-salt.js";
 import { CHANGED_FILES_MTIME_EPS_MS } from "./turn-attachments.js";
+import { thrownText } from "../thrown-value.js";
 export function prepareTurnWiring(input) {
     const { deps, systemPromptSeat, harnessTools, fpRef, model, epochArtifactDigestForSnapshot, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, additionalRootsCanonical, additionalReadRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, abortController, hostTaskId, taskScope, buildAssembleInputs, centerAdoptionRef, harnessRef, epochDeclaredSections, carrierReadFace, carrierWriteFace, readDenyAdditionsNormalized, preparedHolder } = input;
     const cacheBreakDetector = deps.cacheBreakDetection === false ? undefined : new CacheBreakDetector();
@@ -72,7 +73,7 @@ export function prepareTurnWiring(input) {
                 return d.text;
             }
             catch (err) {
-                announceAttachmentSkip(path, err instanceof Error ? err.message : String(err));
+                announceAttachmentSkip(path, thrownText(err));
                 return null;
             }
         }

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

@@ -9,6 +9,7 @@ import { callFaceSeat, parkedCallFaceOf } from "../tool-roster.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { deepJsonEqual, describeSuppliedValue } from "./decide-continuation.js";
 import { mintGateOutcome } from "./gate-exit.js";
+import { asThrownError, thrownText } from "../thrown-value.js";
 export async function resumeApply(input) {
     const { cp, config, internals, outcomeGate, wakeMessage, resumeSignal, recheckGovernanceWindow, plainReviewOutcome, plainParkOutcome, runner, effectiveDelegationFacts } = input;
     let plainPolicyOutcome = input.plainPolicyOutcome;
@@ -29,7 +30,7 @@ export async function resumeApply(input) {
             });
             const screenTimeoutMs = resolveHookTimeoutMs(resumeScreenHooks?.timeoutMs, (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 {
                 }
@@ -53,7 +54,7 @@ export async function resumeApply(input) {
             catch (hookErr) {
                 if (hookErr instanceof CheckpointError)
                     throw hookErr;
-                const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                const err = asThrownError(hookErr);
                 try {
                     runner.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
                 }
@@ -138,7 +139,7 @@ export async function resumeApply(input) {
             catch (err) {
                 if (err instanceof CheckpointError)
                     throw err;
-                rechecked = { action: "deny", message: `the resume-edit policy re-check errored: ${err instanceof Error ? err.message : String(err)}` };
+                rechecked = { action: "deny", message: `the resume-edit policy re-check errored: ${thrownText(err)}` };
             }
             if (rechecked.action === "deny") {
                 throw new CheckpointError("resume.constraint_rejected", `the approver EDITED this call's input and the deployment's resume-edit policy denies the edited args${rechecked.message ? `: ${rechecked.message}` : ""}. ` +
@@ -160,7 +161,7 @@ export async function resumeApply(input) {
             catch (err) {
                 if (err instanceof CheckpointError)
                     throw err;
-                throw new CheckpointError("resume.constraint_rejected", `the declared-observational PreToolUse face threw while observing the approver's edited args (${err instanceof Error ? err.message : String(err)}) — ` +
+                throw new CheckpointError("resume.constraint_rejected", `the declared-observational PreToolUse face threw while observing the approver's edited args (${thrownText(err)}) — ` +
                     "refused fail-closed pre-CAS (the checkpoint stays pending and remains decidable)");
             }
         }