@sema-agent/core 7.23.0 → 7.23.2

package/dist/core/tool-errors.d.ts

@@ -33,12 +33,6 @@ export declare function truncateError(s: string): string;
  *  budget of one character. */
 export declare const OUTPUT_BUDGET_MIN_CHARS = 512;
 export declare function clipWithFilePointer(s: string, limit: number, fullOutputPath?: string): string;
-/**
- * Format a thrown tool error into model-facing text (design/64 §11.1/§11.2): a shell/exec error becomes
- * `Exit code N` + stderr + stdout; a plain Error becomes its message (+ any captured streams); anything
- * else is stringified. The result is truncated to {@link MAX_ERROR_CHARS}. An AbortError is reported as an
- * interruption.
- */
 export declare function formatToolError(error: unknown): string;
 /**
  * A typed, read-side fold of a `TaskResult.errorCode` into the failure CLASS it belongs to (design/80

package/dist/core/tool-errors.js

@@ -2,6 +2,7 @@ import { Value } from "typebox/value";
 const MAX_ERROR_CHARS = 10_000;
 const HALF = MAX_ERROR_CHARS / 2;
 import { isHighSurrogate, isLowSurrogate, sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
+import { readMember, thrownText } from "./thrown-value.js";
 export function truncateError(s) {
     if (s.length <= MAX_ERROR_CHARS)
         return s;
@@ -31,28 +32,49 @@ export function clipWithFilePointer(s, limit, fullOutputPath) {
     return `${s.slice(0, headEnd)}${markerFor(kept)}${s.slice(tailStart)}`;
 }
 function isShellLike(e) {
-    return typeof e === "object" && e !== null && ("exitCode" in e || "stderr" in e || "stdout" in e);
+    try {
+        return typeof e === "object" && e !== null && ("exitCode" in e || "stderr" in e || "stdout" in e);
+    }
+    catch {
+        return false;
+    }
+}
+function isErrorInstance(v) {
+    try {
+        return v instanceof Error;
+    }
+    catch {
+        return false;
+    }
 }
 export function formatToolError(error) {
-    if (error instanceof Error && error.name === "AbortError")
-        return "Interrupted";
     const parts = [];
+    const name = readMember(error, "name");
+    if (isErrorInstance(error) && name === "AbortError")
+        return "Interrupted";
+    const message = readMember(error, "message");
+    const messageText = typeof message === "string" ? message : undefined;
     if (isShellLike(error)) {
-        if (typeof error.exitCode === "number")
-            parts.push(`Exit code ${error.exitCode}`);
-        if (error instanceof Error && error.message)
-            parts.push(error.message);
-        if (error.stderr && error.stderr.trim())
-            parts.push(error.stderr);
-        if (error.stdout && error.stdout.trim())
-            parts.push(error.stdout);
+        const exitCode = readMember(error, "exitCode");
+        const stderr = readMember(error, "stderr");
+        const stdout = readMember(error, "stdout");
+        if (typeof exitCode === "number")
+            parts.push(`Exit code ${exitCode}`);
+        if (isErrorInstance(error) && messageText !== undefined && messageText !== "")
+            parts.push(messageText);
+        if (typeof stderr === "string" && stderr.trim())
+            parts.push(stderr);
+        if (typeof stdout === "string" && stdout.trim())
+            parts.push(stdout);
     }
-    else if (error instanceof Error) {
-        parts.push(error.message || error.name || "Error");
+    else if (isErrorInstance(error)) {
+        parts.push((messageText ?? "") || (typeof name === "string" ? name : "") || "Error");
     }
     else {
-        parts.push(String(error));
+        parts.push(thrownText(error));
     }
+    if (parts.length === 0)
+        parts.push(thrownText(error));
     return truncateError(parts.join("\n").trim() || "Error");
 }
 const BRAIN_FLAT_CODES = new Set([

package/dist/core/tool-model-gate.js

@@ -1,3 +1,4 @@
+import { thrownText } from "./thrown-value.js";
 export function modelIdTail(id) {
     return id.toLowerCase().split("/").pop() ?? "";
 }
@@ -217,7 +218,7 @@ export function applyToolModelGate(input) {
             throw e;
         let msg;
         try {
-            msg = e instanceof Error ? e.message : String(e);
+            msg = thrownText(e);
         }
         catch {
             msg = "[unreportable throw]";

package/dist/core/tool-policy.js

@@ -8,6 +8,8 @@ import { BASH_READONLY_DEFAULT_ALLOW, parseLeadingCommandName } from "../tools/f
 import { protectivePathTargetOf } from "./tool-registry.js";
 import { boundInputHashOf } from "./canonical-json.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY } from "./untrusted-text.js";
+import { describeRejectedValue } from "./tool-search-setting.js";
+import { thrownText } from "./thrown-value.js";
 import { isNamespacedCoveringRuleName, namespacedRuleNameCovers, parsePermissionRule } from "./permission-rules.js";
 import { protocolOf } from "./protocol-table.js";
 import { isAbsoluteForFamily, isAbsolutePathForm, joinForFamily, normalizeAbsPathLexically, pathFamilyOf, writeTargetPath } from "../tools/fs/safety.js";
@@ -944,19 +946,10 @@ export function tryCloneArgs(v) {
     }
 }
 export function describeThrown(err) {
-    try {
-        if (typeof err === "string")
-            return containThrownText(err);
-        if (err instanceof Error) {
-            const message = err.message;
-            if (typeof message === "string" && message !== "")
-                return containThrownText(message);
-        }
-        return `a non-Error value was thrown (${err === null ? "null" : typeof err})`;
-    }
-    catch {
-        return "the value could not be described";
-    }
+    const contained = containThrownText(thrownText(err));
+    if (contained !== "")
+        return contained;
+    return containThrownText(describeRejectedValue(err));
 }
 const THROWN_TEXT_MAX = 300;
 function containThrownText(text) {

package/dist/core/tool-result-store.js

@@ -5,6 +5,7 @@ import { defineTool, errorResult } from "./tools.js";
 import { deliverEngineNotice } from "./types.js";
 import { TOOL_SEARCH_NAME } from "./runner/tool-disclosure.js";
 import { toolFace } from "./tool-catalog-entries.js";
+import { thrownText } from "./thrown-value.js";
 export const TOOL_RESULT_REF_CONFLICT_CODE = "tool_result.ref_conflict";
 export class ToolResultRefConflictError extends Error {
     ref;
@@ -176,7 +177,7 @@ export function createOffloadPersist(store, sessionId, onNotice) {
     return (toolCallId, fullText) => {
         const ref = buildToolResultRef(sessionId, toolCallId, toolResultContentSegment(fullText));
         const reportFailedWrite = (err) => {
-            const cause = err instanceof Error ? err.message : String(err);
+            const cause = thrownText(err);
             const message = `tool-result offload: persisting ref "${ref}" failed (${cause}) — this write attempt stored nothing; ` +
                 `unless an earlier attempt already stored this ref, the inline preview is all that survived. ` +
                 `A later re-clear of the same result retries the write.`;

package/dist/core/tool-spec.d.ts

@@ -69,6 +69,18 @@ export interface ReversibilityVerdict {
      * arm with no named directory) is confirm-or-refuse, and must not be worded as though a grant answers it.
      */
     mandated?: boolean;
