@sema-agent/core 7.23.4 → 7.24.0

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

@@ -29,7 +29,7 @@ import { toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
 import { announceListingTruncation } from "../skill-listing-budget.js";
 import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
 import { flushOwedAnnouncedSnapshot } from "./announce-once-ledger.js";
-import { asThrownError, thrownText } from "../thrown-value.js";
+import { asThrownError, thrownMarksOf, thrownText } from "../thrown-value.js";
 export async function runLeg(input) {
     const { spec, queue, prepared, resume, rs, isDelegatedChild, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
     let final;
@@ -693,18 +693,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     }
     catch (err) {
         const execError = `Error: ${thrownText(err)}`;
-        const marks = (() => {
-            if (err === null || typeof err !== "object")
-                return undefined;
-            const src = err;
-            let d;
-            if (src.details !== null && typeof src.details === "object" && !Array.isArray(src.details)) {
-                d = { ...src.details };
-            }
-            if (typeof src.errorKind === "string")
-                d = { ...(d ?? {}), errorKind: src.errorKind };
-            return d;
-        })();
+        const marks = thrownMarksOf(err);
         await settleEnd(true, { content: execError, ...(marks !== undefined ? { details: marks } : {}) });
         const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, execError, true));
         emitCommitted(eid, "toolResult", pendingAction.toolCallId);

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

@@ -1,7 +1,7 @@
 import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { planRejectionClears } from "../context-edit.js";
 import { landStaleResultClears } from "./prepare-context-lane.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { rebaseCadenceWindows } from "./turn-attachments.js";
@@ -48,26 +48,10 @@ export function runRecoveryLanes(input) {
             if (comp.compacted) {
                 compactionBreaker.failures = 0;
                 recordCompactionReuse(runner, prepared, comp);
-                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                    const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                    rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON && comp.postTriggerTokens !== undefined) {
+                    rs.counters.compactionFloor = Math.ceil(comp.postTriggerTokens * COMPACTION_REGROWTH_FACTOR);
                 }
-                queue.push({
-                    type: "compacted",
-                    trigger: "forced",
-                    tokensBefore: comp.tokensBefore ?? 0,
-                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                    ...(comp.modelFallback ? { modelFallback: true } : {}),
-                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                    ...ident(),
-                });
+                queue.push(mintCompactedEvent(comp, "forced", ident()));
                 if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                     const pd = comp.phaseDurations;
                     const pdDur = comp.durationMs;

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

@@ -20,27 +20,13 @@ import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
+import { mintCompactedEvent } from "../auto-compaction.js";
 import { asThrownError } from "../thrown-value.js";
 export async function runSettleAndTeardown(input) {
     const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
     try {
         if (comp?.compacted) {
-            queue.push({
-                type: "compacted",
-                trigger: "auto",
-                tokensBefore: comp.tokensBefore ?? 0,
-                ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                ...(comp.modelFallback ? { modelFallback: true } : {}),
-                ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                ...ident(),
-            });
+            queue.push(mintCompactedEvent(comp, "auto", ident()));
             if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                 const pd = comp.phaseDurations;
                 const pdDur = comp.durationMs;

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

@@ -1,7 +1,7 @@
 import { mintSystemReminder } from "../reminder-mint.js";
 import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { redactThenCut } from "../../agents/subagent-steps.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, attachmentEnvelopeTags, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, isIntactSource, rebaseCadenceWindows, renderAgentListingFrame, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
@@ -643,22 +643,7 @@ export function createTurnBoundary(input) {
             }
             recordCompactionReuse(runner, prepared, comp);
             if (comp.compacted) {
-                queue.push({
-                    type: "compacted",
-                    trigger: passTrigger,
-                    tokensBefore: comp.tokensBefore ?? 0,
-                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                    ...(comp.modelFallback ? { modelFallback: true } : {}),
-                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                    ...ident(),
-                });
+                queue.push(mintCompactedEvent(comp, passTrigger, ident()));
                 if (!forceManual && recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
                     compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
                     queue.push({ type: "compaction_outcome", outcome: "disabled", trigger: passTrigger, reason: "rapid_refill: compaction disabled for the rest of this task", ...ident() });
@@ -674,9 +659,8 @@ export function createTurnBoundary(input) {
                     rs.attach.attachState.postCompactPending = true;
                     rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
                 }
-                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                    const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                    rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON && comp.postTriggerTokens !== undefined) {
+                    rs.counters.compactionFloor = Math.ceil(comp.postTriggerTokens * COMPACTION_REGROWTH_FACTOR);
                 }
             }
         }

package/dist/core/runner/runtask.js

@@ -6,7 +6,7 @@ import { createRapidRefillState } from "../auto-compaction.js";
 import { boundInputHashOf } from "../canonical-json.js";
 import { emitTrace } from "../trace.js";
 import { emitTaskOutcome } from "../task-outcome.js";
-import { authCarrierFingerprint, normalizeBaseUrl } from "../../brain/route-adjudicator.js";
+import { authCarrierFingerprint, displayUrlOf, routeKeyOf } from "../../brain/route-adjudicator.js";
 import { runWithReasoningWireFacts } from "../../brain/status-sink.js";
 import { expandTiers } from "../roles.js";
 import { screenSwappableDeps } from "../swappable-deps.js";
@@ -208,10 +208,8 @@ export class Runner {
                 const prior = this.deps.models?.[name];
                 if (!prior)
                     continue;
-                const from = normalizeBaseUrl(prior.baseUrl);
-                const to = normalizeBaseUrl(nextModel.baseUrl);
-                if (from !== to && authCarrierFingerprint(prior.headers) === authCarrierFingerprint(nextModel.headers)) {
-                    movedEntries.push({ modelId: name, from, to });
+                if (routeKeyOf(prior.baseUrl) !== routeKeyOf(nextModel.baseUrl) && authCarrierFingerprint(prior.headers) === authCarrierFingerprint(nextModel.headers)) {
+                    movedEntries.push({ modelId: name, from: displayUrlOf(prior.baseUrl), to: displayUrlOf(nextModel.baseUrl) });
                 }
             }
         }

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

@@ -6,7 +6,7 @@ import { createSafeNotifier } from "../safe-notify.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { emitTrace } from "../trace.js";
 import { deliverDelegationLifecycle } from "../types.js";
-import { asThrownError, thrownText } from "../thrown-value.js";
+import { asThrownError, readMember, thrownText } from "../thrown-value.js";
 export function streamSettleBackstop(input) {
     const { spec, resume, queue, taskIdRef, entryTracer, runStartedAt, live, runner, sessions, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
     const onRunRejected = async (err) => {
@@ -57,11 +57,11 @@ export function streamSettleBackstop(input) {
         }
         const remoteEnvFailure = (() => {
             let cur = err;
-            for (let depth = 0; cur && typeof cur === "object" && depth < 8; depth++) {
-                const note = cur.remoteEnvFailure;
+            for (let depth = 0; cur !== null && cur !== undefined && typeof cur === "object" && depth < 8; depth++) {
+                const note = readMember(cur, "remoteEnvFailure");
                 if (note !== undefined)
                     return [note];
-                cur = cur.cause;
+                cur = readMember(cur, "cause");
             }
             return undefined;
         })();
@@ -79,7 +79,7 @@ export function streamSettleBackstop(input) {
                 return observed !== undefined && observed.length > 0 ? { editedFiles: observed } : {};
             })(),
             ...(() => {
-                const hinted = err.retryAfterMs;
+                const hinted = readMember(err, "retryAfterMs");
                 return code === "memory.admission_required" && typeof hinted === "number" && Number.isFinite(hinted) && hinted > 0
                     ? { retryAfterMs: hinted }
                     : {};

package/dist/core/runner/tool-end-body.js

@@ -1,4 +1,5 @@
 import {} from "../../internal/harness.js";
+import { readMember } from "../thrown-value.js";
 import { MCP_DELIVERY_VERDICTS } from "../mcp-failure.js";
 import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
 import { toolOutputFrom } from "./tool-output-projection.js";
@@ -35,11 +36,11 @@ export function batchResponseDigest(result) {
 export function toolEndBodyFrom(result, isError, structured, gate, gatedCallIdOfRun) {
     const o = toolOutputFrom(result);
     const st = structured(result);
-    const det = isError ? result?.details : undefined;
-    const codeRaw = det?.code;
-    const kindRaw = det?.errorKind;
+    const det = isError ? readMember(result, "details") : undefined;
+    const codeRaw = readMember(det, "code");
+    const kindRaw = readMember(det, "errorKind");
     const code = typeof codeRaw === "string" ? codeRaw : typeof kindRaw === "string" ? kindRaw : undefined;
-    const deliveredRaw = det?.delivered;
+    const deliveredRaw = readMember(det, "delivered");
     const delivered = typeof deliveredRaw === "string" && MCP_DELIVERY_VERDICTS.includes(deliveredRaw) ? deliveredRaw : undefined;
     const gatedCallId = code === "gate.parked" ? gatedCallIdOfRun : undefined;
     return {

package/dist/core/runner/tool-output-projection.js

@@ -1,4 +1,5 @@
 import { engineCardTypes } from "../tool-registry.js";
+import { readMember } from "../thrown-value.js";
 const MAX_TOOL_END_OUTPUT_CHARS = 16384;
 const safeJsonLength = (v) => {
     try {
@@ -62,10 +63,10 @@ export function createStructuredProjector(opts = {}) {
     const allowed = new Set([...CC_DETAIL_TYPES, ...(opts.declaredCards ?? [])]);
     const announced = new Set();
     return (result) => {
-        const details = result !== null && typeof result === "object" ? result.details : undefined;
+        const details = readMember(result, "details");
         if (details === null || typeof details !== "object")
             return undefined;
-        const t = details.type;
+        const t = readMember(details, "type");
         if (typeof t !== "string")
             return undefined;
         if (!allowed.has(t)) {

package/dist/core/runner/turn-attachments.d.ts

@@ -346,26 +346,6 @@ export declare const INSTRUCTIONS_CHANGE_BYTE_CAP = 512;
  * `steering_injected` echo are all keyed on that wordlist.
  */
 export declare function createAttachmentState(): AttachmentState;
-/**
- * H4 — thin-projection reducer over a tool's RAW `result.details` (NOT the wire card projector
- * projection and its 4×16K caps: a huge todo list must shrink into a bounded snapshot here, never
- * disarm the reminder by being dropped wholesale). Only the first-party discriminants `todo` /
- * `task` / `task-list` are recognized — every other card type (subagent `agent`/`fork`/`task-output`,
- * bash, fs, mcp, …) is structurally ignored, which is also the child-isolation contract: a subagent's
- * own todo state never reaches the parent's onToolEnd, and its delegation-card types don't parse here.
- *
- * task #51 F3 (窗口复位/投影摄入拆分): this reducer is PROJECTION INGEST ONLY — it
- * never touches the write windows. CC's window anchor is the tool_use block's PRESENCE in the
- * transcript (qFm/BFm match the block by name, :480217-480219/:480253-480254, with no execution-
- * outcome check), so the run loop stamps the windows on INITIATION via {@link stampWriteAnchor}
- * (inside {@link advanceCadenceClock}'s message walk); ingest stays success-only — a failed write
- * has no trustworthy `details`, exactly like CC's reminder body rendering from the authoritative
- * store rather than from tool results.
- *
- * Idempotent (same event twice ⇒ same state) and commutative across DISTINCT task ids (F10); two
- * whole-list writes (TodoWrite / TaskList) racing in one batch are last-write-wins by nature — the
- * later list IS the truer snapshot, documented rather than fought.
- */
 export declare function reduceToolEnd(state: AttachmentState, details: unknown): void;
 /** task #51 F2/F3 — which reminder window a tool_use block resets. Resolved by the run loop (alias-aware:
  *  ToolSpec.aliases over the mounted roster; retired-name normalization is gone); the producers

package/dist/core/runner/turn-attachments.js

@@ -1,4 +1,5 @@
 import { PRESENT_PLAN_TOOL_NAME } from "../present-plan-tool.js";
+import { readMember } from "../thrown-value.js";
 import { delimitUntrustedWithClip, sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
 import { protocolOf } from "../protocol-table.js";
 import { renderSkillLinesWithin, renderSkillsBlock } from "./synthetic-tools.js";
@@ -24,6 +25,7 @@ export const CHANGED_FILES_MAX = 20;
 export const CHANGED_FILES_MTIME_EPS_MS = 2000;
 export const ATTACHMENT_BYTE_CAP = 8 * 1024;
 const PROJECTION_ITEMS_MAX = 50;
+const PROJECTION_SCAN_MAX = 10_000;
 const PROJECTION_CONTENT_MAX = 80;
 const LISTING_FRAME_FLOOR_BYTES = 768;
 const DATE_CHANGE_MAX_BYTES = 160;
@@ -72,52 +74,55 @@ export function createAttachmentState() {
         postCompactPending: false,
     };
 }
+function readListLength(value) {
+    const n = value !== null && typeof value === "object" ? readMember(value, "length") : undefined;
+    return typeof n === "number" && Number.isInteger(n) && n >= 0 ? Math.min(n, PROJECTION_SCAN_MAX) : undefined;
+}
+function readTaskEntry(raw) {
+    const id = readMember(raw, "id");
+    if (typeof id !== "string")
+        return undefined;
+    const subject = readMember(raw, "subject");
+    const status = readMember(raw, "status");
+    return { id, item: { content: typeof subject === "string" ? subject.slice(0, PROJECTION_CONTENT_MAX) : "", status: typeof status === "string" ? status : "pending" } };
+}
 export function reduceToolEnd(state, details) {
-    if (details === null || typeof details !== "object")
-        return;
-    const d = details;
-    if (d.type === "todo") {
-        const newTodos = d.newTodos;
-        if (!Array.isArray(newTodos))
+    const type = readMember(details, "type");
+    if (type === "todo") {
+        const newTodos = readMember(details, "newTodos");
+        const count = readListLength(newTodos);
+        if (count === undefined)
             return;
-        const shaped = newTodos.flatMap((t) => {
-            const item = t;
-            return item && typeof item === "object" && typeof item.content === "string" && typeof item.status === "string"
-                ? [{ content: item.content.slice(0, PROJECTION_CONTENT_MAX), status: item.status }]
-                : [];
-        });
+        const shaped = [];
+        for (let i = 0; i < count; i++) {
+            const item = readMember(newTodos, String(i));
+            const content = readMember(item, "content");
+            const status = readMember(item, "status");
+            if (typeof content === "string" && typeof status === "string")
+                shaped.push({ content: content.slice(0, PROJECTION_CONTENT_MAX), status });
+        }
         const allDone = shaped.length > 0 && shaped.every((t) => t.status === "completed");
         state.todo = allDone ? { items: [] } : { items: shaped.slice(0, PROJECTION_ITEMS_MAX) };
     }
-    else if (d.type === "task") {
+    else if (type === "task") {
         const map = state.taskItems ?? (state.taskItems = new Map());
-        const deleted = d.deleted;
+        const deleted = readMember(details, "deleted");
         if (typeof deleted === "string")
             map.delete(deleted);
-        const task = d.task;
-        if (task !== null && typeof task === "object") {
-            const t = task;
-            if (typeof t.id === "string") {
-                map.set(t.id, {
-                    content: typeof t.subject === "string" ? t.subject.slice(0, PROJECTION_CONTENT_MAX) : "",
-                    status: typeof t.status === "string" ? t.status : "pending",
-                });
-            }
-        }
-    }
-    else if (d.type === "task-list") {
-        const tasks = d.tasks;
-        if (!Array.isArray(tasks))
+        const entry = readTaskEntry(readMember(details, "task"));
+        if (entry !== undefined)
+            map.set(entry.id, entry.item);
+    }
+    else if (type === "task-list") {
+        const tasks = readMember(details, "tasks");
+        const count = readListLength(tasks);
+        if (count === undefined)
             return;
         const map = new Map();
-        for (const raw of tasks) {
-            const t = raw;
-            if (t && typeof t === "object" && typeof t.id === "string") {
-                map.set(t.id, {
-                    content: typeof t.subject === "string" ? t.subject.slice(0, PROJECTION_CONTENT_MAX) : "",
-                    status: typeof t.status === "string" ? t.status : "pending",
-                });
-            }
+        for (let i = 0; i < count; i++) {
+            const entry = readTaskEntry(readMember(tasks, String(i)));
+            if (entry !== undefined)
+                map.set(entry.id, entry.item);
         }
         state.taskItems = map;
     }

package/dist/core/session-store.js

@@ -1,5 +1,6 @@
 import { InMemorySessionRepo, SessionError, uuidv7, } from "../internal/harness.js";
 import { isSessionConflict } from "./session.js";
+import { readMember } from "./thrown-value.js";
 const DAY_MS = 24 * 60 * 60 * 1000;
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
 export { SESSION_DEFAULT_TTL_DAYS };
@@ -285,8 +286,5 @@ async function settledForkOptions(source) {
     return {};
 }
 function isNotFound(err) {
-    return (typeof err === "object" &&
-        err !== null &&
-        "code" in err &&
-        err.code === "not_found");
+    return readMember(err, "code") === "not_found";
 }

package/dist/core/session.d.ts

@@ -8,7 +8,10 @@ export type { SessionWriteOptions } from "../internal/harness.js";
 import type { Session } from "../internal/harness.js";
 import type { SessionTreeEntry } from "../internal/harness.js";
 export type { SessionPlacementRecord } from "../internal/harness.js";
-/** True when `err` is a session optimistic-lock conflict (a concurrent writer won the branch leaf). */
+/** True when `err` is a session optimistic-lock conflict (a concurrent writer won the branch leaf). Both
+ *  halves read what a HOST `SessionStorage` threw, so both are guarded — unreadable is not a conflict,
+ *  never a raise inside the classify-and-rethrow guard. The class test is KEPT: widening the verdict to
+ *  any value carrying the word would arm the CAS retry loop on a foreign error (KL-942b). */
 export declare function isSessionConflict(err: unknown): boolean;
 /**
  * Subagent transcript persistence — the ACQUIRE-form placement declaration a trusted spawner passes

package/dist/core/session.js

@@ -3,8 +3,9 @@ export { InMemorySessionRepo, InMemorySessionStorage, uuidv7, validateEntriesFor
 export { BaseSessionStorage, leafIdAfterEntry, } from "../internal/harness.js";
 export { SessionError } from "../internal/harness.js";
 import { SessionError } from "../internal/harness.js";
+import { readMember, thrownIs } from "./thrown-value.js";
 export function isSessionConflict(err) {
-    return err instanceof SessionError && err.code === "conflict";
+    return thrownIs(err, SessionError) && readMember(err, "code") === "conflict";
 }
 export function hasSessionFork(store) {
     return typeof store.fork === "function";

package/dist/core/task-event.d.ts

@@ -592,16 +592,23 @@ export type TaskEvent = ({
     type: "compacted";
     trigger: "auto" | "manual" | "forced";
     tokensBefore: number;
-    /** TB telemetry B4: post-compaction context size in the TRIGGER-GATE coordinate
-     *  (`postTriggerTokens` = estimate + anchor-less overhead). Pairs with {@link triggerTokensBefore}
-     *  — NOT with `tokensBefore` (which is the CC `pre_tokens` value in prepareCompaction's coordinate,
-     *  lacking the overhead term; subtracting across the two coordinates would mis-state the delta,
-     *  the audit-B-1 / P-13 class). Absent when the post measurement failed (best-effort, never fails a
-     *  successful compaction). */
+    /** How much context this compaction FREED, as the engine measured it: one structural sum over
+     *  the pre-messages minus the same sum over the post-messages, inside the pass. **The only
+     *  subtractable number on this event**, and what a context meter should render. Clamped ≥ 0 at
+     *  the mint, so `0` means "freed nothing", never "could not tell". Absent ⇒ the post
+     *  measurement failed and no delta exists — never a stand-in. */
+    freedTokens?: number;
+    /** DIAGNOSTIC, NOT subtractable. Post-compaction size in the TRIGGER-GATE coordinate
+     *  (structural estimate + the fixed prompt overhead). {@link triggerTokensBefore} is not its
+     *  matching pre-value: the gate reads a usage-ANCHORED figure whenever the provider's last
+     *  usage is fresh, while this is always structural + overhead, so the difference mixes
+     *  coordinates and goes NEGATIVE on ordinary auto passes (3037 − 4591 = −1554, measured on a
+     *  4k window). Use {@link freedTokens}. Absent when the post measurement failed. */
     tokensAfter?: number;
-    /** TB telemetry B4: pre-compaction size in the SAME trigger-gate coordinate as {@link tokensAfter}
-     *  (`triggerTokens` — the exact quantity the compaction gate compared). `triggerTokensBefore −
-     *  tokensAfter` is the self-consistent freed delta. Absent on the legacy emitter. */
+    /** DIAGNOSTIC, NOT subtractable. The quantity the gate compared against its threshold —
+     *  usage-anchored when the anchor is fresh, structural + overhead when it is not. It answers
+     *  WHAT tripped the trigger, a different question from how much was freed; left un-clamped and
+     *  un-paired rather than made to look subtractable. Absent on the legacy emitter. */
     triggerTokensBefore?: number;
     /** TB telemetry B4: wall time of the whole compaction pass (summary call included) — what the
      *  boundary pause actually cost. Absent on legacy emitters. */
@@ -823,6 +830,9 @@ export type TaskEvent = ({
      * Live/ephemeral — NOT persisted (a resumable trace re-derives usage from the result), like `status`.
      * Maps to CC `SDKTaskProgress` (camelCase here → snake_case `task_id`/`total_tokens`/`tool_uses`/`duration_ms`
      * at the SDK/service projection, the same convention as `toolCallId`→`tool_use_id`).
+     * `taskId` is the child RUN's id (`spec.taskId ?? sessionId`), NOT the registry handle: the
+     * background lanes launch with no explicit `spec.taskId`, so it equals the child's session id and
+     * hence its `transcriptId`. Both domains are tabled in `docs/INTEGRATION-CORE.md` §1.6a.
      */
     type: "task_progress";
     taskId: string;

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

@@ -227,6 +227,7 @@ export function formatWorkflowRun(run) {
                 : {}),
             ...(run.journalSkips !== undefined && run.journalSkips > 0 ? { journal_skipped: run.journalSkips } : {}),
             ...(run.status === "failed" && run.error ? { error: delimitUntrusted("workflow error", boundedRedactedSummary(run.error, 500)) } : {}),
+            ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
             ...(run.status === "completed" && run.result !== undefined
                 ? { result: delimitUntrusted("workflow result", run.resultFull ?? run.result) }
                 : {}),

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

@@ -1,18 +1,40 @@
+/**
+ * Is this an Error, including one minted in ANOTHER REALM?
+ *
+ * `instanceof` compares against THIS realm's `Error.prototype`, so a genuine `Error` minted outside it — by
+ * a script the engine ran through a deployment-supplied runner, or a duplicated module instance — fails and would be
+ * described as an anonymous object, losing the message that is the entire point of reporting it. The brand
+ * check is the realm-independent one: an object with the `[[ErrorData]]` internal slot answers `[object Error]`
+ * no matter where it was made, and a proxy forwards it. A plain object can forge the tag through
+ * `Symbol.toStringTag`, which costs nothing — the only thing this decides is whether we look for a `message`,
+ * and a forger that supplies a string message has told us what it wanted rendered anyway.
+ *
+ * Guarded, because both operations are attacker-reachable: `instanceof` walks a prototype chain a revoked
+ * proxy traps, and the tag is a getter that can throw.
+ */
+export declare function isErrorLike(value: unknown): boolean;
+/** `value instanceof ctor`, TOTAL — the class half of {@link readMember}'s rule. The prototype-chain walk
+ *  runs two proxy traps and a revoked proxy throws on both, while every caller tests a value someone else
+ *  threw inside the handler that decides how a failure settles. Unrecognizable is not that class, and
+ *  {@link isErrorLike} is this same rule for `Error`. */
+export declare function thrownIs<T>(value: unknown, ctor: abstract new (...args: never[]) => T): value is T;
+/** The NAME a thrown value carries (`Error.prototype.name` and its subclasses' overrides), read
+ *  realm-independently and guarded — `undefined` when the value is not error-like or its `name` is not a
+ *  string. Callers that compare against a name CONSTANT need exactly this: the comparison is on the WORD
+ *  precisely because the value crossed a seam, so binding the test to this realm's `Error.prototype`
+ *  defeats it. Whether an EMPTY name folds to `undefined` is policy and stays at the call site. */
+export declare function thrownName(err: unknown): string | undefined;
 /**
  * Turning a value that was THROWN at us into text — the ONE rule, for the whole engine.
  *
- * The idiom this replaces is `err instanceof Error ? err.message : String(err)` (and its template-literal
- * twin, `` `${err}` ``). Both spell a PARTIAL function on the non-Error arm: `String` calls the value's own
- * `toString` / `Symbol.toPrimitive`, so it throws on a value that has neither (a null-prototype object) and
- * on one whose own hook throws. The thrower is not ours — a deployment hook, a plugin callback, a model-
- * supplied tool body may reject with any value at all — so the rendering step was the one step that could
- * destroy the report it exists to produce. Where the render sat inside a promise rejection handler, the
- * resulting `TypeError` was an unhandled rejection and took the whole process down: a caller's choice of
- * rejection value decided whether the engine stayed alive.
+ * The idiom it replaces — `err instanceof Error ? err.message : String(err)` — is PARTIAL on its non-Error
+ * arm: `String` calls the value's own `toString` / `Symbol.toPrimitive`, so it throws on a value that has
+ * neither and on one whose hook throws. The thrower is not ours (a deployment hook, a plugin callback, a
+ * model-supplied tool body may reject with anything), so the rendering step was the one step that could
+ * destroy the report it exists to produce — and inside a promise rejection handler it took the process down.
  *
- * Totality is therefore the contract, and it is met the same way the engine's structural describer already
- * meets it: the value is never asked to say what it is. Three arms, in this order, chosen so that the
- * dominant shapes keep their EXACT previous bytes and only the shapes that used to be useless or fatal move:
+ * TOTALITY is therefore the contract, met the way the structural describer meets it: the value is never
+ * asked to say what it is. Three arms, ordered so the dominant shapes keep their EXACT previous bytes:
  *  - a thrown STRING is its own message (a bare `throw "…"`), returned verbatim — the describer would quote
  *    it, which is right when rejecting a config value and wrong when relaying a message someone threw;
  *  - an ERROR hands over `message` verbatim — no cap, no one-lining, no quoting. This is the arm nearly all
@@ -75,5 +97,24 @@ export declare function asThrownError(err: unknown): Error;
  * is `undefined` for BOTH "absent" and "unreadable" — deliberately, because a caller that must tell those
  * apart is asking a question an untrusted value is not obliged to answer; what it does instead is fall back
  * to describing the value, which {@link thrownText} already does totally.
+ *
+ * The read walks the PROTOTYPE CHAIN deliberately — `name` lives on `Error.prototype`. `"__proto__"` is
+ * the one key where that differs from an own read, and its only caller is {@link readOwnMembers}, which
+ * passes it only when it IS an own key (a data property shadows the accessor; both readings agree).
  */
 export declare function readMember(value: unknown, key: string): unknown;
+/** The PLURAL of {@link readMember}: read a value's own enumerable members, once each, into an inert
+ *  snapshot — for sites that want a COPY of a whole bag an untrusted value handed over (a thrown
+ *  error's `details` mark, on its way onto a tool result). The idiom it replaces is `{ ...value }`,
+ *  a second way of running the value's code: the spread asks for its own keys and evaluates every
+ *  getter behind them, so one hostile member took the copy down with it, and a revoked proxy traps the
+ *  enumeration itself (even `Array.isArray` on one throws). Non-objects, arrays (spreading one yields
+ *  index keys) and anything whose keys cannot be enumerated answer `undefined` — "there is no bag
+ *  here"; a member that refuses to be read comes back `undefined` in a PRESENT key. */
+export declare function readOwnMembers(value: unknown): Record<string, unknown> | undefined;
+/** The MACHINE-READABLE marks a thrown value carries (`details`, with a string `errorKind` folded in) —
+ *  the one extractor for both legs that lift them onto a tool result. The live leg and the resume leg
+ *  each had their own copy, and the resume copy still spread the bag and called `Array.isArray` on it,
+ *  so a hostile `details` failed the whole leg where the live one had stopped losing anything but the
+ *  mark. `undefined` = nothing to carry; a caller that must always present a bag folds that itself. */
+export declare function thrownMarksOf(err: unknown): Record<string, unknown> | undefined;

package/dist/core/thrown-value.js

@@ -1,5 +1,5 @@
 import { describeRejectedValue } from "./tool-search-setting.js";
-function isErrorLike(value) {
+export function isErrorLike(value) {
     try {
         if (value instanceof Error)
             return true;
@@ -9,6 +9,18 @@ function isErrorLike(value) {
         return false;
     }
 }
+export function thrownIs(value, ctor) {
+    try {
+        return value instanceof ctor;
+    }
+    catch {
+        return false;
+    }
+}
+export function thrownName(err) {
+    const name = isErrorLike(err) ? readMember(err, "name") : undefined;
+    return typeof name === "string" ? name : undefined;
+}
 export function thrownText(err) {
     try {
         if (typeof err === "string")
@@ -54,3 +66,25 @@ export function readMember(value, key) {
         return undefined;
     }
 }
+export function readOwnMembers(value) {
+    let keys;
+    try {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        keys = Object.keys(value);
+    }
+    catch {
+        return undefined;
+    }
+    const out = {};
+    for (const key of keys)
+        Object.defineProperty(out, key, { value: readMember(value, key), enumerable: true, writable: true, configurable: true });
+    return out;
+}
+export function thrownMarksOf(err) {
+    const details = readOwnMembers(readMember(err, "details"));
+    const errorKind = readMember(err, "errorKind");
+    if (typeof errorKind !== "string")
+        return details;
+    return { ...(details ?? {}), errorKind };
+}