🥮 mooncakes.io

moonflow

Generic durable orchestration engine for Moon Suite

moon add vectie/moonflow@0.1.2
Download zip
Author
Version
0.1.2
License
Apache-2.0
Repository
Last updated
14 days ago
Downloads
3

Dependencies

README

#MoonFlow

Platform · local alpha orchestration engine. Read the product contract for the non-agent boundary, adapter requirements, recovery model and release gates.

MoonFlow is Moon Suite's generic durable orchestration capability and engine.

The governed reinforcement and capability-activation loop is documented in docs/REINFORCEMENT_CAPABILITY_LOOP.md. The executable ownership boundaries and pure test seams are documented in docs/RESPONSIBILITY_AND_TESTABILITY.md. MoonClaw is the suite's single agent runtime: it owns the model loop, personas, reasoning lifecycle, and agent execution, and may call MoonFlow to durably advance declared work. MoonBook owns source intent; MoonFlow imports a versioned Work graph, preserves its source linkage, evaluates dependencies, records attempts and evidence, and projects recoverable orchestration state.

MoonFlow is not an agent and does not have a model loop, persona, autonomous reasoning lifecycle, or self-scheduling behavior. Its library and command-line surfaces perform explicit orchestration operations when invoked by MoonClaw or an operator/developer.

#Constitutional boundary

  • MoonFlow advances durable orchestration for declared intent when invoked; it does not author MoonBook goals or independently decide to run work.
  • MoonFlow owns run events, attempts, policy decisions, and recovery state.
  • Product adapters own their domain effects and return typed receipts.
  • MoonTown may propose work but cannot mark MoonFlow items complete.
  • Physical effects always require separately granted physical authority.

#Event stream v3

moonflow.event-stream.v3 adds governed checkpoint reuse without weakening the fresh execution contract. A Work graph must provide:

  • book_id, declaration_revision, and source_digest;
  • a unique declaration_id for every Work item;
  • canonical requested_authority values;
  • non-empty acceptance_criteria;
  • known, acyclic dependencies.

The importer fails closed instead of creating permanently waiting work when a dependency is unknown or cyclic. Every event carries the immutable source context, so replay rejects events from a different book revision or digest.

Canonical authority classes are observe, cognitive-maintenance, sandbox-execution, workspace-mutation, external-effect, and physical-effect.

#Adapter contract

The adapter boundary records capability, request, attempt, idempotency key, input digest, requested authority, external job identity, terminal status, output digest, artifacts, error classification, and compensability. Production adapters must support reconciliation. Result import fails closed when request, attempt, idempotency, or product identity differs.

Capability records also declare health, operations, authority classes, input/output contracts, and a claim ceiling. The director selects an adapter only when all dimensions match. Unknown outcomes reconcile before any retry; quality rejection revises the input or procedure instead of repeating it.

For cross-product execution, capability truth is compiled instead of hand-authored. A moonflow.capability-source-bundle.v1 combines the product-owned pack.json, a version-bound adapter declaration, and expiring health evidence. It produces canonical operation identities such as moonmold/spatial.operation.execute@0.2.0 and versioned schema identities. The existing director consumes that catalog directly. Graph compilation fails closed on phantom products, invented/unversioned operations, schema or authority drift, unhealthy adapters, and claims above the declared ceiling. Dispatch and unattended execution re-evaluate the health validity window at their recorded execution time. See docs/CAPABILITY_TRUTH.md.

Ready Work items that require a pack-owned operator surface use the generic, digest-bound receiver loop documented in docs/OPERATOR_RECEIVER_LOOP.md. It carries run, attempt, operation, input, evidence, authority, and review identity into a configured manifest entrypoint and accepts only a correlated durable receipt. An accepted receipt advances the existing event stream and unlocks declared dependencies; it does not create another runtime.

prepare-next removes hand-authored dispatch requests. It derives each ready item's requirement from its MoonBook execution binding, selects a healthy compatible adapter, verifies and hashes the declared input artifacts, writes a durable decision/request pair, and submits the attempt event. A rejected selection is retained as a decision receipt and does not start work. complete-artifacts performs the symmetric return path for local adapters: it verifies workspace-relative output artifacts, derives their aggregate digest, materializes the typed result receipt, and reconciles it into review state.

#Native revision and evidence lineage

revise-run creates a child run and never rewrites its parent. It reuses an accepted checkpoint only when declaration identity, owner, authority, acceptance criteria, evidence identity, and every dependency revalidate. Changed checkpoints are explicitly marked invalidated in a moonflow.run-migration.v1 receipt. Reuse is represented by a durable checkpoint-reused event and remains distinct from new execution.

bundle-evidence reads a workspace-relative descriptor, verifies every source before mutation, hashes and stores immutable content-addressed objects, writes a manifest, and verifies workspace containment again after mutation. The command removes manual copying and hash transcription while retaining producer, contract, claim, and result provenance.

#CLI

The CLI is an operator/developer surface for inspecting, driving, and diagnosing the engine. It is not a separate agent process or agent runtime.

