@sema-agent/core 7.17.0 → 7.17.2

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

@@ -1,7 +1,7 @@
-import { realpathSync } from "node:fs";
 import { resolve as resolveFsPath } from "node:path";
 import { AgentHarness, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, summaryOutputBudgetTokens } from "../../internal/harness.js";
 import { sanitizeCompactionSettings } from "../auto-compaction.js";
+import { physicalPathOf } from "../physical-path.js";
 import { projectStaleToolResults, resolveStaleToolResultOffload } from "./compaction-call-options.js";
 import { uuidv7 } from "../../engine/session/uuid.js";
 import { brainToRuntime } from "../runtime.js";
@@ -346,7 +346,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             else {
                 const canonical = (p, what) => {
                     try {
-                        return realpathSync.native(resolveFsPath(p));
+                        return physicalPathOf(resolveFsPath(p));
                     }
                     catch (err) {
                         return failIsolation(`cannot canonicalize ${what} (${err instanceof Error ? err.message : String(err)}) — an unverifiable path is treated as not isolated`);
@@ -690,16 +690,16 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 return undefined;
             });
         }
-        const { askLane } = prepareAskLane({ gateMachineryActive, abortController, effectivePolicy, budgetSnapshot, handsCwdRef, tools, inheritedUnavailableAsks, inheritedAskGrants, onAsk, humanReviewRef, now, ruleOffersOf, askSourceIdentity, riskAxesOf, autoModeDenialTracking, spec, deps, sessionId, runId, hooks, hookTimeoutMs, notifyOwnHookCrash });
+        const { askLane } = prepareAskLane({ gateMachineryActive, abortController, effectivePolicy, budgetSnapshot, handsCwdRef, advertisedWritableDirs, tools, inheritedUnavailableAsks, inheritedAskGrants, onAsk, humanReviewRef, now, ruleOffersOf, askSourceIdentity, riskAxesOf, autoModeDenialTracking, spec, deps, sessionId, runId, hooks, hookTimeoutMs, notifyOwnHookCrash });
         const { saga } = prepareSuspendSaga({ gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter });
         const { suspendForResource, suspendForPlatformLimit, suspendForReview } = prepareBoundaryParks({ saga, spec, checkpointStore, abortController, harness, session, sessions, sessionId, deps, priorLedger, maxSlices, maxSuspends, resourceTotal, priorSuspendCount, suspendChainBase, humanReviewRef, liveSpendRef, now, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, pausedRef, remoteEnvFailures, resourceSuspendEligible, durableSuspendInfraReady, incompleteSuspendAdapter });
-        const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, toolRosterDeltas: rosterSeat, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedTools, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, pausedRef });
+        const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, toolRosterDeltas: rosterSeat, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, advertisedWritableDirs, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedTools, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, pausedRef });
         prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, hooks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, gateOutcomes, batchHaltRef, blockedTracked, hookIdentity, reminderMark, planModeRef, hostTaskId, sessionId, ownGatePreToolUse, hookTimeoutMs, handsCwdRef, hookEnvFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash });
         const { microCompact, charsPerToken } = prepareContextLane({ model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef });
         const preparedHolder = {};
         const { cacheBreakDetector, cacheFingerprint, promptOverheadTokens, readTaskFile, normalizeAttachmentPath, isDedupStubResult, recentlyReadFiles, onCompactionApplied, detectExternalChanges, listBackgroundTasks, centerCompactionCandidate, effectiveReadFaceObserved, effectiveReadDenyObserved } = prepareTurnWiring({ deps, systemPromptSeat, harnessTools, fpRef, model, epochArtifactDigestForSnapshot, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, additionalRootsCanonical, additionalReadRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, abortController, hostTaskId, taskScope, buildAssembleInputs, centerAdoptionRef, harnessRef, epochDeclaredSections, carrierReadFace, readDenyAdditionsNormalized, preparedHolder });
         await onceLedger.settle(session, announcedListingsRef);