+    /**
+     * The WEAKER rung of the same ladder as {@link mandated}: a read boundary the deployment declared was
+     * consulted and DECLINED TO JUDGE where this command reads — it named no path, so it neither declared an
+     * objection nor vouched anything. The resulting ask is ORDINARY on purpose: every ANSWERER may settle it (a
+     * person, the auto-mode classifier, a person's stored allow rule). What it excludes is the other kind of
+     * clearing — an engine table that answers nothing and merely recognises a command SHAPE
+     * (`readOnlyShellVerdict`, whose tables read program names and never paths). A mandate would take the
+     * answerers out too, a trade this class was deliberately not given. TIGHTENING-ONLY like {@link mandated}:
+     * one more question surviving one more configuration, never an ask becoming an allow, read on the demotion
+     * arm alone. Read PRESENCE, never absence.
+     */
+    boundaryDeclined?: boolean;
     /**
      * The directory-scoped GRANT that would clear THIS ask, when the probe can name one: PRESENT ⇒ the only
      * thing between this call and a plain `reversible: true` verdict is the session's declared read

package/dist/core/write-protect.js

@@ -3,6 +3,7 @@ import { protectivePathTargetOf } from "./tool-registry.js";
 import { pathTargetBaseOf } from "./effective-path-target.js";
 import { canonicalDataRootKeys, dataRootSpellings, relativeUnderRoot } from "./sensitive-path-policy.js";
 import { symlinkChainHops } from "./path-identity.js";
+import { thrownText } from "./thrown-value.js";
 const freezeTable = (rows) => Object.freeze(rows.map((r) => Object.freeze(r)));
 export const WRITE_PROTECTED_DEFAULT_TABLE = freezeTable([
     { name: ".gitconfig", kind: "basename" },
@@ -66,8 +67,7 @@ function stripInvisibleFormat(s) {
 }
 function stripWin32Component(raw, normalization) {
     const base = normalization.invisibleFirst ? stripInvisibleFormat(raw) : raw;
-    const colon = normalization.stream ? base.indexOf(":") : -1;
-    return (colon < 0 ? base : base.slice(0, colon)).replace(/[. ]+$/, "");
+    return (normalization.stream ? base.replace(/:.*$/, "") : base).replace(/[. ]+$/, "");
 }
 function foldWriteProtectName(name) {
     return name.split("/").map(foldWriteProtectSegment).join("/");
@@ -277,7 +277,7 @@ export function compileWriteProtection(entries, opts) {
                     noteAbsence(canon.message, canon.unresolvedSymlink === true);
             }
             catch (err) {
-                noteAbsence(err instanceof Error ? err.message : String(err), false);
+                noteAbsence(thrownText(err), false);
             }
             try {
                 if (canonKey !== undefined) {
@@ -309,7 +309,7 @@ export function compileWriteProtection(entries, opts) {
                 }
             }
             catch (err) {
-                noteAbsence(err instanceof Error ? err.message : String(err), false);
+                noteAbsence(thrownText(err), false);
             }
             return { kind: "clear" };
         },

package/dist/engine/compaction/compaction.js

@@ -5,6 +5,7 @@ import { CompactionError, err, isSyntheticApiErrorMessage, ok, } from "../harnes
 import { budgetInvokedSkillsRetention, computeFileLists, createFileOps, extractFileOpsFromMessage, extractInvokedSkills, extractPersistedOutputRefs, formatFileOperations, formatPersistedOutputRefs, PERSISTED_OUTPUT_REFS_MAX_ENTRIES, readElidedMessages, readPersistedOutputRefs, readRetainedInvokedSkills, readUnsummarizedMessages, replaceInvokedSkillBodiesForSummary, serializeConversation, stripFileOperationsFooter, } from "./utils.js";
 import { ENGINE_AUTHORITY_ENVELOPE_TAGS, sanitizeUntrustedText } from "../../core/untrusted-text.js";
 import { sliceHeadSafe } from "../../core/surrogate-safe-slice.js";
+import { thrownText } from "../../core/thrown-value.js";
 function safeJsonStringify(value) {
     try {
         return JSON.stringify(value) ?? "undefined";
@@ -803,9 +804,7 @@ async function summarizeWithPtlRetry(req) {
             return ok(unwrapped);
         }
         const failureMessage = didThrow
-            ? thrown instanceof Error
-                ? thrown.message
-                : String(thrown)
+            ? thrownText(thrown)
             : result && !result.ok
                 ? result.error.message
                 : "";
@@ -913,7 +912,7 @@ async function forkSummarize(fork, model, baseMaxTokens, apiKey, headers, custom
         result = await summarizeWithLengthRecovery("Summarization", model, context, baseMaxTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken);
     }
     catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
+        const msg = thrownText(e);
         if (parsePromptTooLong(msg).isPtl)
             return { kind: "fallback", detail: msg };
         throw e;

package/dist/engine/harness/agent-harness.js

@@ -4,6 +4,7 @@ import { resolveAgentCoreStreamFn } from "../loop/runtime-deps.js";
 import { normalizeEngineSegments } from "../../core/untrusted-text.js";
 import { AUTH_CARRIER_NAMES } from "../../brain/request-params.js";
 import { convertToLlm } from "./messages.js";
+import { thrownText } from "../../core/thrown-value.js";
 import { AgentHarnessError, CompactionError, SessionError, SYNTHETIC_MESSAGE_MODEL, toError, } from "./types.js";
 const API_FAILURE_RECORD_MAX_CHARS = 2000;
 function createUserMessage(text, images, provenance) {
@@ -57,7 +58,7 @@ function createFailureMessage(model, error, aborted) {
         provider: model.provider,
         model: model.id,
         stopReason: aborted ? "aborted" : "error",
-        errorMessage: error instanceof Error ? error.message : String(error),
+        errorMessage: thrownText(error),
         timestamp: Date.now(),
         usage: {
             input: 0,

package/dist/engine/harness/types.js

@@ -1,3 +1,4 @@
+import { asThrownError } from "../../core/thrown-value.js";
 export function ok(value) {
     return { ok: true, value };
 }
@@ -5,18 +6,18 @@ export function err(error) {
     return { ok: false, error };
 }
 export function toError(error) {
-    if (error instanceof Error) {
-        return error;
-    }
-    if (typeof error === "string") {
-        return new Error(error);
-    }
     try {
+        if (error instanceof Error) {
+            return error;
+        }
+        if (typeof error === "string") {
+            return new Error(error);
+        }
         return new Error(JSON.stringify(error));
     }
     catch {
-        return new Error(String(error));
     }
+    return asThrownError(error);
 }
 export class FileError extends Error {
     code;

package/dist/engine/loop/agent-loop.js

@@ -2,6 +2,7 @@ import { findToolByName, validateToolArguments } from "../llm/index.js";
 import { truncateError } from "../../core/tool-errors.js";
 import { INTERRUPTED_BY_USER_FOR_TOOL_USE_MARKER, INTERRUPTED_BY_USER_MARKER, } from "../../core/session-reconcile.js";
 import { resolveAgentCoreStreamFn } from "./runtime-deps.js";
+import { thrownText } from "../../core/thrown-value.js";
 function appendTextDeltaToAssistantMessage(message, contentIndex, delta) {
     const content = [...message.content];
     const currentContent = content[contentIndex];
@@ -1107,7 +1108,7 @@ class StreamToolExecutor {
                 this.retainCancellation(error);
             entry.immediate = {
                 kind: "immediate",
-                result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
+                result: createErrorToolResult(thrownText(error), error),
                 isError: true,
             };
         }
@@ -1359,7 +1360,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
     catch (error) {
         return {
             kind: "immediate",
-            result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
+            result: createErrorToolResult(thrownText(error), error),
             isError: true,
         };
     }
@@ -1400,7 +1401,7 @@ async function executePreparedToolCall(prepared, signal, emit, abortResultDetail
         }
         catch (error) {
             outcome = {
-                result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
+                result: createErrorToolResult(thrownText(error), error),
                 isError: true,
             };
         }
@@ -1410,7 +1411,7 @@ async function executePreparedToolCall(prepared, signal, emit, abortResultDetail
             return outcome;
         const reason = deliveryFailure.reason;
         const details = annotateDeliveryFailure(outcome.result, {
-            message: reason instanceof Error ? reason.message : String(reason),
+            message: thrownText(reason),
         });
         return details === UNANNOTATED ? outcome : { result: { ...outcome.result, details }, isError: outcome.isError };
     })();
@@ -1482,7 +1483,7 @@ async function executePreparedWithDisclosure(currentContext, assistantMessage, p
         if (isAbortSemanticsError(error))
             throw error;
         executed = {
-            result: createErrorToolResult(`[tool execution harness failed: ${error instanceof Error ? error.message : String(error)}]`, error),
+            result: createErrorToolResult(`[tool execution harness failed: ${thrownText(error)}]`, error),
             isError: true,
         };
     }
@@ -1512,7 +1513,7 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
             }
         }
         catch (error) {
-            const note = truncateError(`[post-tool processing failed (the tool already executed): ${error instanceof Error ? error.message : String(error)}]`);
+            const note = truncateError(`[post-tool processing failed (the tool already executed): ${thrownText(error)}]`);
             result = { ...result, content: [...result.content, { type: "text", text: note }] };
         }
         if (deliveryMark !== undefined && readDeliveryFailureMark(result.details) === undefined) {

package/dist/engine/lsp/node-lsp-manager.js

@@ -8,6 +8,7 @@ import { LspDiagnosticsRegistry } from "../../core/lsp-diagnostics.js";
 import { TransportLspSession } from "../../core/lsp-session.js";
 import { StdioLspTransport } from "./stdio-lsp-transport.js";
 import { MAX_LSP_FILE_BYTES, SharedAbortScope, settleOnAbort } from "../../core/lsp.js";
+import { asThrownError, thrownText } from "../../core/thrown-value.js";
 export const DEFAULT_LSP_SERVERS = {
     typescript: "typescript-language-server --stdio",
     javascript: "typescript-language-server --stdio",
@@ -231,7 +232,7 @@ export class NodeLspManager {
             child = await this.spawnFn(command, args, root, signal);
         }
         catch (e) {
-            this.log("lsp_spawn_error", { language, root, command, err: e instanceof Error ? e.message : String(e) });
+            this.log("lsp_spawn_error", { language, root, command, err: thrownText(e) });
             return undefined;
         }
         if (!child) {
@@ -262,7 +263,7 @@ export class NodeLspManager {
             }
             else
                 this.initFailures.set(key, attempt);
-            this.log("lsp_init_degraded", { language, root, err: e instanceof Error ? e.message : String(e), attempt, latched });
+            this.log("lsp_init_degraded", { language, root, err: thrownText(e), attempt, latched });
             return undefined;
         }
         this.initFailures.delete(key);
@@ -333,7 +334,7 @@ export const defaultLspSpawn = (command, args, cwd, signal) => new Promise((reso
         child = spawn(command, args, lspSpawnOptions(cwd));
     }
     catch (e) {
-        return reject(e instanceof Error ? e : new Error(String(e)));
+        return reject(asThrownError(e));
     }
     child.on("error", () => { });
     const onSpawn = () => {
@@ -345,7 +346,7 @@ export const defaultLspSpawn = (command, args, cwd, signal) => new Promise((reso
         if (err?.code === "ENOENT")
             resolve(undefined);
         else
-            reject(err instanceof Error ? err : new Error(String(err)));
+            reject(asThrownError(err));
     };
     const onAbort = () => {
         cleanup();

package/dist/engine/lsp/stdio-lsp-transport.js

@@ -1,6 +1,7 @@
 import { encodeFrame, createFrameDecoder } from "./frame-decoder.js";
 import { killProcessTree } from "../execution-env/kill-tree.js";
 import { brandLspFailure } from "../../core/lsp.js";
+import { asThrownError } from "../../core/thrown-value.js";
 export class StdioLspTransport {
     child;
     requestTimeoutMs;
@@ -132,7 +133,7 @@ export class StdioLspTransport {
                 this.send({ jsonrpc: "2.0", id, method, params });
             }
             catch (e) {
-                this.failAll(brandLspFailure(e instanceof Error ? e : new Error(String(e)), "server_terminated"));
+                this.failAll(brandLspFailure(asThrownError(e), "server_terminated"));
             }
         });
     }
@@ -166,8 +167,14 @@ function jsonRpcReason(code) {
     return "server_error";
 }
 function toError(e) {
-    if (e instanceof Error)
-        return e;
-    const m = e?.message;
-    return new Error(typeof m === "string" && m ? m : String(e));
+    try {
+        if (e instanceof Error)
+            return e;
+        const m = e?.message;
+        if (typeof m === "string" && m)
+            return new Error(m);
+    }
+    catch {
+    }
+    return asThrownError(e);
 }

package/dist/orchestration/dev-vm-script-runner.js

@@ -1,5 +1,6 @@
 import vm from "node:vm";
 import { splitWorkflowMeta, WorkflowScriptError } from "./workflow-meta.js";
+import { thrownText } from "../core/thrown-value.js";
 export const WORKFLOW_DATE_ERR = "Date.now() / new Date() are unavailable in workflow scripts (breaks resume). Stamp results after the workflow returns, or pass timestamps via args.";
 export const WORKFLOW_RANDOM_ERR = "Math.random() is unavailable in workflow scripts (breaks resume). For N independent samples, include the index in the agent label or prompt.";
 const DETERMINISM_SHIM = `(() => {
@@ -45,7 +46,7 @@ export const devWorkflowScriptRunner = {
             }
         }
         catch (err) {
-            throw new WorkflowScriptError(`workflow script failed to compile: ${err instanceof Error ? err.message : String(err)}`);
+            throw new WorkflowScriptError(`workflow script failed to compile: ${thrownText(err)}`);
         }
         const noHostApi = (name) => () => {
             throw new WorkflowScriptError(`${name} is not available in workflow scripts — there are no Node/host APIs here. Use agent()/log()/` +

package/dist/orchestration/run-workflow-tool.js

@@ -20,6 +20,7 @@ import { mergeWorkflowArgs, normalizeStringArg } from "./workflow-script-store.j
 import { builtinWorkflowListings, canonicalWorkflowName, resolveBuiltinWorkflow, workflowNameProbeOrder } from "./builtin-workflows.js";
 import { workflowSizeGuidelineSection } from "./workflow-size-guideline.js";
 import { toolFace } from "../core/tool-catalog-entries.js";
+import { thrownText } from "../core/thrown-value.js";
 export const RUN_WORKFLOW_TOOL_NAME = "Workflow";
 function parentFaceSeat(ctxSeat, dep) {
     if (ctxSeat !== "roots")
@@ -289,7 +290,7 @@ export async function createRunWorkflowTool(d) {
                 };
             }
             catch (e) {
-                return { form: "script", parseError: String(e instanceof Error ? e.message : e).slice(0, 300), scriptChars: a.script.length };
+                return { form: "script", parseError: thrownText(e).slice(0, 300), scriptChars: a.script.length };
             }
         },
         description: "Author and run your own deterministic JS WORKFLOW that spawns and coordinates sub-agents. Pass `script` " +
@@ -425,7 +426,7 @@ export async function createRunWorkflowTool(d) {
                     script = await d.scriptStore.load(rawScriptPath, taskScope ?? "default");
                 }
                 catch (err) {
-                    return structuredError(`failed to read workflow script at scriptPath: ${redactSecrets(err instanceof Error ? err.message : String(err)).slice(0, 300)}`);
+                    return structuredError(`failed to read workflow script at scriptPath: ${redactSecrets(thrownText(err)).slice(0, 300)}`);
                 }
             }
             else if (typeof rawScript === "string" && rawScript.length > 0) {
@@ -444,7 +445,7 @@ export async function createRunWorkflowTool(d) {
                             resolved = await d.scriptStore.resolveName(probeName);
                         }
                         catch (err) {
-                            return structuredError(`failed to resolve workflow name: ${redactSecrets(err instanceof Error ? err.message : String(err)).slice(0, 300)}`);
+                            return structuredError(`failed to resolve workflow name: ${redactSecrets(thrownText(err)).slice(0, 300)}`);
                         }
                         const resolvedShape = resolved;
                         if (resolvedShape !== undefined && (resolvedShape === null || typeof resolvedShape !== "object")) {
@@ -478,7 +479,7 @@ export async function createRunWorkflowTool(d) {
                 meta = parseWorkflowMeta(script);
             }
             catch (err) {
-                return structuredError(err instanceof Error ? err.message : String(err));
+                return structuredError(thrownText(err));
             }
             try {
                 const { body } = splitWorkflowMeta(script);
@@ -489,7 +490,7 @@ export async function createRunWorkflowTool(d) {
                 }
             }
             catch (err) {
-                return structuredError(`workflow script failed to compile: ${err instanceof Error ? err.message : String(err)}`);
+                return structuredError(`workflow script failed to compile: ${thrownText(err)}`);
             }
             const hostOnAsk = ctx.onAsk ?? d.parentOnAsk;
             const hostDurableApproval = ctx.durableApprovalForChildren ?? d.parentDurableApproval;
@@ -583,7 +584,7 @@ export async function createRunWorkflowTool(d) {
                 }, { workflowDepth: d.workflowDepth });
             }
             catch (err) {
-                return structuredError(err instanceof Error ? err.message : String(err));
+                return structuredError(thrownText(err));
             }
             const runId = handle.runId;
             let persistedScriptPath;

package/dist/orchestration/workflow-governance.js

@@ -5,6 +5,7 @@ import { compileReadDeny } from "../tools/fs/read-deny.js";
 import { WorkflowScriptError } from "./workflow-meta.js";
 import { uuidv7 } from "../engine/session/uuid.js";
 import { retiredCheckpointStoreNull } from "../core/checkpoint-store.js";
+import { thrownText } from "../core/thrown-value.js";
 export class WorkflowModelNotAllowedError extends Error {
     modelName;
     code = "workflow.model_not_allowed";
@@ -302,7 +303,7 @@ function pickWhitelist(scriptSpec) {
             compileReadDeny(entries, "agent(spec).readDenyPatterns");
         }
         catch (err) {
-            throw new WorkflowScriptError(err instanceof Error ? err.message : String(err));
+            throw new WorkflowScriptError(thrownText(err));
         }
         safe.readDenyPatterns = entries;
     }

package/dist/orchestration/workflow-sandbox-conformance.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { thrownText } from "../core/thrown-value.js";
 const META = "export const meta = { name: 'conformance', description: 'sandbox escape probes' }\n";
 const WITNESS_FN = "__probeWitness";
 const WITNESS_PRELUDE = `function ${WITNESS_FN}(v) {\n` +
@@ -114,7 +115,7 @@ async function runLivenessCanary(runner) {
         result = out.result;
     }
     catch (err) {
-        return { ok: false, detail: `run() REJECTED with: ${err instanceof Error ? err.message : String(err)}` };
+        return { ok: false, detail: `run() REJECTED with: ${thrownText(err)}` };
     }
     const expected = { marker: CANARY_MARKER, nonce, sum: 42, joined: `${CANARY_MARKER}:${nonce}` };
     try {
@@ -134,7 +135,7 @@ async function runProbeBody(runner, scriptSource, primitives, family, signal) {
         const live = await runLivenessCanary(runner);
         assert.ok(live.ok, `${family}: the probe threw AND the runner then failed the liveness canary — this runner is BROKEN, ` +
             `not blocking, so nothing about its membrane was proven. probe: ${scriptSource.slice(META.length)} | ` +
-            `probe threw: ${err instanceof Error ? err.message : String(err)} | canary: ${live.detail}`);
+            `probe threw: ${thrownText(err)} | canary: ${live.detail}`);
         return { executed: false };
     }
 }

package/dist/orchestration/workflow-script-store.js

@@ -2,6 +2,7 @@ import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { physicalPathOfExisting } from "../core/physical-path.js";
 import { sanitizeScope } from "../stores/file/fs-atomic.js";
+import { thrownText } from "../core/thrown-value.js";
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -85,7 +86,7 @@ export function createFileWorkflowScriptStore(dir) {
                 defaultArgs = JSON.parse(readFileSync(argsPath, "utf-8"));
             }
             catch (err) {
-                throw new Error(`workflow script store: invalid defaultArgs JSON in ${stem}.args.json: ${err instanceof Error ? err.message : String(err)}`);
+                throw new Error(`workflow script store: invalid defaultArgs JSON in ${stem}.args.json: ${thrownText(err)}`);
             }
             return { script, defaultArgs };
         },