moonflow import-graph <workspace> <graph.json>
moonflow status <workspace> <run-id>
moonflow transition <workspace> <run-id> <work-item-id> <action> <recorded-at> [detail]
moonflow advance <workspace> <run-id> <recorded-at>
moonflow submit-attempt <workspace> <run-id> <request.json>
moonflow reconcile-attempt <workspace> <run-id> <result.json>
moonflow review-outcome <workspace> <run-id> <workspace-relative-review-receipt>
moonflow revise-run <workspace> <parent-run-id> <child-graph-artifact> <proposal-artifact> <migration-id> <recorded-at>
moonflow select-adapter <workspace> <capabilities-artifact> <requirement-artifact>
moonflow prepare-next <workspace> <run-id> <capabilities-artifact> <recorded-at>
moonflow complete-artifacts <workspace> <run-id> <work-item-id> <recorded-at> <artifact>...
moonflow bundle-evidence <workspace> <bundle-spec-artifact> <recorded-at>
moonflow run-unattended <workspace> <graph-artifact> <capabilities-artifact> <manifest-artifact> <envelope-artifact> <usage-artifact> <recorded-at>
moonflow validate-capability <capability.json>
moonflow compile-capability-catalog <source-bundle.json>
moonflow validate-work-graph-capabilities <graph.json> <catalog.json> <evaluated-at>
moonflow import-conformant-graph <workspace> <graph.json> <catalog.json> <evaluated-at>
moonflow receive-operator-receipt <workspace> <run-id> <handoff-token> <submission-artifact>
moonflow recover-operator-receipts <workspace> <run-id>
moonflow operator-receiver-status <workspace> <run-id> <handoff-token>

run-unattended requires a v3 manifest. Every attempt is authorized by MoonGate before execution, its declared artifacts are digest-verified, a distinct product attestor must turn the isolated agent draft into a separately declared final artifact, and an independent reviewer must decide the immutable criteria against that product-owned final path. Durable request, draft result, attestation, and review receipts are recovery checkpoints: restarting after any one of them does not repeat completed work or create a second attempt.

Install the cross-product unattended runtime reproducibly instead of copying development build paths into a manifest:

scripts/install_moonsuite_runtime.sh ~/moonsuite

The installer builds the owning products, installs only runtime executables under ~/moonsuite/bin, and writes a content-addressed source/binary manifest at ~/moonsuite/.moonsuite/runtime/installed-runtime.json. Set MOON_SUITE_SOURCE_ROOT only when the source repositories are not sibling directories under ~/Workspace.

The restart invariant is fault-injected at all three post-action boundaries:

python3 scripts/unattended_recovery_smoke.py harness \
  _build/native/debug/build/cmd/main/main.exe

The first three launches are deliberately killed after result, product attestation, and review persistence. The fourth resumes to accepted state and the fifth proves terminal duplicate delivery is a no-op. The smoke test also requires an unattended-qualified intervention scorecard and exactly one attempt identity.

#Ordered HTTP JSON transport

The operator/developer CLI includes one domain-neutral transport utility for transferring selected top-level fields from a fetched JSON object in a declared order. The utility performs no reasoning and does not create an agent loop:

moon run cmd/main -- ordered-http-json \
  fixtures/ordered-http-json.config.json \
  /path/to/new-receipt.json

The configuration contract is moonflow.ordered_http_json.v2:

{
  "contract_version": "moonflow.ordered_http_json.v2",
  "transfer_id": "example-ordered-transfer-v1",
  "source_url": "http://127.0.0.1:4100/api/bundles/example",
  "expected_source_digest": "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
  "max_response_bytes": 1048576,
  "max_attempts": 3,
  "retry_delay_ms": 250,
  "steps": [
    {"field": "record", "destination_url": "http://127.0.0.1:4200/api/ingress/records"},
    {"field": "envelope", "destination_url": "http://127.0.0.1:4200/api/ingress/envelopes"}
  ]
}

The transport performs exactly one GET, requires its raw response digest to match expected_source_digest, requires a top-level JSON object, and then serializes and POSTs each configured field in array order. It accepts no header, token, secret, cookie, username, password, query, or fragment configuration. Every response is streamed under max_response_bytes, must be UTF-8 JSON with a 2xx status, and must not carry a generic error signal (error, non-empty errors, or false ok, success, or accepted).

Each POST is retried at most max_attempts times with retry_delay_ms between failures. Every attempt for one step carries the same Idempotency-Key, derived only from the transfer ID, step ordinal, selected field, destination, and exact request digest. Re-running the same immutable transfer therefore uses the same keys; changing the source bytes, payload, destination, or order changes them.

On complete success the command refuses to overwrite the receipt path, writes one compact canonical receipt with mode 0600, and prints the same value. The receipt binds the source response digest and every ordered request body, destination, idempotency key, attempt count, status, and exact raw response digest; receipt_digest hashes the canonical receipt core. A failed step stops later steps and emits no success receipt. Because later steps cannot start until the prior step returns a successful JSON receipt, record followed by envelope in the configuration is a strict delivery boundary. See fixtures/ordered-http-json.config.schema.json for the strict schema.

