@rulvar/core 1.73.0 → 1.75.0

package/dist/index.d.ts

@@ -1531,7 +1531,17 @@ type ModelCaps = {
   supportsParallelTools: boolean; /** Canonical efforts this model accepts after mapping. */
   reasoningEfforts: Effort[];
   contextWindow: number;
-  maxOutputTokens: number; /** Adapter-reported fallback only; the versioned price table wins. */
+  maxOutputTokens: number;
+  /**
+  * The smallest request output cap the provider accepts (the v1.74
+  * experiment review, P0.1): OpenAI's Responses API rejects
+  * max_output_tokens below 16, so a dispatch under this floor is a
+  * guaranteed 400. The runtime never sends a request output cap below
+  * it: a budget last gasp dispatches the floor instead of one token,
+  * and a remainder that cannot buy the floor is refused typed before
+  * the wire. Absent means one, the historical floor.
+  */
+  minOutputTokensPerTurn?: number; /** Adapter-reported fallback only; the versioned price table wins. */
   pricing?: Pricing;
 };
 interface ProviderAdapter {
@@ -3111,12 +3121,33 @@ interface EngineQuotaConfig {
   * knob. reconcile failures only ever warn.
   */
   onLimiterError?: "deny" | "allow";
+  /**
+  * The drift telemetry opt-in (the v1.71 experiment review, P0.5
+  * resized): the SAME rule declaration `preflightEstimate` takes as
+  * `quotaRules`, mirrored here so the engine can hold it against what
+  * providers actually REPORT. When a live 429 carries
+  * provider-normalized limits (the openai and anthropic adapters
+  * parse the x-ratelimit headers into
+  * `WireError.data.reportedLimits`) and a declared per-minute cap
+  * EXCEEDS the reported one, the run journals a `quota_drift`
+  * decision (provider, model, tenant, dimension, declared, reported;
+  * one per invocation and dimension) and emits a warn log, because a
+  * limiter configured above the provider's real ceiling
+  * under-throttles and live denials follow: the experiment inflated
+  * 12M TPM over a real 1M and paid seven live 429s with nothing
+  * recording the mismatch. Purely observational: nothing clamps, the
+  * limiter keeps enforcing the declaration (clamping is host policy).
+  * Absent = byte identical journals and events.
+  */
+  declaredRules?: readonly QuotaRule[];
 }
 /** The resolved engine-side quota runtime threaded into every run. */
 interface EngineQuotaRuntime {
   limiter: QuotaLimiter;
   tenant?: string;
   onLimiterError: "deny" | "allow";
+  /** The declared rule mirror for drift telemetry; see {@link EngineQuotaConfig}. */
+  declaredRules?: readonly QuotaRule[];
 }
 /**
 * Validates createEngine's quota config as a typed ConfigError before
@@ -4136,6 +4167,16 @@ interface AgentResult<T> {
   */
   transportRetries?: number;
   /**
+  * Provider-reported rate limits observed on this invocation's 429s
+  * (the v1.71 experiment review, P0.5): one entry per (provider,
+  * model), the latest observation winning, parsed by the adapters
+  * into `WireError.data.reportedLimits`. Live telemetry only, exactly
+  * like transportRetries: never journaled, absent on a replayed
+  * result; the ctx layer holds it against `quota.declaredRules` and
+  * journals the drift verdicts, which ARE durable.
+  */
+  rateLimitObservations?: RateLimitObservation[];
+  /**
   * The exploration guard counters (RV-210): present whenever any of
   * the exploration limits (toolBudgetNotices, maxRepeatedToolSignature,
   * maxNoNewEvidenceCalls) was configured. Journaled inside the terminal
@@ -4157,6 +4198,24 @@ interface AgentResult<T> {
   */
   partial?: ProgressReport;
 }
