@rulvar/core 1.59.4 → 1.61.0

package/dist/index.d.ts

@@ -663,6 +663,49 @@ interface UsageSlice {
   role?: InvocationRole;
 }
 /**
+* One live provider dispatch of an agent invocation (P1.3, the durable
+* reconciliation ledger): every wire call the engine actually made,
+* successful or not, with the usage it consumed and the provider's
+* response id when the adapter surfaced one. Quota-denied attempts and
+* abort short circuits that never reached the adapter mint no record:
+* the ledger enumerates exactly the calls a provider could bill.
+* Records are minted from the same sanitized usage the phase slices
+* accumulate, so per-model sums over an entry's records reconcile with
+* `usageByModel` (and with `usage`) by construction on a fully live
+* invocation.
+*/
+interface ProviderCallRecord {
+  /** 1-based dispatch order across the whole invocation, phases included. */
+  ordinal: number;
+  /** The invocation phase that paid the call. */
+  role: InvocationRole;
+  servedBy: ModelRef;
+  /** 1-based try number on the serving target; retries increment it. */
+  attempt: number;
+  /**
+  * 'ok' = a terminal finish; 'error' = a wire failure after dispatch
+  * (the provider may still have billed the recorded usage); 'aborted' =
+  * the stream was severed by `aborted` below.
+  */
+  outcome: "ok" | "error" | "aborted";
+  /**
+  * The provider's response id from the finish metadata
+  * (`providerMetadata[<adapter id>].responseId`, surfaced by both
+  * shipped adapters). Absent when the adapter reported none or the
+  * call never finished; the invoice export marks such rows instead of
+  * dropping them.
+  */
+  responseId?: string;
+  /** This call's usage exactly, sanitized like every accounted number. */
+  usage: Usage;
+  /** True when the stream was cut, so the usage is a lower bound. */
+  usageApprox?: boolean;
+  /** WireError.code on 'error' outcomes. */
+  errorCode?: string;
+  /** What severed an 'aborted' call. */
+  aborted?: "budget" | "external" | "idle";
+}
+/**
 * Cost-attribution facts a live run knows at settlement and a pure
 * journal fold cannot re-derive: the innermost phase name at the call
 * site, the agent profile, the primary invocation role, the budget
@@ -752,6 +795,18 @@ type JournalEntry = {
   */
   costAttribution?: CostAttributionFacts;
   /**
+  * Terminal agent entries: the per-dispatch reconciliation ledger
+  * (P1.3), one record per live provider call the invocation made,
+  * failed and retried attempts included, so every billable wire call
+  * maps to a journal entry and the invoice export can name the
+  * provider response ids behind the usage total. Absent on entries
+  * written before this shipped and on fully replayed invocations
+  * (which made no calls); the invoice fold surfaces such entries as
+  * unattributed rows instead of losing their spend. Policy, never
+  * identity, exactly like usageByModel.
+  */
+  providerCalls?: ProviderCallRecord[];
+  /**
   * The serving adapters' declared usage-telemetry semantics at write
   * time (ProviderAdapter.usageSemantics), stamped so cost numbers stay
   * auditable across normalization corrections: an UNSTAMPED OpenAI
@@ -2627,6 +2682,8 @@ interface TerminalPatch {
   usageByModel?: UsageSlice[];
   /** Attribution facts behind the CostReport breakdowns; see JournalEntry. */
   costAttribution?: CostAttributionFacts;
+  /** The per-dispatch reconciliation ledger (P1.3); see JournalEntry. */
+  providerCalls?: ProviderCallRecord[];
   /** The serving adapter's usage-semantics version; see JournalEntry. */
   usageSemantics?: string;
   transcriptRef?: string;
@@ -3096,6 +3153,15 @@ interface CheckpointState {
   * exactly as they did then.
   */
   usageByModel?: UsageSlice[];
+  /**
+  * The per-dispatch reconciliation ledger so far (P1.3), carried at
+  * every boundary so a kill-and-resume keeps pre-kill wire calls
+  * attributable. Absent before the first call and on checkpoints
+  * written before the ledger shipped: those restore none, and the
+  * invoice fold surfaces the restored usage as an unattributed
+  * remainder instead of losing it.
+  */
+  providerCalls?: ProviderCallRecord[];
   toolCallsUsed: number;
   schemaAttempts: number;
   /** Compaction points; producers arrive with M4-T03. */
@@ -3876,6 +3942,24 @@ interface UsageLimits {
     max: number;
     costs?: Record<string, number>;
   };
+  /**
+  * The guaranteed finalization turn (the experiment-review P1.1): when
+  * a TOOL budget limiter (maxToolCalls or toolUnits) expires, the
+  * runtime closes the current batch's remaining calls with explicit
+  * skipped-call error results instead of dropping them silently, then
+  * grants the model exactly ONE summary turn with tools withheld
+  * before the invocation settles as status 'limit' with the exact
+  * limiter named in the terminal error. The summary text becomes the
+  * limit result's output for schema-less calls; a ridden schema
+  * validates into typed output when the summary parses (one attempt,
+  * no re-prompt). `maxOutputTokens` bounds the summary turn only;
+  * absent, the ordinary per-turn output policy applies. Off by
+  * default: the skip results and the summary instruction enter the
+  * conversation, so enabling it changes recorded model requests.
+  */
+  finalizationReserve?: {
+    maxOutputTokens?: number;
+  };
 }
 declare const DEFAULT_MAX_TURNS = 32;
 declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 12e4;