Adapter success moves Work to review; it never implies acceptance. The only CLI acceptance path is review-outcome, whose typed receipt must match the persisted run, declaration, result, attempt, and output digest, review every original criterion in order, and cite evidence already attached to the Work item.

If execution reveals that a criterion belongs to the wrong product, MoonBook compiles a new declaration revision and revise-run performs checkpoint migration. The old event history remains unchanged; invalid evidence is never reinterpreted in place.

All durable orchestration state is stored under <workspace>/.moonsuite/products/moonflow/runs/<run-id>. Artifact transitions accept only existing workspace-relative paths and reject canonical path escape.

#Verification

moon check --target native --deny-warn
moon test --target native --deny-warn
moon info
moon fmt

#
AcceptanceReviewError

source
pub(all) suberror AcceptanceReviewError {
  InvalidAcceptanceReview(Array[String])
  AcceptanceReviewItemUnavailable(String)
  AcceptanceReviewIdentityMismatch(field~ : String, expected~ : String, actual~ : String)
  AcceptanceReviewConflict(String)
} derive(Eq, ToJson, 
Debug)

#
AdapterContractError

source
pub(all) suberror AdapterContractError {
  InvalidAdapterRequest(Array[String])
  InvalidAdapterResult(Array[String])
  AdapterIdentityMismatch(field~ : String, expected~ : String, actual~ : String)
  AdapterRuntimeItemUnavailable(String)
  AdapterRuntimeItemNotReady(item_id~ : String, status~ : String)
  AdapterAttemptUnavailable(String)
  AdapterReceiptConflict(String)
} derive(Eq, ToJson, 
Debug)

#
FlowError

source
pub(all) suberror FlowError {
  EmptyEventId
  EmptyRunId
  InvalidSequence(expected~ : Int, actual~ : Int)
  ConflictingDuplicateEvent(String)
  RunIdMismatch(expected~ : String, actual~ : String)
  MissingWorkItem(String)
  DuplicateWorkItem(String)
  InvalidTransition(item_id~ : String, from~ : String, event~ : String)
  DependencyNotAccepted(item_id~ : String, dependency_id~ : String)
  MissingArtifactId(String)
  MissingAuthorityId(String)
  MissingRunSource(String)
  MissingDeclarationId(String)
  MissingAcceptanceCriteria(String)
  InvalidAuthority(item_id~ : String, authority~ : String)
  SourceContextMismatch(field~ : String, expected~ : String, actual~ : String)
  MissingAttemptField(item_id~ : String, field~ : String)
  AttemptIdentityMismatch(item_id~ : String, expected~ : String, actual~ : String)
  UnsupportedAttemptStatus(item_id~ : String, status~ : String)
  MissingAcceptanceReview(String)
  MissingAcceptanceReviewField(item_id~ : String, field~ : String)
} derive(Eq, ToJson, 
Debug)

#
AcceptanceCriterionReview

source
pub(all) struct AcceptanceCriterionReview {
  criterion : String
  satisfied : Bool
  evidence_refs : Array[String]
  note : String
} derive(Eq, ToJson, 
Debug)

#
AcceptanceReviewReceipt