+/** One 429's provider-normalized limits, per (provider, model). */
+interface RateLimitObservation {
+  provider: string;
+  model: string;
+  /**
+  * Per-minute limits the provider REPORTED in its rate-limit
+  * headers, normalized by the adapter: openai fills
+  * requestsPerMinute and tokensPerMinute; anthropic fills
+  * requestsPerMinute plus the split inputTokensPerMinute and
+  * outputTokensPerMinute.
+  */
+  reportedLimits: {
+    requestsPerMinute?: number;
+    tokensPerMinute?: number;
+    inputTokensPerMinute?: number;
+    outputTokensPerMinute?: number;
+  };
+}
 type EscalatedResult<T> = AgentResult<T> & {
   status: "escalated";
   escalation: EscalationReport;
@@ -8655,6 +8714,17 @@ interface InvoiceRow {
   responseId?: string;
   usage: Usage;
   usageApprox?: boolean;
+  /**
+  * Present and true when this `unconfirmed` row recorded ZERO usage
+  * on every counter (the v1.71 experiment review, P1.4): a failed
+  * attempt whose usage this ledger never saw. The zeros mean
+  * "nothing recorded", never "the provider metered nothing": the
+  * provider may have billed prompt processing before the failure, so
+  * a statement join must treat this row's usage as unknown, not as
+  * zero. Derived at export time from the journaled record; rows with
+  * any recorded usage, and every other verdict, never carry it.
+  */
+  usageUnknown?: true;
   /** This row priced at its own model's rate; absent when no price row covers it. */
   usd?: number;
   /**
@@ -8699,6 +8769,8 @@ interface InvoiceExport {
   }>;
   /** Rows whose reconciliation is not 'provider-id-present'. */
   reconciliationFailures: number;
+  /** Rows carrying `usageUnknown`; present when at least one does. */
+  usageUnknownRows?: number;
   /** Present and true when any contributing entry carried approximate usage. */
   usageApprox?: boolean;
 }
@@ -9496,4 +9568,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, 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, 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 };

package/dist/index.js

