agentfootprint 9.136.0 → 9.138.0

package/dist/core/Agent.js

@@ -44,7 +44,7 @@ const types_js_1 = require("../reliability/types.js");
 const extractSequence_js_1 = require("../security/extractSequence.js");
 const PolicyHaltError_js_1 = require("../security/PolicyHaltError.js");
 const CacheGateDecider_js_1 = require("../cache/CacheGateDecider.js");
-const strategyRegistry_js_1 = require("../cache/strategyRegistry.js");
+const cacheStrategyFor_js_1 = require("../cache/cacheStrategyFor.js");
 const skillBrains_js_1 = require("./agent/skillBrains.js");
 const conventions_js_1 = require("../conventions.js");
 const pause_js_1 = require("./pause.js");
@@ -140,6 +140,9 @@ const stepNudge_js_1 = require("./agent/stages/stepNudge.js");
 const evidenceRecheck_js_1 = require("./agent/stages/evidenceRecheck.js");
 const stagedRefs_js_1 = require("./agent/stagedRefs.js");
 const wrapUp_js_1 = require("./agent/stages/wrapUp.js");
+const failFastRecord_js_1 = require("../reliability/failFastRecord.js");
+const terminalVerdict_js_1 = require("./terminalVerdict.js");
+const breakFinal_js_1 = require("./agent/stages/breakFinal.js");
 const gate_js_1 = require("./agent/evidence/gate.js");
 const errors_js_2 = require("./agent/evidence/errors.js");
 const types_js_2 = require("../adapters/types.js");
@@ -160,10 +163,10 @@ const RunnerBase_js_1 = require("./RunnerBase.js");
 const validators_js_1 = require("./agent/validators.js");
 const route_js_1 = require("./agent/stages/route.js");
 const answerValidation_js_1 = require("./agent/stages/answerValidation.js");
+const messagePhase_js_1 = require("./agent/middleware/messagePhase.js");
 const answerCoverage_js_1 = require("./agent/stages/answerCoverage.js");
 const index_js_1 = require("../answer-validation/index.js");
 const seed_js_1 = require("./agent/stages/seed.js");
-const errors_js_3 = require("./agent/middleware/errors.js");
 const callLLM_js_1 = require("./agent/stages/callLLM.js");
 const toolCalls_js_1 = require("./agent/stages/toolCalls.js");
 const toolResolver_js_1 = require("./agent/stages/toolResolver.js");
@@ -180,7 +183,7 @@ const buildToolRegistry_js_1 = require("./agent/buildToolRegistry.js");
 const AgentBuilder_js_1 = require("./agent/AgentBuilder.js");
 Object.defineProperty(exports, "AgentBuilder", { enumerable: true, get: function () { return AgentBuilder_js_1.AgentBuilder; } });
 const buildThinkingSubflow_js_1 = require("./slots/buildThinkingSubflow.js");
-const registry_js_1 = require("../thinking/registry.js");
+const thinkingHandlerFor_js_1 = require("../thinking/thinkingHandlerFor.js");
 // Public types (AgentOptions, AgentInput, AgentOutput) extracted to
 // ./agent/types.ts and re-exported above (v2.11.1).
 // AgentState extracted to ./agent/types.ts (v2.11.1).