-        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(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, pausedRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(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, pausedRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         rollback.commit();
         const prepared = buildPrepared();
         preparedHolder.current = prepared;

package/dist/core/runner/run-harness-handlers.js

@@ -287,7 +287,10 @@ export function createHarnessHandlers(input) {
             prepared.workCutRef.abortedBeforeTurnEnd = true;
         const stopExtra = rs.turn.turnStopReason !== undefined ? { stopReason: rs.turn.turnStopReason } : {};
         const usage = rs.turn.turnUsage ?? { inputTokens: 0, totalInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costMicroUsd: 0 };
-        queue.push({ type: "turn_end", usage, ...(rs.turn.turnUsage === undefined || rs.turn.turnUsageMissing ? { usageMissing: true } : {}), ...stopExtra, ...ident() });
+        const turnUsageUnknown = rs.turn.turnUsage === undefined || rs.turn.turnUsageMissing;
+        if (turnUsageUnknown)
+            stats.usageMissing = true;
+        queue.push({ type: "turn_end", usage, ...(turnUsageUnknown ? { usageMissing: true } : {}), ...stopExtra, ...ident() });
         rs.turn.turnUsageMissing = false;
         rs.turn.turnStopReason = undefined;
         if (parentToolCallId !== undefined) {

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

@@ -10,7 +10,7 @@ import { applyPersistedTightening, disclosedRuleSet } from "../persisted-rule-ar
 import { computeCostMicroUsd } from "../pricing.js";
 import { mintSystemReminder } from "../reminder-mint.js";
 import { hasDestroy } from "../remote-env.js";
-import { refuseOutOfContractDecision } from "../tool-policy.js";
+import { advertisedWritableRootsSeat, refuseOutOfContractDecision } from "../tool-policy.js";
 import { callFaceSeat, judgeParkedToolIdentity, rosterEntryNamed, toolCallFaceOf } from "../tool-roster.js";
 import { deliverEngineNotice } from "../types.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
@@ -571,6 +571,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
             toolCallId: pendingAction.toolCallId,
             budget: beltBudget,
             ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+            ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs),
             ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
         }, prepared.abortController.signal));
         const beltUnsafe = rechecked.action === "deny" ||