source
pub(all) struct AcceptanceReviewReceipt {
  contract_id : String
  review_id : String
  run_id : String
  work_item_id : String
  declaration_id : String
  result_id : String
  attempt_id : String
  output_digest : String
  decision : String
  criteria : Array[AcceptanceCriterionReview]
  reviewer_id : String
  review_authority_id : String
  receipt_artifact : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
AcceptanceReviewReceipt::quality_issues

source
fn AcceptanceReviewReceipt::quality_issues(self : AcceptanceReviewReceipt) -> Array[String]

#
AdapterAttemptStatus

source
pub(all) enum AdapterAttemptStatus {
  Submitted
  Running
  Succeeded
  Failed
  Cancelled
  Unknown
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
AdapterAttemptStatus::id

source

#
AdapterAttemptStatus::is_terminal

source
fn AdapterAttemptStatus::is_terminal(self : AdapterAttemptStatus) -> Bool

#
AdapterCapability

source
pub(all) struct AdapterCapability {
  adapter_id : String
  product_id : String
  protocol : String
  operations : Array[String]
  authority_classes : Array[String]
  input_contracts : Array[String]
  output_contracts : Array[String]
  claim_ceiling : String
  healthy : Bool
  supports_cancel : Bool
  supports_reconcile : Bool
} derive(Eq, ToJson, 
Debug)

#
AdapterCapability::quality_issues

source
fn AdapterCapability::quality_issues(self : AdapterCapability) -> Array[String]

#
AdapterDeclarationV1

source
pub(all) struct AdapterDeclarationV1 {
  contract_id : String
  adapter_id : String
  product_id : String
  pack_id : String
  pack_version : String
  protocol : String
  operations : Array[AdapterOperationDeclarationV1]
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
AdapterHealthAttestationV1

source
pub(all) struct AdapterHealthAttestationV1 {
  contract_id : String
  adapter_id : String
  product_id : String
  pack_id : String
  pack_version : String
  protocol : String
  status : String
  checked_at : String
  valid_until : String
  operation_refs : Array[String]
  evidence_ref : String
  evidence_digest : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
AdapterOperationDeclarationV1

source
pub(all) struct AdapterOperationDeclarationV1 {
  operation_id : String
  claim_ceiling : String
  supports_cancel : Bool
  supports_reconcile : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
AdapterRequest

source
pub(all) struct AdapterRequest {
  request_id : String
  run_id : String
  book_id : String
  work_item_id : String
  declaration_id : String
  attempt_id : String
  idempotency_key : String
  product_id : String
  operation : String
  requested_authority : String
  acceptance_criteria : Array[String]
  input_contracts : Array[String]
  output_contracts : Array[String]
  required_claim : String
  input_digest : String
  input_artifacts : Array[String]
  timeout_ms : Int
  created_at : String
} derive(Eq, ToJson, 
Debug)

#
AdapterRequest::quality_issues

source
fn AdapterRequest::quality_issues(self : AdapterRequest) -> Array[String]

#
AdapterResult

source
pub(all) struct AdapterResult {
  result_id : String
  request_id : String
  attempt_id : String
  idempotency_key : String
  product_id : String
  external_job_id : String
  status : AdapterAttemptStatus
  output_digest : String
  output_artifacts : Array[String]
  error_kind : String
  compensable : Bool
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
AdapterResult::quality_issues

source
fn AdapterResult::quality_issues(self : AdapterResult) -> Array[String]

#
CapabilityActivationProjectionV1

source
pub(all) struct CapabilityActivationProjectionV1 {
  contract_version : String
  activation_id : String
  request : CapabilityRecordRefV1
  receipt : CapabilityRecordRefV1
  scope_id : String
  rollout_mode : String
  status : String
  challenger_participant_ids : Array[String]
  max_observations : Int
  experiment : CapabilityRecordRefV1
  old_capability : CapabilityRecordRefV1
  new_capability : CapabilityRecordRefV1
  rollback : CapabilityRecordRefV1
  activation_review : CapabilityRecordRefV1
  activation_reviewer_id : String
  activation_reviewer_authority_ref : String
  activated_at : Int64
  observations : Array[CapabilityObservationV1]
  settlement : CapabilitySettlementRequestV1?
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityActivationProjectionV1::record_observation

source

#
CapabilityActivationProjectionV1::settle

source

#
CapabilityActivationRequestV1

source
pub(all) struct CapabilityActivationRequestV1 {
  contract_version : String
  request : CapabilityRecordRefV1
  receipt : CapabilityRecordRefV1
  scope_id : String
  rollout_mode : String
  challenger_participant_ids : Array[String]
  max_observations : Int
  experiment : CapabilityRecordRefV1
  old_capability : CapabilityRecordRefV1
  new_capability : CapabilityRecordRefV1
  rollback : CapabilityRecordRefV1
  activation_review : CapabilityRecordRefV1
  activation_reviewer_id : String
  activation_reviewer_authority_ref : String
  requested_at : Int64
  adoption_authorized : Bool
  source_side_effects_applied : Bool
  activation_side_effects_applied : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityCatalogV1

source
pub(all) struct CapabilityCatalogV1 {
  contract_id : String
  catalog_id : String
  compiled_at : String
  conformant : Bool
  products : Array[CapabilityProductV1]
  operations : Array[CapabilityOperationV1]
  issues : Array[CapabilityConformanceIssueV1]
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityCatalogV1::adapter_capabilities

source
fn CapabilityCatalogV1::adapter_capabilities(self : CapabilityCatalogV1) -> Array[AdapterCapability]

#
CapabilityCatalogV1::adapter_capabilities_at

source
fn CapabilityCatalogV1::adapter_capabilities_at(self : CapabilityCatalogV1, evaluated_at : String) -> Array[AdapterCapability] raise

#
CapabilityConformanceIssueV1

source
pub(all) struct CapabilityConformanceIssueV1 {
  code : String
  subject : String
  detail : String
  suggestions : Array[String]
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityObservationV1

source
pub(all) struct CapabilityObservationV1 {
  observation_id : String
  scope_id : String
  participant_id : String
  assignment : String
  capability : CapabilityRecordRefV1
  outcome : CapabilityRecordRefV1
  reward_evidence : CapabilityRecordRefV1
  accepted : Bool
  recorded_at : Int64
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityOperationV1

source
pub(all) struct CapabilityOperationV1 {
  operation_ref : String
  product_id : String
  pack_id : String
  pack_version : String
  tool_id : String
  adapter_id : String
  protocol : String
  authority : String
  input_schema_ref : String
  output_schema_ref : String
  claim_ceiling : String
  idempotent : Bool
  review_required : Bool
  supports_cancel : Bool
  supports_reconcile : Bool
  health_checked_at : String
  health_valid_until : String
  health_evidence_ref : String
  health_evidence_digest : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityProductV1

source
pub(all) struct CapabilityProductV1 {
  product_id : String
  pack_id : String
  pack_version : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityRecordRefV1

source
pub(all) struct CapabilityRecordRefV1 {
  record_id : String
  record_version : String
  record_digest : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilityResolutionV1

source
pub(all) struct CapabilityResolutionV1 {
  contract_version : String
  scope_id : String
  participant_id : String
  assignment : String
  selected_capability : CapabilityRecordRefV1
  shadow_capability : CapabilityRecordRefV1?
  activation_id : String
  experiment : CapabilityRecordRefV1
  status : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CapabilitySettlementRequestV1

source
pub(all) struct CapabilitySettlementRequestV1 {
  contract_version : String
  settlement_id : String
  scope_id : String
  decision : String
  experiment_outcome : CapabilityRecordRefV1
  reviewer_id : String
  reviewer_authority_ref : String
  review_evidence : CapabilityRecordRefV1
  settled_at : Int64
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
CheckpointMigrationDecision

source
pub(all) struct CheckpointMigrationDecision {
  child_work_item_id : String
  source_work_item_id : String
  declaration_id : String
  decision : String
  reason : String
  evidence_refs : Array[String]
} derive(Eq, ToJson, 
Debug)

#
DirectorCandidateReview

source
pub(all) struct DirectorCandidateReview {
  adapter_id : String
  accepted : Bool
  reasons : Array[String]
} derive(Eq, ToJson, 
Debug)

#
DirectorDecision

source
pub(all) struct DirectorDecision {
  contract_id : String
  requirement_id : String
  selected_adapter_id : String
  accepted : Bool
  reviews : Array[DirectorCandidateReview]
} derive(Eq, ToJson, 
Debug)

#
DirectorFailureClass

source
pub(all) enum DirectorFailureClass {
  TransientFailure
  QualityRejection
  AuthorityDenial
  PermanentIncompatibility
  UnknownOutcome
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
DirectorFailureClass::id

source

#
DirectorRequirement

source
pub(all) struct DirectorRequirement {
  requirement_id : String
  product_id : String
  operation : String
  requested_authority : String
  input_contracts : Array[String]
  output_contracts : Array[String]
  required_claim : String
} derive(Eq, ToJson, 
Debug)

#
DirectorRetryDecision

source
pub(all) struct DirectorRetryDecision {
  failure_class : DirectorFailureClass
  action : String
  preserves_attempt_evidence : Bool
  reuses_idempotency_lineage : Bool
  requires_reconciliation : Bool
} derive(Eq, ToJson, 
Debug)

#
EventKind

source
pub(all) enum EventKind {
  RunCreated
  ItemRegistered
  ItemReady
  ItemStarted
  ItemWaiting
  ItemBlocked
  ItemReviewRequested
  ItemAccepted
  ItemFailed
  ItemCancelled
  ItemSuperseded
  ArtifactAttached
  ApprovalGranted
  AttemptSubmitted
  AttemptReconciled
  CheckpointReused
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
EventKind::id

source
fn EventKind::id(self : EventKind) -> String

#
EvidenceBundleEntry

source
pub(all) struct EvidenceBundleEntry {
  artifact_ref : String
  object_ref : String
  producer_product_id : String
  contract_id : String
  claim_class : String
  result_id : String
  sha256 : String
  size_bytes : Int
} derive(Eq, ToJson, 
Debug)

#
EvidenceBundleManifest

source
pub(all) struct EvidenceBundleManifest {
  contract_id : String
  bundle_id : String
  content_digest : String
  entries : Array[EvidenceBundleEntry]
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
EvidenceBundleManifest::quality_issues

source
fn EvidenceBundleManifest::quality_issues(self : EvidenceBundleManifest) -> Array[String]

#
EvidenceBundleSpec

source
pub(all) struct EvidenceBundleSpec {
  contract_id : String
  bundle_id : String
  sources : Array[EvidenceSourceSpec]
} derive(Eq, ToJson, 
Debug)

#
EvidenceSourceSpec

source
pub(all) struct EvidenceSourceSpec {
  artifact_ref : String
  producer_product_id : String
  contract_id : String
  claim_class : String
  result_id : String
} derive(Eq, ToJson, 
Debug)

#
GraphCapabilityBindingV1

source
pub(all) struct GraphCapabilityBindingV1 {
  work_item_id : String
  operation_ref : String
  adapter_id : String
  input_schema_ref : String
  output_schema_ref : String
  authority : String
  claim_ceiling : String
  review_required : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
GraphCapabilityReportV1

source
pub(all) struct GraphCapabilityReportV1 {
  contract_id : String
  catalog_id : String
  graph_id : String
  accepted : Bool
  bindings : Array[GraphCapabilityBindingV1]
  issues : Array[CapabilityConformanceIssueV1]
  catalog_issues : Array[CapabilityConformanceIssueV1]
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
PackCapabilityManifestV1

source
pub(all) struct PackCapabilityManifestV1 {
  pack_id : String
  product_id : String
  pack_version : String
  schemas : Array[PackSchemaDescriptorV1]
  tools : Array[PackToolDescriptorV1]
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
PackSchemaDescriptorV1

source
pub(all) struct PackSchemaDescriptorV1 {
  id : String
  version : String
  path : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
PackToolDescriptorV1

source
pub(all) struct PackToolDescriptorV1 {
  id : String
  owner_product : String
  input_schema_id : String
  output_schema_id : String
  authority : String
  idempotent : Bool
  review_required : Bool
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
ReconciliationDecision

source
pub(all) enum ReconciliationDecision {
  Pending
  ImportSuccess
  ImportFailure
  ImportCancellation
  InvestigateUnknown
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
RunMigrationReceipt

source
pub(all) struct RunMigrationReceipt {
  contract_id : String
  migration_id : String
  parent_run_id : String
  child_run_id : String
  parent_revision : String
  child_revision : String
  parent_source_digest : String
  child_source_digest : String
  revision_proposal_ref : String
  decisions : Array[CheckpointMigrationDecision]
  reused_count : Int
  invalidated_count : Int
  new_count : Int
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
RunMigrationReceipt::quality_issues

source
fn RunMigrationReceipt::quality_issues(self : RunMigrationReceipt) -> Array[String]

#
RunProjection

source
pub(all) struct RunProjection {
  run_id : String
  book_id : String
  declaration_revision : String
  source_digest : String
  last_sequence : Int
  items : Array[RuntimeItem]
  applied_event_ids : Array[String]
  applied_events : Array[RuntimeEvent]
  outcome : String
} derive(Eq, ToJson, 
Debug)

#
RunProjection::apply

source
fn RunProjection::apply(self : RunProjection, event : RuntimeEvent) -> Unit raise FlowError

#
RunProjection::find_item

source
fn RunProjection::find_item(self : RunProjection, item_id : String) -> RuntimeItem?

#
RunProjection::runnable_item_ids

source
fn RunProjection::runnable_item_ids(self : RunProjection) -> Array[String]

#
RunRevisionResult

source
pub(all) struct RunRevisionResult {
  events : Array[RuntimeEvent]
  receipt : RunMigrationReceipt
} derive(Eq, ToJson, 
Debug)

#
RuntimeEvent

source
pub(all) struct RuntimeEvent {
  sequence : Int
  event_id : String
  run_id : String
  work_item_id : String
  kind : EventKind
  product_id : String
  declaration_id : String
  book_id : String
  declaration_revision : String
  source_digest : String
  requested_authority : String
  acceptance_criteria : Array[String]
  operation : String
  input_contracts : Array[String]
  output_contracts : Array[String]
  required_claim : String
  input_artifacts : Array[String]
  timeout_ms : Int
  request_id : String
  result_id : String
  attempt_id : String
  idempotency_key : String
  external_job_id : String
  attempt_status : String
  input_digest : String
  output_digest : String
  output_artifacts : Array[String]
  error_kind : String
  compensable : Bool
  depends_on : Array[String]
  detail : String
  artifact_id : String
  authority_id : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
RuntimeItem

source
pub(all) struct RuntimeItem {
  work_item_id : String
  declaration_id : String
  product_id : String
  requested_authority : String
  acceptance_criteria : Array[String]
  operation : String
  input_contracts : Array[String]
  output_contracts : Array[String]
  required_claim : String
  input_artifacts : Array[String]
  timeout_ms : Int
  depends_on : Array[String]
  status : RuntimeStatus
  attempt_count : Int
  request_id : String
  result_id : String
  active_attempt_id : String
  idempotency_key : String
  external_job_id : String
  attempt_status : String
  input_digest : String
  output_digest : String
  error_kind : String
  compensable : Bool
  blocker : String
  acceptance_review_id : String
  acceptance_review_artifact : String
  acceptance_reviewer_id : String
  artifacts : Array[String]
  approvals : Array[String]
} derive(Eq, ToJson, 
Debug)

#
RuntimeStatus

source
pub(all) enum RuntimeStatus {
  Proposed
  Ready
  Active
  Waiting
  Blocked
  Review
  Accepted
  Failed
  Cancelled
  Superseded
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
RuntimeStatus::id

source
fn RuntimeStatus::id(self : RuntimeStatus) -> String

#
RuntimeStatus::is_terminal

source
fn RuntimeStatus::is_terminal(self : RuntimeStatus) -> Bool

#
UnattendedDriver

source
pub(all) struct UnattendedDriver {
  adapter_id : String
  executable : String
  arguments : Array[String]
  draft_output_artifacts : Array[String]
  expected_output_artifacts : Array[String]
  attestor_id : String
  attestor_executable : String
  attestor_arguments : Array[String]
  reviewer_id : String
  reviewer_executable : String
  reviewer_arguments : Array[String]
  review_authority_id : String
  budget_request : 
AutonomyBudgetUsage
} derive(Eq, 
Debug)

#
UnattendedManifest

source
pub(all) struct UnattendedManifest {
  contract_id : String
  gate_executable : String
  gate_arguments : Array[String]
  max_cycles : Int
  drivers : Array[UnattendedDriver]
  observer_executable : String
  observer_arguments : Array[String]
} derive(Eq, 
Debug)

#
UnattendedManifest::find_driver

source
fn UnattendedManifest::find_driver(self : UnattendedManifest, adapter_id : String) -> UnattendedDriver?

#
UnattendedManifest::quality_issues

source
fn UnattendedManifest::quality_issues(self : UnattendedManifest) -> Array[String]

#
acceptance_review_event

source
fn acceptance_review_event(projection : RunProjection, receipt : AcceptanceReviewReceipt) -> RuntimeEvent raise AcceptanceReviewError

#
activate_capability_v1

source
fn activate_capability_v1(request : CapabilityActivationRequestV1, activation_id~ : String, activated_at~ : Int64) -> CapabilityActivationProjectionV1 raise

#
adapter_attempt_status_from_id

source
fn adapter_attempt_status_from_id(id : String) -> AdapterAttemptStatus raise

#
adapter_declaration_contract_v1

source
fn adapter_declaration_contract_v1() -> String

#
adapter_health_contract_v1

source
fn adapter_health_contract_v1() -> String

#
adapter_reconciliation_event

source
fn adapter_reconciliation_event(projection : RunProjection, result : AdapterResult) -> RuntimeEvent raise AdapterContractError

#
adapter_submission_event

source
fn adapter_submission_event(projection : RunProjection, request : AdapterRequest) -> RuntimeEvent raise AdapterContractError

#
artifact_ref_is_workspace_relative

source
fn artifact_ref_is_workspace_relative(artifact_ref : String) -> Bool

#
authority_class_is_canonical

source
fn authority_class_is_canonical(authority : String) -> Bool

#
canonical_authority_classes

source
fn canonical_authority_classes() -> Array[String]

#
capability_catalog_contract_v1

source
fn capability_catalog_contract_v1() -> String

#
capability_guarded_events_from_work_graph_v1

source
fn capability_guarded_events_from_work_graph_v1(graph : Json, capabilities : Json, evaluated_at : String) -> Array[RuntimeEvent] raise

#
capability_loop_contract_version

source
fn capability_loop_contract_version() -> String

Generic activation contract consumed from MoonBook. Domain reward meaning remains opaque to MoonFlow and is carried only through evidence references.

#
capability_source_bundle_contract_v1

source
fn capability_source_bundle_contract_v1() -> String

#
claim_class_rank

source
fn claim_class_rank(claim : String) -> Int?

#
compile_capability_catalog_v1

source
fn compile_capability_catalog_v1(value : Json) -> CapabilityCatalogV1 raise

#
compile_work_graph_capabilities_at_v1

source
fn compile_work_graph_capabilities_at_v1(graph : Json, catalog : CapabilityCatalogV1, evaluated_at : String) -> GraphCapabilityReportV1 raise

#
compile_work_graph_capabilities_v1

source
fn compile_work_graph_capabilities_v1(graph : Json, catalog : CapabilityCatalogV1) -> GraphCapabilityReportV1 raise

#
conformant_events_from_work_graph_at_v1

source
fn conformant_events_from_work_graph_at_v1(graph : Json, catalog : CapabilityCatalogV1, evaluated_at : String) -> Array[RuntimeEvent] raise

#
conformant_events_from_work_graph_v1

source
fn conformant_events_from_work_graph_v1(graph : Json, catalog : CapabilityCatalogV1) -> Array[RuntimeEvent] raise

#
decode_acceptance_review_receipt

source
fn decode_acceptance_review_receipt(value : Json) -> AcceptanceReviewReceipt raise

#
decode_adapter_capabilities

source
fn decode_adapter_capabilities(value : Json) -> Array[AdapterCapability] raise

#
decode_adapter_capabilities_at_v1

source
fn decode_adapter_capabilities_at_v1(value : Json, evaluated_at : String) -> Array[AdapterCapability] raise

#
decode_adapter_capability

source
fn decode_adapter_capability(value : Json) -> AdapterCapability raise

#
decode_adapter_declaration_v1

source
fn decode_adapter_declaration_v1(value : Json) -> AdapterDeclarationV1 raise

#
decode_adapter_health_attestation_v1

source
fn decode_adapter_health_attestation_v1(value : Json) -> AdapterHealthAttestationV1 raise

#
decode_adapter_request

source
fn decode_adapter_request(value : Json) -> AdapterRequest raise

#
decode_adapter_result

source
fn decode_adapter_result(value : Json) -> AdapterResult raise

#
decode_capability_activation_projection_v1

source
fn decode_capability_activation_projection_v1(value : Json) -> CapabilityActivationProjectionV1 raise

#
decode_capability_activation_request_v1

source
fn decode_capability_activation_request_v1(value : Json) -> CapabilityActivationRequestV1 raise

#
decode_capability_catalog_v1

source
fn decode_capability_catalog_v1(value : Json) -> CapabilityCatalogV1 raise

#
decode_capability_observation_v1

source
fn decode_capability_observation_v1(value : Json) -> CapabilityObservationV1 raise

#
decode_capability_settlement_request_v1

source
fn decode_capability_settlement_request_v1(value : Json) -> CapabilitySettlementRequestV1 raise

#
decode_director_requirement

source
fn decode_director_requirement(value : Json) -> DirectorRequirement raise

#
decode_event_array

source
fn decode_event_array(value : Json) -> Array[RuntimeEvent] raise

#
decode_evidence_bundle_spec

source
fn decode_evidence_bundle_spec(value : Json) -> EvidenceBundleSpec raise

#
decode_pack_capability_manifest_v1

source
fn decode_pack_capability_manifest_v1(value : Json) -> PackCapabilityManifestV1 raise

#
decode_runtime_event

source
fn decode_runtime_event(value : Json) -> RuntimeEvent raise

#
decode_unattended_manifest

source
fn decode_unattended_manifest(value : Json) -> UnattendedManifest raise

#
director_input_artifacts

source
fn director_input_artifacts(projection : RunProjection, item : RuntimeItem) -> Array[String]

#
director_request_for_item

source
fn director_request_for_item(projection : RunProjection, item : RuntimeItem, input_digest : String, recorded_at : String) -> AdapterRequest

#
director_requirement_for_item

source
fn director_requirement_for_item(item : RuntimeItem) -> DirectorRequirement

#
director_retry_decision

source
fn director_retry_decision(failure_class : DirectorFailureClass) -> DirectorRetryDecision

#
director_success_result_for_item

source
fn director_success_result_for_item(item : RuntimeItem, output_digest : String, output_artifacts : Array[String], recorded_at : String) -> AdapterResult

#
empty_projection

source
fn empty_projection(run_id : String) -> RunProjection

#
event_array_json

source
fn event_array_json(events : Array[RuntimeEvent]) -> Json

#
event_kind_from_id

source
fn event_kind_from_id(id : String) -> EventKind raise

#
events_from_work_graph

source
fn events_from_work_graph(value : Json) -> Array[RuntimeEvent] raise

#
evidence_bundle_manifest

source
fn evidence_bundle_manifest(spec : EvidenceBundleSpec, entries : Array[EvidenceBundleEntry], content_digest : String, recorded_at : String) -> EvidenceBundleManifest raise

#
graph_capability_report_contract_v1

source
fn graph_capability_report_contract_v1() -> String

#
normalize_workspace_path

source
fn normalize_workspace_path(path : String) -> String

#
path_is_within_workspace

source
fn path_is_within_workspace(workspace_root : String, candidate : String) -> Bool

#
product_attestation_issues

source
fn product_attestation_issues(value : Json, driver : UnattendedDriver, request : AdapterRequest, result : AdapterResult) -> Array[String]

#
product_id

source
fn product_id() -> String

#
projection_json

source
fn projection_json(projection : RunProjection) -> Json

#
protocol_id

source
fn protocol_id() -> String

#
ready_events

source
fn ready_events(projection : RunProjection, recorded_at : String) -> Array[RuntimeEvent]

#
reconcile_adapter_result

source
fn reconcile_adapter_result(request : AdapterRequest, result : AdapterResult) -> ReconciliationDecision raise AdapterContractError

#
render_unattended_arguments

source
fn render_unattended_arguments(arguments : Array[String], workspace : String, request_artifact : String, result_artifact : String, receipt_artifact : String, review_artifact : String) -> Array[String]

#
render_unattended_attestor_arguments

source
fn render_unattended_attestor_arguments(arguments : Array[String], workspace : String, request_artifact : String, result_artifact : String, attestation_artifact : String, draft_artifact : String, final_artifact : String) -> Array[String]

#
render_unattended_observer_arguments

source
fn render_unattended_observer_arguments(arguments : Array[String], workspace : String, run_id : String, book_id : String, projection_path : String, recorded_at : String) -> Array[String]

#
replay

source
fn replay(run_id : String, events : Array[RuntimeEvent]) -> RunProjection raise FlowError

#
resolve_capability_v1

source
fn resolve_capability_v1(projection : CapabilityActivationProjectionV1, scope_id~ : String, participant_id~ : String) -> CapabilityResolutionV1 raise

#
revise_run

source
fn revise_run(parent : RunProjection, child_graph : Json, migration_id : String, revision_proposal_ref : String, recorded_at : String) -> RunRevisionResult raise

#
runtime_event_json

source
fn runtime_event_json(event : RuntimeEvent) -> Json

#
runtime_protocol_id

source
fn runtime_protocol_id() -> String

#
select_adapter

source
fn select_adapter(capabilities : Array[AdapterCapability], requirement : DirectorRequirement) -> DirectorDecision

#
validate_adapter_capability

source
fn validate_adapter_capability(value : Json) -> AdapterCapability raise AdapterContractError

#
versioned_operation_ref

source
fn versioned_operation_ref(product_id : String, tool_id : String, pack_version : String) -> String

#
versioned_schema_ref

source
fn versioned_schema_ref(product_id : String, schema_id : String, schema_version : String) -> String

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io