@@ -237,11 +240,9 @@ class Agent extends RunnerBase_js_1.RunnerBase {
      */
     cachingDisabledValue;
     /**
-     * Provider-specific CacheStrategy. Auto-resolved from
-     * `getDefaultCacheStrategy(provider.name)` at agent build time
-     * unless the consumer explicitly passes one via builder option.
-     * Phase 7+ implementations (Anthropic, OpenAI, Bedrock) register
-     * themselves in the strategyRegistry on import.
+     * The CacheStrategy this agent runs. Chosen at build time from the
+     * provider's declared `promptCaching` (`cacheStrategyFor`) unless the
+     * consumer passes one explicitly.
      */
     cacheStrategy;
     registry;
@@ -609,6 +610,10 @@ class Agent extends RunnerBase_js_1.RunnerBase {
      *  kept here rather than read back from the recording. Undefined after a run
      *  that failed or paused. */
     lastRunAnswer;
+    /** Whether any run on this instance got past input admission — so a
+     *  refused FIRST turn is reported as 'never-run', never as "continue from
+     *  your earlier accepted checkpoint" when there is none. */
+    hadAdmittedRun = false;
     /** The id the CONSUMER chose, or undefined when they took the default.
      *  `this.id` cannot answer that question — it is `'agent'` either way — and
      *  the stored-conversation fingerprint refuses only on ids somebody picked
@@ -666,8 +671,8 @@ class Agent extends RunnerBase_js_1.RunnerBase {
      */
     reliabilityConfig;
     /**
-     * Resolved ThinkingHandler (v2.14+). Auto-wired by `provider.name`
-     * via `findThinkingHandler` UNLESS the builder explicitly set one
+     * Resolved ThinkingHandler (v2.14+). The provider's DECLARED one
+     * (`thinkingHandlerFor`) UNLESS the builder explicitly set one
      * (or `null` to opt out). When undefined, the NormalizeThinking
      * sub-subflow is NOT mounted at chart build time — zero overhead
      * for non-thinking agents.
@@ -743,9 +748,11 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         this.systemPromptValue = systemPromptValue;
         this.systemPromptCachePolicy = systemPromptCachePolicy;
         this.cachingDisabledValue = cachingDisabled;
-        // Auto-resolve strategy from provider.name unless caller overrides.
-        // NoOp is the wildcard fallback so unknown providers stay safe.
-        this.cacheStrategy = cacheStrategy ?? (0, strategyRegistry_js_1.getDefaultCacheStrategy)(opts.provider.name);
+        // The strategy the provider's DECLARED prompt caching selects, unless the
+        // caller overrides it — never one looked up by `provider.name`, which a
+        // renaming decorator (`withRetry`, an app's own wrapper) rewrites. A
+        // provider that declares nothing gets the no-op strategy.
+        this.cacheStrategy = cacheStrategy ?? (0, cacheStrategyFor_js_1.cacheStrategyFor)(opts.provider);
         this.registry = registry;
         this.injections = injections;
         this.skillGraphNextSkill = skillGraphNextSkill;
@@ -1076,12 +1083,12 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         if (reliabilityConfig !== undefined)
             this.reliabilityConfig = reliabilityConfig;
         // v2.14 — Resolve thinking handler. Three states:
-        //   - thinkingHandlerValue === undefined → auto-wire by provider.name
+        //   - thinkingHandlerValue === undefined → the provider's DECLARED handler
         //   - thinkingHandlerValue === null      → opt out (no handler)
         //   - thinkingHandlerValue: ThinkingHandler → explicit override
-        // Auto-wire returns undefined for providers without a registered
-        // handler (gpt-4o, mistral, etc.), in which case the subflow is NOT
-        // mounted at chart build time.
+        // A provider that declares none gets no subflow at chart build time.
+        // Never chosen by `provider.name`: a renaming wrapper that forwards the
+        // declaration keeps it.
         if (thinkingHandlerValue === null) {
             // explicit opt-out
         }
@@ -1089,9 +1096,9 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             this.thinkingHandler = thinkingHandlerValue;
         }
         else {
-            const auto = (0, registry_js_1.findThinkingHandler)(opts.provider.name);
-            if (auto)
-                this.thinkingHandler = auto;
+            const declared = (0, thinkingHandlerFor_js_1.thinkingHandlerFor)(opts.provider);
+            if (declared)
+                this.thinkingHandler = declared;
         }
         if (thinkingBudgetValue !== undefined)
             this.thinkingBudget = thinkingBudgetValue;
@@ -1525,7 +1532,7 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         // starts — a run with no zone anywhere runs with its zone UNKNOWN (G15),
         // never on the server's zone.
         const clockDraft = this.clockDraftFor(runInput.time ?? options?.time, 'Agent.run');
-        const engineOptions = withoutTime(options);
+        const engineOptions = (0, RunnerBase_js_1.withRunSignalInEnv)(withoutTime(options));
         // Timing next, and before the executor exists: both of these refuse a call
         // that would have SUCCEEDED into corrupted per-instance state or an
         // orphaned human question. See ./conversation.ts for why they are throws.
@@ -1709,6 +1716,7 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             this.fileIntegrityDisposition();
             // Always released: a recording left subscribed would keep listening
             // through the next run and grow a tail nobody reads.
+            this.noteAdmittedRun();
             recording?.stop();
             stopTracking();
             this.inFlightRunId = undefined;
@@ -1759,12 +1767,12 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         // Refuse BEFORE the timing guards, so "there is nothing to follow up on"
         // is never reported as "a run is in flight" for an agent that has simply
         // not run yet.
-        if (this.getLastSnapshot() === undefined) {
+        if (this.getLastSnapshot() === undefined || (this.lastInputRefused() && !this.hadAdmittedRun)) {
             throw new conversation_js_1.NoConversationError('Agent.followUp', 'never-run');
         }
         const conversation = this.checkpoint();
         if (conversation === undefined || conversation.history.length === 0) {
-            throw new conversation_js_1.NoConversationError('Agent.followUp', 'last-run-unfinished');
+            throw new conversation_js_1.NoConversationError('Agent.followUp', this.lastInputRefused() ? 'last-input-refused' : 'last-run-unfinished');
         }
         return this.run({ message, continueFrom: conversation }, options);
     }
@@ -2040,7 +2048,7 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         // moves; it is never applied — the paused turn's clock is kept, and a
         // differing value is recorded by the ToolCalls resume door.
         const passedTime = this.passedTimeFor(options?.time, 'Agent.resume');
-        options = withoutTime(options);
+        options = (0, RunnerBase_js_1.withRunSignalInEnv)(withoutTime(options));
         const gate = (0, pause_js_1.pauseDemandsDecision)(checkpoint.pauseData);
         if (gate && !(0, checkin_js_1.isCheckInDecision)(input))
             throw new pause_js_1.DecisionRequiredError(gate, input);
@@ -2179,6 +2187,7 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // Same terms as the fresh-run path: rows on every exit, before the
             // recording stops (9.60.0).
             this.fileIntegrityDisposition();
+            this.noteAdmittedRun();
             recording?.stop();
             this.inFlightRunId = undefined;
         }
@@ -2223,7 +2232,10 @@ class Agent extends RunnerBase_js_1.RunnerBase {
      * hand it back next turn, and the agent continues where it left off — across
      * a restart, a deploy, or a different machine.
      *
-     * Returns `undefined` before any run has completed.
+     * Returns `undefined` before any run has completed or when the latest run
+     * was refused by input middleware. A refused input is not an admitted
+     * conversation. Keep an earlier accepted checkpoint to continue explicitly;
+     * `followUp()` after input denial raises `NoConversationError`.
      *
      * **Read from the run's own recording, not from a second copy.** The history
      * comes from `getLastSnapshot().sharedState.history` — the state the run
@@ -2253,8 +2265,9 @@ class Agent extends RunnerBase_js_1.RunnerBase {
      * const conversation = agent.checkpoint();          // persist anywhere
      * // …a restart later, on a fresh Agent:
      * await agent.run({ message: 'Make it three.', continueFrom: conversation });
-     * // `continueFrom` runs the 'input' middleware chain on the new turn; a user
-     * // entry appended to `history` by hand and passed to `resumeOnError` skips it.
+     * // `continueFrom` admits the new turn through the 'input' middleware chain.
+     * // `resumeOnError` rechecks originalInput but replays stored history as-is;
+     * // it does not rewrite entries manually appended to that history.
      * ```
      */
     checkpoint() {
@@ -2262,6 +2275,10 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         if (!snapshot)
             return undefined;
         const state = snapshot.sharedState;
+        // Admission is decided by seed, before any conversation state is written.
+        // Do not manufacture a blank replay carrier for an unadmitted attempt.
+        if (this.lastInputRefused())
+            return undefined;
         const recorded = (state?.history ?? []);
         const history = structuredClone(recorded);
         if (this.lastRunAnswer !== undefined && this.lastRunAnswer.length > 0) {
@@ -2300,6 +2317,17 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             ...(turnNumber !== undefined && { turnNumber }),
         };
     }
+    /** Called as each run/resume ends: remember a run that got past input admission. */
+    noteAdmittedRun() {
+        if (this.getLastSnapshot() !== undefined && !this.lastInputRefused()) {
+            this.hadAdmittedRun = true;
+        }
+    }
+    /** Whether input middleware refused the last run's message — the one reading both doors ask. */
+    lastInputRefused() {
+        const state = this.getLastSnapshot()?.sharedState;
+        return state?.messageDeniedPhase === 'input';
+    }
     /** Both checkpoint doors keep the repair budget separately from conversation text. */
     evidenceRecoveryOf(state) {
         if (state?.evidenceRevisionSpent !== true)
@@ -3570,110 +3598,158 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         const { assessAnswer } = await Promise.resolve().then(() => __importStar(require('./agent/assessment/assess.js')));
         return assessAnswer({ snapshot }, declarations);
     }
-    finalizeResult(executor, result) {
-        const paused = this.detectPause(executor, result);
-        if (paused)
-            return paused;
-        // Reliability fail-fast translation (v2.11.5+) — when the
-        // reliability retry loop in callLLM hits a `fail-fast` decision,
-        // it writes scope.reliabilityFailKind + payload and calls $break.
-        // The chart stops; the executor returns the last finalContent
-        // (typically empty). At the API boundary we surface the typed
-        // error so consumers can `instanceof ReliabilityFailFastError`
-        // and branch on `.kind`.
+    /**
+     * @internal What a mount of this agent's chart handed back
+     * (`core/terminalVerdict.ts` · `ReadsItsOwnOutcome`, read by every
+     * composition): the ANSWER, or the terminal verdict the chart ended on. A
+     * string, or the validated answer's `{ finalContent, answerValidationCommitted }`,
+     * is the answer; a verdict is read ONLY from the chart's state — handed over
+     * when the chart returned no result — with the one translation this agent's
+     * own run boundary (`finalizeResult`) uses. The `'tell-model'` consent record
+     * travels off tracked state, so it is raised by the run boundary only.
+     */
+    outcomeOf(sfOutput) {
+        if (typeof sfOutput === 'string')
+            return { answer: sfOutput };
+        if ((0, breakFinal_js_1.isValidatedDelivery)(sfOutput))
+            return { answer: sfOutput.finalContent };
+        if (typeof sfOutput === 'object' && sfOutput !== null) {
+            const state = sfOutput;
+            const verdict = this.refusalVerdictOf(state) ?? this.validationVerdictOf(state);
+            if (verdict !== undefined)
+                return { verdict };
+        }
+        return { answer: sfOutput };
+    }
+    /** The records a run ends on in place of an answer, in the order the boundary raises them. */
+    refusalVerdictOf(state) {
+        // Reliability fail-fast (v2.11.5+) — the loop in callLLM writes the record
+        // and calls $break (`reliability/failFastRecord.ts`).
         if (this.reliabilityConfig !== undefined) {
-            const snap = executor.getSnapshot();
-            // Read via Pick<AgentState, …> so the read shape cannot drift from
-            // the typed write side (the fields are declared once on AgentState).
-            const state = snap.sharedState;
-            if (state.reliabilityFailKind !== undefined) {
-                // Reconstruct the cause Error from the captured message+name —
-                // see the matching note in reliabilityExecution.failFast about
-                // why we don't keep the original Error in scope.
-                let cause;
-                if (state.reliabilityFailCauseMessage !== undefined) {
-                    cause = new Error(state.reliabilityFailCauseMessage);
-                    if (state.reliabilityFailCauseName !== undefined) {
-                        cause.name = state.reliabilityFailCauseName;
-                    }
-                }
-                throw new types_js_1.ReliabilityFailFastError({
-                    kind: state.reliabilityFailKind,
-                    reason: state.reliabilityFailReason ?? state.reliabilityFailKind,
-                    ...(cause !== undefined && { cause }),
-                    ...(state.reliabilityFailPayload !== undefined && {
-                        payload: state.reliabilityFailPayload,
-                    }),
-                    snapshot: snap,
-                });
-            }
+            const record = (0, failFastRecord_js_1.failFastRecordOf)(state);
+            if (record !== undefined)
+                return { kind: 'reliability-fail-fast', record };
         }
-        // Policy-halt translation (v2.12+) — when a `PermissionChecker` returns
-        // `{ result: 'halt', ... }`, the toolCalls handler writes a synthetic
-        // tool_result, emits `agentfootprint.permission.halt`, sets
-        // scope.policyHalt* fields, and calls $break. The chart stops; we
-        // surface the typed error here so callers can `instanceof PolicyHaltError`
-        // and branch on `.reason` for alert routing.
-        {
-            const snap = executor.getSnapshot();
-            const state = snap.sharedState;
-            if (state.policyHaltReason !== undefined && state.policyHaltTarget !== undefined) {
-                const history = state.history ?? [];
-                const iteration = state.policyHaltIteration ?? 1;
-                // Sequence at halt time — derived from history. Includes the
-                // proposed call (which DID land in history as the synthetic
-                // tool_result for protocol compliance, but the policy denied
-                // execution). Filter it out so callers see only dispatched
-                // calls, then append the proposed entry as a hint.
-                const sequenceWithoutProposed = (0, extractSequence_js_1.extractSequence)(history.slice(0, -1), iteration);
-                throw new PolicyHaltError_js_1.PolicyHaltError({
-                    reason: state.policyHaltReason,
-                    ...(state.policyHaltTellLLM !== undefined && { tellLLM: state.policyHaltTellLLM }),
+        // Policy halt (v2.12+) — a `PermissionChecker` returned `halt`; the
+        // toolCalls handler wrote a synthetic tool_result and the policyHalt*
+        // fields, and called $break.
+        const halt = state;
+        if (halt.policyHaltReason !== undefined && halt.policyHaltTarget !== undefined) {
+            const history = halt.history ?? [];
+            const iteration = halt.policyHaltIteration ?? 1;
+            // Sequence at halt time — derived from history. Includes the
+            // proposed call (which DID land in history as the synthetic
+            // tool_result for protocol compliance, but the policy denied
+            // execution). Filter it out so callers see only dispatched
+            // calls, then append the proposed entry as a hint.
+            const sequenceWithoutProposed = (0, extractSequence_js_1.extractSequence)(history.slice(0, -1), iteration);
+            return {
+                kind: 'policy-halt',
+                halt: {
+                    reason: halt.policyHaltReason,
+                    ...(halt.policyHaltTellLLM !== undefined && { tellLLM: halt.policyHaltTellLLM }),
                     sequence: [
                         ...sequenceWithoutProposed,
-                        { name: state.policyHaltTarget, args: state.policyHaltArgs, iteration },
+                        { name: halt.policyHaltTarget, args: halt.policyHaltArgs, iteration },
                     ],
                     iteration,
                     history,
-                    proposed: { name: state.policyHaltTarget, args: state.policyHaltArgs ?? {} },
-                    ...(state.policyHaltCheckerId !== undefined && { checkerId: state.policyHaltCheckerId }),
-                });
-            }
+                    proposed: { name: halt.policyHaltTarget, args: halt.policyHaltArgs ?? {} },
+                    ...(halt.policyHaltCheckerId !== undefined && { checkerId: halt.policyHaltCheckerId }),
+                },
+            };
         }
         // Message-boundary refusal (7.18+) — a `messageMiddleware` returned
-        // `deny`. The stage wrote the flags and (at 'input') broke the chart. We
-        // surface the typed error here, the same way a policy halt is surfaced,
-        // because a refusal must never be mistaken for an answer: at 'input' no
-        // model was ever asked, and at 'output' the middleware has just declined
-        // to release what the model said.
+        // `deny`; a refusal must never be mistaken for an answer: at 'input' no
+        // model was asked, and at 'output' the middleware declined to release it.
         if (this.messageMiddleware.length > 0) {
-            const state = executor.getSnapshot().sharedState;
-            if (state.messageDeniedReason !== undefined) {
-                throw new errors_js_3.MessageDeniedError({
-                    reason: state.messageDeniedReason,
-                    phase: state.messageDeniedPhase ?? 'output',
-                    middleware: state.messageDeniedBy ?? 'middleware',
-                });
+            const denied = state;
+            if (denied.messageDeniedReason !== undefined) {
+                return {
+                    kind: 'message-denied',
+                    denial: {
+                        reason: denied.messageDeniedReason,
+                        phase: denied.messageDeniedPhase ?? 'output',
+                        middleware: denied.messageDeniedBy ?? 'middleware',
+                    },
+                };
             }
         }
-        // Evidence refusal (9.35.0, `posture: 'rails'` only) — the final answer
-        // still states values that appear in no tool result, after the one
-        // revision the posture allows. Surfaced the way a denied message is, and
-        // for the same reason: `rails` was chosen precisely so an answer carrying
-        // invented identifiers cannot reach the caller as a string they are free
-        // to ignore. `'assist'` and `'guard'` never reach here — their verdict is
-        // committed state and an event, and `run()` returns the answer.
+        // Evidence rails (9.35.0) — the answer still states values no tool result
+        // carried, after the one revision the posture allows. `'assist'` and
+        // `'guard'` never end here: their verdict is committed state and an event.
         if (this.evidenceGate?.posture === 'rails') {
-            const state = executor.getSnapshot().sharedState;
             const verdict = state.unsupportedValues;
             if (verdict !== undefined && verdict.refused) {
-                throw new errors_js_2.UnsupportedValuesError({
-                    values: verdict.values,
-                    candidates: verdict.candidates,
-                    revised: verdict.revised,
-                    message: (0, gate_js_1.evidenceRefusalSentence)(verdict.values, 'rails', verdict.revised),
+                return {
+                    kind: 'unsupported-values',
+                    refusal: {
+                        values: verdict.values,
+                        candidates: verdict.candidates,
+                        revised: verdict.revised,
+                        message: (0, gate_js_1.evidenceRefusalSentence)(verdict.values, 'rails', verdict.revised),
+                    },
+                };
+            }
+        }
+        return undefined;
+    }
+    /** Answer validation's verdict on a run that reached the end (7.24): blocked, or never committed. */
+    validationVerdictOf(state) {
+        const config = this.answerValidationConfig;
+        if (config === undefined)
+            return undefined;
+        const s = state;
+        if (s.answerValidationBlocked === true && s.answerValidation !== undefined) {
+            return { kind: 'answer-validation', report: s.answerValidation };
+        }
+        if (s.answerValidation === undefined ||
+            s.answerValidationCommitted !== true ||
+            typeof s.finalContent !== 'string') {
+            return {
+                kind: 'answer-validation',
+                report: {
+                    validatorId: config.id,
+                    validatorVersion: config.version,
+                    mode: config.mode,
+                    status: 'unverified',
+                    checked: 0,
+                    failed: 0,
+                    unreachable: 0,
+                    notApplicable: 0,
+                    checks: [],
+                    resolvedRefs: [],
+                    schemaAccepted: false,
+                    reason: 'delivery-incomplete',
+                },
+            };
+        }
+        return undefined;
+    }
+    finalizeResult(executor, result) {
+        const paused = this.detectPause(executor, result);
+        if (paused)
+            return paused;
+        const snap = executor.getSnapshot();
+        const state = snap.sharedState;
+        const refusal = this.refusalVerdictOf(state);
+        if (refusal !== undefined) {
+            if (refusal.kind === 'message-denied' && refusal.denial.phase === 'output') {
+                // The chart stopped cleanly, so ErrorBridge's onRunFailed cannot
+                // close public streams. This API boundary owns the refusal on both
+                // run and resume. Name it as a virtual stage, not a fabricated
+                // engine failure, and never echo policy text into a public stream.
+                this.dispatcher.dispatch({
+                    type: 'agentfootprint.error.fatal',
+                    payload: {
+                        error: 'The output policy withheld this answer.',
+                        stage: '__output_admission__',
+                        scope: 'run',
+                    },
+                    meta: (0, eventMeta_js_1.buildEventMeta)({ runtimeStageId: '__output_admission__' }, this.currentRunContext),
                 });
             }
+            throw (0, terminalVerdict_js_1.terminalErrorOf)(refusal, snap);
         }
         // Credential-consent translation (8.6.0, `'tell-model'` only) — a tool
         // DECLARED a credential, the provider answered `authorization-required`,
@@ -3697,38 +3773,18 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         }
         if (result instanceof Error)
             throw result;
-        if (this.answerValidationConfig !== undefined) {
-            const state = executor.getSnapshot().sharedState;
-            if (state.answerValidationBlocked === true && state.answerValidation !== undefined) {
-                throw new index_js_1.AnswerValidationError(state.answerValidation);
-            }
-            if (state.answerValidation === undefined ||
-                state.answerValidationCommitted !== true ||
-                typeof state.finalContent !== 'string') {
-                const config = this.answerValidationConfig;
-                throw new index_js_1.AnswerValidationError({
-                    validatorId: config.id,
-                    validatorVersion: config.version,
-                    mode: config.mode,
-                    status: 'unverified',
-                    checked: 0,
-                    failed: 0,
-                    unreachable: 0,
-                    notApplicable: 0,
-                    checks: [],
-                    resolvedRefs: [],
-                    schemaAccepted: false,
-                    reason: 'delivery-incomplete',
-                });
-            }
+        const invalid = this.validationVerdictOf(state);
+        if (invalid !== undefined)
+            throw (0, terminalVerdict_js_1.terminalErrorOf)(invalid);
+        if (this.answerValidationConfig !== undefined)
             return state.finalContent;
-        }
         if (typeof result === 'string')
             return result;
         throw new Error('Agent: unexpected result shape — expected final-answer string');
     }
     // ─── Chart assembly ────────────────────────────────────────────
     buildChart() {
+        const governsOutput = (0, messagePhase_js_1.hasOutputMiddleware)(this.messageMiddleware);
         const provider = this.provider;
         const model = this.model;
         const temperature = this.temperature;
@@ -4358,7 +4414,10 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // seam peels `_findings` where the served schema carries it (ruled
             // tools only) — value-conditional, the same grammar.
             ...(argumentSources && { argumentSources: true }),
-            ...(this.answerValidationConfig !== undefined && { suppressDraftTokens: true }),
+            ...((this.answerValidationConfig !== undefined || governsOutput) && {
+                suppressDraftTokens: true,
+            }),
+            ...(governsOutput && { withholdDraftContent: true }),
             // Tool choice by classifier (9.105.0): the outcome row after the reply.
             ...(this.toolChoiceOptions !== undefined && { toolChoice: true }),
             // The declared ontology (9.106.0): the piece served from the run
@@ -4428,14 +4487,15 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // brain or an escalation exists, so every other agent's stage reads no
             // new scope key and resolves on the exact line it always did. The
             // per-brain cache strategies resolve HERE, once, where the agent's own
-            // strategy (override included) is known: same-name brains keep it,
-            // foreign providers get their registry default (markers are
-            // provider-aware — the one genuinely risky seam, resolved statically).
+            // strategy (override included) is known: a brain on the agent's own
+            // provider keeps it, any other provider gets the strategy its declared
+            // `promptCaching` selects (markers are provider-aware — the one
+            // genuinely risky seam, resolved statically).
             ...(this.skillBrains !== undefined &&
                 (this.skillBrains.bySkill.size > 0 || this.skillBrains.escalation !== undefined) && {
                 brainFor: (0, skillBrains_js_1.buildBrainFor)({
                     brains: this.skillBrains,
-                    agentProviderName: provider.name,
+                    agentProvider: provider,
                     agentCacheStrategy: cacheStrategy,
                 }),
             }),
@@ -4759,12 +4819,12 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             },
         });
         // v2.14 — Build the NormalizeThinking sub-subflow only when a
-        // ThinkingHandler resolved (auto-wired by provider.name OR
+        // ThinkingHandler resolved (declared by the provider OR
         // explicitly set via .thinkingHandler()). Conditional mount ensures
         // zero overhead for non-thinking agents — the chart has zero extra
         // stages when undefined.
         const thinkingSubflow = this.thinkingHandler
-            ? (0, buildThinkingSubflow_js_1.buildThinkingSubflow)(this.thinkingHandler)
+            ? (0, buildThinkingSubflow_js_1.buildThinkingSubflow)(this.thinkingHandler, this.provider.name)
             : undefined;
         // Chart composition extracted to ./agent/buildAgentChart.ts (v2.11.2).
         // The deps object is identical for both chart shapes — only the
@@ -4885,6 +4945,7 @@ class Agent extends RunnerBase_js_1.RunnerBase {
                         toolMiddleware: this.toolMiddleware.length > 0,
                     }),
                     ...(this.answerLayerOption.standingLine === true && { standingLine: true }),
+                    ...(this.answerValidationConfig !== undefined && { validated: true }),
                 },
             }),
             // Tool choice by classifier (9.105.0): the mount args on the Tools
@@ -4909,6 +4970,8 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             ...(this.timeOptions !== undefined && { timeWindows: true }),
             ...(inputsArmed && this.timeOptions !== undefined && { timeLimits: true }),
             ...(this.answerValidationConfig !== undefined && { hasAnswerValidation: true }),
+            ...(governsOutput && { releaseOutputTokens: true }),
+            ...(this.evidenceGate?.posture === 'rails' && { evidenceRails: true }),
             // The out-of-budget wrap-up branch (9.56.0) — the conditional-mount law
             // above, decided once beside the Route decider that routes to it so the
             // two can never disagree about whether the branch exists.