@sema-agent/core 7.23.4 → 7.24.0

package/dist/core/tool-catalog-entries.js

@@ -108,7 +108,7 @@ export const TOOL_CATALOG_ENTRIES = [
     { id: "task-stop-hands", name: "TaskStop", source: "builtin", definedIn: "src/tools/fs/fs-bash.ts", mountedBy: ["hands"], cards: [], face: { family: "delegate", effect: "write", contract: TASK_STOP_CONTRACT } },
     { id: "task-output", name: "TaskOutput", source: "builtin", definedIn: "src/core/task-registry.ts", mountedBy: ["delegation"], cards: ["task-output"], face: { family: "delegate", effect: "read", contract: TASK_OUTPUT_CONTRACT } },
     { id: "task-stop", name: "TaskStop", source: "builtin", definedIn: "src/core/task-registry.ts", mountedBy: ["delegation"], cards: ["task-stop"], face: { family: "delegate", effect: "write", contract: TASK_STOP_CONTRACT } },
-    { id: "monitor", name: "Monitor", source: "builtin", definedIn: "src/tools/monitor.ts", mountedBy: ["backgroundTasks"], cards: ["monitor-start"], face: { family: "other", effect: "write", contract: c("core.monitor@1"), offloadThresholdChars: 10_000 } },
+    { id: "monitor", name: "Monitor", source: "builtin", definedIn: "src/tools/monitor.ts", mountedBy: ["backgroundTasks"], cards: ["monitor-start", "readonly_out_of_root"], face: { family: "other", effect: "write", contract: c("core.monitor@1"), offloadThresholdChars: 10_000 } },
     { id: "send-message", name: "SendMessage", source: "builtin", definedIn: "src/agents/send-message-tool.ts", mountedBy: ["delegation", "hostInternals", "peerLane"], cards: ["send-message"], face: { family: "protocol", effect: "write", contract: c("core.send_message@1") } },
     { id: "agent-transcript", name: "AgentTranscript", source: "builtin", definedIn: "src/agents/agent-transcript-tool.ts", mountedBy: ["delegation"], cards: ["agent-transcript"], face: { family: "delegate", effect: "read", contract: c("core.agent_transcript@1") } },
     { id: "list-agents", name: "ListAgents", source: "builtin", definedIn: "src/agents/list-agents-tool.ts", mountedBy: ["peerLane"], cards: ["list-agents"], face: { family: "protocol", effect: "read", aliases: ["ListPeers"], contract: c("core.list_agents@1") } },

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

@@ -33,6 +33,12 @@ 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,7 +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";
+import { isErrorLike, readMember, thrownName, thrownText } from "./thrown-value.js";
 export function truncateError(s) {
     if (s.length <= MAX_ERROR_CHARS)
         return s;
@@ -39,18 +39,10 @@ function isShellLike(e) {
         return false;
     }
 }
-function isErrorInstance(v) {
-    try {
-        return v instanceof Error;
-    }
-    catch {
-        return false;
-    }
-}
 export function formatToolError(error) {
     const parts = [];
-    const name = readMember(error, "name");
-    if (isErrorInstance(error) && name === "AbortError")
+    const name = thrownName(error);
+    if (name === "AbortError")
         return "Interrupted";
     const message = readMember(error, "message");
     const messageText = typeof message === "string" ? message : undefined;
@@ -60,15 +52,15 @@ export function formatToolError(error) {
         const stdout = readMember(error, "stdout");
         if (typeof exitCode === "number")
             parts.push(`Exit code ${exitCode}`);
-        if (isErrorInstance(error) && messageText !== undefined && messageText !== "")
+        if (isErrorLike(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 (isErrorInstance(error)) {
-        parts.push((messageText ?? "") || (typeof name === "string" ? name : "") || "Error");
+    else if (isErrorLike(error)) {
+        parts.push((messageText ?? "") || (name ?? "") || "Error");
     }
     else {
         parts.push(thrownText(error));

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

@@ -1,4 +1,4 @@
-import { thrownText } from "./thrown-value.js";
+import { readMember, thrownText } from "./thrown-value.js";
 export function modelIdTail(id) {
     return id.toLowerCase().split("/").pop() ?? "";
 }
@@ -207,22 +207,10 @@ export function applyToolModelGate(input) {
         merged = input.depsSeat === false ? undefined : mergeToolModelGateClasses(input.depsSeat);
     }
     catch (e) {
-        let code;
-        try {
-            code = e?.code;
-        }
-        catch {
-            code = undefined;
-        }
+        const code = readMember(e, "code");
         if (code !== undefined)
             throw e;
-        let msg;
-        try {
-            msg = thrownText(e);
-        }
-        catch {
-            msg = "[unreportable throw]";
-        }
+        const msg = thrownText(e);
         throw gateConfigError(`RunnerDeps.toolModelGate could not be read (${msg}) — a config seat whose reads throw is a bad value, refused rather than passed.`);
     }
     const raw = input.envRaw;

package/dist/core/tools.js

@@ -1,11 +1,12 @@
 import { Value } from "typebox/value";
 import { formatToolError, formatZodValidationError } from "./tool-errors.js";
+import { readMember } from "./thrown-value.js";
 import { attachToolContract } from "../prompt-assembly/tool-catalog.js";
 function normalizeContent(ret) {
     if (typeof ret === "string") {
         return { content: [{ type: "text", text: ret }], details: undefined, terminate: false, isError: false };
     }
-    const raw = ret.content;
+    const raw = readMember(ret, "content");
     if (typeof raw !== "string" && !Array.isArray(raw)) {
         return {
             content: [{ type: "text", text: "Tool error: content must be a string or an array of content blocks." }],
@@ -15,7 +16,7 @@ function normalizeContent(ret) {
         };
     }
     const content = typeof raw === "string" ? [{ type: "text", text: raw }] : raw;
-    return { content, details: ret.details, terminate: ret.terminate ?? false, isError: ret.isError === true };
+    return { content, details: readMember(ret, "details"), terminate: readMember(ret, "terminate") === true, isError: readMember(ret, "isError") === true };
 }
 function isEmptyToolContent(content) {
     if (content.length === 0)
@@ -107,28 +108,26 @@ export function defineTool(spec, options) {
                     isError: true,
                 };
             }
-            let ret;
             try {
                 const baseCtx = { toolCallId, signal };
                 const ctx = options?.enrichCtx ? stampCallIdentity(options.enrichCtx(baseCtx), toolCallId, signal) : baseCtx;
-                ret = await spec.execute(params, ctx);
+                const ret = await spec.execute(params, ctx);
+                const { content, details, terminate, isError } = normalizeContent(ret);
+                const guarded = isEmptyToolContent(content)
+                    ? [{ type: "text", text: isError ? `(${spec.name} reported an error with no further output)` : `(${spec.name} completed with no output)` }]
+                    : content;
+                return { content: guarded, details, terminate, ...(isError ? { isError: true } : {}) };
             }
             catch (err) {
                 const wrapped = new Error(formatToolError(err));
-                if (err !== null && typeof err === "object") {
-                    const src = err;
-                    if (src.details !== undefined)
-                        wrapped.details = src.details;
-                    if (typeof src.errorKind === "string")
-                        wrapped.errorKind = src.errorKind;
-                }
+                const marks = readMember(err, "details");
+                if (marks !== undefined)
+                    wrapped.details = marks;
+                const errorKind = readMember(err, "errorKind");
+                if (typeof errorKind === "string")
+                    wrapped.errorKind = errorKind;
                 throw wrapped;
             }
-            const { content, details, terminate, isError } = normalizeContent(ret);
-            const guarded = isEmptyToolContent(content)
-                ? [{ type: "text", text: isError ? `(${spec.name} reported an error with no further output)` : `(${spec.name} completed with no output)` }]
-                : content;
-            return { content: guarded, details, terminate, ...(isError ? { isError: true } : {}) };
         },
     };
     if (spec.contract) {

package/dist/core/untrusted-text.d.ts

@@ -405,6 +405,12 @@ export declare function inlineUntrusted(text: string, maxLen?: number): string;
  *  checkpoint-store closed an ESM evaluation cycle (checkpoint-store → tool-policy → tools/fs →
  *  checkpoint-store, a latent TDZ). Both already import this module; one cap, no cycle. */
 export declare const PROBE_CAUSE_PATH_MAX = 200;
+/** The bloat ceiling on a probe's one-sentence account (`RiskDescriptor.probeReason` /
+ *  `AskRequest.probeReason`); the neutralizer is the INJECTION ceiling, this is only the LENGTH one. Homed
+ *  here for the same reason as the constant above: three readers — the shell probe that MINTS the sentence
+ *  (tools/fs) and must fit every load-bearing part inside this bound, the gate, the persist boundary — and
+ *  a value import from tools/fs into checkpoint-store closes an ESM cycle. */
+export declare const PROBE_REASON_MAX = 200;
 /** The one body bound every "reviewer note" relay passes to {@link delimitUntrusted} — the decider's
  *  free text attached to a deny (sync `AskOutcome.reason` and the durable `ResumeOutcome` `reason`
  *  legs alike). A note is steering, not payload: unbounded it can flood the transcript/context the

package/dist/core/untrusted-text.js

@@ -601,6 +601,7 @@ function sanitizeLabel(label) {
     return inlineUntrusted(label, LABEL_MAX);
 }
 export const PROBE_CAUSE_PATH_MAX = 200;
+export const PROBE_REASON_MAX = 200;
 export const REVIEWER_NOTE_MAX_BODY = 2048;
 export function delimitUntrusted(label, text, maxBody) {
     return delimitUntrustedWithClip(label, text, maxBody).text;

package/dist/core/workflow-run-store-contract.js

@@ -118,6 +118,19 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
         byId.get("d-over").budgetOvershoot.spentTokens = 7;
         assert.equal((await store.get("d-over")).budgetOvershoot.spentTokens, 1_200);
     });
+    run("the failure CODE reaches the LIST row verbatim, and a run without one keeps the key ABSENT", async () => {
+        const store = make();
+        const coded = createWorkflowRun({ id: "f-coded", status: "failed", createdAt: 5_000, error: "the body gave up", errorCode: "workflow.agent_blocked" });
+        const codeless = createWorkflowRun({ id: "f-codeless", status: "failed", createdAt: 6_000, error: "the body gave up" });
+        const ok = createWorkflowRun({ id: "f-ok", status: "completed", createdAt: 7_000 });
+        for (const r of [coded, codeless, ok])
+            await store.put(r.id, r);
+        const byId = new Map((await store.listByScope("tenant-a")).map((s) => [s.id, s]));
+        assert.equal(byId.get("f-coded").errorCode, "workflow.agent_blocked");
+        assert.equal("errorCode" in byId.get("f-codeless"), false, "a failed run with no code ⇒ the key is OMITTED, not an `unknown` stand-in");
+        assert.equal("errorCode" in byId.get("f-ok"), false, "a completed run never carries one ⇒ the key is OMITTED");
+        assert.deepEqual(byId.get("f-coded"), summarizeWorkflowRun(coded));
+    });
     run("the TOTAL-TIMEOUT disclosure reaches the LIST row: timeoutInterruption projects (de-aliased), and a run without it keeps the key ABSENT", async () => {
         const store = make();
         const seat = { timeoutMs: 600_000, agentsCompleted: 3, agentsFailed: 1, agentsInFlight: 2, approvalWaitedMs: 540_000 };

package/dist/core/workflow-run-store.d.ts

@@ -46,6 +46,21 @@ export interface WorkflowRunSummary {
     description?: string;
     /** Lifecycle status ({@link WorkflowRun.status}): running / completed / failed. */
     status: WorkflowRunStatus;
+    /** The MACHINE code of the failure that ended the run ({@link WorkflowRun.errorCode}) — the same word,
+     *  in the same vocabulary, that the full run carries; never re-derived and never a second taxonomy.
+     *  The fourth member of the same family as {@link agentFailures} / {@link budgetOvershoot} /
+     *  {@link timeoutInterruption}: those three qualify a row that LOOKS clean, and this one says WHY a
+     *  `failed` row failed. Nothing else on this projection can answer that — {@link status} is `failed`
+     *  for a refused spawn, a blown budget, a stalled run and a body that simply threw alike, so a list
+     *  face without this seat must `get` the full run per failed row to say anything at all, which is the
+     *  N+1 this projection exists to avoid.
+     *
+     *  PRESENT EXACTLY WHEN THE RUN CARRIES ONE, absent otherwise — an absent key reads "no code on the
+     *  record", never "the run succeeded" and never a `workflow.unknown` stand-in. A `completed` run never
+     *  carries one (per {@link WorkflowRun.errorCode}), and a `failed` run whose body threw a codeless
+     *  error with no failed child on the record carries none either. Free of any own attribution rule: the
+     *  attribution (thrown code → first failed agent → absent) happens once, where the run is written. */
+    errorCode?: string;
     /** Count of agent-runs that ended failed ({@link WorkflowRun.agentFailures}) — present only when > 0.
      *  Lets a list view flag a "completed, with failures" run without an N+1 `get` of the full run. */
     agentFailures?: number;

package/dist/core/workflow-run-store.js

@@ -8,6 +8,7 @@ export function summarizeWorkflowRun(run) {
         ...(run.name !== undefined ? { name: run.name } : {}),
         ...(run.description !== undefined ? { description: run.description } : {}),
         status: run.status,
+        ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
         ...(run.agentFailures !== undefined ? { agentFailures: run.agentFailures } : {}),
         ...(run.budgetOvershoot !== undefined ? { budgetOvershoot: { ...run.budgetOvershoot } } : {}),
         ...(run.timeoutInterruption !== undefined ? { timeoutInterruption: { ...run.timeoutInterruption } } : {}),

package/dist/engine/llm/types.d.ts

@@ -911,14 +911,14 @@ export interface RoutePairingConfig {
 export type RoutePairingPosture = "per-model" | "paired" | "unpinned" | "keyless";
 /** Machine codes an adjudication refusal carries (minted here, forwarded verbatim by consumers). */
 export type RouteRefusalCode = "route.credential_mismatch" | "route.credential_missing";
-/** The structured account of a refusal — enough for a caller to render the two halves and the fix. */
+/** The structured account of a refusal — the two halves and the fix, every URL a DISPLAY spelling. */
 export interface RouteRefusalDetail {
     modelId: string;
-    /** The entry's declared URL half (`Model.baseUrl`, normalized). */
+    /** The entry's declared URL half (`Model.baseUrl`), via `displayUrlOf` — NOT route identity. */
     entryBaseUrl: string;
-    /** The root the request would actually target (normalized). */
+    /** The root the request would actually target, rendered (use `routeKeyOf` for identity). */
     requestBaseUrl: string;
-    /** The deployment's declared root the credential is paired with (mismatch refusals). */
+    /** The declared root the credential is paired with (mismatch refusals), rendered. */
     configBaseUrl?: string;
     /** One-line configuration fix. */
     fixHint: string;

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

@@ -2,7 +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";
+import { isErrorLike, readMember, thrownMarksOf, thrownText } from "../../core/thrown-value.js";
 function appendTextDeltaToAssistantMessage(message, contentIndex, delta) {
     const content = [...message.content];
     const currentContent = content[contentIndex];
@@ -1537,33 +1537,19 @@ function safeAbortDetails(fn) {
     }
 }
 function isAbortSemanticsError(error) {
-    try {
-        let cursor = error;
-        for (let depth = 0; depth < 8 && cursor instanceof Error; depth++) {
-            if (cursor.name === "AbortError")
-                return true;
-            const next = cursor.cause;
-            if (next === cursor)
-                break;
-            cursor = next;
-        }
-    }
-    catch {
-        return false;
+    let cursor = error;
+    for (let depth = 0; depth < 8 && isErrorLike(cursor); depth++) {
+        if (readMember(cursor, "name") === "AbortError")
+            return true;
+        const next = readMember(cursor, "cause");
+        if (next === cursor)
+            break;
+        cursor = next;
     }
     return false;
 }
 function createErrorToolResult(message, source) {
-    let details = {};
-    if (source !== null && typeof source === "object") {
-        const marks = source;
-        if (marks.details !== null && typeof marks.details === "object" && !Array.isArray(marks.details)) {
-            details = { ...marks.details };
-        }
-        if (typeof marks.errorKind === "string") {
-            details.errorKind = marks.errorKind;
-        }
-    }
+    const details = thrownMarksOf(source) ?? {};
     return {
         content: [{ type: "text", text: truncateError(message) }],
         details,

package/dist/index.d.ts

@@ -325,7 +325,7 @@ export { createCircuitBreakerBrain, type CircuitBreakerOptions, type BreakerStat
 export { createDegradingBrain, readDegradation, DEGRADED_DIAGNOSTIC_TYPE, type DegradingBrainOptions, type DegradeReason, type DegradationInfo, } from "./brain/degrading.js";
 export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { WAITING_FIRST_TOKEN_AFTER_MS, WAITING_FIRST_TOKEN_EVERY_MS } from "./brain/stream-engine.js";
-export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, normalizeBaseUrl, hasAuthCarrier, type RoutePairingStatus, } from "./brain/route-adjudicator.js";
+export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, routeKeyOf, displayUrlOf, resolveRequestRoot, hasAuthCarrier, type RoutePairingStatus, } from "./brain/route-adjudicator.js";
 export type { RouteAdjudication, RouteCredential, RouteCredentialSource, RoutePairingConfig, RoutePairingPosture, RouteRefusalCode, RouteRefusalDetail, } from "./internal/llm.js";
 export { ROUTE_ADJUDICATION_CONFORMANCE_CORPUS, type RouteAdjudicationVector } from "./brain/route-conformance.js";
 export { type BrainTimeoutConfig } from "./brain/timeout.js";

package/dist/index.js

@@ -279,7 +279,7 @@ export { createCircuitBreakerBrain, CIRCUIT_OPEN_MARKER, } from "./brain/circuit
 export { createDegradingBrain, readDegradation, DEGRADED_DIAGNOSTIC_TYPE, } from "./brain/degrading.js";
 export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { WAITING_FIRST_TOKEN_AFTER_MS, WAITING_FIRST_TOKEN_EVERY_MS } from "./brain/stream-engine.js";
-export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, normalizeBaseUrl, hasAuthCarrier, } from "./brain/route-adjudicator.js";
+export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, routeKeyOf, displayUrlOf, resolveRequestRoot, hasAuthCarrier, } from "./brain/route-adjudicator.js";
 export { ROUTE_ADJUDICATION_CONFORMANCE_CORPUS } from "./brain/route-conformance.js";
 export {} from "./brain/timeout.js";
 export { createAssistantMessageEventStream } from "./internal/llm.js";

package/dist/orchestration/workflow.js

@@ -23,7 +23,7 @@ import { compileOutputSchema } from "../core/runner/strict-output-schema.js";
 import { WorkflowBudgetExceededError, WorkflowNestingError, WorkflowAgentBlockedError, WorkflowAgentParkedError, WorkflowAgentSchemaError, WorkflowAgentStalledError, WorkflowMaxAgentsError, WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } from "./workflow-types.js";
 import { WorkflowScriptError } from "./workflow-meta.js";
 import { STALL_CONNECT_MS, STALL_FIRST_TOKEN_MS } from "../brain/timeout.js";
-import { asThrownError, thrownText } from "../core/thrown-value.js";
+import { asThrownError, isErrorLike, readMember, thrownIs, thrownName, thrownText } from "../core/thrown-value.js";
 export * from "./workflow-types.js";
 const MAX_TRANSCRIPT_CHARS = 4000;
 const WORKFLOW_RESULT_MAX = 4000;
@@ -176,7 +176,7 @@ export function assertSupportedAgentIsolation(isolation) {
     }
 }
 function rethrowIfMaxAgents(e) {
-    if (e instanceof WorkflowMaxAgentsError)
+    if (thrownIs(e, WorkflowMaxAgentsError))
         throw e;
     return null;
 }
@@ -186,7 +186,7 @@ function foldFanOutSettled(settled, lane, errorsOut, emitRunLog) {
     const results = settled.map((s) => {
         if (s.ok)
             return s.v;
-        if (s.e instanceof WorkflowBudgetExceededError) {
+        if (thrownIs(s.e, WorkflowBudgetExceededError)) {
             dropped++;
             droppedSlots.push(s.i);
             errorsOut?.push(workflowFanOutSlotError(s.i, s.e));
@@ -201,9 +201,19 @@ function foldFanOutSettled(settled, lane, errorsOut, emitRunLog) {
         emitRunLog(`${lane}: ${dropped} ${dropped === 1 ? "slot" : "slots"} dropped — token budget exceeded (${dropped === 1 ? "slot" : "slots"} ${droppedSlots.join(", ")})`);
     return results;
 }
+function thrownMessageOf(err) {
+    if (!isErrorLike(err))
+        return undefined;
+    const message = readMember(err, "message");
+    return typeof message === "string" && message !== "" ? message : undefined;
+}
+function thrownNameOf(err) {
+    const name = thrownName(err);
+    return name !== undefined && name !== "" ? name : undefined;
+}
 function workflowFanOutSlotError(index, e) {
-    const code = e?.code;
-    const kind = typeof code === "string" && code.length > 0 ? code : e instanceof Error ? e.name : "Error";
+    const code = readMember(e, "code");
+    const kind = typeof code === "string" && code.length > 0 ? code : thrownNameOf(e) ?? "Error";
     return { index, kind, message: boundedRedactedSummary(thrownText(e), 300) };
 }
 export class WorkflowResultTooLargeError extends Error {
@@ -247,12 +257,20 @@ export const MAX_WORKFLOW_ITEMS = 4096;
 function describeFanOutValue(v) {
     if (v === null)
         return "null";
-    if (Array.isArray(v))
+    if (isFanOutArray(v))
         return "array";
-    if (v instanceof Promise)
+    if (thrownIs(v, Promise))
         return "a Promise (an already-CALLED agent(...) — wrap it: () => agent(...))";
     return typeof v;
 }
+function isFanOutArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
 function assertFanOutCallables(lane, member, list) {
     for (let i = 0; i < list.length; i++) {
         if (typeof list[i] !== "function") {
@@ -263,7 +281,7 @@ function assertFanOutCallables(lane, member, list) {
     }
 }
 function assertFanOutArray(lane, what, v) {
-    if (!Array.isArray(v)) {
+    if (!isFanOutArray(v)) {
         throw new WorkflowScriptError(`${lane}(): ${what} must be an ARRAY (got ${describeFanOutValue(v)}). Nothing was run.`);
     }
 }
@@ -1740,14 +1758,14 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                 }
             }
             catch (err) {
-                if (drive !== undefined && !finalized && !(err instanceof WorkflowAgentParkedError)) {
+                if (drive !== undefined && !finalized && !thrownIs(err, WorkflowAgentParkedError)) {
                     emitRunLog(`[park] the parked leg "${label}" could not be driven — the resume was refused before the checkpoint was consumed (${withoutToken(errText(err), drive.token)}); the park stands.`);
                     return await parkAgentLeg(rec, drive.paused, activityTail, false);
                 }
                 if (!finalized) {
                     rec.status = "failed";
                     rec.endedAt = now();
-                    const salvaged = err instanceof WorkflowAgentStalledError ? err.lastResult : undefined;
+                    const salvaged = thrownIs(err, WorkflowAgentStalledError) ? err.lastResult : undefined;
                     if (salvaged?.runId === undefined)
                         delete rec.taskRunId;
                     if (salvaged !== undefined) {
@@ -1763,17 +1781,18 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         rec.output = boundedRedactedSummary(salvaged.structuredOutput ?? salvaged.result, MAX_TRANSCRIPT_CHARS) || (rec.errorMessage ?? "");
                         rec.stats = { tokens: salvaged.stats.tokens ?? 0, turns: salvaged.stats.turns ?? 0, costMicroUsd: salvaged.stats.costMicroUsd };
                     }
-                    if (err instanceof WorkflowAgentBlockedError) {
+                    if (thrownIs(err, WorkflowAgentBlockedError)) {
                         rec.errorCode = WORKFLOW_SPAWN_BLOCKED_ERROR_CODE;
                         rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
                     }
-                    if (err instanceof WorkflowBudgetExceededError) {
+                    if (thrownIs(err, WorkflowBudgetExceededError)) {
                         rec.errorCode = err.code;
                         rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
                     }
-                    if (rec.errorMessage === undefined && err instanceof Error && err.message !== "")
-                        rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
-                    if (err instanceof WorkflowAgentStalledError && err.attempts > 1) {
+                    const preLaunchMessage = thrownMessageOf(err);
+                    if (rec.errorMessage === undefined && preLaunchMessage !== undefined)
+                        rec.errorMessage = boundedRedactedSummary(preLaunchMessage, MAX_TRANSCRIPT_CHARS);
+                    if (thrownIs(err, WorkflowAgentStalledError) && err.attempts > 1) {
                         rec.attempts = err.attempts;
                         rec.lastAttemptReason = "stalled";
                     }
@@ -1785,12 +1804,12 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         result: boundedRedactedSummary(thrownText(err), 500),
                         terminal: {
                             kind: "failed",
-                            ...(err instanceof WorkflowAgentBlockedError ? { code: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } : err instanceof WorkflowBudgetExceededError ? { code: err.code } : {}),
+                            ...(thrownIs(err, WorkflowAgentBlockedError) ? { code: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } : thrownIs(err, WorkflowBudgetExceededError) ? { code: err.code } : {}),
                             message: boundedRedactedSummary(thrownText(err), 500),
                         },
                         stats: { turns: 0, tokens: 0, costMicroUsd: 0, usageMissing: true },
                     }, label).catch(() => undefined);
-                    if (!((err instanceof WorkflowBudgetExceededError || err instanceof WorkflowAgentParkedError) && rec.startedAt === undefined))
+                    if (!((thrownIs(err, WorkflowBudgetExceededError) || thrownIs(err, WorkflowAgentParkedError)) && rec.startedAt === undefined))
                         await journaled;
                     bceTerminal(callKey, "failed", rec.output ?? (thrownText(err)), rec.sessionId, rec.stats);
                 }
@@ -1955,9 +1974,10 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     releaseLeg();
                     return await parkAgentLeg(rec, drive.paused, [], false);
                 }
-                if (!finalized && rec.errorMessage === undefined && err instanceof Error && err.message !== "")
-                    rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
-                if (!finalized && err instanceof WorkflowAgentBlockedError) {
+                const spawnMessage = thrownMessageOf(err);
+                if (!finalized && rec.errorMessage === undefined && spawnMessage !== undefined)
+                    rec.errorMessage = boundedRedactedSummary(spawnMessage, MAX_TRANSCRIPT_CHARS);
+                if (!finalized && thrownIs(err, WorkflowAgentBlockedError)) {
                     rec.errorCode = WORKFLOW_SPAWN_BLOCKED_ERROR_CODE;
                     rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
                     void journalAppend(callKey, {
@@ -2210,8 +2230,9 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                             prior = await opts.store.get(opts.resumeFromRunId);
                         }
                         catch (err) {
-                            const errCode = err instanceof Error ? err.code : undefined;
-                            const errClass = err instanceof Error ? `${err.name}${typeof errCode === "string" ? `/${errCode}` : ""}` : typeof err;
+                            const errName = thrownNameOf(err);
+                            const errCode = errName !== undefined ? readMember(err, "code") : undefined;
+                            const errClass = errName !== undefined ? `${errName}${typeof errCode === "string" ? `/${errCode}` : ""}` : typeof err;
                             throw new WorkflowParkRefusal("workflow.park_truth_unreadable", `startWorkflow: resume from "${fromRunId}" was REFUSED — the prior run's record could not be read from the run store (${errClass}), so its parks cannot be proven.`, { reason: "store_threw" });
                         }
                         if (prior !== null && prior.scope !== scope)
@@ -2376,7 +2397,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             run.status = "failed";
             run.completionId ??= uuidv7();
             run.endedAt = now();
-            if (parkedLeg !== undefined && !(err instanceof WorkflowAgentParkedError))
+            if (parkedLeg !== undefined && !thrownIs(err, WorkflowAgentParkedError))
                 err = parkedError();
             run.error = thrownText(err);
             closeAbandonedAgents(run.endedAt);

package/dist/stores/file/file-history-store.js

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { appendFileSync, closeSync, existsSync, fsyncSync, openSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { thrownText } from "../../core/thrown-value.js";
 import { applyFileRestoreViaEnv, boundaryPublishVerdict, worldStillMatchesMint, captureFileBackupViaEnv, modeProvenDifferent, previewFileDelta, describeTrackKey, fileHistoryExportDigest, resolveTrackKey, trackKeyOf, validateFileHistoryExport, } from "../../core/file-history-store.js";
 import { fileHistoryBoundariesToKeep, resolveFileHistoryRetention } from "../../core/file-history-retention.js";
 import { atomicWriteFile, ensureDir, sanitizePathComponent, sanitizeScope, writeThenLink } from "./fs-atomic.js";
@@ -456,7 +457,7 @@ export class FileFileHistoryStore {
             return { ok: true, minted: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${err.message}` } };
+            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${thrownText(err)}` } };
         }
     }
     async annulTrack(scope, absPath, root, verify) {
@@ -511,7 +512,7 @@ export class FileFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${err.message}` } };
+            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${thrownText(err)}` } };
         }
     }
     scopeIsEmptySync(scope) {
@@ -677,7 +678,7 @@ export class FileFileHistoryStore {
         }
         catch (err) {
             nestedSetAdd(this.spentAttempts, scope, entryId);
-            return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${err.message}` } };
+            return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${thrownText(err)}` } };
         }
         finally {
             this.activeCaptures.get(scope)?.delete(entryId);
@@ -754,7 +755,7 @@ export class FileFileHistoryStore {
                     });
                 }
                 catch (err) {
-                    applied = { outcome: "failed", reason: err.message };
+                    applied = { outcome: "failed", reason: thrownText(err) };
                 }
                 if (applied.outcome === "applied")
                     ledger.filesChanged.push(key);
@@ -771,7 +772,7 @@ export class FileFileHistoryStore {
         }
         catch (err) {
             const touched = ledger.filesChanged.length > 0 || ledger.identicalSkipped.length > 0 || ledger.refused.length > 0 || ledger.failed.length > 0;
-            return { outcome: touched ? "partial" : "failed", ...ledger, error: { code: "restore_failed", message: err.message } };
+            return { outcome: touched ? "partial" : "failed", ...ledger, error: { code: "restore_failed", message: thrownText(err) } };
         }
     }
     async canRestore(scope, entryId) {
@@ -889,7 +890,7 @@ export class FileFileHistoryStore {
                 this.writeTracked(scope, tracked);
             }
             catch (err) {
-                this.disclose(this.trackedPath(scope), `version-chain trim could not be committed (${err.message}) — trim skipped this pass; untrimmed versions keep their blobs live`);
+                this.disclose(this.trackedPath(scope), `version-chain trim could not be committed (${thrownText(err)}) — trim skipped this pass; untrimmed versions keep their blobs live`);
             }
         }
         this.collectBlobs();
@@ -1091,7 +1092,7 @@ export class FileFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${err.message}` } };
+            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${thrownText(err)}` } };
         }
     }
     async exportHistory(scope) {
@@ -1151,7 +1152,7 @@ export class FileFileHistoryStore {
             return await this.runImport(scope, data, srcGetBlob, importJournal, identicalRepublish);
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${err.message}` } };
+            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}` } };
         }
     }
     async runImport(scope, data, srcGetBlob, importJournal, identicalRepublish) {
@@ -1178,7 +1179,7 @@ export class FileFileHistoryStore {
                         bytes = await srcGetBlob(v.blobHash);
                     }
                     catch (err) {
-                        return { ok: false, error: { code: "unsupported_format", message: `source blob ${v.blobHash} fetch failed: ${err.message}` } };
+                        return { ok: false, error: { code: "unsupported_format", message: `source blob ${v.blobHash} fetch failed: ${thrownText(err)}` } };
                     }
                     if (bytes === undefined)
                         return { ok: false, error: { code: "not_found", message: `source blob ${v.blobHash} is missing — the envelope's graph cannot be completed, so nothing is published` } };
@@ -1222,7 +1223,7 @@ export class FileFileHistoryStore {
                 }
                 catch (err) {
                     safeRm(staging);
-                    return { ok: false, error: { code: "adopt_failed", message: `importHistory could not publish the staged graph for "${scope}": ${err.message} — nothing was published (a local storage fault, not a malformed envelope)` } };
+                    return { ok: false, error: { code: "adopt_failed", message: `importHistory could not publish the staged graph for "${scope}": ${thrownText(err)} — nothing was published (a local storage fault, not a malformed envelope)` } };
                 }
                 if (published !== "published") {
                     safeRm(staging);
@@ -1238,7 +1239,7 @@ export class FileFileHistoryStore {
             return { ok: true };
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${err.message}` } };
+            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${thrownText(err)}` } };
         }
         finally {
             safeRm(importJournal);