@sema-agent/core 5.45.0 → 5.47.0

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

@@ -26,6 +26,7 @@ import { findAdmittingRule, suggestRulesForCommand } from "../permission-rule-mo
 import { ActiveSkillScope, createActiveSkillScopePolicy } from "./active-skill-scope.js";
 import { CHANGED_FILES_MTIME_EPS_MS, fenceMcpServerInstructions, renderAgentListingDelta } from "./turn-attachments.js";
 import { inlineUntrusted } from "../untrusted-text.js";
+import { isValidReminderMark, mintReminderMark, reminderMarkDeclaration } from "../reminder-mint.js";
 import { policyAskClassOf } from "../ask-class.js";
 import { emitTrace } from "../trace.js";
 import { createSessionRulePolicy, PATH_CONFINABLE_WRITE_TOOLS } from "./session-rule-policy.js";
@@ -46,9 +47,10 @@ import { TOOL_SEARCH_NAME, buildDeferredRegistry, classifyDeferred, extractDisco
 import { createSharedMemoryTools } from "../shared-memory/tools.js";
 import { SHARED_MEMORY_TOOL_NAMES } from "../shared-memory/types.js";
 import { MEMORY_ENGINE_TOOL_NAMES } from "../memory-engine/tools.js";
-import { MEMORY_RECALL_DISCIPLINE } from "../memory-engine/engine.js";
+import { memoryRecallDisciplineSegment } from "../memory-engine/engine.js";
 import { classifyToolContentOrigin, contentOriginPollutes, delegationCallIsExternal } from "../memory-engine/content-origin.js";
 import { narrowContentSafety, readCardAttestation } from "../memory-engine/delegation-provenance.js";
+import { recordSyncUnattestable, sessionSettlements } from "../memory-engine/delegation-settlement.js";
 import { composeMemoryBlock } from "../memory.js";
 import { COMPLIANCE_CAPABILITIES, WEB_FETCH_TOOL_NAME, complianceCallDenial, resolveComplianceDenies } from "../compliance.js";
 import { foldAdmissionFreeze } from "../memory-admission.js";
@@ -333,7 +335,7 @@ function cwdConflictsRestoreError(requestedCwd) {
 export async function prepareTask(spec, deps, sessions, resume, internals, runnerSelf) {
     const doors = prepareConfigDoors({ spec, deps, sessions, resume, internals });
     spec = doors.spec;
-    const { toolFaceSnapshot, promptProfile, lockedPreflight, resolvedInteractionPosture, resolvedRole, model, thinking, compModel, fableMitigations, memoryDelegationEvidence, usageWindows, brainCallGuardrailRef, brainCallGuardrailMs } = doors;
+    const { toolFaceSnapshot, promptProfile, lockedPreflight, resolvedInteractionPosture, resolvedRole, model, thinking, compModel, fableMitigations, memoryDelegationEvidence, memoryProvenance, usageWindows, brainCallGuardrailRef, brainCallGuardrailMs } = doors;
     announceToolModelGate(deps.onNotice, model.id, doors.modelGate);
     const { toolEffects, egressTools, irreversibleTools, irreversibilityTier, axisExplicitNegatives, reversibilityProbes, ownToolNames } = prepareSafetyScan({ spec, deps });
     let shellGatedBash = false;
@@ -351,6 +353,30 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     const taskScope = internals?.registryScope ?? spec.principal ?? "default";
     internals?.peerSelfRef?.addAxis("s", sessionId);
     internals?.peerSelfRef?.addAxis("t", hostTaskId);
+    const sessionReminderMark = await (async () => {
+        try {
+            return await session.getReminderMark();
+        }
+        catch (err) {
+            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            return undefined;
+        }
+    })();
+    const reminderMark = isValidReminderMark(resume?.seed.reminderMark)
+        ? resume.seed.reminderMark
+        : isValidReminderMark(internals?.reminderMark)
+            ? internals.reminderMark
+            : isValidReminderMark(sessionReminderMark)
+                ? sessionReminderMark
+                : mintReminderMark();
+    if (reminderMark !== sessionReminderMark) {
+        try {
+            await session.appendReminderMark(reminderMark);
+        }
+        catch (err) {
+            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+        }
+    }
     const offloadScope = spec.principal ?? "default";
     if (internals?.registryScope !== undefined && internals.registryScope !== offloadScope) {
         deps.onError?.(new Error(`offload/tool-result namespace note: this run mounts in registry domain "${internals.registryScope}" but its offloaded tool results live under the TRUST identity "${offloadScope}" (principal${spec.principal === undefined ? " absent → default" : ""}). Before 2.13.0 the registry domain named this namespace too; if a deployment used registryScope as its ref-tenancy boundary, that boundary is now the principal — pass one, or read refs under "${offloadScope}".`), { phase: "config", sessionId });
@@ -708,6 +734,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const frozenOnQuestion = spec.onQuestion ?? deps.onQuestion;
         const provenanceForChildrenRef = {};
         const delegationProvenanceForChildren = () => provenanceForChildrenRef.current;
+        const delegationSettlementRef = {};
+        const delegationSettlementForChildren = () => delegationSettlementRef.current;
         const inheritedGateForChildren = () => {
             const ancestorRules = [
                 ...(inheritedAncestorRules ?? []),
@@ -797,11 +825,13 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             ...(spec.memoryPersistenceCapable !== undefined ? { memoryPersistenceCapable: spec.memoryPersistenceCapable } : {}),
             getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
             parentCwd: taskRootFinal,
+            reminderMark,
             ...(centerAdoption !== undefined ? { centerArtifactDigest: centerAdoption.artifact.artifactDigest } : {}),
             ...(centerAdoption?.sourceRevision !== undefined ? { centerSourceRevision: centerAdoption.sourceRevision } : {}),
             activeSkillScope: () => skillScope.active(),
             inheritedGateForChildren,
             delegationProvenanceForChildren,
+            delegationSettlement: delegationSettlementForChildren,
             ...(autoModeDecider ? { autoModeReview: { decider: autoModeDecider } } : {}),
             ...(spec.durableApproval !== undefined ? { durableApprovalForChildren: { ...spec.durableApproval } } : {}),
             ...(spec.checkpointStore === null ? { checkpointStoreDisabledForChildren: true } : {}),
@@ -983,6 +1013,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 sourceTaskId: hostTaskId,
                 parentModel: () => harnessRef.current?.getModel(),
                 ...(spec.getApiKeyAndHeaders !== undefined ? { parentGetApiKeyAndHeaders: spec.getApiKeyAndHeaders } : {}),
+                ...(frozenOnAsk !== undefined ? { parentOnAsk: frozenOnAsk } : {}),
                 principal: spec.principal,
                 oneShot: spec.oneShot,
                 ...(resolvedInteractionPosture !== undefined ? { parentInteractionPosture: resolvedInteractionPosture } : {}),
@@ -1198,7 +1229,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         foldProtocolAxes(a2a.toolAxes, "A2A");
         const callIssuedAtRef = {};
         const memoryWriteGateRef = {};
-        const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGateRef, firstPartyOffload, tools, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes };
+        const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGateRef, firstPartyOffload, tools, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes, reminderMark };
         const handsReadFace = handsEnabled ? await prepareHandsMount(handsReadFaceInput) : resolveHandsLessReadFace(handsReadFaceInput);
         const { readFileStateForCheckpoint, seedContextFiles, handsCwdRef, workspaceStateSettle, wsSnapshot, rebaseWsPath, backgroundTaskToolsActive, additionalRootsCanonical, additionalReadRootsCanonical, attachmentRootCanonical, readDenyMatcher } = handsReadFace;
         resolvedReadFace = handsReadFace.resolvedReadFace;
@@ -1439,9 +1470,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             sessionId,
             taskRootPath: taskRootFinal,
             memoryWriteGateRef,
+            reminderMark,
             writeToolsMounted: tools.some((t) => t.name === "Write") &&
                 !(toolFaceSnapshot.exclude?.includes("Write") ?? false) &&
                 !(handsEnabled && isRemoteExecutionEnv(executionEnv) && spec.memoryPersistenceCapable !== true),
+            memoryProvenance,
             memoryPersistenceDeclared: spec.memoryPersistenceCapable,
             rosterCanPersist: spec.memoryPersistenceCapable ??
                 tools.some((t) => {
@@ -1644,6 +1677,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             policyEnabled: promptPolicyEnabled,
             hooksEnabled: promptHooksEnabled,
             isolationEnabled: isIsolated(executionEnv),
+            reminderMark,
             readFaceOpen: resolvedReadFace === "open",
             orchestrationEnabled: selfOrchestrationActive,
             orchestrationDeferred: selfOrchestrationActive && (toolFaceSnapshot.defer?.includes("Workflow") ?? false),
@@ -1833,12 +1867,13 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 if (memoryEnginePair.length > 0) {
                     memoryEnginePairMounted = false;
                     if (memoryBlock !== undefined) {
-                        if (memoryBlock === MEMORY_RECALL_DISCIPLINE)
+                        const segment = memoryRecallDisciplineSegment(memoryProvenance);
+                        if (memoryBlock === segment)
                             memoryBlock = undefined;
-                        else if (memoryBlock.includes(`\n\n${MEMORY_RECALL_DISCIPLINE}`))
-                            memoryBlock = memoryBlock.replace(`\n\n${MEMORY_RECALL_DISCIPLINE}`, "");
-                        else if (memoryBlock.startsWith(`${MEMORY_RECALL_DISCIPLINE}\n\n`))
-                            memoryBlock = memoryBlock.slice(MEMORY_RECALL_DISCIPLINE.length + 2);
+                        else if (memoryBlock.includes(`\n\n${segment}`))
+                            memoryBlock = memoryBlock.replace(`\n\n${segment}`, "");
+                        else if (memoryBlock.startsWith(`${segment}\n\n`))
+                            memoryBlock = memoryBlock.slice(segment.length + 2);
                     }
                     deps.onError?.(new Error(`Memory tools ${MEMORY_ENGINE_TOOL_NAMES.join("/")} were NOT mounted: mounting them would inject ` +
                         `the "${TOOL_SEARCH_NAME}" tool, whose name this task already declares — the pair mounts together or not at all.`), { phase: "config", sessionId, classification: "memory-tools-not-mounted" });
@@ -1861,6 +1896,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             const trustedTools = effectiveSafety.trustedTools;
             const execIsExternalContent = effectiveSafety.execIsExternalContent;
             provenanceForChildrenRef.current = { trustedTools: [...trustedTools], execIsExternalContent };
+            if (memoryEngineSession?.settlement !== undefined) {
+                delegationSettlementRef.current = { controlDir: memoryEngineSession.settlement.controlDir, sessionId: memoryEngineSession.settlement.sessionId };
+            }
             const recordExternal = () => {
                 if (delegationProvenanceChannel !== undefined)
                     delegationProvenanceChannel.ref.current.sawExternal = true;
@@ -1890,6 +1928,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 isCallerTool: true,
                 trusted: trustedTools.has(t.name),
             }), execIsExternalContent);
+            const recallTaintJudge = memoryEngineSession?.recallTaint?.judgeDeliveredPath;
             contentOriginWrapRef.current = () => {
                 for (let i = 0; i < tools.length; i++) {
                     const t = tools[i];
@@ -1899,14 +1938,15 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     const delegation = delegationByName.get(t.name);
                     const isDelegation = delegation !== undefined;
                     const pollutes = contentOriginPollutes(origin, execIsExternalContent);
-                    if (!pollutes && !isDelegation) {
+                    const readsMemoryPlane = recallTaintJudge !== undefined && t.name === "Read";
+                    if (!pollutes && !isDelegation && !readsMemoryPlane) {
                         contentOriginWrapped.add(t);
                         continue;
                     }
                     const inner = t.execute.bind(t);
-                    const mark = (reason) => {
+                    const mark = (reason, cause) => {
                         try {
-                            pollution?.markPolluted(reason);
+                            pollution?.markPolluted(reason, cause);
                         }
                         catch {
                         }
@@ -1915,11 +1955,42 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         ...t,
                         execute: async (toolCallId, params, signal, onUpdate) => {
                             if (pollutes) {
-                                mark(`tool "${t.name}" (${origin} content class) was invoked in this session`);
+                                mark(`tool "${t.name}" (${origin} content class) was invoked in this session`, "observed");
                                 recordExternal();
                             }
-                            if (!isDelegation)
-                                return inner(toolCallId, params, signal, onUpdate);
+                            if (!isDelegation) {
+                                if (!readsMemoryPlane)
+                                    return inner(toolCallId, params, signal, onUpdate);
+                                const result = await inner(toolCallId, params, signal, onUpdate);
+                                const raw = result;
+                                const contentField = typeof raw === "object" && raw !== null ? raw.content : undefined;
+                                const headText = typeof raw === "string"
+                                    ? raw
+                                    : typeof contentField === "string"
+                                        ? contentField
+                                        : Array.isArray(contentField) && typeof contentField[0]?.text === "string"
+                                            ? contentField[0].text
+                                            : "";
+                                const delivered = result?.isError !== true &&
+                                    result?.details?.type !== "file_unchanged" &&
+                                    !headText.startsWith("<system-reminder");
+                                const fp = params?.file_path;
+                                if (delivered && typeof fp === "string" && recallTaintJudge(fp)) {
+                                    mark(`the "${t.name}" tool delivered the content of an external-origin memory entry file`, "derived");
+                                }
+                                return result;
+                            }
+                            let preCallLaunchRows;
+                            if (delegationEvidenceAttestedOnly && memoryEngineSession?.settlement !== undefined) {
+                                try {
+                                    preCallLaunchRows = new Set(sessionSettlements(memoryEngineSession.settlement.controlDir, memoryEngineSession.settlement.sessionId)
+                                        .filter((r) => r.row.lane === "background" && r.row.toolUseId === toolCallId)
+                                        .map((r) => r.row.settleId));
+                                }
+                                catch {
+                                    preCallLaunchRows = undefined;
+                                }
+                            }
                             const requested = params?.subagent_type;
                             const external = delegationCallIsExternal({
                                 requestedType: typeof requested === "string" ? requested : undefined,
@@ -1931,7 +2002,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             const att = readCardAttestation(result?.details);
                             if (att === "external") {
                                 mark(`tool "${t.name}" returned the output of a delegated agent that invoked an external-content-class tool at runtime` +
-                                    (typeof requested === "string" ? ` (subagent_type "${requested}")` : ""));
+                                    (typeof requested === "string" ? ` (subagent_type "${requested}")` : ""), "observed");
                                 recordExternal();
                             }
                             else if (att !== "clean") {
@@ -1939,9 +2010,38 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                     const staticFaceReason = `tool "${t.name}" returned the output of a delegated agent whose tool face can reach external content` +
                                         (typeof requested === "string" ? ` (subagent_type "${requested}")` : " (no subagent_type named — classified fail-closed)");
                                     if (!delegationEvidenceAttestedOnly) {
-                                        mark(staticFaceReason);
+                                        mark(staticFaceReason, "static");
                                     }
-                                    else if (pollution !== undefined && !staticMarkWaiverAnnounced) {
+                                    else {
+                                        const receiptDetails = result?.details;
+                                        const claimsLaunchReceipt = receiptDetails !== undefined && receiptDetails !== null && receiptDetails.status === "async_launched";
+                                        const claimedSettleId = claimsLaunchReceipt && typeof receiptDetails.settle_id === "string" ? receiptDetails.settle_id : undefined;
+                                        const settlementSeat = memoryEngineSession?.settlement;
+                                        let isLaunchReceipt = false;
+                                        if (claimsLaunchReceipt && settlementSeat !== undefined) {
+                                            try {
+                                                isLaunchReceipt =
+                                                    preCallLaunchRows !== undefined &&
+                                                        claimedSettleId !== undefined &&
+                                                        !preCallLaunchRows.has(claimedSettleId) &&
+                                                        sessionSettlements(settlementSeat.controlDir, settlementSeat.sessionId).some((r) => r.row.lane === "background" && r.row.settleId === claimedSettleId && r.row.toolUseId === toolCallId);
+                                            }
+                                            catch {
+                                                isLaunchReceipt = false;
+                                            }
+                                        }
+                                        if (!isLaunchReceipt && settlementSeat !== undefined) {
+                                            try {
+                                                recordSyncUnattestable(settlementSeat.controlDir, { sessionId: settlementSeat.sessionId, toolCallId, now: Date.now });
+                                            }
+                                            catch (err) {
+                                                const e = new Error(`delegated output withheld (fail-closed): the delegation delivered without a provable attestation and the settlement account could not record the fact (${err instanceof Error ? err.message : String(err)}) — repair the memory control plane or retry`);
+                                                e.code = "memory.settlement_record_failed";
+                                                throw e;
+                                            }
+                                        }
+                                    }
+                                    if (delegationEvidenceAttestedOnly && pollution !== undefined && !staticMarkWaiverAnnounced) {
                                         staticMarkWaiverAnnounced = true;
                                         const waivedReason = inlineUntrusted(staticFaceReason, 200);
                                         deliverEngineNotice(deps.onNotice, {
@@ -2043,6 +2143,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 centerAdoption = undefined;
         }
         let systemPrompt = assembled.systemPrompt;
+        if (!systemPrompt.includes(reminderMarkDeclaration(reminderMark))) {
+            deps.onError?.(new Error("reminder-mark declaration missing from the assembled system prompt: this run's PromptProvider owns the prompt and did not render the mark declaration, so engine <system-reminder> tags carry a mark the model is never told about (the impersonation defense is inactive for this deployment). Render `reminderMarkDeclaration(ctx.reminderMark)` (exported; the value rides StablePromptContext.reminderMark) in the provider, or accept the disclosure."), { phase: "config", sessionId });
+        }
         const renderWithDate = assembled.renderWithDate
             ? (date) => {
                 systemPrompt = assembled.renderWithDate(date);
@@ -3406,6 +3509,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 consolidationNotes: undefined,
                 readFileState: readFileStateForCheckpoint ? [...readFileStateForCheckpoint.entries()] : undefined,
                 readFace: faceCheckpointSection(),
+                reminderMark,
                 repairBundle: repairBundleForCheckpoint(parkedSpendMicroUsd),
                 workspaceHandle,
                 handsCwd: handsCwdRef?.current,
@@ -4069,7 +4173,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             if (notifyPermissionDenied) {
                                 await notifyPermissionDenied({ toolName: e.toolName, input: cloneObserverInput(e.input), toolCallId: e.toolCallId, reason: complianceDeny, source: "safety", identity: hookIdentity });
                             }
-                            return { block: true, reason: formatHookFeedback(complianceDeny), preToolContext: [] };
+                            return { block: true, reason: formatHookFeedback(complianceDeny, reminderMark), preToolContext: [] };
                         }
                     }
                     if (planModeRef.active && (toolEffects.get(e.toolName) ?? "write") !== "read") {
@@ -4082,7 +4186,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         }
                         return {
                             block: true,
-                            reason: formatHookFeedback(planDenyReason),
+                            reason: formatHookFeedback(planDenyReason, reminderMark),
                             preToolContext: [],
                         };
                     }
@@ -4092,6 +4196,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: spec.taskId ?? sessionId, site: f.site, message: f.error.message, ts: Date.now() })),
                             event: e,
                             identity: hookIdentity,
+                            reminderMark,
                             preToolUse: ownGatePreToolUse,
                             ...(hookEnvFace !== undefined ? { hookEnv: hookEnvFace } : {}),
                             adjudicate,
@@ -4208,7 +4313,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             details: clonedDetails,
                         }, { toolCallId: e.toolCallId, toolName: e.toolName, ...(hookEnvFace !== undefined ? { env: hookEnvFace } : {}), identity: hookIdentity });
                         if (patch?.additionalContext) {
-                            content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext) }];
+                            content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];
                             changed = true;
                         }
                     }
@@ -4220,14 +4325,14 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         changed = true;
                     }
                     if (patch?.additionalContext) {
-                        content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext) }];
+                        content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];
                         changed = true;
                     }
                 }
                 const pre = preToolContexts.get(e.toolCallId);
                 if (pre) {
                     preToolContexts.delete(e.toolCallId);
-                    content = [...content, ...pre.map((t) => ({ type: "text", text: formatHookFeedback(t) }))];
+                    content = [...content, ...pre.map((t) => ({ type: "text", text: formatHookFeedback(t, reminderMark) }))];
                     changed = true;
                 }
                 return changed ? { content } : undefined;
@@ -4501,7 +4606,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const effectiveReadFaceObserved = carrierReadFace();
         const effectiveReadDenyObserved = readDenyAdditionsNormalized.length > 0 ? readDenyAdditionsNormalized.map((e) => ({ ...e })) : undefined;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath: taskRootFinal, model, thinking, compModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, approvalSettlement, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, reminderMark, taskRootPath: taskRootFinal, model, thinking, compModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, approvalSettlement, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;