@@ -632,6 +633,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
             ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
             budget: beltBudget,
             ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+            ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs),
         }, prepared.abortController.signal));
         if (narrowed.action === "deny") {
             const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`, prepared.reminderMark);
@@ -651,6 +653,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
             ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
             budget: beltBudget,
             ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+            ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs),
         }))
             .then((answer) => normalizePersistedRuleHit(answer)), unreadable, { signal: prepared.abortController.signal, timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS });
         const tightened = applyPersistedTightening({ action: "allow" }, read);

package/dist/core/sensitive-path-policy.js

@@ -104,14 +104,13 @@ export function createSensitivePathPolicy(opts) {
                 return { action: "allow" };
             const canon = await canonicalizeTarget(opts.env, path, signal, pathFamilyOf({ root: opts.rootPath, cwd: req.cwd ?? opts.env.cwd }), pathTargetBaseOf(protective, { root: opts.rootPath, cwd: req.cwd }));
             if (!canon.ok) {
-                if (canon.unresolvedSymlink) {
-                    return {
-                        action: "deny",
-                        message: `write to "${path}" is blocked: it is a symlink whose real target could not be resolved (it could point onto a guarded sensitive path)`,
-                        decisionReason: "safety",
-                    };
-                }
-                return { action: "allow" };
+                return {
+                    action: "deny",
+                    message: canon.unresolvedSymlink
+                        ? `write to "${path}" is blocked: it is a symlink whose real target could not be resolved (it could point onto a guarded sensitive path)`
+                        : `write to "${path}" is blocked: its target could not be resolved on this tree (${canon.refused ?? canon.message}), so the sensitive-path guard cannot judge it`,
+                    decisionReason: "safety",
+                };
             }
             let relative = null;
             for (const rootKey of await dataRootKeys(signal)) {

package/dist/core/skills-directory.js

@@ -1,5 +1,6 @@
-import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
+import { physicalPathOf } from "./physical-path.js";
 import { isSkillSpecifierEnforced, parseSkillToolEntry } from "./skill-tool-specifier.js";
 const SKILL_FILE = "SKILL.md";
 const RESOURCE_DIRS = ["assets", "references", "scripts"];
@@ -200,7 +201,7 @@ function resolveInsideSkill(abs, rel, walk) {
     let real;
     let stats;
     try {
-        real = realpathSync(abs);
+        real = physicalPathOf(abs);
         stats = statSync(abs);
     }
     catch (err) {
@@ -220,7 +221,7 @@ function resolveInsideSkill(abs, rel, walk) {
 function readAttachments(skillDir, skillName, budgetBytes, warn) {
     let realRoot;
     try {
-        realRoot = realpathSync(skillDir);
+        realRoot = physicalPathOf(skillDir);
     }
     catch (err) {
         warn({ code: "read_failed", skill: skillName, detail: `the skill directory could not be resolved (${errText(err)}) — attachments skipped` });

package/dist/core/spec-contract.js

@@ -1,7 +1,8 @@
 import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { lstatSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { lstatSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
+import { physicalPathOf } from "./physical-path.js";
 const DEFAULT_GATE_TIMEOUT_MS = 60_000;
 const GATE_MAX_BUFFER = 16 * 1024 * 1024;
 const OUTPUT_TAIL_CHARS = 1500;
@@ -139,8 +140,8 @@ export async function runOracle(gates, cwdRoot, opts) {
                 continue;
             }
             try {
-                const physRoot = realpathSync(root);
-                const phys = realpathSync(candidate);
+                const physRoot = physicalPathOf(root);
+                const phys = physicalPathOf(candidate);
                 if (phys !== physRoot && !phys.startsWith(physRoot + sep)) {
                     results.push(err(gate, `gate cwd physically escapes the spec root (symlink): ${gate.cwd}`));
                     continue;
@@ -247,7 +248,7 @@ function restoreOneAtomic(p, bytes) {
 }
 function safeRealpath(p) {
     try {
-        return realpathSync(p);
+        return physicalPathOf(p);
     }
     catch {
         return undefined;

package/dist/core/task-registry-shared.d.ts

@@ -40,7 +40,11 @@ export interface UnifiedTaskOutput {
     code?: string;
     /** RB-386② — machine-readable failure code on a FAILED background_agent row's poll
      *  details (the child's TaskResult.errorCode taxonomy — brain codes / `limit.*` / `budget.*` …).
-     *  Additive; absent on non-failed rows, on rows whose failure carried no code, and on other lanes. */
+     *  Additive; absent on non-failed rows, on rows whose failure carried no code, and on other lanes.
+     *  The same key also carries a failed WORKFLOW run's `WorkflowRun.errorCode` (
+     *  `workflow.*` for the orchestration's own refusals / a failed child's terminal code), populated
+     *  by `formatWorkflowRun`: one field name for "why this poll answer is a failure", whichever lane
+     *  minted the failure. */
     errorCode?: string;
     /** RB-386② — retryability verdict for a FAILED background_agent row, derived at settle time by the
      *  same classifier the sync sub-agent report's `error_kind (retryable: …)` line uses. Additive. */

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

@@ -259,6 +259,7 @@ export function formatWorkflowRun(run) {
             status: run.status,
             retrieval_status: "success",
             ...(run.completionId !== undefined ? { completionId: run.completionId } : {}),
+            ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
             details: summary,
         },
     };

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

@@ -165,7 +165,7 @@ export function toolFace(id) {
     const e = byId.get(id);
     if (e === undefined)
         throw new Error(`tool catalog: no definition ${JSON.stringify(id)}`);
-    return structuredClone(e.face);
+    return { contentOrigin: "local", ...structuredClone(e.face) };
 }
 function deepFreeze(value) {
     if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {

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

@@ -58,6 +58,30 @@ export interface ToolCallRequest {
      * window — at that declaration, not here.
      */
     cwd?: string;
+    /**
+     * The CANONICAL directories THIS RUN'S PROMPT ADVERTISES AS WRITABLE — the admitted list of the root
+     * fence's advertised-writable-directory seat (the memory engine's write home, the deployment's
+     * scratchpad), in admission order, deduplicated. Stamped by the Runner on every policy adjudication of
+     * the run, read live at adjudication time (a directory admitted by a later phase is on the list the
+     * next call carries).
+     *
+     * WHY IT EXISTS: the fence and the write gate were judging one fact twice. The prompt tells the model
+     * "write to it directly with the Write tool" and the fence opens the hole for exactly the directories
+     * this list names — but a deployment-authored write gate knew nothing of them, so every advertised
+     * write still asked (a memory entry plus its index = two questions the person was told would not be
+     * asked). Reading THIS field makes the gate's exemption domain the same list the fence admitted,
+     * instead of a second copy the deployment maintains by hand.
+     *
+     * A containment gate reads it EXACTLY as {@link import("./fs-write-gate-policy.js").FsWriteGatePolicyOptions.exemptDirs}:
+     * a covered write whose canonical target lands inside one of these directories is allowed and not
+     * asked. It grants nothing else — a DENY composed alongside (sensitive-path, an org rule) still
+     * outranks it under the deny > ask > allow fold, and an unresolvable target still fails closed.
+     *
+     * ABSENT outside a Runner, or when the run has no hands, or when nothing was advertised. Absence is NO
+     * exemption, never a wildcard (an empty list reads the same). Read-only — a policy cannot advertise a
+     * directory by writing one back.
+     */
+    advertisedWritableRoots?: readonly string[];
     /**
      * design/80 D-E-core: read-only per-run budget snapshot so a STATELESS policy can self-limit against
      * state that survives suspend/resume (a fresh in-memory counter would reset every leg — the supervisor
@@ -104,6 +128,23 @@ export interface ToolCallRequest {
 /** `read_only` (#619): the shell tool's command was PROVABLY read-only by the engine's transcribed upstream
  *  tables (`readOnlyShellVerdict`) and the allow layer let it run without a question — after every
  *  deny/ask lane and the person's own allow rules, never over a mandated ask. */
+/**
+ * Stamp {@link ToolCallRequest.advertisedWritableRoots} from the run's advertised-writable-directory seat
+ * — the ONE place the seat becomes a request field, so every adjudication station stamps it alike (the
+ * `callFaceSeat` shape).
+ *
+ * The list is COPIED AND FROZEN here, and that is load-bearing rather than tidy. The seat's `roots` getter
+ * hands back its own admission ledger, and {@link combinePolicies} walks every layer with ONE request
+ * object: a layer handed the live array could append to the very domain the write gate exempts, widening
+ * it for that call and for every later one. `readonly` is a compile-time word; this is the runtime one.
+ * (What a frozen array does not close is a layer REPLACING the whole field on the shared request — the
+ * pre-existing shape that `cwd`, `budget` and `face` live with; it belongs to the fold, not to this seat.)
+ */
+export declare function advertisedWritableRootsSeat(seat: {
+    readonly roots: readonly string[];
+} | undefined): {
+    advertisedWritableRoots?: readonly string[];
+};
 declare const DECISION_REASONS: readonly ["rule", "mode", "hook", "safety", "classifier", "persisted_rule", "sandbox", "org_rule", "org_unavailable", "read_only"];
 export type DecisionReason = (typeof DECISION_REASONS)[number];
 /** Carry every engine attestation (settlement, classifier cause) from a decision onto a reconstruction of it — the
@@ -1419,6 +1460,21 @@ export declare function durableMandateSourceOf(args: {
     durableApprovalDeclared: boolean;
     onAsk: OnAsk | undefined;
 }): DurableMandateSource | undefined;
+/**
+ * Has this leg DECLARED a durable park opt-in, from EITHER source (the per-principal
+ * entitlement or the task's own `durableApproval`) — with NO live-seat narrowing. Deliberately
+ * NOT {@link durableMandateSourceOf}: that one asks "is every ask MANDATED to gate durably" (a
+ * live approver seat beside a mere `durableApproval` opt-in defeats the mandate), while this one
+ * asks "does this leg have a durable park FACILITY at all" — the question-face mount decision and
+ * the inherited-mandate float both need the bare declaration, seat or no seat, and had each spelled
+ * `forceDurableGate === true || durableApprovalDeclared` by hand (two call sites, `prepare-
+ * question-face.ts` and `prepare-policy-chain.ts`, one drifting from the other silently if either
+ * grows a third source or a typo'd operator).
+ */
+export declare function durableParkOptInDeclared(args: {
+    forceDurableGate: boolean;
+    durableApprovalDeclared: boolean;
+}): boolean;
 /** EXACT structural clone for the approval boundary (alias isolation) — fail-closed, never lossy,
  *  never identity: a JSON round-trip would silently DROP unclonable members (presented ≠ executing =
  *  consent misrepresentation) and an identity fallback would hand the approver the live executing

package/dist/core/tool-policy.js

@@ -10,6 +10,9 @@ import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY } from "./unt
 import { isNamespacedCoveringRuleName, namespacedRuleNameCovers, parsePermissionRule } from "./permission-rules.js";
 import { protocolOf } from "./protocol-table.js";
 import { isAbsoluteForFamily, isAbsolutePathForm, joinForFamily, normalizeAbsPathLexically, pathFamilyOf, writeTargetPath } from "../tools/fs/safety.js";
+export function advertisedWritableRootsSeat(seat) {
+    return seat === undefined ? {} : { advertisedWritableRoots: Object.freeze([...seat.roots]) };
+}
 const DECISION_REASONS = ["rule", "mode", "hook", "safety", "classifier", "persisted_rule", "sandbox", "org_rule", "org_unavailable", "read_only"];
 const DECISION_REASON_SET = new Set(DECISION_REASONS);
 function settledByNobody(kind) {
@@ -914,6 +917,9 @@ export function durableMandateSourceOf(args) {
         return "durable_approval";
     return undefined;
 }
+export function durableParkOptInDeclared(args) {
+    return args.forceDurableGate || args.durableApprovalDeclared;
+}
 export function tryCloneArgs(v) {
     try {
         const value = structuredClone(v);

package/dist/engine/execution-env/node-execution-env.js

@@ -1,13 +1,14 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { closeSync, constants, createReadStream, mkdtempSync, openSync, readSync, statSync, truncateSync, unlinkSync } from "node:fs";
-import { access, appendFile, lstat, mkdir, mkdtemp, open, readdir, readFile, readlink, realpath, rename, rm, unlink, writeFile, } from "node:fs/promises";
+import { access, appendFile, lstat, mkdir, mkdtemp, open, readdir, readFile, readlink, rename, rm, unlink, writeFile, } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { ExecutionError, err, FileError, ok, toError, } from "../harness/types.js";
 import { killProcessTree, shutdownDebug } from "./kill-tree.js";
 import { scrubSecretEnv } from "../../core/secret-env.js";
+import { physicalPathOfAsync } from "../../core/physical-path.js";
 import { RollingTailBuffer, markTruncated, newStreamCursorState, sliceStreamIncrement, } from "../../core/exec-output-tail.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
 import { SchedulerError } from "../../core/scheduler.js";
@@ -802,7 +803,7 @@ export class NodeExecutionEnv {
                 let hop;
                 try {
                     const link = await readlink(resolved);
-                    const parentReal = await realpath(resolve(resolved, "..")).catch(() => resolve(resolved, ".."));
+                    const parentReal = await physicalPathOfAsync(resolve(resolved, "..")).catch(() => resolve(resolved, ".."));
                     hop = isAbsolute(link) ? link : resolve(parentReal, link);
                 }
                 catch {
@@ -1004,7 +1005,7 @@ export class NodeExecutionEnv {
     async canonicalPath(path) {
         const resolved = resolvePath(this.cwd, path);
         try {
-            return ok(await realpath(resolved));
+            return ok(await physicalPathOfAsync(resolved));
         }
         catch (error) {
             return err(toFileError(error, resolved));

package/dist/index.d.ts

@@ -83,6 +83,7 @@ export { getShellConfig, isWslBashLauncher } from "./engine/execution-env/node-e
 export { isSecretEnvKey, scrubSecretEnv } from "./core/secret-env.js";
 export type { SecretEnvFinding, SecretEnvFindingKind } from "./core/secret-env.js";
 export { MAX_EXEC_OUTPUT_BYTES, RollingTailBuffer, markTruncated } from "./core/exec-output-tail.js";
+export { physicalPathOf, physicalPathOfExisting } from "./core/physical-path.js";
 export type { ExecutionEnv, FileInfo, Result, FileErrorCode, ExecutionErrorCode, WriteExpectation, WriteReceipt } from "./internal/harness.js";
 export type { ExecResult } from "./internal/harness.js";
 export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, missingRestoreSurface, isRetryableRemoteErrorCode, RETRYABLE_REMOTE_ERROR_CODES, } from "./core/remote-env.js";

package/dist/index.js

@@ -68,6 +68,7 @@ export { killProcessTree, signalProcessTree } from "./engine/execution-env/kill-
 export { getShellConfig, isWslBashLauncher } from "./engine/execution-env/node-execution-env.js";
 export { isSecretEnvKey, scrubSecretEnv } from "./core/secret-env.js";
 export { MAX_EXEC_OUTPUT_BYTES, RollingTailBuffer, markTruncated } from "./core/exec-output-tail.js";
+export { physicalPathOf, physicalPathOfExisting } from "./core/physical-path.js";
 export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, missingRestoreSurface, isRetryableRemoteErrorCode, RETRYABLE_REMOTE_ERROR_CODES, } from "./core/remote-env.js";
 export { withRetry } from "./core/with-retry.js";
 export { addWorktree, pruneWorktrees, WORKTREE_PARENT } from "./core/git-worktree-env.js";

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

@@ -1,5 +1,6 @@
-import { mkdirSync, readFileSync, realpathSync, writeFileSync, existsSync } from "node:fs";
-import { basename, dirname, join, resolve, sep } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { physicalPathOfExisting } from "../core/physical-path.js";
 import { sanitizeScope } from "../stores/file/fs-atomic.js";
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -33,23 +34,6 @@ function safeFileStem(id) {
 function containedBy(root, p) {
     return p === root || p.startsWith(root + sep);
 }
-function canonicalizeDeepestExisting(p) {
-    let cur = p;
-    const missingTail = [];
-    for (;;) {
-        try {
-            const real = realpathSync(cur);
-            return missingTail.length === 0 ? real : join(real, ...[...missingTail].reverse());
-        }
-        catch {
-            const parent = dirname(cur);
-            if (parent === cur)
-                return undefined;
-            missingTail.push(basename(cur));
-            cur = parent;
-        }
-    }
-}
 export function createFileWorkflowScriptStore(dir) {
     const root = resolve(dir);
     const scopeDir = (scope) => join(root, sanitizeScope(scope));
@@ -71,17 +55,17 @@ export function createFileWorkflowScriptStore(dir) {
             if (!containedBy(base, full)) {
                 throw new Error(`workflow script store: scriptPath is outside this scope's script partition`);
             }
