@agentplat/mesh-sim 0.3.0-beta.2 → 0.3.0-beta.4

package/README.md

@@ -2,6 +2,37 @@
 
 Deterministic simulation kernel for AgentPlat Mesh peers.
 
+## Scalable provider-neutral evaluation runner
+
+`runScalableEvaluationV1()` is the executable counterpart to the scalable
+evaluation contracts. It opens a multi-domain environment, starts a sharded
+session and episode, binds a sparse schedule to both team ports, validates and
+accounts public observations, forwards cross-shard messages, and requests
+fenced effects for declared actions. The runner keeps only bounded accounting
+state, recovery state, and a configured record tail; it never materializes the
+declared 500, 5K, or 100K peer population.
+
+Each compared team receives an isolated session and episode with the same
+scenario seed, so effects or targeted perturbations from one side cannot alter
+the other side's state. Environment effect receipts and cross-shard
+acknowledgements are accepted only after exact request/batch binding and digest
+recomputation.
+
+The embedding application supplies team implementations. Scheduled
+perturbations require a `ScalableEvaluationPerturbationPortV1` and a recovery
+metric port, plus an evaluator baseline for every affected team/domain pair.
+The simulation provider must return a content-bound injection receipt before
+the runtime records the occurrence; a plan entry alone is never reported as an
+injected fault. Active recovery is sampled on subsequent logical steps until
+its baseline tolerance is actually restored. Declared actions require an
+application-owned `ScalableEvaluationActionAuthorityV1`; the runner does not
+synthesize fencing authority.
+
+Runs are local and transport-neutral: this package does not start a service,
+create a campaign, or deploy infrastructure. An `AbortSignal`-compatible
+object returns a `cancelled` result between external calls; budget exhaustion
+prevents the next team step before it can create effects or messages.
+
 The kernel uses the production `reduceMeshPeer` function for local commands and
 the production `processMeshEnvelope` boundary for every remote delivery. There
 is no simulation-only accepted-message path.
