@rulvar/core 1.76.0 → 1.78.0

package/dist/index.d.ts

@@ -4197,6 +4197,16 @@ interface AgentResult<T> {
   * seeing a bare 'terminal status limit'.
   */
   partial?: ProgressReport;
+  /**
+  * Terminal-tool exchanges whose ARGUMENTS died at the schema gate
+  * (the unparsed second chance included, when it did not recover): the
+  * v1.74 experiment lost six finish payloads to exactly this class,
+  * and nothing outside the transcript said so (host validation
+  * rejections, by contrast, journal decision entries). Derived from
+  * the message window like the repair-reserve grants, so live and
+  * resumed segments count the same total; absent when zero.
+  */
+  schemaRejectedTerminalExchanges?: number;
 }
 /** One 429's provider-normalized limits, per (provider, model). */
 interface RateLimitObservation {
@@ -6317,13 +6327,47 @@ interface FinishValidator {
   validate(input: FinishValidationInput): FinishValidationVerdict;
 }
 /**
+* How section markers must appear in the judged text (cycle 74):
+* 'anywhere' is the historical substring test; 'line' demands the
+* marker as its own line (surrounding whitespace ignored), so a
+* mid sentence mention or a quoted marker no longer satisfies a
+* heading requirement.
+*/
+type SectionMatchMode = "anywhere" | "line";
+/**
+* Whether fenced code participates in textual validation (cycle 74):
+* 'counted' is the historical behavior; 'excluded' removes fenced code
+* blocks (see {@link stripFencedBlocks}) before matching, counting, or
+* slicing, so code samples can neither satisfy a section marker nor
+* inflate word and citation counts.
+*/
+type FencedCodeMode = "counted" | "excluded";
+/**
+* Removes fenced code blocks from a text, the delimiter lines
+* included, and returns the remaining lines joined by newlines. The
+* grammar is the CommonMark shape as a deliberate line heuristic: a
+* fence opens at a line starting (after at most three spaces) with
+* three or more backticks or tildes, an optional info string allowed;
+* it closes at the next line carrying only at least as many of the
+* SAME character; an unclosed fence runs to the end of the text.
+* Indented (four space) code blocks are not treated as code. This is
+* the exact exclusion the `fencedCode: 'excluded'` validator option
+* applies, exported so custom host validators can stay symmetric.
+*/
+declare function stripFencedBlocks(text: string): string;
+/**
 * Requires every named section to appear LITERALLY in the result text
 * (a heading like 'FINDINGS' or any marker the goal demands). Default
 * name 'required-sections'; pass `name` to run several instances.
+* `match: 'line'` demands each marker as its own line and
+* `fencedCode: 'excluded'` ignores markers inside fenced code blocks
+* (cycle 74); both default to the historical byte identical behavior.
 */
 declare function requiredSectionsValidator(options: {
-  sections: string[];
+  sections: readonly string[];
   name?: string;
+  match?: SectionMatchMode;
+  fencedCode?: FencedCodeMode;
 }): FinishValidator;
 /**
 * Requires the result to be a JSON object carrying every named field
@@ -6333,7 +6377,7 @@ declare function requiredSectionsValidator(options: {
 * validator). Default name 'required-fields'.
 */
 declare function requiredFieldsValidator(options: {
-  fields: string[];
+  fields: readonly string[];
   name?: string;
 }): FinishValidator;
 /**
@@ -6342,12 +6386,16 @@ declare function requiredFieldsValidator(options: {
 * v1.71 experiment review, P0.7: a formal length requirement must be
 * code, never a natural-language plea the model may round away). At
 * least one bound is required; both are positive integers with
-* min <= max. Default name 'word-count'.
+* min <= max. Default name 'word-count'. `fencedCode: 'excluded'`
+* counts only words outside fenced code blocks (cycle 74), so code
+* samples cannot pad a length requirement; the default counts
+* everything, byte identical to the historical behavior.
 */
 declare function wordCountValidator(options: {
   min?: number;
   max?: number;
   name?: string;
+  fencedCode?: FencedCodeMode;
 }): FinishValidator;
 /** The default citation shape: a path with an extension, a colon, a line number. */
 declare const DEFAULT_CITATION_PATTERN = "[\\w./-]+\\.\\w+:\\d+";
@@ -6386,14 +6434,20 @@ declare function evidencePreservedValidator(options?: {
 * text is its own failure reason, because coverage of a missing
 * section cannot silently count as satisfied.
 * requiredSectionsValidator still owns plain presence. Default name
-* 'section-citations'.
+* 'section-citations'. `match: 'line'` anchors each section at the
+* first line equal to its marker and `fencedCode: 'excluded'` removes
+* fenced code before anchoring, slicing, and counting (cycle 74), so a
+* marker echoed inside a code sample can neither anchor a slice nor
+* donate citations; both default to the historical behavior.
 */
 declare function sectionCitationsValidator(options: {
-  sections: string[];
+  sections: readonly string[];
   pattern?: string;
   flags?: string;
   min: number;
   name?: string;
+  match?: SectionMatchMode;
+  fencedCode?: FencedCodeMode;
 }): FinishValidator;
 /**
 * Requires at least `min` matches of `pattern` in the result text (the
@@ -6402,12 +6456,17 @@ declare function sectionCitationsValidator(options: {
 * ConfigError before any run exists) and matches globally; `min` is a
 * positive integer. Default name 'min-matches'; pass `name` to run
 * several instances, because names must be unique per orchestrate call.
+* `fencedCode: 'excluded'` matches only outside fenced code blocks
+* (cycle 74), so citations quoted inside code samples do not count;
+* the default matches everything, byte identical to the historical
+* behavior.
 */
 declare function minMatchesValidator(options: {
   pattern: string;
   flags?: string;
   min: number;
   name?: string;
+  fencedCode?: FencedCodeMode;
 }): FinishValidator;
 //#endregion
 //#region src/orchestrator/output-contract.d.ts
@@ -6441,6 +6500,16 @@ interface FinishContractCitations {
 interface FinishContractManifest {
   /** Literal section markers the result must contain. */
   sections?: string[];
+  /**
+  * How section markers must appear (cycle 74): 'anywhere' (the
+  * default, a plain substring test) or 'line' (each marker must
+  * stand as its own line, surrounding whitespace ignored, so a mid
+  * sentence mention no longer satisfies a heading). Requires
+  * `sections`. Joins the hash and the prompt statement only when
+  * 'line'; an explicit 'anywhere' normalizes away, keeping the hash
+  * of the plain manifest.
+  */
+  sectionsMatch?: SectionMatchMode;
   /** Word bounds over the result text (whitespace separated tokens). */
   words?: {
     min?: number;
@@ -6448,14 +6517,52 @@ interface FinishContractManifest {
   };
   /** Citation demands over the result text. */
   citations?: FinishContractCitations;
+  /**
+  * Whether fenced code blocks count (cycle 74): 'counted' (the
+  * default) or 'excluded' (fenced code is removed before section
+  * matching, slicing, word counting, and citation matching, so code
+  * samples can neither satisfy a marker nor pad a count). Joins the
+  * hash and adds a prompt statement only when 'excluded'; an explicit
+  * 'counted' normalizes away. With 'excluded', a section marker or a
+  * citation sample that would itself OPEN a fence is a ConfigError,
+  * because the golden fixtures embed both at line starts.
+  */
+  fencedCode?: FencedCodeMode;
+}
+/**
+* One per validator reject golden (cycle 74): a fixture the NAMED
+* contract validator is proven to reject at construction time.
+* {@link selfTestFinishValidation} holds the CONFIGURED validator of
+* that name against it, so a same-name replacement weaker than the
+* contract's own validator (a words minimum of one standing in for
+* three thousand) is caught before any provider call instead of
+* silently accepting what the journaled contract hash forbids.
+*/
+interface FinishContractGoldenReject {
+  /** The contract validator this fixture targets, by name. */
+  readonly validator: string;
+  /** The fixture that validator must reject. */
+  readonly input: FinishValidationInput;
 }
-/** What {@link finishContract} builds from a manifest. */
+/**
+* What {@link finishContract} builds from a manifest. The whole bundle
+* is DEEPLY frozen (cycle 74): the nested manifest objects, the
+* sections array, the validators array, and each validator object, so
+* a post construction mutation throws instead of silently diverging
+* behavior from the journaled contract hash.
+*/
 interface FinishContract {
-  /** The normalized manifest (defaults applied), frozen. */
+  /** The normalized manifest (defaults applied), deeply frozen. */
   readonly manifest: FinishContractManifest;
   /** sha256 hex over the JCS serialization of the normalized manifest. */
   readonly hash: string;
-  /** The stock validators enforcing the manifest; names are 'contract-*'. */
+  /**
+  * The stock validators enforcing the manifest; names are
+  * 'contract-*'. The array and each validator object are frozen at
+  * runtime (the type stays mutable for source compatibility), so an
+  * in-place pop or a validate() swap throws instead of silently
+  * weakening what the hash promises.
+  */
   readonly validators: FinishValidator[];
   /** The contract statement for the model, one demand per line. */
   readonly promptLines: readonly string[];
@@ -6467,6 +6574,13 @@ interface FinishContract {
   * empty result is then legitimately acceptable.
   */
   readonly goldenReject?: FinishValidationInput;
+  /**
+  * One reject golden PER contract validator (cycle 74), in validator
+  * order, each verified at construction; boundary sharp where a
+  * boundary is mechanically safe (the words fixture sits exactly one
+  * word outside the bound), the empty text otherwise.
+  */
+  readonly goldenRejects: readonly FinishContractGoldenReject[];
 }
 /**
 * Builds a {@link FinishContract} from one manifest: validation and the
@@ -6490,7 +6604,11 @@ interface FinishSelfTestFixtures {
 /** One self test failure. */
 interface FinishSelfTestFailure {
   fixture: "accept" | "reject";
-  /** The rejecting validator on the accept side; absent on the vacuous reject side. */
+  /**
+  * The failing validator: the rejecting one on the accept side, the
+  * named one on a per validator reject golden (cycle 74); absent
+  * only on the vacuous single-fixture reject side.
+  */
   validator?: string;
   reasons: string[];
 }
@@ -6509,12 +6627,18 @@ interface FinishSelfTestReport {
 * nothing). A validator that THROWS here is a host defect and the
 * ConfigError propagates, the same posture the live loop takes.
 * Deterministic and free: validators are pure synchronous host code by
-* contract, so this costs zero provider calls.
+* contract, so this costs zero provider calls. `rejects` (cycle 74)
+* carries the contract's per validator reject goldens: for each one
+* the CONFIGURED validator of that name must exist and must reject
+* the fixture, so a same-name replacement weaker than the contract's
+* own validator fails here instead of silently accepting what the
+* journaled contract hash forbids.
 */
 declare function selfTestFinishValidation(options: {
-  validators: FinishValidator[];
+  validators: readonly FinishValidator[];
   accept?: FinishValidationInput;
   reject?: FinishValidationInput;
+  rejects?: readonly FinishContractGoldenReject[];
 }): FinishSelfTestReport;
 //#endregion
 //#region src/orchestrator/handles.d.ts
@@ -7162,8 +7286,22 @@ interface FinishValidationSpec {
   * hash and the validator names. A resumed segment whose live
   * contract hash differs appends a SUPERSEDING descriptor instead of
   * failing, because fixing a stale validator and resuming is the
-  * intended remedy, never a fault. Absent = byte identical pre 1.72
-  * behavior.
+  * intended remedy, never a fault. The remedy is generation-scoped
+  * (cycle 73): every decision entry written under a contract carries
+  * `contractHash`, and only the CURRENT generation is judged, so
+  * repairsUsed restarts under a fixed contract and a final rejection
+  * a superseded generation left in the crash window neither rolls
+  * forward at boot nor re-arms on replay (its exchange replays byte
+  * identical and the loop continues to a live repair turn). Decisions
+  * recorded before 1.77 carry no hash and bind to the current
+  * contract only while the journal holds a single bundle descriptor;
+  * once a supersession is recorded they are stale. The bundle is
+  * deeply frozen and the construction self test also runs the
+  * contract's per validator reject goldens against the CONFIGURED
+  * set (cycle 74), so a post construction mutation throws and a
+  * same-name replacement weaker than the contract's own validator is
+  * a ConfigError before any provider call. Absent = byte identical
+  * pre 1.72 behavior.
   */
   contract?: FinishContract;
   /**
@@ -8947,9 +9085,12 @@ interface PreflightInput {
   * review, P1.1). Programmatic only: validator functions cannot ride
   * a JSON config file, so the CLI never carries this. When present,
   * preflight runs the SAME golden self test orchestrate runs at
-  * construction and reports every drift as an error finding (code
-  * 'output-contract-validator-mismatch') instead of throwing, so a
-  * planner surfaces it next to the quota and budget findings.
+  * construction and reports every drift as an error finding instead
+  * of throwing, so a planner surfaces it next to the quota and budget
+  * findings: 'output-contract-validator-mismatch' for containment and
+  * accept-side drift, 'output-contract-validator-weakened' (cycle 74)
+  * when a configured validator fails the contract's per validator
+  * reject golden, the same-name weakened replacement.
   */
   finishValidation?: {
     validators: FinishValidator[];
@@ -8964,6 +9105,13 @@ interface PreflightInput {
     * runtime would actually grant.
     */
     repairTurnReserve?: number;
+    /**
+    * Mirrors FinishValidationSpec.maxRepairs (default
+    * {@link DEFAULT_FINISH_MAX_REPAIRS}): with zero, the first
+    * rejection is final and there is no repair exchange to fund, so
+    * the repair-reserve-unfunded warning stays silent.
+    */
+    maxRepairs?: number;
   };
 }
 /** One linter verdict; `spawn` names the wave entry it is about. */
@@ -9625,4 +9773,4 @@ interface SandboxBridge {
 declare const SANDBOX_AGENT_OPT_KEYS: readonly string[];
 declare function createSandboxBridge(ctx: Ctx<never>, options: SandboxBridgeOptions): SandboxBridge;
 //#endregion
-export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildIdentityInput, ChildResultPage, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostAttributionFacts, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishContract, FinishContractCitations, FinishContractManifest, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceExport, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, JournalSerializationContext, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, type PhaseRow, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, RefEntryAppender, RefEntryClassification, RefusalInfo, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, StructuredOutputTier, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, finishContract, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildIdentityInput, ChildResultPage, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostAttributionFacts, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceExport, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, JournalSerializationContext, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, type PhaseRow, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, RefEntryAppender, RefEntryClassification, RefusalInfo, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, StructuredOutputTier, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, finishContract, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotUsage, spawnDepthOf, stripFencedBlocks, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -10181,6 +10181,15 @@ function estimateInputTokens(messages) {
 	return Math.ceil(chars / 4);
 }
 /**
+* The terminal tool's schema-rejection feedback line. One producer, two
+* readers: the interception writes it as the error result, and the
+* window-derived schemaRejectedTerminalExchanges counter recognizes the
+* exchange by exactly these bytes, so the two can never drift.
+*/
+function terminalSchemaRejectionMessage(name) {
+	return `the '${name}' call failed validation`;
+}
+/**
 * The serving model's declared minimum request output cap, default one.
 * OpenAI's Responses API rejects max_output_tokens below 16, so a
 * below-floor dispatch is a guaranteed provider 400: the v1.74
@@ -10870,7 +10879,7 @@ async function runAgent(options) {
 						durationMs: now() - gateStartedAt
 					});
 					parts.push(errorPart(call, {
-						error: `the '${gatedCall.name}' call failed validation`,
+						error: terminalSchemaRejectionMessage(gatedCall.name),
 						issues: validation === void 0 ? [] : validation.issues.map((i) => i.message)
 					}));
 					continue;
@@ -12008,6 +12017,9 @@ async function runAgent(options) {
 	if (errorMessage !== void 0) result.errorMessage = errorMessage;
 	if (guard !== void 0) result.exploration = guard.summary(toolCallsUsed);
 	if (limitPartial !== void 0) result.partial = limitPartial;
+	const terminalName = options.terminalTool?.name;
+	const schemaRejectedTerminalExchanges = terminalName === void 0 ? 0 : messages.reduce((count, message) => count + message.parts.filter((part) => part.type === "tool-result" && part.name === terminalName && part.isError === true && part.result?.error === terminalSchemaRejectionMessage(terminalName)).length, 0);
+	if (schemaRejectedTerminalExchanges > 0) result.schemaRejectedTerminalExchanges = schemaRejectedTerminalExchanges;
 	if (usageApprox) result.usageApprox = true;
 	if (transportRetries > 0) result.transportRetries = transportRetries;
 	if (rateLimitObservations.size > 0) result.rateLimitObservations = [...rateLimitObservations.values()];
@@ -15334,22 +15346,92 @@ const ok = { ok: true };
 function requireNonEmptyStrings(values, what) {
 	if (!Array.isArray(values) || values.length === 0) throw new ConfigError(`${what} must be a non empty array of strings`);
 	for (const value of values) if (typeof value !== "string" || value.length === 0) throw new ConfigError(`${what} must contain only non empty strings`);
-	return values;
+	return [...values];
+}
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+const FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+/**
+* Removes fenced code blocks from a text, the delimiter lines
+* included, and returns the remaining lines joined by newlines. The
+* grammar is the CommonMark shape as a deliberate line heuristic: a
+* fence opens at a line starting (after at most three spaces) with
+* three or more backticks or tildes, an optional info string allowed;
+* it closes at the next line carrying only at least as many of the
+* SAME character; an unclosed fence runs to the end of the text.
+* Indented (four space) code blocks are not treated as code. This is
+* the exact exclusion the `fencedCode: 'excluded'` validator option
+* applies, exported so custom host validators can stay symmetric.
+*/
+function stripFencedBlocks(text) {
+	const kept = [];
+	let fence;
+	for (const line of text.split("\n")) {
+		if (fence === void 0) {
+			const delimiter = FENCE_OPEN.exec(line)?.[1];
+			if (delimiter !== void 0) {
+				fence = {
+					char: delimiter.charAt(0),
+					length: delimiter.length
+				};
+				continue;
+			}
+			kept.push(line);
+			continue;
+		}
+		const close = FENCE_CLOSE.exec(line)?.[1];
+		if (close !== void 0 && close.charAt(0) === fence.char && close.length >= fence.length) fence = void 0;
+	}
+	return kept.join("\n");
+}
+function requireSectionMatchMode(value, what) {
+	if (value !== "anywhere" && value !== "line") throw new ConfigError(`${what} must be 'anywhere' or 'line'; got ${String(value)}`);
+	return value;
+}
+function requireFencedCodeMode(value, what) {
+	if (value !== "counted" && value !== "excluded") throw new ConfigError(`${what} must be 'counted' or 'excluded'; got ${String(value)}`);
+	return value;
+}
+/**
+* The first position of a section marker in the (already fence
+* filtered) scope under the configured match mode: the plain substring
+* offset for 'anywhere', the offset of the first line whose trimmed
+* content EQUALS the marker for 'line'; -1 when absent. One shared
+* primitive so presence checks and slice anchoring can never disagree.
+*/
+function sectionPosition(scope, section, match) {
+	if (match === "anywhere") return scope.indexOf(section);
+	let offset = 0;
+	for (const line of scope.split("\n")) {
+		if (line.trim() === section) return offset;
+		offset += line.length + 1;
+	}
+	return -1;
+}
+function missingSectionQualifier(match, fencedCode) {
+	const demands = (match === "line" ? " as its own line" : "") + (fencedCode === "excluded" ? " outside fenced code" : "");
+	return demands === "" ? "" : ` (required${demands})`;
 }
 /**
 * Requires every named section to appear LITERALLY in the result text
 * (a heading like 'FINDINGS' or any marker the goal demands). Default
 * name 'required-sections'; pass `name` to run several instances.
+* `match: 'line'` demands each marker as its own line and
+* `fencedCode: 'excluded'` ignores markers inside fenced code blocks
+* (cycle 74); both default to the historical byte identical behavior.
 */
 function requiredSectionsValidator(options) {
 	const sections = requireNonEmptyStrings(options.sections, "requiredSectionsValidator sections");
+	const match = options.match === void 0 ? "anywhere" : requireSectionMatchMode(options.match, "requiredSectionsValidator match");
+	const fencedCode = options.fencedCode === void 0 ? "counted" : requireFencedCodeMode(options.fencedCode, "requiredSectionsValidator fencedCode");
+	const qualifier = missingSectionQualifier(match, fencedCode);
 	return {
 		name: options.name ?? "required-sections",
 		validate: (input) => {
-			const missing = sections.filter((section) => !input.text.includes(section));
+			const scope = fencedCode === "excluded" ? stripFencedBlocks(input.text) : input.text;
+			const missing = sections.filter((section) => sectionPosition(scope, section, match) < 0);
 			return missing.length === 0 ? ok : {
 				ok: false,
-				reasons: missing.map((section) => `required section '${section}' is missing`)
+				reasons: missing.map((section) => `required section '${section}' is missing${qualifier}`)
 			};
 		}
 	};
@@ -15391,21 +15473,26 @@ function requiredFieldsValidator(options) {
 * v1.71 experiment review, P0.7: a formal length requirement must be
 * code, never a natural-language plea the model may round away). At
 * least one bound is required; both are positive integers with
-* min <= max. Default name 'word-count'.
+* min <= max. Default name 'word-count'. `fencedCode: 'excluded'`
+* counts only words outside fenced code blocks (cycle 74), so code
+* samples cannot pad a length requirement; the default counts
+* everything, byte identical to the historical behavior.
 */
 function wordCountValidator(options) {
 	const { min, max } = options;
 	if (min === void 0 && max === void 0) throw new ConfigError("wordCountValidator requires min, max, or both");
 	for (const [label, value] of [["min", min], ["max", max]]) if (value !== void 0 && (!Number.isInteger(value) || value < 1)) throw new ConfigError(`wordCountValidator ${label} must be a positive integer; got ${String(value)}`);
 	if (min !== void 0 && max !== void 0 && min > max) throw new ConfigError(`wordCountValidator min ${String(min)} exceeds max ${String(max)}`);
+	const fencedCode = options.fencedCode === void 0 ? "counted" : requireFencedCodeMode(options.fencedCode, "wordCountValidator fencedCode");
+	const counted = fencedCode === "excluded" ? " (fenced code excluded)" : "";
 	return {
 		name: options.name ?? "word-count",
 		validate: (input) => {
-			const trimmed = input.text.trim();
+			const trimmed = (fencedCode === "excluded" ? stripFencedBlocks(input.text) : input.text).trim();
 			const count = trimmed.length === 0 ? 0 : trimmed.split(/\s+/).length;
 			const reasons = [];
-			if (min !== void 0 && count < min) reasons.push(`result word count ${String(count)} is below the required minimum ${String(min)}`);
-			if (max !== void 0 && count > max) reasons.push(`result word count ${String(count)} exceeds the maximum ${String(max)}`);
+			if (min !== void 0 && count < min) reasons.push(`result word count ${String(count)}${counted} is below the required minimum ${String(min)}`);
+			if (max !== void 0 && count > max) reasons.push(`result word count ${String(count)}${counted} exceeds the maximum ${String(max)}`);
 			return reasons.length === 0 ? ok : {
 				ok: false,
 				reasons
@@ -15483,7 +15570,11 @@ function evidencePreservedValidator(options) {
 * text is its own failure reason, because coverage of a missing
 * section cannot silently count as satisfied.
 * requiredSectionsValidator still owns plain presence. Default name
-* 'section-citations'.
+* 'section-citations'. `match: 'line'` anchors each section at the
+* first line equal to its marker and `fencedCode: 'excluded'` removes
+* fenced code before anchoring, slicing, and counting (cycle 74), so a
+* marker echoed inside a code sample can neither anchor a slice nor
+* donate citations; both default to the historical behavior.
 */
 function sectionCitationsValidator(options) {
 	const sections = requireNonEmptyStrings(options.sections, "sectionCitationsValidator sections");
@@ -15496,12 +15587,17 @@ function sectionCitationsValidator(options) {
 		throw new ConfigError(`sectionCitationsValidator pattern does not compile: ${thrown instanceof Error ? thrown.message : String(thrown)}`);
 	}
 	if (!Number.isInteger(options.min) || options.min < 1) throw new ConfigError(`sectionCitationsValidator min must be a positive integer; got ${String(options.min)}`);
+	const match = options.match === void 0 ? "anywhere" : requireSectionMatchMode(options.match, "sectionCitationsValidator match");
+	const fencedCode = options.fencedCode === void 0 ? "counted" : requireFencedCodeMode(options.fencedCode, "sectionCitationsValidator fencedCode");
+	const qualifier = missingSectionQualifier(match, fencedCode);
+	const counted = fencedCode === "excluded" ? " (fenced code excluded)" : "";
 	return {
 		name: options.name ?? "section-citations",
 		validate: (input) => {
+			const scope = fencedCode === "excluded" ? stripFencedBlocks(input.text) : input.text;
 			const positions = /* @__PURE__ */ new Map();
 			for (const section of sections) {
-				const at = input.text.indexOf(section);
+				const at = sectionPosition(scope, section, match);
 				if (at >= 0) positions.set(section, at);
 			}
 			const ordered = [...positions.entries()].sort((a, b) => a[1] - b[1]);
@@ -15509,12 +15605,12 @@ function sectionCitationsValidator(options) {
 			for (const section of sections) {
 				const at = positions.get(section);
 				if (at === void 0) {
-					reasons.push(`required section '${section}' is missing, so its citation coverage cannot be judged`);
+					reasons.push(`required section '${section}' is missing${qualifier}, so its citation coverage cannot be judged`);
 					continue;
 				}
 				const next = ordered.find(([, position]) => position > at);
-				const matches = input.text.slice(at, next === void 0 ? input.text.length : next[1]).match(new RegExp(pattern, globalFlags))?.length ?? 0;
-				if (matches < options.min) reasons.push(`section '${section}' carries ${String(matches)} citations matching /${pattern}/; at least ${String(options.min)} required`);
+				const matches = scope.slice(at, next === void 0 ? scope.length : next[1]).match(new RegExp(pattern, globalFlags))?.length ?? 0;
+				if (matches < options.min) reasons.push(`section '${section}' carries ${String(matches)} citations matching /${pattern}/${counted}; at least ${String(options.min)} required`);
 			}
 			return reasons.length === 0 ? ok : {
 				ok: false,
@@ -15530,6 +15626,10 @@ function sectionCitationsValidator(options) {
 * ConfigError before any run exists) and matches globally; `min` is a
 * positive integer. Default name 'min-matches'; pass `name` to run
 * several instances, because names must be unique per orchestrate call.
+* `fencedCode: 'excluded'` matches only outside fenced code blocks
+* (cycle 74), so citations quoted inside code samples do not count;
+* the default matches everything, byte identical to the historical
+* behavior.
 */
 function minMatchesValidator(options) {
 	const flags = options.flags ?? "";
@@ -15540,13 +15640,15 @@ function minMatchesValidator(options) {
 		throw new ConfigError(`minMatchesValidator pattern does not compile: ${thrown instanceof Error ? thrown.message : String(thrown)}`);
 	}
 	if (!Number.isInteger(options.min) || options.min < 1) throw new ConfigError(`minMatchesValidator min must be a positive integer; got ${String(options.min)}`);
+	const fencedCode = options.fencedCode === void 0 ? "counted" : requireFencedCodeMode(options.fencedCode, "minMatchesValidator fencedCode");
+	const counted = fencedCode === "excluded" ? " (fenced code excluded)" : "";
 	return {
 		name: options.name ?? "min-matches",
 		validate: (input) => {
-			const found = input.text.match(new RegExp(options.pattern, globalFlags))?.length ?? 0;
+			const found = (fencedCode === "excluded" ? stripFencedBlocks(input.text) : input.text).match(new RegExp(options.pattern, globalFlags))?.length ?? 0;
 			return found >= options.min ? ok : {
 				ok: false,
-				reasons: [`expected at least ${String(options.min)} matches of /${options.pattern}/${flags}; found ${String(found)}`]
+				reasons: [`expected at least ${String(options.min)} matches of /${options.pattern}/${flags}; found ${String(found)}${counted}`]
 			};
 		}
 	};
@@ -15590,7 +15692,7 @@ function countWords(text) {
 */
 function finishContract(manifest) {
 	if (typeof manifest !== "object" || manifest === null) throw new ConfigError("finishContract manifest must be an object");
-	const { sections, words, citations } = manifest;
+	const { sections, sectionsMatch, words, citations, fencedCode } = manifest;
 	if (sections === void 0 && words === void 0 && citations === void 0) throw new ConfigError("finishContract manifest must declare sections, words, or citations");
 	let normalizedSections;
 	if (sections !== void 0) {
@@ -15646,36 +15748,65 @@ function finishContract(manifest) {
 			...citations.perSection === void 0 ? {} : { perSection: citations.perSection }
 		};
 	}
+	let normalizedSectionsMatch;
+	if (sectionsMatch !== void 0) {
+		if (sectionsMatch !== "anywhere" && sectionsMatch !== "line") throw new ConfigError(`finishContract sectionsMatch must be 'anywhere' or 'line'; got ${String(sectionsMatch)}`);
+		if (normalizedSections === void 0) throw new ConfigError("finishContract sectionsMatch requires sections");
+		if (sectionsMatch === "line") normalizedSectionsMatch = "line";
+	}
+	let normalizedFencedCode;
+	if (fencedCode !== void 0) {
+		if (fencedCode !== "counted" && fencedCode !== "excluded") throw new ConfigError(`finishContract fencedCode must be 'counted' or 'excluded'; got ${String(fencedCode)}`);
+		if (fencedCode === "excluded") normalizedFencedCode = "excluded";
+	}
+	if (normalizedFencedCode === "excluded") {
+		const opensFence = /^\s*(`{3,}|~{3,})/;
+		for (const section of normalizedSections ?? []) if (opensFence.test(section)) throw new ConfigError(`finishContract section '${section}' would open a code fence under fencedCode 'excluded'`);
+		if (normalizedCitations !== void 0 && opensFence.test(normalizedCitations.sample)) throw new ConfigError(`finishContract citations.sample '${normalizedCitations.sample}' would open a code fence under fencedCode 'excluded'`);
+	}
 	const normalized = {
 		...normalizedSections === void 0 ? {} : { sections: normalizedSections },
+		...normalizedSectionsMatch === void 0 ? {} : { sectionsMatch: normalizedSectionsMatch },
 		...normalizedWords === void 0 ? {} : { words: normalizedWords },
-		...normalizedCitations === void 0 ? {} : { citations: normalizedCitations }
+		...normalizedCitations === void 0 ? {} : { citations: normalizedCitations },
+		...normalizedFencedCode === void 0 ? {} : { fencedCode: normalizedFencedCode }
 	};
 	const hash = createHash("sha256").update(jcsSerialize(normalized), "utf8").digest("hex");
+	if (normalizedSections !== void 0) Object.freeze(normalizedSections);
+	if (normalizedWords !== void 0) Object.freeze(normalizedWords);
+	if (normalizedCitations !== void 0) Object.freeze(normalizedCitations);
+	const matchOption = normalizedSectionsMatch === void 0 ? {} : { match: normalizedSectionsMatch };
+	const fencedOption = normalizedFencedCode === void 0 ? {} : { fencedCode: normalizedFencedCode };
 	const validators = [];
 	if (normalizedSections !== void 0) validators.push(requiredSectionsValidator({
 		sections: normalizedSections,
-		name: "contract-sections"
+		name: "contract-sections",
+		...matchOption,
+		...fencedOption
 	}));
 	if (normalizedWords !== void 0) validators.push(wordCountValidator({
 		...normalizedWords,
-		name: "contract-words"
+		name: "contract-words",
+		...fencedOption
 	}));
 	if (normalizedCitations?.min !== void 0) validators.push(minMatchesValidator({
 		pattern: normalizedCitations.pattern,
 		flags: normalizedCitations.flags,
 		min: normalizedCitations.min,
-		name: "contract-citations"
+		name: "contract-citations",
+		...fencedOption
 	}));
 	if (normalizedCitations?.perSection !== void 0 && normalizedSections !== void 0) validators.push(sectionCitationsValidator({
 		sections: normalizedSections,
 		pattern: normalizedCitations.pattern,
 		flags: normalizedCitations.flags,
 		min: normalizedCitations.perSection,
-		name: "contract-section-citations"
+		name: "contract-section-citations",
+		...matchOption,
+		...fencedOption
 	}));
 	const promptLines = [];
-	if (normalizedSections !== void 0) promptLines.push("The final result must contain each of these section markers verbatim: " + normalizedSections.map((section) => `'${section}'`).join(", ") + ".");
+	if (normalizedSections !== void 0) promptLines.push((normalizedSectionsMatch === "line" ? "The final result must contain each of these section markers verbatim, each on its own line: " : "The final result must contain each of these section markers verbatim: ") + normalizedSections.map((section) => `'${section}'`).join(", ") + ".");
 	if (normalizedWords !== void 0) {
 		const { min, max } = normalizedWords;
 		if (min !== void 0 && max !== void 0) promptLines.push(`The final result must be between ${String(min)} and ${String(max)} words (whitespace separated).`);
@@ -15686,6 +15817,7 @@ function finishContract(manifest) {
 		if (normalizedCitations.min !== void 0) promptLines.push(`Include at least ${String(normalizedCitations.min)} citations matching /${normalizedCitations.pattern}/ overall (for example '${normalizedCitations.sample}').`);
 		if (normalizedCitations.perSection !== void 0) promptLines.push(`Every required section must itself contain at least ${String(normalizedCitations.perSection)} such citations.`);
 	}
+	if (normalizedFencedCode === "excluded") promptLines.push("Text inside fenced code blocks (``` or ~~~) does not count toward sections, word counts, or citations.");
 	const lines = [];
 	const perSection = normalizedCitations?.perSection ?? 0;
 	for (const section of normalizedSections ?? []) {
@@ -15725,13 +15857,69 @@ function finishContract(manifest) {
 		text: "",
 		children: Object.freeze([])
 	}) : void 0;
+	for (const validator of validators) {
+		const verdict = validator.validate(goldenAccept);
+		if (!verdict.ok) throw new ConfigError(`finishContract self check failed: '${validator.name}' rejects the generated golden accept fixture: ${verdict.reasons.join("; ")}`);
+	}
+	const rejectInput = (text) => Object.freeze({
+		result: text,
+		text,
+		children: Object.freeze([])
+	});
+	const goldenRejects = [];
+	const addGoldenReject = (validator, candidate) => {
+		let fixture = rejectInput(candidate);
+		if (validator.validate(fixture).ok) fixture = rejectInput("");
+		if (validator.validate(fixture).ok) throw new ConfigError(`finishContract cannot build a reject golden for '${validator.name}': it accepts both the boundary fixture and the empty text, so it validates nothing`);
+		goldenRejects.push(Object.freeze({
+			validator: validator.name,
+			input: fixture
+		}));
+	};
+	for (const validator of validators) switch (validator.name) {
+		case "contract-sections": {
+			if (normalizedSections === void 0) break;
+			const last = normalizedSections[normalizedSections.length - 1];
+			addGoldenReject(validator, goldenText.split("\n").filter((line) => line !== last).join("\n"));
+			break;
+		}
+		case "contract-words": {
+			const deficit = normalizedWords?.min !== void 0 ? normalizedWords.min - 1 : (normalizedWords?.max ?? 0) + 1;
+			addGoldenReject(validator, Array.from({ length: deficit }, () => FILLER_WORD).join(" "));
+			break;
+		}
+		case "contract-citations": {
+			if (normalizedCitations === void 0) break;
+			const sample = normalizedCitations.sample;
+			addGoldenReject(validator, Array.from({ length: (normalizedCitations.min ?? 1) - 1 }, () => sample).join(" "));
+			break;
+		}
+		case "contract-section-citations": {
+			if (normalizedSections === void 0 || normalizedCitations === void 0) break;
+			const markers = normalizedSections;
+			const sample = normalizedCitations.sample;
+			const per = normalizedCitations.perSection ?? 1;
+			const rows = [];
+			markers.forEach((section, index) => {
+				rows.push(section);
+				const grant = index === markers.length - 1 ? per - 1 : per;
+				if (grant > 0) rows.push(Array.from({ length: grant }, () => sample).join(" "));
+			});
+			addGoldenReject(validator, rows.join("\n"));
+			break;
+		}
+		default: break;
+	}
+	for (const validator of validators) Object.freeze(validator);
+	Object.freeze(validators);
 	return Object.freeze({
 		manifest: Object.freeze(normalized),
 		hash,
 		validators,
 		promptLines: Object.freeze(promptLines),
 		goldenAccept,
-		...goldenReject === void 0 ? {} : { goldenReject }
+		...goldenReject === void 0 ? {} : { goldenReject },
+		goldenRejects: Object.freeze(goldenRejects)
 	});
 }
 /**
@@ -15744,7 +15932,12 @@ function finishContract(manifest) {
 * nothing). A validator that THROWS here is a host defect and the
 * ConfigError propagates, the same posture the live loop takes.
 * Deterministic and free: validators are pure synchronous host code by
-* contract, so this costs zero provider calls.
+* contract, so this costs zero provider calls. `rejects` (cycle 74)
+* carries the contract's per validator reject goldens: for each one
+* the CONFIGURED validator of that name must exist and must reject
+* the fixture, so a same-name replacement weaker than the contract's
+* own validator fails here instead of silently accepting what the
+* journaled contract hash forbids.
 */
 function selfTestFinishValidation(options) {
 	const run = (validator, input) => {
@@ -15771,6 +15964,22 @@ function selfTestFinishValidation(options) {
 			reasons: ["every configured validator accepts the known-bad fixture; the validation is vacuous"]
 		});
 	}
+	for (const golden of options.rejects ?? []) {
+		const named = options.validators.find((validator) => validator.name === golden.validator);
+		if (named === void 0) {
+			failures.push({
+				fixture: "reject",
+				validator: golden.validator,
+				reasons: [`no configured validator is named '${golden.validator}', so its reject golden cannot run`]
+			});
+			continue;
+		}
+		if (run(named, golden.input).ok) failures.push({
+			fixture: "reject",
+			validator: golden.validator,
+			reasons: ["the configured validator accepts the fixture the contract's own validator rejects; a same name replacement must be at least as strict"]
+		});
+	}
 	return {
 		ok: failures.length === 0,
 		failures
@@ -15903,13 +16112,15 @@ function validateOrchestrateOptions(opts) {
 		const acceptFixture = selfTest?.accept ?? contract?.goldenAccept;
 		const rejectFixture = selfTest?.reject ?? contract?.goldenReject;
 		if (selfTest !== void 0 && acceptFixture === void 0 && rejectFixture === void 0) throw new ConfigError("orchestrate finishValidation.selfTest requires an accept or reject fixture");
-		if (acceptFixture !== void 0 || rejectFixture !== void 0) {
+		const rejectGoldens = contract?.goldenRejects;
+		if (acceptFixture !== void 0 || rejectFixture !== void 0 || rejectGoldens !== void 0) {
 			const report = selfTestFinishValidation({
 				validators: fv.validators,
 				...acceptFixture === void 0 ? {} : { accept: acceptFixture },
-				...rejectFixture === void 0 ? {} : { reject: rejectFixture }
+				...rejectFixture === void 0 ? {} : { reject: rejectFixture },
+				...rejectGoldens === void 0 ? {} : { rejects: rejectGoldens }
 			});
-			if (!report.ok) throw new ConfigError("the finish validation self test failed BEFORE any provider call: " + report.failures.map((failure) => failure.validator === void 0 ? failure.reasons.join("; ") : `validator '${failure.validator}' rejected the accept fixture: ` + failure.reasons.join("; ")).join("; "));
+			if (!report.ok) throw new ConfigError("the finish validation self test failed BEFORE any provider call: " + report.failures.map((failure) => failure.validator === void 0 ? failure.reasons.join("; ") : failure.fixture === "reject" ? `validator '${failure.validator}' failed its reject golden: ` + failure.reasons.join("; ") : `validator '${failure.validator}' rejected the accept fixture: ` + failure.reasons.join("; ")).join("; "));
 		}
 	}
 	if (opts.synthesis !== void 0) {
@@ -16869,6 +17080,12 @@ function makeOrchestratorWorkflow(goal, opts) {
 		const validationSpec = opts?.finishValidation;
 		const validationAbort = new AbortController();
 		let validationTermination;
+		/**
+		* The synthesis invocation's schema-dead finish exchanges (cycle
+		* 73), captured from its full agent result so the failure
+		* enrichment can fold BOTH windows into one honest counter.
+		*/
+		let synthesisSchemaRejectedExchanges = 0;
 		const finishValidationError = (decision) => new FailRunError(`the orchestrator finish failed host validation with all ${String(decision.maxRepairs)} repair attempts spent: ` + decision.failed.map((f) => `validator '${f.name}' rejected: ${f.reasons.join("; ")}`).join("; "), { data: {
 			source: "orchestrator_finish_validation",
 			callId: decision.callId,
@@ -16877,6 +17094,22 @@ function makeOrchestratorWorkflow(goal, opts) {
 			maxRepairs: decision.maxRepairs
 		} });
 		const validationDecisions = () => internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.value?.decisionType === "orchestrator_finish_validation").map((entry) => entry.value);
+		/**
+		* The contract generation membership test (cycle 73). Without a
+		* contract there are no generations and every decision is current
+		* (the pre 1.77 behavior, byte identical). With one, a decision
+		* belongs to the current generation when its journaled hash matches
+		* the live contract; a pre 1.77 decision carries no hash and counts
+		* as current only while the journal has never recorded a
+		* superseding bundle descriptor, because a single descriptor means
+		* every decision was necessarily rendered under it.
+		*/
+		const contractGenerationCurrent = (decision) => {
+			const hash = validationSpec?.contract?.hash;
+			if (hash === void 0) return true;
+			if (decision.contractHash !== void 0) return decision.contractHash === hash;
+			return internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.value?.decisionType === "orchestrator_finish_validation_bundle").length <= 1;
+		};
 		const validateFinish = async (call) => {
 			if (validationSpec === void 0) return { ok: true };
 			const maxRepairs = validationSpec.maxRepairs ?? 1;
@@ -16915,14 +17148,15 @@ function makeOrchestratorWorkflow(goal, opts) {
 						reasons: verdict.reasons
 					});
 				}
-				const repairsUsed = known.filter((candidate) => candidate.verdict !== "accepted").length;
+				const repairsUsed = known.filter((candidate) => candidate.verdict !== "accepted" && contractGenerationCurrent(candidate)).length;
 				decision = {
 					decisionType: "orchestrator_finish_validation",
 					callId: call.id,
 					verdict: failed.length === 0 ? "accepted" : repairsUsed < maxRepairs ? "repair" : "rejected",
 					failed,
 					repairsUsed,
-					maxRepairs
+					maxRepairs,
+					...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash }
 				};
 				await internals.replayer.appendSinglePhase({
 					scope: callingState.scope,
@@ -16936,8 +17170,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 			}
 			if (decision.verdict === "accepted") return { ok: true };
 			if (decision.verdict === "rejected") {
-				validationTermination = finishValidationError(decision);
-				validationAbort.abort("rulvar:finish-validation");
+				if (contractGenerationCurrent(decision)) {
+					validationTermination = finishValidationError(decision);
+					validationAbort.abort("rulvar:finish-validation");
+				}
 				return {
 					ok: false,
 					feedback: {
@@ -17357,6 +17593,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				}
 			};
 			const synthesized = await runtime.runInScope(synthesisState, () => ctx.agent(prompt, synthesisOpts));
+			synthesisSchemaRejectedExchanges = synthesized.schemaRejectedTerminalExchanges ?? 0;
 			if (validationTermination !== void 0) throw validationTermination;
 			if (synthesized.status === "ok") return synthesized.output;
 			if (validationSpec !== void 0) throw new FailRunError(`the synthesis invocation terminated with status '${synthesized.status}'` + (synthesized.errorMessage === void 0 ? "" : `: ${synthesized.errorMessage}`) + "; finish validators are configured, so the unvalidated draft cannot stand", { data: {
@@ -17419,7 +17656,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 		if (capDecisionRef !== void 0) return await settleCapOutcome();
 		if (validationSpec !== void 0) {
 			const priorRejection = validationDecisions().find((decision) => decision.verdict === "rejected");
-			if (priorRejection !== void 0) throw finishValidationError(priorRejection);
+			if (priorRejection !== void 0) {
+				const settle = lastRunSettle(internals.replayer.snapshot());
+				if (settle !== void 0 && settle.runStatus !== "running" && settle.runStatus !== "suspended" || contractGenerationCurrent(priorRejection)) throw finishValidationError(priorRejection);
+			}
 		}
 		const promptLines = [
 			...extension?.promptLines?.() ?? [],
@@ -17430,28 +17670,28 @@ function makeOrchestratorWorkflow(goal, opts) {
 		const liveTermination = extensionTermination;
 		if (liveTermination !== void 0) throw liveTermination;
 		if (capDecisionRef !== void 0) return await settleCapOutcome();
-		if (validationTermination !== void 0) throw validationTermination;
-		if (orchestratorAccount !== void 0) internals.cost.orchestrator.spentUsd = internals.budget.accountView(orchestratorAccount)?.spentUsd ?? 0;
-		if (result.status !== "ok") throw new ConfigError(`the orchestrator agent terminated with status '${result.status}'` + (result.errorMessage === void 0 ? "" : `: ${result.errorMessage}`));
 		/**
-		* The synthesis failure enrichment (the v1.71 experiment review,
-		* P0.8 remainder + P1.7): every typed failure a synthesis
-		* invocation throws gains the verdict-derived repair taxonomy read
-		* from the JOURNALED validation decisions (identical live and on
-		* replay), and, when an acceptance verdict exists, the acceptance
-		* snapshot the children already earned; the completion mirror then
-		* lifts completion and childStatusCounts onto the error outcome,
-		* exactly like the acceptance rejection path. The experiment's
-		* outcome showed completion null beside four accepted children;
-		* these are the fields that say "the fan-out work is complete, the
-		* failure is downstream". The rejection-past-the-bound error keeps
-		* its own repairsUsed/maxRepairs/failed untouched.
+		* The finish-validation failure enrichment (the v1.71 experiment
+		* review, P0.8 remainder + P1.7; widened by cycle 73): every typed
+		* failure a finish rejection produces gains the verdict-derived
+		* repair taxonomy read from the JOURNALED validation decisions of
+		* the CURRENT contract generation (identical live and on replay),
+		* the schema-dead finish exchange counter derived from the
+		* coordination and synthesis windows (the class the v1.74 run lost
+		* six payloads to, invisible in every other field), and, when an
+		* acceptance verdict exists, the acceptance snapshot the children
+		* already earned: completion and childStatusCounts, and now the
+		* degradation facts beside them (degradedReasons and the salvage
+		* lists), exactly what the ok envelope reports. The
+		* rejection-past-the-bound error keeps its own
+		* repairsUsed/maxRepairs/failed untouched.
 		*/
 		const enrichSynthesisFailure = (thrown, snapshot) => {
 			if (!(thrown instanceof FailRunError)) throw thrown;
 			const base = thrown.data ?? {};
-			const spent = validationDecisions().filter((candidate) => candidate.verdict !== "accepted");
+			const spent = validationDecisions().filter((candidate) => candidate.verdict !== "accepted" && contractGenerationCurrent(candidate));
 			const rejectedValidators = [...new Set(spent.flatMap((candidate) => candidate.failed.map((f) => f.name)))];
+			const schemaRejected = (result.schemaRejectedTerminalExchanges ?? 0) + synthesisSchemaRejectedExchanges;
 			throw new FailRunError(thrown.message, { data: {
 				...base,
 				...snapshot ?? {},
@@ -17459,9 +17699,13 @@ function makeOrchestratorWorkflow(goal, opts) {
 					repairsUsed: spent.length,
 					maxRepairs: validationSpec?.maxRepairs ?? 1,
 					rejectedValidators
-				}
+				},
+				...schemaRejected === 0 || base.schemaRejectedFinishExchanges !== void 0 ? {} : { schemaRejectedFinishExchanges: schemaRejected }
 			} });
 		};
+		if (validationTermination !== void 0) enrichSynthesisFailure(validationTermination);
+		if (orchestratorAccount !== void 0) internals.cost.orchestrator.spentUsd = internals.budget.accountView(orchestratorAccount)?.spentUsd ?? 0;
+		if (result.status !== "ok") throw new ConfigError(`the orchestrator agent terminated with status '${result.status}'` + (result.errorMessage === void 0 ? "" : `: ${result.errorMessage}`));
 		if (opts?.acceptance === void 0) try {
 			return await runSynthesis(result.output);
 		} catch (thrown) {
@@ -17545,7 +17789,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 		} catch (thrown) {
 			enrichSynthesisFailure(thrown, {
 				completion: decision.completion,
-				childStatusCounts: decision.childStatusCounts
+				childStatusCounts: decision.childStatusCounts,
+				degradedReasons: decision.degradedReasons,
+				...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren },
+				...decision.salvagedTerminalOutputChildren === void 0 ? {} : { salvagedTerminalOutputChildren: decision.salvagedTerminalOutputChildren }
 			});
 		}
 		return {
@@ -17677,6 +17924,39 @@ function preflightEstimate(input) {
 	const say = (finding) => {
 		findings.push(finding);
 	};
+	/**
+	* The contract turn feasibility check (the v1.74 experiment review,
+	* cycle 73), run against the invocation the validators bind. The
+	* floor is the contract's own minimal accepting payload, serialized
+	* exactly as the model must emit it ({ result }) and priced at the
+	* loop's four-characters-per-token output heuristic: the v1.74 run's
+	* conforming payloads truncated at their 9000 token turn cap, and its
+	* contract's minimum alone prices above that cap. A minimum at or
+	* over the bound is an error (every conforming finish truncates mid
+	* payload); a minimum within double of the bound is a warning,
+	* because real conforming payloads run richer than the minimum.
+	*/
+	const contractFeasibilityFindings = (outputBound, spawn, servedBy) => {
+		const contract = input.finishValidation?.contract;
+		if (contract === void 0 || outputBound === void 0) return;
+		const minTokens = Math.ceil(JSON.stringify({ result: contract.goldenAccept.text }).length / 4);
+		const which = spawn === "synthesis" ? "the synthesis invocation" : "the coordination loop";
+		if (minTokens >= outputBound) {
+			say({
+				severity: "error",
+				code: "output-contract-turn-infeasible",
+				message: `the finish contract's minimal accepting payload is about ${String(minTokens)} tokens (four characters per token over the golden accept fixture) but ${which} dispatches at most ${String(outputBound)} output tokens per turn ('${servedBy}'): every conforming finish truncates mid payload; raise maxOutputTokensPerTurn or shrink the contract`,
+				spawn
+			});
+			return;
+		}
+		if (minTokens * 2 > outputBound) say({
+			severity: "warning",
+			code: "output-contract-turn-headroom",
+			message: `the finish contract's minimal accepting payload is about ${String(minTokens)} tokens against the ${String(outputBound)} token output bound of ${which} ('${servedBy}'): real conforming payloads run richer than the minimum and the margin is under double; raise the bound or trim the contract`,
+			spawn
+		});
+	};
 	const adapters = new Map((engine.adapters ?? []).map((adapter) => [adapter.id, adapter]));
 	const capsOf = (ref) => {
 		const { adapterId, model } = parseModelRef(ref);
@@ -17922,6 +18202,7 @@ function preflightEstimate(input) {
 				message: `the orchestrator sets maxOutputTokensPerTurn ${String(orchLimits.maxOutputTokensPerTurn)} below the ${String(caps.minOutputTokensPerTurn)} token output floor of '${servedBy}': every dispatch would be refused typed before the wire; raise the cap to at least the floor`,
 				spawn: "orchestrator"
 			});
+			if (input.orchestrator.synthesis === void 0) contractFeasibilityFindings(outputBound, "orchestrator", servedBy);
 			const { adapterId, model } = parseModelRef(servedBy);
 			const unit = {
 				label: "orchestrator",
@@ -17990,6 +18271,7 @@ function preflightEstimate(input) {
 					message: `the synthesis invocation sets maxOutputTokensPerTurn ${String(merged.maxOutputTokensPerTurn)} below the ${String(caps.minOutputTokensPerTurn)} token output floor of '${servedBy}': every dispatch would be refused typed before the wire; raise the cap to at least the floor`,
 					spawn: "synthesis"
 				});
+				contractFeasibilityFindings(outputBound, "synthesis", servedBy);
 				const projected = projectedProviderTurnsOf(merged, overallExecutedCeiling(merged, toolCeilingsOf(merged))) + finishRepairReserve;
 				if (orchestratorEcho !== void 0) orchestratorEcho.synthesis = {
 					projectedProviderTurns: projected,
@@ -18214,6 +18496,15 @@ function preflightEstimate(input) {
 			names.add(validator.name);
 		}
 		if (fv.repairTurnReserve !== void 0) requireNonNegativeInteger(fv.repairTurnReserve, "preflight finishValidation.repairTurnReserve");
+		if (fv.maxRepairs !== void 0) requireNonNegativeInteger(fv.maxRepairs, "preflight finishValidation.maxRepairs");
+		{
+			const grantedRepairs = fv.maxRepairs ?? 1;
+			if (grantedRepairs > 0 && fv.repairTurnReserve === void 0) findings.push({
+				severity: "warning",
+				code: "repair-reserve-unfunded",
+				message: `finishValidation grants up to ${String(grantedRepairs)} repair exchange(s) but declares no repairTurnReserve: a rejected finish burns an ordinary turn and a window at maxTurns settles 'limit' with the repair unspent; set finishValidation.repairTurnReserve to fund the repair exchanges`
+			});
+		}
 		if (fv.contract !== void 0) {
 			for (const contractValidator of fv.contract.validators) if (!names.has(contractValidator.name)) findings.push({
 				severity: "error",
@@ -18223,19 +18514,24 @@ function preflightEstimate(input) {
 		}
 		const acceptFixture = fv.selfTest?.accept ?? fv.contract?.goldenAccept;
 		const rejectFixture = fv.selfTest?.reject ?? fv.contract?.goldenReject;
+		const rejectGoldens = fv.contract?.goldenRejects;
 		let selfTestOutcome = "skipped";
-		if (acceptFixture !== void 0 || rejectFixture !== void 0) {
+		if (acceptFixture !== void 0 || rejectFixture !== void 0 || rejectGoldens !== void 0) {
 			const report = selfTestFinishValidation({
 				validators: fv.validators,
 				...acceptFixture === void 0 ? {} : { accept: acceptFixture },
-				...rejectFixture === void 0 ? {} : { reject: rejectFixture }
+				...rejectFixture === void 0 ? {} : { reject: rejectFixture },
+				...rejectGoldens === void 0 ? {} : { rejects: rejectGoldens }
 			});
 			selfTestOutcome = report.ok ? "passed" : "failed";
-			for (const failure of report.failures) findings.push({
-				severity: "error",
-				code: "output-contract-validator-mismatch",
-				message: failure.validator === void 0 ? failure.reasons.join("; ") : `validator '${failure.validator}' rejected the golden accept fixture: ` + failure.reasons.join("; ")
-			});
+			for (const failure of report.failures) {
+				const weakened = failure.fixture === "reject" && failure.validator !== void 0;
+				findings.push({
+					severity: "error",
+					code: weakened ? "output-contract-validator-weakened" : "output-contract-validator-mismatch",
+					message: failure.validator === void 0 ? failure.reasons.join("; ") : weakened ? `validator '${failure.validator}' failed its reject golden: ` + failure.reasons.join("; ") : `validator '${failure.validator}' rejected the golden accept fixture: ` + failure.reasons.join("; ")
+				});
+			}
 		}
 		finishValidationEcho = {
 			...fv.contract === void 0 ? {} : { contractHash: fv.contract.hash },
@@ -20063,4 +20359,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, finishContract, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, finishContract, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotUsage, spawnDepthOf, stripFencedBlocks, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.76.0",
+  "version": "1.78.0",
   "description": "Rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
   "type": "module",
   "license": "Apache-2.0",