-            const physRoot = canonicalizeDeepestExisting(root);
-            const physBase = canonicalizeDeepestExisting(base);
-            const physFull = canonicalizeDeepestExisting(full);
+            const physRoot = physicalPathOfExisting(root);
+            const physBase = physicalPathOfExisting(base);
+            const physFull = physicalPathOfExisting(full);
             const refusePhysical = () => {
                 throw new Error(`workflow script store: scriptPath is outside this scope's script partition after symlink resolution`);
             };
-            if (physRoot !== undefined && physBase !== undefined && !containedBy(physRoot, physBase))
+            if (!containedBy(physRoot, physBase))
                 refusePhysical();
-            if (physBase !== undefined && physFull !== undefined && !containedBy(physBase, physFull))
+            if (!containedBy(physBase, physFull))
                 refusePhysical();
-            return readFileSync(physFull ?? full, "utf-8");
+            return readFileSync(physFull, "utf-8");
         },
         resolveName(name) {
             if (/^wf_/i.test(name))

package/dist/orchestration/workflow.js

@@ -460,6 +460,9 @@ export const workflowResumeClaimFallback = {
             table.delete(key);
     },
 };
+function parkLaneArmed(opts) {
+    return opts.store !== undefined && opts.checkpointStore !== undefined;
+}
 export function startWorkflow(runner, fn, opts = {}, internals) {
     const alsDepth = currentWorkflowDepth();
     const internalDepth = internals?.workflowDepth;
@@ -472,10 +475,10 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
     if (opts.resumeFromRunId !== undefined && opts.journalStore === undefined) {
         throw new Error("runWorkflow: resumeFromRunId requires a journalStore to load the prior run's journal");
     }
-    if (opts.checkpointStore !== undefined && opts.store === undefined) {
+    if (opts.checkpointStore !== undefined && !parkLaneArmed(opts)) {
         throw new WorkflowParkRefusal("workflow.park_requires_run_store", "runWorkflow: checkpointStore (the store this run's children park in) requires a WorkflowRunStore — a workflow child's park is recorded on its wa* row and proven against the checkpoint store at the next resume, and without a run store there is no durable row for a host to route the parked approval by", {});
     }
-    if (opts.defaultDurableApproval !== undefined && (opts.store === undefined || opts.checkpointStore === undefined)) {
+    if (opts.defaultDurableApproval !== undefined && !parkLaneArmed(opts)) {
         throw new WorkflowParkRefusal("workflow.park_requires_run_store", "runWorkflow: defaultDurableApproval requires a WorkflowRunStore and a checkpointStore — a workflow child's park is recorded on its wa* row and read back from the checkpoint store at the next resume; without both there is no durable row for a host to route the parked approval by, or no way for a resume to prove the park", {});
     }
     if (opts.parkedResume !== undefined && opts.resumeFromRunId === undefined) {
@@ -917,7 +920,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         const seat = s.checkpointStore;
         if (seat === undefined || seat === "disabled")
             return;
-        if (parkSeat === undefined) {
+        if (!parkLaneArmed(opts)) {
             throw new WorkflowParkRefusal("workflow.park_requires_run_store", "workflow agent: the child's checkpointStore would let it park where this workflow cannot read the park back — a workflow whose children can park needs a WorkflowRunStore and that checkpoint store as its read seat (RunWorkflowOptions.store + checkpointStore); wire both, or leave the child's seat unset.", {});
         }
         if (seat !== parkSeat) {

package/dist/stores/cc/task-list-store.js

@@ -2,21 +2,13 @@ import { readFileSync, readdirSync, mkdirSync, unlinkSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { assertJsonMetadata, normalizeTaskShape } from "../../tools/task-list.js";
 import { atomicWriteFile } from "../file/fs-atomic.js";
-import { realpathSync } from "node:fs";
-function realpathSyncSafe(p) {
-    try {
-        return realpathSync(p);
-    }
-    catch {
-        return p;
-    }
-}
+import { physicalPathOf } from "../../core/physical-path.js";
 import { withCcLock } from "./lockfile.js";
 export function createCcFileTaskListStore(listDir) {
     const dir = resolve(listDir);
     mkdirSync(dir, { recursive: true });
     const hwmPath = join(dir, ".highwatermark");
-    const lockTarget = realpathSyncSafe(dir);
+    const lockTarget = physicalPathOf(dir);
     const CC_TASK_ID_RE = /^[A-Za-z0-9_-]+$/;
     const validId = (id) => CC_TASK_ID_RE.test(id);
     const taskPath = (id) => {

package/dist/stores/file/fs-atomic.d.ts

@@ -11,10 +11,8 @@ export declare function sanitizePathComponent(raw: string): string;
  * on-disk dir name, never the stored data. Never `path.join` a raw scope.
  */
 export declare function sanitizeScope(scope: string): string;
-/**
- * Resolve the data root (CC `getClaudeConfigHomeDir` analog): `$AGENT_DATA_DIR ?? ~/.ai-agent`,
- * NFC-normalized, and `realpath`-canonicalized once the dir exists. Creates the dir (0o700) if absent.
- */
+/** Resolve the data root (CC `getClaudeConfigHomeDir` analog): `$AGENT_DATA_DIR ?? ~/.ai-agent`,
+ *  NFC-normalized, canonicalized once the dir exists. Creates the dir (0o700) if absent. */
 export declare function resolveDataRoot(explicit?: string): string;
 /** Ensure a directory exists with 0o700 perms (idempotent). */
 /**
@@ -59,25 +57,24 @@ export declare function readJsonlRecords<T>(path: string, onCorrupt?: (info: {
  * append (the checkpoint commit point ALWAYS fsyncs; session/memory cadence is the caller's `fsyncEvery`).
  */
 /**
- * RB-144 (2026-07-25, 按面收口): THE canonical key for "one authority per physical location".
- *
- * Every file backend keeps a module-level table so that N instances over one directory collapse into one
- * CAS authority. Getting the KEY wrong reopens the exact defect the table exists to close — and this repo
- * has now paid for that four separate times: RB-62 taught the mailbox to realpath, RB-101 taught the
- * session store, RB-119 added case folding there, and a defect hunt then found the agent store, the run store
- * and the task-list still keying on a lexical `resolve()` while two of them cite the mailbox as the
- * precedent they copied. Point fixes kept missing siblings, so the rule now lives in ONE place that all of
- * them call.
+ * RB-144: THE canonical key for "one authority per physical location". Every file backend keeps a
+ * module-level table so that N instances over one directory collapse into one CAS authority; getting the
+ * KEY wrong reopens the defect the table exists to close, which this repo paid for four times (mailbox,
+ * session store, then the agent/run/task-list stores still keying on a lexical `resolve()`). Point fixes
+ * kept missing siblings, so the rule lives in ONE place they all call.
  *
  * Two normalizations, each for a demonstrated failure:
- *  - REALPATH — a symlinked data dir (`/var` → `/private/var` on macOS, a container bind-mount, a linked
+ *  - PHYSICAL PATH — a symlinked data dir (`/var` → `/private/var` on macOS, a bind-mount, a linked
  *    `~/.ai-agent`) otherwise yields two authorities for one directory, and both writers win the CAS.
- *  - CASE FOLD — on a case-insensitive filesystem (macOS/Windows default) `Foo/` and `foo/` are the same
- *    directory; `realpath` does NOT fold case there, so realpath alone is not enough (measured).
+ *  - CASE FOLD — on a case-insensitive filesystem `Foo/` and `foo/` are the same directory. The mint
+ *    answers with the on-disk spelling, which folds the two only where the entry EXISTS; the fold here
+ *    also covers a not-yet-created tail, and folding a PATH would name a different directory on a
+ *    case-SENSITIVE volume (see the cc task-list store's lock target, which must not fold) — so it stays
+ *    at this call site, which keys, rather than inside the mint, which answers about paths.
  *
  * The key is used ONLY for table lookup — never for I/O, so the on-disk name stays verbatim. A path that
- * does not exist yet resolves through its parent directory; if even that fails, the lexical form is used
- * (a store must not fail to construct because canonicalization is unavailable).
+ * does not exist yet resolves through its deepest existing ancestor; a path with no resolvable ancestor at
+ * all keys on its lexical form (a store must not fail to construct because canonicalization is unavailable).
  */
 export declare function canonicalStoreKey(p: string): string;
 export declare class AppendLog {

package/dist/stores/file/fs-atomic.js

@@ -1,9 +1,10 @@
-import { closeSync, constants as FS, existsSync, fstatSync, linkSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, truncateSync, unlinkSync, writeFileSync, writeSync, fsyncSync, } from "node:fs";
+import { closeSync, constants as FS, existsSync, fstatSync, linkSync, mkdirSync, openSync, readFileSync, readSync, renameSync, truncateSync, unlinkSync, writeFileSync, writeSync, fsyncSync, } from "node:fs";
 import { homedir, hostname, uptime } from "node:os";
 import { hrtime } from "node:process";
 import { basename, dirname, join, resolve as resolvePath } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 import { execFileSync } from "node:child_process";
+import { physicalPathOf, physicalPathOfExisting } from "../../core/physical-path.js";
 const SAFE_COMPONENT = /^[A-Za-z0-9_.-]+$/;
 export function sanitizePathComponent(raw) {
     if (raw === "" || raw === "." || raw === ".." || !SAFE_COMPONENT.test(raw)) {
@@ -18,7 +19,7 @@ export function sanitizeScope(scope) {
 export function resolveDataRoot(explicit) {
     const raw = (explicit ?? process.env.AGENT_DATA_DIR ?? join(homedir(), ".ai-agent")).normalize("NFC");
     mkdirSync(raw, { recursive: true, mode: 0o700 });
-    return realpathSync(raw);
+    return physicalPathOf(raw);
 }
 export function writeThenLink(target, content) {
     ensureDir(dirnameOf(target));
@@ -134,18 +135,7 @@ export function readJsonlRecords(path, onCorrupt) {
     return out;
 }
 export function canonicalStoreKey(p) {
-    const abs = resolvePath(p);
-    try {
-        return realpathSync(abs).toLowerCase();
-    }
-    catch {
-        try {
-            return join(realpathSync(dirname(abs)), basename(abs)).toLowerCase();
-        }
-        catch {
-            return abs.toLowerCase();
-        }
-    }
+    return physicalPathOfExisting(p).toLowerCase();
 }
 export class AppendLog {
     fd;

package/dist/stores/file/mailbox-store.d.ts

@@ -81,17 +81,13 @@ export declare class FileMailboxStore implements MailboxStore {
     /**
      * The canonical mutex / shared-state key — instance-independent (X-5).
      *
-     * RB-162 (2026-07-26): this went through `realpath` (RB-62) but NOT the case fold (RB-67/RB-119), even
-     * though the module header above claims "the shared-state KEY goes through `canonicalStoreKey`, which
-     * also folds case". It did not — that name appeared exactly once in this file, inside that sentence.
-     * The handle component was folded by `boxPath`, but the ROOT was not: two spellings of the same
-     * directory on a case-insensitive filesystem produced two shared-state slots over one physical file, and
-     * each allocated its own `seq` — the very contract violation the realpath comment above describes,
-     * reached by the other half of the same canonicalization.
-     *
-     * Worse for the record: the enumerative guard written for this exact family tested
-     * `src.includes("canonicalStoreKey")`, which that one comment satisfied. The guard was green because the
-     * file talked about the rule.
+     * RB-162: this went through the physical path but NOT the case fold, even though the module header
+     * claimed otherwise. The handle component was folded by `boxPath` while the ROOT was not, so two
+     * spellings of one directory on a case-insensitive filesystem produced two shared-state slots over one
+     * physical file, each allocating its own `seq` — the same contract violation the RB-62 comment above
+     * describes, reached by the other half of the same canonicalization. The enumerative guard written for
+     * this family tested `src.includes("canonicalStoreKey")`, which the CLAIM satisfied: a guard that reads
+     * prose is green while the code diverges.
      */
     private lockKey;
     /**