@@ -3896,6 +3980,9 @@ interface EffectiveUsageLimits {
     max: number;
     costs?: Record<string, number>;
   };
+  finalizationReserve?: {
+    maxOutputTokens?: number;
+  };
 }
 /**
 * Limits merge per spawn: AgentOpts.limits over profile limits over engine
@@ -3967,6 +4054,17 @@ interface AgentResult<T> {
   * which (usage, servedBy) already describes exactly.
   */
   usageByModel?: UsageSlice[];
+  /**
+  * The per-dispatch reconciliation ledger (P1.3): one record per live
+  * provider call this invocation made, failed and retried attempts
+  * included, each with its own usage and the provider's response id
+  * when the adapter surfaced one. Journaled on the terminal entry and
+  * restored verbatim on replay, so a live result and its replayed one
+  * read the same ledger; `invoiceFromJournal` folds the same records
+  * into the invoice export. Absent when the invocation made no wire
+  * call (a fully replayed invocation).
+  */
+  providerCalls?: ProviderCallRecord[];
   transcriptRef: string;
   artifacts?: Artifact[];
   error?: AgentError;
@@ -5319,8 +5417,13 @@ declare class AdmissionController {
 }
 //#endregion
 //#region src/engine/cost-report.d.ts
-/** Folds the per-run attribution buckets into the normative CostReport. */
-declare function buildCostReport(attribution: CostAttribution, totalUsd: number): CostReport;
+/**
+* Folds the per-run attribution buckets into the normative CostReport.
+* Live attribution buckets never see abandoned subtrees, so a host
+* that tracked abandoned spend itself passes it as `abandoned`;
+* omitted, the report shows a gross equal to the net.
+*/
+declare function buildCostReport(attribution: CostAttribution, totalUsd: number, abandoned?: CostReport["abandoned"]): CostReport;
 /**
 * The pure journal fold: the complete CostReport from terminal entries,
 * the same summation the kernel ledger uses (terminal usage exactly
@@ -5345,7 +5448,37 @@ interface PendingExternal {
 }
 /** Full contract: https://docs.rulvar.com/guide/observability. */
 interface CostReport {
+  /**
+  * The NET ledger: priced terminal usage with abandoned subtrees
+  * contributing zero (their spend is a sunk cost of branches the
+  * orchestrator discarded, not of the work the run kept). The
+  * provider still billed them: reconcile invoices against `grossUsd`,
+  * never this.
+  */
   totalUsd: number;
+  /**
+  * The gross/net split (P1.3): totalUsd + abandoned.usd, every priced
+  * terminal slice with abandonment included. This is the immutable
+  * provider-spend figure an invoice reconciles against; abandoning a
+  * branch never shrinks it.
+  */
+  grossUsd: number;
+  /**
+  * Priced spend under abandoned subtrees, exactly the part totalUsd
+  * excludes. `unpriced` here surfaces abandoned slices with no price
+  * row (the top-level `unpriced` lists only slices contributing to
+  * totalUsd), and `usageApprox` follows the same semantics as the
+  * top-level flag over the abandoned entries; grossUsd is an estimate
+  * whenever either flag is raised.
+  */
+  abandoned: {
+    usd: number;
+    unpriced: Array<{
+      model: string;
+      usage: Usage;
+    }>;
+    usageApprox?: boolean;
+  };
   /** Keyed by canonical ModelRef 'adapterId:model'. */
   byModel: Record<string, number>;
   /** ctx.phase names; phase is structural for this map. */
@@ -8150,6 +8283,57 @@ declare class FileTranscriptStore implements TranscriptStore {
   delete(ref: string): Promise<void>;
 }
 //#endregion
+//#region src/engine/invoice.d.ts
+/** How a row lines up against a provider invoice. */
+type InvoiceReconciliation = "matched" | "missing-provider-id" | "unconfirmed" | "unattributed";
+/** One billable provider call (or an unattributed usage remainder). */
+interface InvoiceRow {
+  /** The terminal journal entry the row folds from. */
+  entrySeq: number;
+  scope: string;
+  key: string;
+  /** The call's dispatch ordinal within its invocation; remainder and slice rows continue past it. */
+  ordinal: number;
+  servedBy: ModelRef;
+  role?: InvocationRole;
+  /** 1-based try number on the serving target (retries increment it). */
+  attempt?: number;
+  outcome: ProviderCallRecord["outcome"] | "unattributed";
+  responseId?: string;
+  usage: Usage;
+  usageApprox?: boolean;
+  /** This row priced at its own model's rate; absent when no price row covers it. */
+  usd?: number;
+  /** The row lies under an abandoned subtree: in grossUsd, not in netUsd. */
+  abandoned?: true;
+  reconciliation: InvoiceReconciliation;
+}
+/** The machine-readable invoice: rows plus the ledger totals. */
+interface InvoiceExport {
+  rows: InvoiceRow[];
+  /** Every priced terminal slice, abandonment included: equals CostReport.grossUsd. */
+  totalUsd: number;
+  /** The net ledger (abandoned subtrees contribute zero): equals CostReport.totalUsd. */
+  netUsd: number;
+  /** The abandoned share: totalUsd - netUsd, equals CostReport.abandoned.usd. */
+  abandonedUsd: number;
+  /** Usage on models absent from pricing, net and abandoned alike; never a silent zero. */
+  unpriced: Array<{
+    model: string;
+    usage: Usage;
+  }>;
+  /** Rows whose reconciliation is not 'matched'. */
+  reconciliationFailures: number;
+  /** Present and true when any contributing entry carried approximate usage. */
+  usageApprox?: boolean;
+}
+/**
+* The pure invoice fold. Pass the same entries and price table you
+* would pass `costReportFromJournal`; the totals are that report's
+* gross/net split verbatim.
+*/
+declare function invoiceFromJournal(entries: readonly JournalEntry[], priceUsd: (servedBy: ModelRef, usage: Usage) => number | undefined): InvoiceExport;
+//#endregion
 //#region src/engine/run-profiles.d.ts
 interface RunProfile {
   /** Per-role canonical effort hints (the model refs come from the host). */
@@ -8651,4 +8835,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_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, FinishInfo, 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, 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, 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, PriceTable, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, 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, 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, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, 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, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, 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_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, FinishInfo, 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, 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, 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, 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, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, 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, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -6995,6 +6995,7 @@ var Replayer = class {
 			if (patch.servedBy !== void 0) entry.servedBy = patch.servedBy;
 			if (patch.usageByModel !== void 0) entry.usageByModel = patch.usageByModel;
 			if (patch.costAttribution !== void 0) entry.costAttribution = patch.costAttribution;
+			if (patch.providerCalls !== void 0) entry.providerCalls = patch.providerCalls;
 			if (patch.usageSemantics !== void 0) entry.usageSemantics = patch.usageSemantics;
 			if (patch.transcriptRef !== void 0) entry.transcriptRef = patch.transcriptRef;
 			if (patch.checkpointRef !== void 0) entry.checkpointRef = patch.checkpointRef;
@@ -8064,8 +8065,16 @@ function emptyByRole() {
 function isOrchestratorAccount(scope) {
 	return scope === "orchestrator" || scope.endsWith("/orchestrator");
 }
-/** Folds the per-run attribution buckets into the normative CostReport. */
-function buildCostReport(attribution, totalUsd) {
+/**
+* Folds the per-run attribution buckets into the normative CostReport.
+* Live attribution buckets never see abandoned subtrees, so a host
+* that tracked abandoned spend itself passes it as `abandoned`;
+* omitted, the report shows a gross equal to the net.
+*/
+function buildCostReport(attribution, totalUsd, abandoned = {
+	usd: 0,
+	unpriced: []
+}) {
 	const byRole = emptyByRole();
 	for (const [role, usd] of attribution.byRole) byRole[role] = usd;
 	const orchestrator = attribution.orchestrator ?? {
@@ -8076,6 +8085,8 @@ function buildCostReport(attribution, totalUsd) {
 	};
 	return {
 		totalUsd,
+		grossUsd: totalUsd + abandoned.usd,
+		abandoned,
 		byModel: Object.fromEntries(attribution.byModel),
 		byPhase: Object.fromEntries(attribution.byPhase),
 		byAgentType: Object.fromEntries(attribution.byAgentType),
@@ -8106,6 +8117,9 @@ function costReportFromJournal(entries, priceUsd) {
 	const unpriced = [];
 	let totalUsd = 0;
 	let usageApprox = false;
+	let abandonedUsd = 0;
+	const abandonedUnpriced = [];
+	let abandonedApprox = false;
 	let orchestratorSpentUsd = 0;
 	let reserveUsedUsd = 0;
 	let wakes = 0;
@@ -8113,7 +8127,18 @@ function costReportFromJournal(entries, priceUsd) {
 	for (const entry of entries) {
 		if (entry.kind === "decision" && entry.value?.decisionType === "orchestrator_budget_cap") forcedFinish = true;
 		if (entry.kind === "external" && entry.status === "suspended" && typeof entry.value?.key === "string" && (entry.value.key.startsWith("wake:") || entry.value.key.includes(":wake:"))) wakes += 1;
-		if (entry.kind !== "resolution" && entry.kind !== "abandon" && abandonFold.isAbandoned(entry.ref ?? entry.seq)) continue;
+		if (entry.kind !== "resolution" && entry.kind !== "abandon" && abandonFold.isAbandoned(entry.ref ?? entry.seq)) {
+			if (entry.status !== "running" && entry.usage !== void 0) {
+				const abandonedPriced = priceEntryUsage(entry, priceUsd);
+				abandonedUsd += abandonedPriced.usd;
+				for (const slice of abandonedPriced.unpriced) abandonedUnpriced.push({
+					model: slice.servedBy,
+					usage: slice.usage
+				});
+				if (entry.usageApprox === true) abandonedApprox = true;
+			}
+			continue;
+		}
 		if (entry.status === "running" || entry.usage === void 0) continue;
 		const priced = priceEntryUsage(entry, priceUsd);
 		for (const slice of priced.unpriced) unpriced.push({
@@ -8137,6 +8162,12 @@ function costReportFromJournal(entries, priceUsd) {
 	}
 	return {
 		totalUsd,
+		grossUsd: totalUsd + abandonedUsd,
+		abandoned: {
+			usd: abandonedUsd,
+			unpriced: abandonedUnpriced,
+			...abandonedApprox ? { usageApprox: true } : {}
+		},
 		byModel,
 		byPhase,
 		byAgentType,
@@ -8153,6 +8184,142 @@ function costReportFromJournal(entries, priceUsd) {
 	};
 }
 //#endregion
+//#region src/engine/invoice.ts
+/**
+* The invoice export (P1.3): a pure fold over terminal entries that
+* turns the per-dispatch reconciliation ledger (`providerCalls`) into
+* one row per billable provider call, so a host can line the run up
+* against the provider's invoice. The totals are the SAME slice fold
+* `costReportFromJournal` runs, so `totalUsd` here equals
+* `CostReport.grossUsd` (and `netUsd` equals `CostReport.totalUsd`)
+* exactly, never approximately; per-row `usd` prices each call
+* individually and is informational, since a nonlinear price table
+* (long-context tiers) prices a split differently from its sum.
+*
+* Coverage is loss-free by construction: an entry whose records do not
+* cover its usage total (a resume restored from a checkpoint written
+* before the ledger shipped) contributes an `unattributed` remainder
+* row, and an entry with no records at all (written before the ledger
+* shipped, or a fully replayed invocation) contributes one
+* `unattributed` row per usage slice. Missing provider ids are marked,
+* never dropped: a finished call without one reconciles as
+* `missing-provider-id`, a failed or severed call without one as
+* `unconfirmed` (the provider may or may not have billed it; there is
+* no id to match).
+*
+* Pricing happens at fold time from the table you pass, exactly like
+* CostReport: the export reflects current rates, not the rates at
+* write time.
+*/
+const USAGE_FIELDS = [
+	"inputTokens",
+	"outputTokens",
+	"cacheReadTokens",
+	"cacheWriteTokens"
+];
+/** entry.usage minus the records' sum, clamped at zero per field. */
+function usageRemainder(total, records) {
+	const remainder = {
+		inputTokens: total.inputTokens,
+		outputTokens: total.outputTokens,
+		cacheReadTokens: total.cacheReadTokens,
+		cacheWriteTokens: total.cacheWriteTokens
+	};
+	let reasoning = total.reasoningTokens ?? 0;
+	for (const record of records) {
+		for (const field of USAGE_FIELDS) remainder[field] = Math.max(0, remainder[field] - record.usage[field]);
+		reasoning = Math.max(0, reasoning - (record.usage.reasoningTokens ?? 0));
+	}
+	if (reasoning > 0) remainder.reasoningTokens = reasoning;
+	return USAGE_FIELDS.some((field) => remainder[field] > 0) || (remainder.reasoningTokens ?? 0) > 0 ? remainder : void 0;
+}
+/** A single row priced at its own model's rate; broken rates fold as unpriced. */
+function rowUsd(priceUsd, servedBy, usage) {
+	const usd = priceUsd(servedBy, usage);
+	return usd !== void 0 && Number.isFinite(usd) && usd >= 0 ? usd : void 0;
+}
+/**
+* The pure invoice fold. Pass the same entries and price table you
+* would pass `costReportFromJournal`; the totals are that report's
+* gross/net split verbatim.
+*/
+function invoiceFromJournal(entries, priceUsd) {
+	const report = costReportFromJournal(entries, priceUsd);
+	const abandonFold = buildAbandonFold(entries);
+	const rows = [];
+	for (const entry of entries) {
+		if (entry.status === "running" || entry.usage === void 0) continue;
+		const abandoned = entry.kind !== "resolution" && entry.kind !== "abandon" && abandonFold.isAbandoned(entry.ref ?? entry.seq);
+		const base = {
+			entrySeq: entry.seq,
+			scope: entry.scope,
+			key: entry.key
+		};
+		const mark = abandoned ? { abandoned: true } : {};
+		const records = entry.providerCalls ?? [];
+		for (const record of records) {
+			const usd = rowUsd(priceUsd, record.servedBy, record.usage);
+			rows.push({
+				...base,
+				ordinal: record.ordinal,
+				servedBy: record.servedBy,
+				role: record.role,
+				attempt: record.attempt,
+				outcome: record.outcome,
+				...record.responseId === void 0 ? {} : { responseId: record.responseId },
+				usage: record.usage,
+				...record.usageApprox === true ? { usageApprox: true } : {},
+				...usd === void 0 ? {} : { usd },
+				...mark,
+				reconciliation: record.responseId !== void 0 ? "matched" : record.outcome === "ok" ? "missing-provider-id" : "unconfirmed"
+			});
+		}
+		if (records.length === 0) {
+			entryUsageSlices(entry).forEach((slice, index) => {
+				const usd = rowUsd(priceUsd, slice.servedBy, slice.usage);
+				rows.push({
+					...base,
+					ordinal: index + 1,
+					servedBy: slice.servedBy,
+					...slice.role === void 0 ? {} : { role: slice.role },
+					outcome: "unattributed",
+					usage: slice.usage,
+					...entry.usageApprox === true ? { usageApprox: true } : {},
+					...usd === void 0 ? {} : { usd },
+					...mark,
+					reconciliation: "unattributed"
+				});
+			});
+			continue;
+		}
+		const remainder = usageRemainder(entry.usage, records);
+		if (remainder !== void 0 && entry.servedBy !== void 0) {
+			const usd = rowUsd(priceUsd, entry.servedBy, remainder);
+			rows.push({
+				...base,
+				ordinal: records.length + 1,
+				servedBy: entry.servedBy,
+				outcome: "unattributed",
+				usage: remainder,
+				...entry.usageApprox === true ? { usageApprox: true } : {},
+				...usd === void 0 ? {} : { usd },
+				...mark,
+				reconciliation: "unattributed"
+			});
+		}
+	}
+	const usageApprox = report.usageApprox === true || report.abandoned.usageApprox === true;
+	return {
+		rows,
+		totalUsd: report.grossUsd,
+		netUsd: report.totalUsd,
+		abandonedUsd: report.abandoned.usd,
+		unpriced: [...report.unpriced, ...report.abandoned.unpriced],
+		reconciliationFailures: rows.filter((row) => row.reconciliation !== "matched").length,
+		...usageApprox ? { usageApprox: true } : {}
+	};
+}
+//#endregion
 //#region src/engine/run-profiles.ts
 /**
 * The shipped presets (fast / standard / deep / ultra "and similar").
@@ -9328,6 +9495,8 @@ function mergeUsageLimits(call, profile, engine) {
 	if (maxCallsPerTool !== void 0) merged.maxCallsPerTool = maxCallsPerTool;
 	const toolUnits = pick("toolUnits");
 	if (toolUnits !== void 0) merged.toolUnits = toolUnits;
+	const finalizationReserve = pick("finalizationReserve");
+	if (finalizationReserve !== void 0) merged.finalizationReserve = finalizationReserve;
 	return merged;
 }
 /**
@@ -9367,6 +9536,12 @@ function validateUsageLimits(limits, site) {
 			for (const [name, cost] of Object.entries(costs)) requireNonNegativeInteger(cost, `${site}.toolUnits.costs['${name}']`);
 		}
 	}
+	if (limits.finalizationReserve !== void 0) {
+		const reserve = limits.finalizationReserve;
+		if (typeof reserve !== "object" || reserve === null || Array.isArray(reserve)) throw new ConfigError(`${site}.finalizationReserve must be { maxOutputTokens? }`);
+		const { maxOutputTokens } = reserve;
+		if (maxOutputTokens !== void 0) requirePositiveInteger(maxOutputTokens, `${site}.finalizationReserve.maxOutputTokens`);
+	}
 }
 //#endregion
 //#region src/runtime/model-retry.ts
@@ -10455,6 +10630,7 @@ async function runAgent(options) {
 			usage: addUsage$1(prior?.usage ?? ZERO_USAGE$1, usage)
 		});
 	};
+	const providerCalls = [];
 	let invocationCounter = 0;
 	let transportRetries = 0;
 	const roleUsageSnapshot = (role) => {
@@ -10530,8 +10706,27 @@ async function runAgent(options) {
 	let toolCallsUsed = 0;
 	let escalationRequest;
 	let abortClass;
+	/**
+	* Set at a tool-budget expiry when limits.finalizationReserve is
+	* configured (P1.1); the reserve turn itself runs at ONE site after
+	* the loop ends (the pending-turn path trips before the dispatch
+	* machinery below is even defined), inside the still-open loop phase.
+	*/
+	let reserveRequest;
 	const noProgress = new NoProgressDetector(limits.noProgressTurns);
 	const guard = explorationTrackingEnabled(limits) ? new ExplorationGuard(limits) : void 0;
+	/**
+	* The exact limiter behind a tool-budget expiry, with its counts: the
+	* wording rides the finalization-reserve instruction and the 'limit'
+	* terminal's errorMessage (P1.1 criterion: the terminal names the
+	* limiter, never a bare status).
+	*/
+	const toolBudgetDetail = (limiter) => {
+		if (limiter === "maxToolCalls") return `maxToolCalls (${String(toolCallsUsed)}/${String(limits.maxToolCalls ?? 0)})`;
+		const max = limits.toolUnits?.max ?? 0;
+		const used = guard === void 0 ? max : guard.summary(toolCallsUsed).toolUnitsUsed ?? max;
+		return `toolUnits (${String(used)}/${String(max)})`;
+	};
 	if (limits.toolBudgetNotices === true && limits.maxToolCalls === void 0) events?.emit({
 		type: "log",
 		level: "warn",
@@ -10585,6 +10780,10 @@ async function runAgent(options) {
 			addPhaseUsage(slice.role ?? primaryRole, slice.servedBy, sliceUsage);
 			options.budget?.onUsage(sliceUsage, slice.servedBy);
 		}
+		for (const record of restored.providerCalls ?? []) providerCalls.push(usageViolations(record.usage).length === 0 ? record : {
+			...record,
+			usage: sanitizeUsage(record.usage)
+		});
 		guard?.restore(messages);
 		if (limits.toolBudgetNotices === true && limits.maxToolCalls !== void 0) for (const threshold of crossedNoticeThresholds(toolCallsUsed, limits.maxToolCalls)) firedNotices.add(threshold);
 	}
@@ -10619,6 +10818,7 @@ async function runAgent(options) {
 			toolCallsUsed,
 			schemaAttempts,
 			compaction: [...compactionPoints],
+			...providerCalls.length === 0 ? {} : { providerCalls: [...providerCalls] },
 			...pending === void 0 ? {} : { pending }
 		});
 	};
@@ -10653,15 +10853,42 @@ async function runAgent(options) {
 			part.isError = true;
 			return part;
 		};
+		/**
+		* Closes the batch tail at a tool-budget expiry (P1.1): with the
+		* finalization reserve configured every not-admitted call gets a
+		* typed skipped-call error result naming the limiter, so the model
+		* (and the transcript) sees exactly which calls never executed and
+		* the summary turn's history stays well formed (providers reject
+		* tool calls without matching results). Without the reserve the
+		* tail stays unanswered, byte-identical to before.
+		*/
+		const closeSkippedTail = (skippedCalls, limiter) => {
+			if (limits.finalizationReserve === void 0) return;
+			for (const call of skippedCalls) parts.push(errorPart(call, {
+				error: "skipped: the tool budget is exhausted; the call was not executed",
+				limiter,
+				skipped: true
+			}));
+		};
 		for (const [index, call] of calls.entries()) {
-			if (limits.maxToolCalls !== void 0 && toolCallsUsed >= limits.maxToolCalls) return {
-				parts,
-				limitHit: true
-			};
-			if (guard !== void 0 && guard.unitsExhausted()) return {
-				parts,
-				limitHit: true
-			};
+			if (limits.maxToolCalls !== void 0 && toolCallsUsed >= limits.maxToolCalls) {
+				closeSkippedTail(calls.slice(index), "maxToolCalls");
+				return {
+					parts,
+					limitHit: true,
+					limiter: "maxToolCalls",
+					skipped: calls.length - index
+				};
+			}
+			if (guard !== void 0 && guard.unitsExhausted()) {
+				closeSkippedTail(calls.slice(index), "toolUnits");
+				return {
+					parts,
+					limitHit: true,
+					limiter: "toolUnits",
+					skipped: calls.length - index
+				};
+			}
 			const def = runtime.defs.find((candidate) => candidate.name === call.name);
 			events?.emit({
 				type: "tool:start",
@@ -10863,7 +11090,7 @@ async function runAgent(options) {
 			if (record.isError === true) part.isError = true;
 			return part;
 		});
-		const { parts, limitHit, escalated, finished, guardTrip } = await runToolCalls([restored.pending.awaiting, ...restored.pending.remaining], priorParts);
+		const { parts, limitHit, escalated, finished, guardTrip, limiter, skipped } = await runToolCalls([restored.pending.awaiting, ...restored.pending.remaining], priorParts);
 		if (parts.length > 0) messages.push({
 			role: "tool",
 			parts
@@ -10884,6 +11111,16 @@ async function runAgent(options) {
 					retryable: false
 				};
 				errorMessage = guard.describeTrip();
+			} else if (limiter !== void 0 && limits.finalizationReserve !== void 0) {
+				agentError = {
+					kind: "terminal",
+					retryable: false
+				};
+				errorMessage = `tool budget exhausted: ${toolBudgetDetail(limiter)}; skipped tool calls: ${String(skipped ?? 0)}`;
+				reserveRequest = {
+					limiter,
+					skipped: skipped ?? 0
+				};
 			}
 		} else {
 			maybePushBudgetNotice();
@@ -10925,6 +11162,7 @@ async function runAgent(options) {
 		const reasoningRemainder = Math.max(0, (safe.reasoningTokens ?? 0) - (reported.reasoningTokens ?? 0));
 		if (reasoningRemainder > 0) remainder.reasoningTokens = reasoningRemainder;
 		if (remainder.inputTokens > 0 || remainder.outputTokens > 0 || remainder.cacheReadTokens > 0 || remainder.cacheWriteTokens > 0) options.budget?.onUsage(remainder, ref);
+		return safe;
 	};
 	const retryPolicy = options.retry?.policy ?? DEFAULT_RETRY_POLICY;
 	const retryOn = retryPolicy.retryOn ?? DEFAULT_RETRY_POLICY.retryOn ?? [];
@@ -10939,7 +11177,8 @@ async function runAgent(options) {
 		usage: ZERO_USAGE$1,
 		reported: ZERO_USAGE$1,
 		usageApprox: true,
-		aborted
+		aborted,
+		neverDispatched: true
 	});
 	const backoffWait = async (ms) => {
 		const signals = [];
@@ -11055,7 +11294,23 @@ async function runAgent(options) {
 						msg: `the shared quota limiter failed to reconcile a reservation: ${detail}`
 					});
 				}
-				if (outcome.quotaDenied !== true) recordUsage(outcome.usage, outcome.reported, target.adapter.id, target.resolved.ref, site.role, outcome.usageViolation);
+				if (outcome.quotaDenied !== true && outcome.neverDispatched !== true) {
+					const accounted = recordUsage(outcome.usage, outcome.reported, target.adapter.id, target.resolved.ref, site.role, outcome.usageViolation);
+					const namespace = outcome.providerMetadata?.[target.adapter.id];
+					const record = {
+						ordinal: providerCalls.length + 1,
+						role: site.role,
+						servedBy: target.resolved.ref,
+						attempt: tries + 1,
+						outcome: outcome.aborted !== void 0 ? "aborted" : outcome.wireError !== void 0 ? "error" : "ok",
+						usage: accounted
+					};
+					if (typeof namespace?.responseId === "string") record.responseId = namespace.responseId;
+					if (outcome.usageApprox) record.usageApprox = true;
+					if (outcome.aborted !== void 0) record.aborted = outcome.aborted;
+					else if (outcome.wireError !== void 0) record.errorCode = outcome.wireError.code;
+					providerCalls.push(record);
+				}
 				tries += 1;
 				const retryClass = outcome.aborted === "idle" ? "transport" : outcome.wireError === void 0 ? void 0 : retryClassOf(outcome.wireError);
 				if (retryClass === void 0) return {
@@ -11285,7 +11540,7 @@ async function runAgent(options) {
 		}
 		if (options.tools !== void 0 && outcome.turn.toolCalls.length > 0) {
 			noProgress.recordTurn({ toolCalls: outcome.turn.toolCalls.length });
-			const { parts, limitHit, escalated, finished, guardTrip } = await runToolCalls(outcome.turn.toolCalls, []);
+			const { parts, limitHit, escalated, finished, guardTrip, limiter, skipped } = await runToolCalls(outcome.turn.toolCalls, []);
 			if (parts.length > 0) messages.push({
 				role: "tool",
 				parts
@@ -11310,6 +11565,16 @@ async function runAgent(options) {
 						retryable: false
 					};
 					errorMessage = guard.describeTrip();
+				} else if (limiter !== void 0 && limits.finalizationReserve !== void 0) {
+					agentError = {
+						kind: "terminal",
+						retryable: false
+					};
+					errorMessage = `tool budget exhausted: ${toolBudgetDetail(limiter)}; skipped tool calls: ${String(skipped ?? 0)}`;
+					reserveRequest = {
+						limiter,
+						skipped: skipped ?? 0
+					};
 				}
 				break;
 			}
@@ -11495,6 +11760,110 @@ async function runAgent(options) {
 		await saveBoundary();
 		continue loop;
 	}
+	if (status === "limit" && reserveRequest !== void 0) {
+		const { limiter, skipped } = reserveRequest;
+		let proceed = true;
+		try {
+			options.budget?.beforeTurn();
+		} catch {
+			events?.emit({
+				type: "log",
+				level: "warn",
+				msg: "the finalization reserve turn was skipped: the budget blocks further turns"
+			});
+			proceed = false;
+		}
+		if (proceed) {
+			turns += 1;
+			const reserveMessages = [...messages, {
+				role: "user",
+				parts: [{
+					type: "text",
+					text: `The tool budget is exhausted (${toolBudgetDetail(limiter)}). Skipped tool calls: ${String(skipped)}; no further tool calls will execute. This is the final turn: produce your best final answer from the evidence already collected.`
+				}]
+			}];
+			let reserveDispatch;
+			try {
+				reserveDispatch = await dispatchPhase({
+					role: primaryRole,
+					chain: loopChain,
+					cursor: loopCursor,
+					requestFor: (target) => {
+						let req = buildRequest(target.resolved, projectHistory(reserveMessages, providerOf(target.adapter)), limits, options.tools?.contracts);
+						if (options.schema !== void 0 && options.canonicalSchema !== void 0 && !separateExtract) req = applyStructuredOutputTier(req, rideTierFor(target), options.canonicalSchema);
+						if (req.tools !== void 0) req = {
+							...req,
+							toolChoice: "none"
+						};
+						const reserveMax = limits.finalizationReserve?.maxOutputTokens;
+						if (reserveMax !== void 0) req = {
+							...req,
+							maxOutputTokens: Math.min(req.maxOutputTokens ?? reserveMax, reserveMax)
+						};
+						return applyOutputBudget(req, target, options.budget);
+					},
+					streamOptionsFor: (target) => {
+						const reserveStreamOptions = {
+							idleTimeoutMs: limits.streamIdleTimeoutMs,
+							signals: options.signal === void 0 ? [] : [options.signal],
+							onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
+						};
+						if (options.budget?.signal !== void 0) reserveStreamOptions.budgetSignal = options.budget.signal;
+						if (options.stream === true) reserveStreamOptions.onDelta = (delta) => events?.emit({
+							type: "agent:stream",
+							delta
+						});
+						return reserveStreamOptions;
+					}
+				});
+			} catch (thrown) {
+				if (!(thrown instanceof BudgetExhaustedError)) throw thrown;
+				events?.emit({
+					type: "log",
+					level: "warn",
+					msg: `the finalization reserve turn was skipped: ${thrown.message}`
+				});
+			}
+			if (reserveDispatch !== void 0) {
+				const { outcome, target: reserveTarget } = reserveDispatch;
+				servedBy = reserveTarget.resolved.ref;
+				usageApprox = usageApprox || outcome.usageApprox;
+				messages.push(assistantMsg(outcome.turn, liftRetainedParts(outcome.providerMetadata, reserveTarget.adapter)));
+				if (invariantViolation !== void 0) {
+					status = "error";
+					agentError = {
+						kind: "transport",
+						retryable: false
+					};
+					errorMessage = invariantViolation;
+				} else if (outcome.aborted === "external") status = "cancelled";
+				else if (outcome.aborted === "budget") {
+					status = "cancelled";
+					agentError = {
+						kind: "budget",
+						retryable: false
+					};
+				} else {
+					await saveBoundary();
+					if (outcome.wireError !== void 0 || outcome.aborted === "idle") events?.emit({
+						type: "log",
+						level: "warn",
+						msg: "the finalization reserve turn failed; the limit terminal stands" + (outcome.wireError === void 0 ? " (stream idle timeout)" : ` (${outcome.wireError.message})`)
+					});
+					else if (options.schema === void 0) {
+						const summary = outcome.turn.text;
+						if (summary.trim() !== "") output = summary;
+					} else if (!separateExtract && options.canonicalSchema !== void 0) {
+						const candidate = extractCandidate(outcome.turn, rideTierFor(reserveTarget));
+						if (candidate !== void 0) {
+							const validation = await validateSchemaSpec(options.schema, candidate.raw);
+							if (validation.valid) output = validation.value;
+						}
+					}
+				}
+			}
+		}
+	}
 	endPhase(loopPhase, phaseOutcome(), servedBy);
 	if (status === "ok" && !finishedViaTool && options.finalize !== void 0) {
 		const finalizeResolved = options.finalize.resolved;
@@ -11752,6 +12121,7 @@ async function runAgent(options) {
 		transcriptRef
 	};
 	if (usageByPhaseModel.size > 1) result.usageByModel = usageSlices();
+	if (providerCalls.length > 0) result.providerCalls = providerCalls;
 	if (agentError !== void 0) result.error = agentError;
 	if (escalationRequest !== void 0) result.escalationRequest = escalationRequest;
 	if (abortClass !== void 0) result.abortClass = abortClass;
@@ -13638,6 +14008,7 @@ function createCtx(internals, rootWorkflow) {
 				result.errorMessage = terminal.error.message;
 			}
 			if (terminal?.artifacts !== void 0) result.artifacts = terminal.artifacts;
+			if (terminal?.providerCalls !== void 0) result.providerCalls = terminal.providerCalls;
 			if (terminal?.status === "escalated" && terminal.escalation !== void 0) result.escalation = terminal.escalation;
 			{
 				const stampedData = terminal?.error?.data;
@@ -14199,6 +14570,7 @@ function createCtx(internals, rootWorkflow) {
 			servedBy: result.servedBy,
 			...servedSemantics === void 0 ? {} : { usageSemantics: servedSemantics },
 			...result.usageByModel === void 0 ? {} : { usageByModel: result.usageByModel },
+			...result.providerCalls === void 0 ? {} : { providerCalls: result.providerCalls },
 			costAttribution: {
 				...state.phase === void 0 ? {} : { phase: state.phase },
 				agentType,
@@ -14209,7 +14581,7 @@ function createCtx(internals, rootWorkflow) {
 			transcriptRef: result.transcriptRef
 		};
 		if (result.status === "escalated" && result.escalation !== void 0) terminalPatch.escalation = result.escalation;
-		if (result.output !== null && result.status === "ok") terminalPatch.value = result.output;
+		if (result.output !== null && (result.status === "ok" || result.status === "limit")) terminalPatch.value = result.output;
 		if (result.error !== void 0) terminalPatch.error = agentErrorToWire(result.error, result.errorMessage ?? `agent terminated with status ${result.status}`);
 		const resultUsageApprox = result.usageApprox === true;
 		if (resultUsageApprox) terminalPatch.usageApprox = true;
@@ -18068,4 +18440,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_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, 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, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, 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, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, 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_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, 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, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, 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, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

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