@@ -41,8 +72,8 @@ coordination, allocation, execution, timer, and recovery reducers.
 
 ```ts
 const trace = await runMeshReducerScenario(config, {
-  driverId: 'my-coordination-driver-v1',
-  projectionId: 'my-safety-projection-v1',
+  driverId: "my-coordination-driver-v1",
+  projectionId: "my-safety-projection-v1",
   reduce({ state, action, logicalTime }) {
     return dispatchToPublicMeshReducer(state, action, logicalTime);
   },
@@ -107,3 +138,417 @@ records exact replay. Its fault and adversary schedules are interpreted at
 driver boundaries; production reducers contain no experiment bypass. The
 500-agent mission remains below 5,000 interactions and records its observed
 directed topology instead of inferring an asymptotic claim.
+
+## Deterministic evaluation environment
+
+`createCollectiveDeterministicEnvironmentHarnessV1()` is the reference
+implementation of the separate
+`@agentplat/collective-planning/evaluation` boundary. The harness returns a
+runner-visible `environment`, an evaluator-only `monitor`, and an evaluator-only
+`finalize()` operation. Only the environment port should be passed to a runner.
+
+The reference world keeps peer observation queues, authoritative effect state,
+idempotency records, terminal predicates and the hidden canary in closures.
+Observation cursors are exact-idempotent and conflicting reuse is rejected.
+Effects validate the current Work Contract, epoch, authority generation and
+fence atomically. Timeouts before commit never enter the effect ledger;
+timeouts after commit return an indeterminate first receipt and a committed
+receipt on exact retry. Public snapshot handles are backed by evaluator-owned
+opaque state, so another harness with the same registration can restore and
+replay without serializing hidden values.
+
+Finalization constructs trace V2, replays its interaction ledger, snapshots the
+independent monitor and creates boundary evidence. An exceeded interaction
+ceiling becomes a terminal mission failure. The historical V1 evaluation
+driver and reports remain unchanged.
+
+## Nominal closed-loop execution
+
+The Increment 5 closed-loop surface is an opt-in, nominal-only reference path
+for deterministic experiments with 3 through 100 logical peers. It is not a
+durable runtime or a production orchestration service. Its hard interaction
+limit is 5,000 and its public result contains trace-bound state roots and
+artifacts, not caller-supplied success or safety counters.
+
+`runAdaptiveCollectiveClosedLoopV1()` and
+`runCentralizedPlannerClosedLoopV1()` share the same Mesh, governed-action and
+environment boundaries. Both are bound to the registered nominal definition,
+intent, policy, mandate, peer topology and evaluator boundary. The centralized
+mode records every delivered observation as an accounted directive, retains a
+deterministic bounded public subset and calls `decideCentralized()` exactly
+once; it does not execute the peer-local decision loop or receive the
+evaluator's hidden state, monitor, terminal predicate or a free communication
+channel.
+
+Before a planning policy runs, the runner requests observations separately for
+each peer. A policy receives only that peer's identity, intent, local
+observations, local planning view and logical time. Proposal decisions must be
+made by that peer and cite only its delivered observation digests. The runner
+does not expose an assignee lookup or allow a proposal or adaptive role to
+authorize an effect.
+
+The shared runtime performs real Mesh discovery, capability handling, offer,
+bid selection, award, acceptance and checkpoint transitions. The winning bid
+is selected by the Mesh allocation reducer. A Work Contract is created while
+the accepted assignment is still active, before completion changes the
+execution head.
+
+The 50- and 100-peer reference topologies connect the owner to all other peers.
+Every peer receives observations; adaptive mode records one local decision per
+peer, while centralized mode records one directive per peer. Mesh discovers
+the remote peers and respects its existing bounded fanout by offering to and receiving
+bids from at most 32 candidates for one Work item. The result publishes those
+participant sets instead of treating registration alone as participation.
+
+The one protected action then traverses Trust eligibility, inference assessment
+and grant issuance, grant-ledger reservation, governed permit issuance and a
+`downstream_atomic` fenced environment effect. Currentness is checked at the
+governed boundary, including the Work Contract's exact Trust and inference
+policy IDs. Authorization time is runner-derived after the signed checkpoint
+and within the mission validity window, and is exposed with the action evidence.
+A signed `work.result` is
+emitted only after the same evaluator returns the exact committed receipt and
+its output digest matches the result digest.
+
+`replayAdaptiveCollectiveClosedLoopV1()` and
+`replayCentralizedPlannerClosedLoopV1()` execute fresh inputs twice and require
+the run, trace and boundary-evidence digests to match exactly. Cryptographic
+handles are runtime dependencies: callers may reuse them for a replay, but
+private key material is never included in the serialized definition, trace or
+result.
+
+## Resilient closed-loop reference
+
+Increment 6 adds an opt-in resilience wrapper; the nominal runner remains
+nominal-only. `CollectiveClosedLoopResilienceDefinitionV1` binds the nominal
+definition to a strict, digest-bound fault plan and a bounded epoch count.
+Its closed fault vocabulary is capability withdrawal, assignment decline, peer
+crash, peer restart, directed partition and directed heal. Every reported fault
+has a scheduled, injected and observed digest; a declared-only record is
+rejected. A trace-event trigger must resolve to the exact earlier journal event.
+
+`runCollectiveClosedLoopCausalReplanningV1()` is a focused planning primitive:
+an accepted successor must cite an explicit trigger observation and the exact
+prior semantic-slot head. It records the causal successor and projects its new
+Work identity through the planning reducer; it does not promise automatic
+replanning for arbitrary runtime failures.
+
+`runCollectiveClosedLoopFaultMatrixV1()` is a deterministic test driver over
+the supplied reducer runtime. Its focused conformance coverage processes a
+signed capability withdrawal through the real Mesh discovery reducer and an
+assignment decline plus causal reoffer through the real allocation reducer.
+Crash/resume and partition/heal remain explicit simulator-driver faults, not
+special reducer paths.
+
+The resilient runner does not accept an arbitrary callback returning matrix
+evidence. `createCollectiveClosedLoopFaultMatrixPortV1()` snapshots the driver
+input into a private registration and binds it to the exact nominal planning,
+Mesh, Work Contract, checkpoint and assignment state. Execution validates every
+fault's family, logical time, target, directed link and predecessor against the
+public plan.
+
+The resilient runner starts from the real nominal Mesh state and executes
+lease expiry/grace, proposal, witness votes, certificate, recovery award,
+replacement acceptance and checkpoint resume through the Mesh reducers. The
+replacement receives a Work Contract from the active epoch-two assignment. An
+epoch-one progress or result is fenced with `execution_authority_invalid`; a
+provenance-bound committed effect receipt is required before the replacement
+can emit the epoch-two `work.result`. The evidence retains the real rejected
+envelope and the action must occur inside the recovered lease's absolute time
+window.
+
+`runPairedCollectiveClosedLoopResilienceCampaignV1()` compares construction
+fairness and public-observation digests for adaptive and centralized modes.
+Both sides share the same policy implementation and must match environment,
+monitor and mission-bound matrix inputs; executed scenario, records and driver
+faults are compared again after execution. Exact replay then covers the run,
+trace, evidence and matrix. This is a compact deterministic reference campaign,
+not the 50–500 agent statistical release campaign.
+
+`peer.restart` in this reference is the simulator's in-memory `peer.resume`:
+the configured instance resumes with retained reducer state. It is not a fresh
+instance lifecycle, durable restore, production recovery protocol or cloud
+deployment.
+
+## Statistical campaign contracts
+
+The package exports deterministic configuration and evidence contracts for the
+50/100/250/500-agent ladder. `createCollectiveStatisticalCampaignTopologyV1()`
+builds the registered sparse directed topology; scale configuration binds the
+exact interaction ceiling and fault-family row. These functions allocate
+configuration data only and do not execute a scale campaign.
+
+`verifyCollectiveStatisticalCampaignBundleV1()` is a side-effect-free verifier
+for a fully supplied in-memory evidence bundle. It requires the canonical
+Collective Planning registration and terminal manifest, the exact four
+adaptive/centralized first/replay slots for every registered cell, closed
+sample/trace/ledger/evidence indexes, trusted source-lock expectations and
+independently recomputed comparison and summary statistics. Replay equality
+covers the stable outcome plus trace, ledger and observation records. A failed
+execution remains present and forces a failed summary.
+
+Inputs are snapshotted from data descriptors before validation, paths are
+logical safe-relative names, and unknown/accessor-bearing shapes fail closed.
+Each artifact is capped at 16 MiB and the supplied bundle at 256 MiB before JSON
+decoding. The daily command is deliberately a registration/configuration
+contract smoke; it is not statistical or scale-execution evidence.
+
+`runCollectiveStatisticalCampaignShardV1()` executes any deterministic subset
+of the registered cells and writes an immutable execution record before it
+settles the revision-CAS lease state. A restart reads both state and records by
+`runKey`, validates their execution identity and complete artifact content, and
+continues without rerunning committed slots. An expired running slot is
+reconciled from its durable record, or conservatively marked as an indeterminate
+external effect when no record exists. Runner exceptions become terminal failed
+samples, while the remaining slots still execute. The orchestration store is an
+interface; the simulation package does not choose a filesystem, database or
+cloud provider.
+
+`aggregateCollectiveStatisticalCampaignV1()` accepts only the exact registered
+closure, rejects duplicate or divergent replay slots, materializes the terminal
+manifest, recomputes paired comparisons and produces bytes accepted by the
+public bundle verifier. It cannot promote a partial shard set.
+
+### Normative analysis and streaming custody
+
+The public surface includes a bounded artifact-stream verifier and deterministic
+normative analysis for the registered 240-cell / 960-slot campaign. The stream
+verifier reads one indexed artifact at a time, checks exact closure, byte hash
+and canonical digest, and applies artifact and total-byte limits before a
+visitor receives decoded data. Limits cannot exceed 16,384 artifacts, 16 MiB
+per artifact or 256 MiB total, and empty or unbounded chunk streams fail closed.
+The analyzer consumes evaluator-owned projections and derives its normalized
+rows internally, uses a pre-registered one-sided Wilson acceptance bound plus
+descriptive two-sided intervals, and returns an ineligible or incomplete
+decision whenever closure or evidence is insufficient.
+
+`runCollectiveStatisticalCampaignNormativeOperationV1()` executes exactly one
+authorized five-cell shard through a trusted registry resolver. The resolved
+runner implementation and evaluator digests must match the authorized
+descriptor before mutation, direct runner/projector injection is not accepted,
+every projection must retain that evaluator binding, and state/slot/evidence
+identity is derived from the exact plan and stable authenticated authorization
+digest. A caller can
+recompute the namespace with
+`collectiveStatisticalCampaignNormativeExecutionIdV1()`.
+
+This is a control-plane capability only: it does not execute the 50–500-agent
+campaign, invoke a provider, or claim that the campaign has passed.
+
+## Progressive scale execution surface
+
+`COLLECTIVE_PROGRESSIVE_SCALE_PROFILES_V1` defines three closed industry
+profiles. They progress from 500 participants and 5,000 interactions to 5,000
+participants and 50,000 interactions, then to 100,000 participants and
+1,000,000 interactions. The profiles also bind the role-coherence horizon,
+benign or Byzantine affected population, recovery-work class and physical,
+social or cyber scenario domains. Existing V1 campaign contracts remain
+unchanged.
+
+`createCollectiveProgressiveScalePlanV1()` produces an immutable execution plan
+whose sparse topology is an algorithmic descriptor. A worker derives one
+peer's O(log N) neighbors and affected-population membership on demand; the
+plan never materializes the global peer or edge set. Peer and interaction
+ranges are exact, non-overlapping shards, and the implicit affine permutation
+selects the configured affected population without a global membership list.
+
+`runCollectiveProgressiveScaleShardV1()` binds a provider-neutral executor ID
+and version to one exact shard. Results retain interaction, recovery-work,
+mission-success and digest-only event-stream evidence. The aggregate report
+requires an exact shard closure, the registered role-coherence horizon, the
+complete affected population, restored mission success and the profile's
+quadratic, N log N or linear recovery ceiling. These APIs make large-scale
+execution pluggable and bounded; constructing a plan or a conformant-shaped
+report is not evidence that a large campaign was actually executed.
+
+`createCollectiveProgressiveScaleOverlayBindingV2()` connects each execution
+tier to the production `@agentplat/mesh/overlay` profile with the same peer,
+interaction and sparse-degree bounds. The additive
+`createCollectiveProgressiveScalePeerRoutingV2()` helper constructs one peer's
+bounded active/reserve view and exact outbound interaction quota without
+materializing the plan's global population or topology. Existing progressive
+scale V1 artifacts and digests are unchanged.
+
+## Sharded simulation and scale interoperability
+
+The root package also exports a transport-neutral environment bridge and three
+closed logical-peer profiles: 500/5,000 interactions, 5,000/50,000 and
+100,000/1,000,000. `createShardedSimulationAssignmentsV1()` partitions peers
+and interactions without materializing a global topology, while
+`shardedSimulationAssignmentForPeerV1()` resolves a peer's shard in constant
+time.
+
+Runner-visible ports cover partial observations, fenced effects, cross-shard
+message batches and opaque evaluator-owned checkpoints. Success, recovery and
+role-coherence metrics are available only through the separate evaluator port;
+a runner cannot supply those verdicts. The in-memory bridge is a reference
+composition surface, not a distributed deployment or scale claim.
+
+Fault schedules are closed, bounded inputs interpreted at the driver boundary.
+Failures, restarts, partitions, compromised or rogue actors and misleading or
+conflicting observations alter the simulated interaction path and every
+scheduled fault must be observed. External HTTP or gRPC bridges must return
+exact digest-bound envelopes and preserve durable checkpoint anchors.
+
+## Multi-domain environment adapters
+
+The root export includes open descriptors and manifests for physical, social,
+cyber and hybrid environments. A manifest binds implementation, schemas,
+scenario, profile, seed, population, topology/transition/visibility/fault
+policies and resource budgets. The reference bridge applies those scenario
+budgets and population bounds before runner-visible operations.
+
+`runMultiDomainAdapterConformanceV1()` rejects substitution of the requested
+definition and exercises deterministic observations, undeclared capability and
+stale-fence denial, checkpoint/restore after mutation, out-of-population
+actions and byte bounds. Passing black-box conformance is a contract signal,
+not proof of simulator fidelity or a completed scale run.
+
+## Verified benchmark registry
+
+Benchmark suites bind one exact multi-domain scenario, scale profile, seed,
+budget and centralized baseline. Candidate metrics are derived from trace
+facts; callers cannot submit a score. Verification additionally requires a
+trusted evaluator evidence port for candidate and baseline trace provenance.
+
+Leaderboards are suite-specific, deterministic and exclude invalid,
+over-budget, duplicate or replayed-trace submissions from ranking. Source,
+artifact and build locks are digest references: deployments remain responsible
+for custody, evaluator independence and environment relevance.
+
+## Scalable evaluation runtime
+
+The `./scalable-evaluation` export provides a provider-neutral configuration
+and accounting layer over the existing sharded simulation and multi-domain
+environment contracts. Its `standard-500`, `large-5000`, and
+`frontier-100000` profiles bind 500/5,000, 5,000/50,000, and
+100,000/1,000,000 agent/interaction envelopes. Message count, message bytes,
+interaction count, and the bounded retained-record tail are explicit budgets;
+creating these values does not allocate agents or start a run.
+
+Definitions bind physical, social, or cyber scenario manifests to an explicit
+partial-observation policy and the benign, Byzantine, rogue, or context
+poisoning perturbations selected by the evaluator. Target selectors stay
+private and are represented publicly by cardinality and digest, preventing a
+100,000-agent profile from materializing a global target list.
+
+`InMemoryScalableEvaluationRuntimeV1` accepts strictly sequenced accounting
+records and keeps aggregate counters by team and domain. The full history is
+committed by a chain digest while only the configured tail remains in memory.
+With the closed two-team, three-domain contract, retained state is
+O(teams + domains + perturbations + tail) and is independent of the declared
+agent population.
+Recovery episodes compare provider-measured basis-point samples with a
+pre-perturbation baseline and report the accounted interactions and messages
+needed to return within tolerance. Injection and recovery receipts are signed
+with Ed25519 and bind the exact definition, scenario, environment adapter,
+provider authorization, team, session, episode, perturbation schedule and
+sample identity. `WebCryptoScalableEvaluationEvidenceVerifierV1` captures the
+platform verifier and its authorization/key resolvers at construction; caller
+supplied crypto, structural boolean verifiers and non-canonical signatures are
+rejected. The accounting runtime accepts only receipts branded by that verified
+path, so a provider cannot turn an unsigned metric array into recovery evidence.
+
+Both sides of a `team-vs-team` matchup implement the same
+`ScalableEvaluationTeamPortV1`. A centralized controller can occupy either
+side as a replaceable reference without receiving hidden environment state,
+and the comparison output contains signed deltas rather than an inferred
+winner. Environment binding validates the exact multi-domain scenario before
+returning its bridge; it does not start sessions, invoke team callbacks, or
+execute an evaluation campaign.
+
+`runScalableEvaluationV1()` routes every team message through the environment
+delivery ingress, including messages whose source and destination currently
+share a shard. Accounting advances only after an exact digest-bound ACK names
+every expected event; there is no local synthetic-delivery shortcut. A message
+also carries a complete bounded `transportEnvelope` and its digest. The batch
+commits that envelope digest, the ACK commits the exact `batchDigest`, and only
+after validating that complete binding does the runner hand the envelope to
+the team's acknowledged-message ingress. A port that emits messages but
+supplies no ingress fails closed.
+
+The reference integrated adapter connects genuine
+`@agentplat/collective-host/reference-integrated-stack` instances to the same
+team port. `ReferenceIntegratedScalableEvaluationEgressRuntimeV1` installs a
+real sparse peer plane with a nominal delivery queue, preserving the exact
+recipient indexes chosen by the overlay. The same egress is the stack's
+recovery-aware assignment authority: protected commits stop in an idempotent
+action outbox, and the outer runner is the only component that applies those
+actions to the evaluation environment. Peer binding checks the stack's private
+construction brand and exact plane/authority object identities; callback-shaped
+lookalikes, effect mappers and invented routing targets are not accepted. The
+reserved implementation ID
+`agentplat.reference-integrated-collective-stack.v1` is accepted only from this
+nominal factory path.
+
+The delivery capture and action outbox in this reference egress are bounded,
+in-memory state for one evaluation process. They are not a production durable
+transport or protected-effect sink, so this particular port remains suitable
+only for the non-durable runner path. `runScalableEvaluationV1()` also has an
+explicit restart-durable mode: supply both `durableStore` and `runId`, plus
+restart-durable environment, team, perturbation, recovery and action-authority
+ports. The runner rejects a partial declaration or a callback-shaped claim.
+Providers opt in with a module-created
+`ScalableEvaluationRestartDurabilityDeclarationV1`; the declaration identity
+and the exact definition, adapter descriptor, sparse schedule, assignments,
+shard count, baselines and team descriptors are bound into the checkpoint
+configuration digest.
+
+`ScalableEvaluationDurableCheckpointStoreV1` is provider-neutral and advances
+one run by revision-and-digest CAS. A checkpoint carries the exact phase,
+logical step/team/cursor, trace predecessor, active recoveries, a bounded
+one-step saga, both environment checkpoints, both team checkpoints and the
+canonical `ScalableEvaluationRuntimeStateV1`. Runtime state is independently
+hash-chained by revision and predecessor and includes the two team states,
+global and per-domain counters, baselines, perturbation observations,
+recoveries, environment bindings and the configured accounting-record ring
+with its physical cursor. Restore validates the definition and adapter binding
+before installing any state.
+
+The durable phase journal covers perturbation, observation, team step, each
+action, each message, accounting, recovery and trace advance. Every external
+operation has a stable content-derived operation ID and is reconciled before
+the next phase is committed. Durable environment and team providers must be
+able to restore the last committed checkpoint even if a newer orphan
+checkpoint was created before a process failed, and must return the same
+idempotent receipt when that operation is reconciled. Missing continuity,
+restore or reconciliation fails closed; the runner never assumes process
+memory or repeats an unreceipted effect.
+
+The nominal transport envelope contains the exact `MeshSparseDeliveryV2` and
+its authenticated content-addressed collective artifact; no callback rebuilds
+either value. Post-ACK ingress validates their complete binding, stores and
+re-reads the artifact through the genuine destination stack, then admits the
+delivery to a bounded peer inbox. At the next peer step, ingress always calls
+`MeshSparsePeerPlaneRuntimeV1.receive()` first, so routing, expiry, deduplication
+and relay semantics run before `node.receive()` performs protocol and artifact
+admission. Deferred causal predecessors remain queued rather than being
+reported as delivered protocol state.
+
+Each peer is owned by exactly one nominal team port, and mission binding checks
+tenant, mesh, mission intent and objective together. A bounded per-step journal
+records `prepared`, `node_mutated`, `output_staged`, `settled` or
+`indeterminate`: exact retries return the staged output, while any mutation
+that cannot be reconciled fails closed and is never executed again. Delivery
+captures are released only after the target ingress receipt is bound to the
+exact batch and ACK; effect captures are released only after the corresponding
+terminal fenced environment request and receipt. This makes pending outbox
+capacity reusable. The pending inbox and admitted-message idempotency window
+are each capped at 65,536 entries, while each peer retains 64 step journals.
+Terminal journals and their settlement records are pruned as the window rolls;
+retries older than that window fail closed instead of re-executing. Egress
+settlement retention is also explicitly bounded by `maximumSettledReceipts`.
+These reference journals and receipts provide exact retry only inside one
+evaluation process. Cross-process recovery uses the opt-in durable runner path
+above and therefore requires implementations of its explicit checkpoint,
+restore and reconciliation ports; the in-memory reference egress does not
+claim those capabilities.
+
+Durable state does not expand the declared population. A run remains limited
+to two teams, three accounting domains, at most 16,384 sparse schedule steps,
+1,024 actions and 1,024 messages (16 MiB total message bytes) per step, and a
+single retained step saga. Public metadata remains capped at 64 KiB, depth 32
+and 16,384 nodes. Runtime record retention is exactly
+`maximumRetainedRecords`; durability declarations may advertise at most 64 MiB
+per checkpoint, and the runner enforces the smallest capacity declared by the
+store, environment bridge and either team port.

package/dist/collective-closed-loop-action.d.ts

@@ -0,0 +1,80 @@
+import { type BudgetReservationV1, type CollectiveAuthorityStateV1, type GovernedActionPermitV1, type WorkContractV1 } from "@agentplat/collective-control";
+import { type GovernedActionDispatchDecisionV1 } from "@agentplat/collective-control/actions";
+import { MemoryCollectiveExecutionRepositoryV1 } from "@agentplat/collective-control/memory";
+import { type ActionBinding, type ActionGrant, type ControlJsonObject } from "@agentplat/inference-control/tools";
+import { type ActionGrantStateV1, type AssessmentRequestV1, type InferenceAssessmentV1, type InferenceControlStateV1 } from "@agentplat/inference-control";
+import { type CollectiveEnvironmentPortV1, type CollectiveProtectedEffectAttemptV1, type CollectiveProtectedEffectReceiptV1 } from "@agentplat/collective-planning/evaluation";
+import type { PlanningDigestV1 } from "@agentplat/collective-planning";
+import { type EvidenceTrustStateV1, type TrustEligibilityDecisionV1, type TrustEligibilityRequestV1 } from "@agentplat/trust";
+/**
+ * The current Mesh projection required to cross the governed action boundary.
+ * It deliberately contains no proposal, adaptive-role, or assignee lookup.
+ */
+export interface CollectiveClosedLoopCurrentMeshV1 {
+    readonly meshId: string;
+    readonly objectiveId: string;
+    readonly objectiveRevision: number;
+    readonly workItemId: string;
+    readonly workItemRevision: number;
+    readonly assignedPeerId: string;
+    readonly assignedInstanceId: string;
+    readonly assignmentAuthorityId: string;
+    readonly assignmentEpoch: number;
+    readonly authorityGeneration: number;
+    readonly fencingToken: string;
+    readonly leaseExpiresAtLogicalMs: number;
+    readonly objectiveTerminal: boolean;
+    readonly workTerminal: boolean;
+}
+export interface CollectiveClosedLoopEffectMetadataV1 {
+    readonly registrationDigest: PlanningDigestV1;
+    readonly missionIntentId: string;
+    readonly intentRevision: number;
+    readonly intentDigest: PlanningDigestV1;
+    readonly actionClass: string;
+}
+export interface CollectiveClosedLoopActionInputV1 {
+    /** A mandate already accepted by this exact authority state. */
+    readonly mandate: Parameters<MemoryCollectiveExecutionRepositoryV1["registerWork"]>[0]["mandate"];
+    readonly authorityState: CollectiveAuthorityStateV1;
+    /** Must have been derived from a current accepted Mesh assignment. */
+    readonly workContract: WorkContractV1;
+    readonly mesh: CollectiveClosedLoopCurrentMeshV1;
+    readonly environment: CollectiveEnvironmentPortV1;
+    readonly effect: CollectiveClosedLoopEffectMetadataV1;
+    readonly actionBinding: ActionBinding;
+    readonly actionInput: ControlJsonObject;
+    readonly trustState: EvidenceTrustStateV1;
+    readonly trustRequest: TrustEligibilityRequestV1;
+    /** State has a registered policy, current run and negotiated capability. */
+    readonly inferenceState: InferenceControlStateV1;
+    readonly assessmentRequest: AssessmentRequestV1;
+    readonly assessment: InferenceAssessmentV1;
+    readonly actionGrant: ActionGrantStateV1;
+    readonly logicalTimeMs: number;
+    readonly wallTime: string;
+    readonly gatewayId: string;
+    readonly reservationId: string;
+    readonly permitId: string;
+    readonly decisionId: string;
+}
+export interface CollectiveClosedLoopActionResultV1 {
+    /** Runner-owned wall time used to authorize this exact governed action. */
+    readonly authorizedAt: string;
+    readonly trustDecision: TrustEligibilityDecisionV1;
+    readonly inferenceState: InferenceControlStateV1;
+    readonly actionGrant: ActionGrant;
+    readonly budgetReservation: BudgetReservationV1;
+    readonly actionPermit: GovernedActionPermitV1;
+    readonly executionStateDigest: string;
+    readonly action: GovernedActionDispatchDecisionV1;
+    readonly effectAttempt: CollectiveProtectedEffectAttemptV1 | null;
+    readonly receipt: CollectiveProtectedEffectReceiptV1 | null;
+}
+/**
+ * Runs one protected action through real Trust, inference, Collective Control
+ * and the fenced evaluation sink.  It is intentionally a one-shot composition
+ * boundary: callers produce observations/results outside this module.
+ */
+export declare function runCollectiveClosedLoopActionV1(input: CollectiveClosedLoopActionInputV1): Promise<CollectiveClosedLoopActionResultV1>;
+//# sourceMappingURL=collective-closed-loop-action.d.ts.map

package/dist/collective-closed-loop-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collective-closed-loop-action.d.ts","sourceRoot":"","sources":["../src/collective-closed-loop-action.ts"],"names":[],"mappings":"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"}