@@ -8361,6 +8361,8 @@ function invoiceFromJournal(entries, priceUsd) {
 		const records = entry.providerCalls ?? [];
 		for (const record of records) {
 			const usd = rowUsd(priceUsd, record.servedBy, record.usage);
+			const reconciliation = record.responseId !== void 0 ? "provider-id-present" : record.outcome === "ok" ? "missing-provider-id" : "unconfirmed";
+			const usageUnknown = reconciliation === "unconfirmed" && USAGE_FIELDS.every((field) => record.usage[field] === 0) && (record.usage.reasoningTokens ?? 0) === 0;
 			rows.push({
 				...base,
 				ordinal: record.ordinal,
@@ -8371,10 +8373,11 @@ function invoiceFromJournal(entries, priceUsd) {
 				...record.responseId === void 0 ? {} : { responseId: record.responseId },
 				usage: record.usage,
 				...record.usageApprox === true ? { usageApprox: true } : {},
+				...usageUnknown ? { usageUnknown: true } : {},
 				...usd === void 0 ? {} : { usd },
 				allocatedUsd: 0,
 				...mark,
-				reconciliation: record.responseId !== void 0 ? "provider-id-present" : record.outcome === "ok" ? "missing-provider-id" : "unconfirmed"
+				reconciliation
 			});
 		}
 		if (records.length === 0) {
@@ -8424,6 +8427,10 @@ function invoiceFromJournal(entries, priceUsd) {
 		rowUsdNonAdditive: true,
 		unpriced: [...report.unpriced, ...report.abandoned.unpriced],
 		reconciliationFailures: rows.filter((row) => row.reconciliation !== "provider-id-present").length,
+		...(() => {
+			const count = rows.filter((row) => row.usageUnknown === true).length;
+			return count === 0 ? {} : { usageUnknownRows: count };
+		})(),
 		...usageApprox ? { usageApprox: true } : {}
 	};
 }
@@ -8954,6 +8961,8 @@ function validateEngineQuotaConfig(config, site = "createEngine quota") {
 	if (typeof limiter !== "object" || limiter === null || typeof limiter.reserve !== "function" || typeof limiter.reconcile !== "function") throw new ConfigError(`${site}.limiter must implement QuotaLimiter (reserve and reconcile functions)`);
 	if (candidate.tenant !== void 0 && (typeof candidate.tenant !== "string" || candidate.tenant === "")) throw new ConfigError(`${site}.tenant must be a nonempty string when given`);
 	if (candidate.onLimiterError !== void 0 && candidate.onLimiterError !== "deny" && candidate.onLimiterError !== "allow") throw new ConfigError(`${site}.onLimiterError must be 'deny' or 'allow' when given`);
+	const declared = candidate.declaredRules;
+	if (declared !== void 0) validateQuotaRules(declared, `${site}.declaredRules`);
 }
 //#endregion
 //#region src/runtime/usage-limits.ts
@@ -10172,31 +10181,53 @@ function estimateInputTokens(messages) {
 	return Math.ceil(chars / 4);
 }
 /**
+* 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
+* experiment's terminal repair died exactly there (the review, P0.1).
+* Defensive lookup: a caps() throw must not fail turns that never
+* consulted caps at this point before.
+*/
+function outputFloorOf(target) {
+	try {
+		const declared = target.adapter.caps(target.resolved.model).minOutputTokensPerTurn;
+		return declared !== void 0 && Number.isInteger(declared) && declared > 1 ? declared : 1;
+	} catch {
+		return 1;
+	}
+}
+/**
 * Layer 2b at the wire boundary: clamps the outgoing request's
 * maxOutputTokens to what the remaining budget affords from the serving
-* model. The clamp uses the heuristic prompt estimate; the DENIAL does
-* not: a turn is refused (BudgetExhaustedError, never dispatched) only
-* when the remainder cannot buy even ONE output token at zero input,
-* which is exact. Denying on the estimate would kill turns the budget
-* still funds, including the DEF-7 forced finish paid from the released
-* finalize reserve; when the estimate says the prompt alone spends the
-* remainder, the turn dispatches with a one-token output floor and the
-* exact layers (2 and 3) settle the difference. A no-op without a hook
-* or when the hook reports no bound. The clamp touches only the wire
-* request, exactly like limits.maxOutputTokensPerTurn above it; identity
-* is computed at the ctx layer and never sees it.
+* model, and holds every dispatch at or above the serving model's
+* output floor. The clamp uses the heuristic prompt estimate; the
+* DENIAL does not: a turn is refused (BudgetExhaustedError, never
+* dispatched) only when the remainder cannot buy the floor at zero
+* input, which is exact. Denying on the estimate would kill turns the
+* budget still funds, including the DEF-7 forced finish paid from the
+* released finalize reserve; when the estimate says the prompt alone
+* spends the remainder, the turn dispatches AT the floor and the exact
+* layers (2 and 3) settle the difference. A configured per-turn cap
+* below the floor is a ConfigError before any wire call: the provider
+* would reject every dispatch, so failing typed beats paying for a
+* guaranteed 400. A no-op without a hook or when the hook reports no
+* bound. The clamp touches only the wire request, exactly like
+* limits.maxOutputTokensPerTurn above it; identity is computed at the
+* ctx layer and never sees it.
 */
 function applyOutputBudget(req, target, budget) {
+	const floor = outputFloorOf(target);
+	if (req.maxOutputTokens !== void 0 && req.maxOutputTokens < floor) throw new ConfigError(`the per-turn output cap ${String(req.maxOutputTokens)} is below the ${String(floor)} token output floor of ${target.resolved.ref}; the provider would reject every dispatch, so raise limits.maxOutputTokensPerTurn to at least the floor`);
 	const hook = budget?.maxAffordableOutputTokens;
 	if (hook === void 0) return req;
 	const affordable = hook(target.resolved.ref, estimateInputTokens(req.messages));
 	if (affordable === void 0) return req;
-	if (affordable < 1) {
+	if (affordable < floor) {
 		const zeroInputAffordable = hook(target.resolved.ref, 0);
-		if (zeroInputAffordable !== void 0 && zeroInputAffordable < 1) throw new BudgetExhaustedError(`the remaining budget cannot afford one output token from ${target.resolved.ref}; the turn was not dispatched`);
+		if (zeroInputAffordable !== void 0 && zeroInputAffordable < floor) throw new BudgetExhaustedError(floor === 1 ? `the remaining budget cannot afford one output token from ${target.resolved.ref}; the turn was not dispatched` : `the remaining budget cannot afford the ${String(floor)} token output floor of ${target.resolved.ref}; the turn was not dispatched`);
 		return {
 			...req,
-			maxOutputTokens: 1
+			maxOutputTokens: floor
 		};
 	}
 	if (req.maxOutputTokens === void 0 || affordable < req.maxOutputTokens) return {
@@ -10251,6 +10282,101 @@ function assistantMsg(turn, retained = []) {
 	};
 }
 /**
+* The adapter parse-failure wrapper, recognized by exact shape: both
+* first-class wires deliver tool arguments their single strict
+* JSON.parse rejected as `{__unparsed: raw}` and nothing else.
+*/
+function unparsedMarkerOf(args) {
+	if (typeof args !== "object" || args === null || Array.isArray(args)) return;
+	const keys = Object.keys(args);
+	const raw = args.__unparsed;
+	return keys.length === 1 && keys[0] === "__unparsed" && typeof raw === "string" ? raw : void 0;
+}
+/** JSON.parse to a plain object, or undefined; never throws. */
+function parsePlainObject(text) {
+	try {
+		const value = JSON.parse(text);
+		return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* One bounded deterministic normalization of a near-JSON arguments
+* string: strip a single markdown fence, cut at the end of the first
+* balanced top-level object (drops trailing prose), and escape raw
+* control characters inside string literals (models writing markdown
+* documents into arguments emit real newlines, which strict JSON
+* forbids). Truncated payloads stay unbalanced and still fail the
+* parse; nothing here can invent structure the model did not write.
+*/
+function normalizeNearJson(raw) {
+	let text = raw.trim();
+	const fence = /^```[a-zA-Z]*[\t ]*\r?\n([\s\S]*?)\r?\n?```$/.exec(text);
+	if (fence?.[1] !== void 0) text = fence[1].trim();
+	const start = text.indexOf("{");
+	if (start >= 0) {
+		let depth = 0;
+		let inString = false;
+		let escaped = false;
+		for (let index = start; index < text.length; index += 1) {
+			const char = text[index];
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = inString;
+				continue;
+			}
+			if (char === "\"") {
+				inString = !inString;
+				continue;
+			}
+			if (inString) continue;
+			if (char === "{") depth += 1;
+			else if (char === "}") {
+				depth -= 1;
+				if (depth === 0) {
+					text = text.slice(start, index + 1);
+					break;
+				}
+			}
+		}
+	}
+	let escapedText = "";
+	let inString = false;
+	let escaped = false;
+	for (const char of text) {
+		if (!escaped && char === "\"") inString = !inString;
+		escaped = inString && !escaped && char === "\\";
+		const code = char.codePointAt(0) ?? 0;
+		if (inString && code < 32) escapedText += char === "\n" ? "\\n" : char === "\r" ? "\\r" : char === "	" ? "\\t" : `\\u${code.toString(16).padStart(4, "0")}`;
+		else escapedText += char;
+	}
+	return escapedText;
+}
+/**
+* The deterministic second chance (the v1.74 experiment review, P1.5):
+* a strict re-parse of the wrapped raw string, then one normalization
+* pass. The v1.74 experiment durably proved three complete coordination
+* drafts were recoverable this way and were thrown away instead. Only a
+* plain object counts; the recovered value still faces the tool schema
+* at the caller.
+*/
+function recoverUnparsedArgs(raw) {
+	const strict = parsePlainObject(raw);
+	if (strict !== void 0) return {
+		value: strict,
+		pass: "strict"
+	};
+	const normalized = parsePlainObject(normalizeNearJson(raw));
+	if (normalized !== void 0) return {
+		value: normalized,
+		pass: "normalized"
+	};
+}
+/**
 * Executes one model-issued tool call to a tool-result part. Failures are
 * surfaced to the model as error tool results and never thrown past
 * policy: unknown names, argument-validation issues, ModelRetry (bounded
@@ -10279,7 +10405,22 @@ async function executeToolCall(options) {
 		return part;
 	};
 	if (def === void 0) return finish({ error: `unknown tool '${call.name}'` }, "error");
-	const validation = await validateSchemaSpec(def.parameters, call.args);
+	let validation = await validateSchemaSpec(def.parameters, call.args);
+	if (!validation.valid) {
+		const unparsedRaw = unparsedMarkerOf(call.args);
+		const recovered = unparsedRaw === void 0 ? void 0 : recoverUnparsedArgs(unparsedRaw);
+		if (recovered !== void 0) {
+			const revalidation = await validateSchemaSpec(def.parameters, recovered.value);
+			if (revalidation.valid) {
+				validation = revalidation;
+				options.events?.emit({
+					type: "log",
+					level: "warn",
+					msg: `arguments for '${call.name}' arrived unparsed (${String(unparsedRaw?.length ?? 0)} chars) and were recovered by a ${recovered.pass} JSON pass; the recovered object passed the tool schema and the call executed`
+				});
+			}
+		}
+	}
 	if (!validation.valid) return finish({
 		error: `arguments for '${call.name}' failed validation`,
 		issues: validation.issues.map((issue) => issue.message)
@@ -10340,6 +10481,7 @@ async function runAgent(options) {
 	const providerCalls = [];
 	let invocationCounter = 0;
 	let transportRetries = 0;
+	const rateLimitObservations = /* @__PURE__ */ new Map();
 	const roleUsageSnapshot = (role) => {
 		const snapshot = /* @__PURE__ */ new Map();
 		for (const [key, slice] of usageByPhaseModel) if (slice.role === role) snapshot.set(key, slice.usage);
@@ -11017,6 +11159,12 @@ async function runAgent(options) {
 					if (outcome.aborted !== void 0) record.aborted = outcome.aborted;
 					else if (outcome.wireError !== void 0) record.errorCode = outcome.wireError.code;
 					providerCalls.push(record);
+					const limited = outcome.wireError?.data;
+					if (limited?.kind === "rate-limit" && typeof limited.reportedLimits === "object" && limited.reportedLimits !== null) rateLimitObservations.set(`${target.adapter.id}:${target.resolved.model}`, {
+						provider: target.adapter.id,
+						model: target.resolved.model,
+						reportedLimits: limited.reportedLimits
+					});
 				}
 				tries += 1;
 				const retryClass = outcome.aborted === "idle" ? "transport" : outcome.wireError === void 0 ? void 0 : retryClassOf(outcome.wireError);
@@ -11839,6 +11987,7 @@ async function runAgent(options) {
 	if (limitPartial !== void 0) result.partial = limitPartial;
 	if (usageApprox) result.usageApprox = true;
 	if (transportRetries > 0) result.transportRetries = transportRetries;
+	if (rateLimitObservations.size > 0) result.rateLimitObservations = [...rateLimitObservations.values()];
 	return result;
 }
 //#endregion
@@ -13991,6 +14140,59 @@ function createCtx(internals, rootWorkflow) {
 			exitActivity?.();
 		}
 		internals.budget.releaseReserve(reserve, budgetAccount);
+		const declaredRules = internals.quota?.declaredRules;
+		if (declaredRules !== void 0 && result.rateLimitObservations !== void 0) for (const observation of result.rateLimitObservations) {
+			const probe = {
+				provider: observation.provider,
+				model: observation.model,
+				...internals.quota?.tenant === void 0 ? {} : { tenant: internals.quota.tenant },
+				estimate: {
+					requests: 1,
+					inputTokens: 0
+				}
+			};
+			const matching = declaredRules.filter((rule) => quotaRuleMatches(rule, probe));
+			const declaredOf = (pick) => {
+				const caps = matching.map(pick).filter((cap) => cap !== void 0);
+				return caps.length === 0 ? void 0 : Math.min(...caps);
+			};
+			const reported = observation.reportedLimits;
+			const reportedTokens = reported.tokensPerMinute ?? (reported.inputTokensPerMinute !== void 0 && reported.outputTokensPerMinute !== void 0 ? reported.inputTokensPerMinute + reported.outputTokensPerMinute : void 0);
+			const dimensions = [{
+				dimension: "requests",
+				declared: declaredOf((rule) => rule.requestsPerMinute),
+				observed: reported.requestsPerMinute
+			}, {
+				dimension: "tokens",
+				declared: declaredOf((rule) => rule.tokensPerMinute),
+				observed: reportedTokens
+			}];
+			for (const { dimension, declared, observed } of dimensions) {
+				if (declared === void 0 || observed === void 0 || declared <= observed) continue;
+				const key = `quota-drift:${dimension}:${observation.provider}:${observation.model}`;
+				if (!internals.replayer.snapshot().some((entry) => entry.kind === "decision" && entry.scope === state.scope && entry.key === key)) await internals.replayer.appendSinglePhase({
+					scope: state.scope,
+					key,
+					kind: "decision",
+					status: "ok",
+					spanId,
+					value: {
+						decisionType: "quota_drift",
+						provider: observation.provider,
+						model: observation.model,
+						...internals.quota?.tenant === void 0 ? {} : { tenant: internals.quota.tenant },
+						dimension,
+						declaredPerMinute: declared,
+						reportedPerMinute: observed
+					}
+				});
+				internals.events.emit({
+					type: "log",
+					level: "warn",
+					msg: `declared quota exceeds the provider-reported limit: ${observation.provider}:${observation.model} ${dimension} declared ${String(declared)}/min, the provider reports ${String(observed)}/min; the limiter under-throttles and live 429s follow (journaled decision 'quota_drift')`
+				}, spanId);
+			}
+		}
 		const collectAndDisposeWorktree = async () => {
 			if (acquired === void 0) return;
 			try {
@@ -17494,6 +17696,12 @@ function preflightEstimate(input) {
 			message: `spawn '${label}' sets maxOutputTokensPerTurn ${String(limits.maxOutputTokensPerTurn)} above the model's maxOutputTokens ${String(caps.maxOutputTokens)}: the model clamp wins`,
 			spawn: label
 		});
+		if (caps?.minOutputTokensPerTurn !== void 0 && limits.maxOutputTokensPerTurn !== void 0 && limits.maxOutputTokensPerTurn < caps.minOutputTokensPerTurn) say({
+			severity: "error",
+			code: "output-cap-below-provider-minimum",
+			message: `spawn '${label}' sets maxOutputTokensPerTurn ${String(limits.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: label
+		});
 		const turnFloorUsd = pricing === void 0 || outputBound === void 0 ? void 0 : priceUsdOf(pricing, {
 			inputTokens: spec.estInputTokens ?? 0,
 			outputTokens: outputBound,
@@ -17622,6 +17830,12 @@ function preflightEstimate(input) {
 			const pricing = pricingOf(servedBy);
 			const orchLimits = mergeUsageLimits(input.orchestrator.limits, void 0, defaults.limits);
 			const outputBound = caps === void 0 ? orchLimits.maxOutputTokensPerTurn : orchLimits.maxOutputTokensPerTurn === void 0 ? caps.maxOutputTokens : Math.min(caps.maxOutputTokens, orchLimits.maxOutputTokensPerTurn);
+			if (caps?.minOutputTokensPerTurn !== void 0 && orchLimits.maxOutputTokensPerTurn !== void 0 && orchLimits.maxOutputTokensPerTurn < caps.minOutputTokensPerTurn) say({
+				severity: "error",
+				code: "output-cap-below-provider-minimum",
+				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"
+			});
 			const { adapterId, model } = parseModelRef(servedBy);
 			const unit = {
 				label: "orchestrator",
@@ -17669,6 +17883,12 @@ function preflightEstimate(input) {
 				const caps = capsOf(servedBy);
 				const merged = mergeUsageLimits(synthesis.limits ?? { maxTurns: 4 }, void 0, defaults.limits);
 				const outputBound = caps === void 0 ? merged.maxOutputTokensPerTurn : merged.maxOutputTokensPerTurn === void 0 ? caps.maxOutputTokens : Math.min(caps.maxOutputTokens, merged.maxOutputTokensPerTurn);
+				if (caps?.minOutputTokensPerTurn !== void 0 && merged.maxOutputTokensPerTurn !== void 0 && merged.maxOutputTokensPerTurn < caps.minOutputTokensPerTurn) say({
+					severity: "error",
+					code: "output-cap-below-provider-minimum",
+					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"
+				});
 				const projected = projectedProviderTurnsOf(merged, overallExecutedCeiling(merged, toolCeilingsOf(merged))) + finishRepairReserve;
 				if (orchestratorEcho !== void 0) orchestratorEcho.synthesis = {
 					projectedProviderTurns: projected,
@@ -18830,7 +19050,8 @@ function createEngine(options) {
 	const quotaRuntime = options.quota === void 0 ? void 0 : {
 		limiter: options.quota.limiter,
 		...options.quota.tenant === void 0 ? {} : { tenant: options.quota.tenant },
-		onLimiterError: options.quota.onLimiterError ?? "deny"
+		onLimiterError: options.quota.onLimiterError ?? "deny",
+		...options.quota.declaredRules === void 0 ? {} : { declaredRules: options.quota.declaredRules }
 	};
 	const knowledgeStore = options.stores?.modelKnowledge;
 	const knowledge = knowledgeStore === void 0 ? void 0 : { current: () => knowledgeStore.current() };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.73.0",
+  "version": "1.75.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",