From 969ef90540fbef68acc8e3800ce1f9da03562062 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 15:12:00 +0100 Subject: [PATCH 1/9] Declare program steps and carry their bundles through apply A `program` step names one ES module by sha256 (optional stalled-after). The step definition stores it as ProgramSpec {bundle, bundle_hash, stalled_after_ms}, so publishing the declaration promotes the blob and replicas receive it. fractal apply (plain and owned-set) reads each declared bundle, checks its hash and sends the bytes base64 by sha256; the daemon verifies and stages them before it publishes, and the store refuses a program whose blob it does not hold (missing-program-bundle). fractal validate and apply --dry-run check the bundle locally. Registers the program.step journal claim kind. --- .../src/api/client_v0.rs | 1 + crates/fractal-api-core/src/api.rs | 45 ++++++++++++- crates/fractal-api-core/src/api/owned_sets.rs | 1 + crates/fractal-api-core/src/api/tests.rs | 53 +++++++++++++++ crates/fractal-kernel/src/model.rs | 43 ++++++++++++ crates/fractal-missions-base/src/mission.rs | 64 +++++++++++++++++- .../src/mission_render.rs | 38 ++++++++++- crates/fractal-schema/retention.toml | 2 + crates/fractal-schema/src/lib.rs | 19 ++++++ crates/fractal-store/src/store.rs | 2 + crates/fractal-store/src/store/owned_sets.rs | 3 + .../src/store/program_bundles.rs | 29 ++++++++ crates/fractal/src/main.rs | 10 +++ crates/fractal/src/onboarding.rs | 1 + crates/fractal/src/program_bundles.rs | 67 +++++++++++++++++++ crates/fractal/src/validate_cli.rs | 4 ++ crates/fractal/tests/owned_sets.rs | 1 + docs/st3/mission-graph-runtime.md | 11 ++- docs/st3/program-engine.md | 31 ++++++--- docs/st3/schema.md | 1 + fixtures/convergence/claims-v17.json | 66 ++++++++++++++++++ release-notes/program-step-declaration.json | 11 +++ 22 files changed, 488 insertions(+), 15 deletions(-) create mode 100644 crates/fractal-store/src/store/program_bundles.rs create mode 100644 crates/fractal/src/program_bundles.rs create mode 100644 release-notes/program-step-declaration.json diff --git a/crates/fractal-api-client-v0/src/api/client_v0.rs b/crates/fractal-api-client-v0/src/api/client_v0.rs index 9ed8761df7d..581cf9057a0 100644 --- a/crates/fractal-api-client-v0/src/api/client_v0.rs +++ b/crates/fractal-api-client-v0/src/api/client_v0.rs @@ -7770,6 +7770,7 @@ async fn apply_runtime_control_intent( expected_subjects: preview.subject_tokens, idempotency_key: format!("{}:runtime-intent", request.idempotency_key), actor: Some(actor.to_owned()), + program_bundles: Default::default(), }), ) .await? diff --git a/crates/fractal-api-core/src/api.rs b/crates/fractal-api-core/src/api.rs index 95db44c6e2f..4f378f56e38 100644 --- a/crates/fractal-api-core/src/api.rs +++ b/crates/fractal-api-core/src/api.rs @@ -730,8 +730,8 @@ pub fn router_for_transport(state: AppState, transport: ClientTransportBoundary, .route("/v1/gate-checks", post(runs::start_gate_check)) .route("/v1/gate-checks/{id}", get(runs::read_gate_check)) .route("/v1/sets/preview", post(owned_sets::preview)) - .route("/v1/sets/apply", post(owned_sets::apply)) - .route("/v1/intent/apply", post(launches::apply_with_bound)) + .route("/v1/sets/apply", post(owned_sets::apply).layer(DefaultBodyLimit::max(PUBLICATION_BODY_LIMIT))) + .route("/v1/intent/apply", post(launches::apply_with_bound).layer(DefaultBodyLimit::max(PUBLICATION_BODY_LIMIT))) .route("/v1/agents/rename", post(agents::rename_agent)) .route("/v1/persons/rename", post(agents::rename_person)) .route("/v1/agents/rename-id", post(agents::rename_agent_id)) @@ -11121,6 +11121,7 @@ async fn apply_with_authority( if let Some(error) = publication_refusals(&state, &intent).await?.error() { return Err(ApiError::bad(error)); } + store_program_bundles(&state, &intent, &request.program_bundles)?; let mut response = state .store .apply_as( @@ -11135,6 +11136,46 @@ async fn apply_with_authority( Ok(Json(response)) } +/// The request body a publication may use: program bundles travel inside it as base64. +pub const PUBLICATION_BODY_LIMIT: usize = 32 * 1024 * 1024; + +/// Verify each program bundle a publication carries against the hash its intent names, then stage +/// the bytes as local blobs; the `mission.published` claim that names the hash promotes them +/// (docs/st3/program-engine.md §4). A bundle the intent does not name is refused, so a publication +/// cannot stage arbitrary bytes, and nothing is staged unless every bundle checks out. +pub(crate) fn store_program_bundles( + state: &AppState, + intent: &crate::model::NormalizedIntent, + bundles: &BTreeMap, +) -> Result<(), ApiError> { + use base64::Engine as _; + let named = intent.missions.values().flat_map(|mission| mission.programs()).map(|(_, program)| program.bundle_hash.as_str()).collect::>(); + let mut verified = Vec::with_capacity(bundles.len()); + for (hash, encoded) in bundles { + if !named.contains(hash.as_str()) { + return Err(ApiError::bad(FractalError::new( + "unused-program-bundle", + format!("the publication carries program bundle {hash}, which none of its programs names"), + ))); + } + let bytes = base64::engine::general_purpose::STANDARD.decode(encoded).map_err(|error| { + ApiError::bad(FractalError::new("invalid-program-bundle", format!("program bundle {hash} is not base64: {error}"))) + })?; + let actual = hex::encode(Sha256::digest(&bytes)); + if actual != *hash { + return Err(ApiError::bad(FractalError::new( + "program-bundle-hash-mismatch", + format!("program bundle {hash} has sha256 {actual}"), + ))); + } + verified.push(bytes); + } + for bytes in verified { + state.store.put_blob(&bytes).map_err(ApiError::internal)?; + } + Ok(()) +} + /// One write a rule in audit mode would have refused. #[derive(Clone, Debug, Deserialize, Serialize)] pub struct RuleAudit { diff --git a/crates/fractal-api-core/src/api/owned_sets.rs b/crates/fractal-api-core/src/api/owned_sets.rs index 58e78c67c04..3ec04bec00a 100644 --- a/crates/fractal-api-core/src/api/owned_sets.rs +++ b/crates/fractal-api-core/src/api/owned_sets.rs @@ -53,6 +53,7 @@ pub async fn apply( if let Some(error) = publication_refusals(&state, &intent).await?.error() { return Err(ApiError::bad(error)); } + store_program_bundles(&state, &intent, &request.program_bundles)?; let response = state .store .apply_owned_set( diff --git a/crates/fractal-api-core/src/api/tests.rs b/crates/fractal-api-core/src/api/tests.rs index f2052840cb8..cd4dad3c96f 100644 --- a/crates/fractal-api-core/src/api/tests.rs +++ b/crates/fractal-api-core/src/api/tests.rs @@ -4104,6 +4104,7 @@ fn apply_request(state: &AppState, source: &str, actor: &str, key: &str) -> Appl expected_subjects: preview.subject_tokens, idempotency_key: key.into(), actor: Some(actor.into()), + program_bundles: Default::default(), } } @@ -6515,6 +6516,14 @@ async fn mission_resolves_a_bare_document_to_immutable_bytes() { } async fn preview_and_apply(app: Router, kdl: &str) -> (Value, StatusCode, Value) { + preview_and_apply_with_bundles(app, kdl, BTreeMap::new()).await +} + +async fn preview_and_apply_with_bundles( + app: Router, + kdl: &str, + program_bundles: BTreeMap, +) -> (Value, StatusCode, Value) { let (status, preview) = json_request( app.clone(), "/v1/intent/mission", @@ -6541,6 +6550,7 @@ async fn preview_and_apply(app: Router, kdl: &str) -> (Value, StatusCode, Value) .unwrap(), idempotency_key: format!("apply-{}", hex::encode(Sha256::digest(kdl))), actor: Some("person/alex".into()), + program_bundles, }) .unwrap(), ) @@ -6548,6 +6558,48 @@ async fn preview_and_apply(app: Router, kdl: &str) -> (Value, StatusCode, Value) (preview, status, applied) } +#[tokio::test] +async fn publication_stores_the_program_bundle_its_declaration_names() { + use base64::Engine as _; + let root = tempfile::tempdir().unwrap(); + let state = state(root.path()); + let store = state.store.clone(); + let app = router(state); + let bytes = b"export default {}"; + let hash = hex::encode(Sha256::digest(bytes)); + let kdl = format!( + "version 2\nmission \"land\" state=\"ready\" {{\n goal \"Land.\"\n step \"program\" {{ program \"/bundles/land.mjs\" sha256=\"{hash}\" }}\n}}" + ); + let encoded = |bytes: &[u8]| base64::engine::general_purpose::STANDARD.encode(bytes); + let before = store.index().unwrap(); + // A declaration whose bytes this member never received would be refused by every replica. + let (_, status, error) = preview_and_apply(app.clone(), &kdl).await; + assert!(status.is_client_error(), "{error}"); + assert_eq!(error["code"], "missing-program-bundle"); + let (_, status, error) = + preview_and_apply_with_bundles(app.clone(), &kdl, BTreeMap::from([(hash.clone(), encoded(b"export default 2"))])).await; + assert!(status.is_client_error(), "{error}"); + assert_eq!(error["code"], "program-bundle-hash-mismatch"); + let (_, status, error) = preview_and_apply_with_bundles( + app.clone(), + &kdl, + BTreeMap::from([(hash.clone(), encoded(bytes)), ("0".repeat(64), encoded(b""))]), + ) + .await; + assert!(status.is_client_error(), "{error}"); + assert_eq!(error["code"], "unused-program-bundle"); + assert_eq!(store.index().unwrap(), before); + assert_eq!(store.get_blob(&hash).unwrap(), None); + + let (_, status, applied) = + preview_and_apply_with_bundles(app, &kdl, BTreeMap::from([(hash.clone(), encoded(bytes))])).await; + assert_eq!(status, StatusCode::OK, "{applied}"); + assert_eq!(store.get_blob(&hash).unwrap().as_deref(), Some(&bytes[..])); + // The published definition names the blob by `bundle_hash`, which promotes and replicates it. + let published = store.latest_claim("mission/land", Some("mission.published")).unwrap().unwrap(); + assert!(published.body.to_string().contains(&format!("\"bundle_hash\":\"{hash}\"")), "{}", published.body); +} + #[tokio::test] async fn publication_accepts_a_step_assigned_to_an_undeclared_person() { let root = tempfile::tempdir().unwrap(); @@ -6788,6 +6840,7 @@ mission "invalid-message" state="ready" { expected_subjects: BTreeMap::new(), idempotency_key: "reject-invalid-nested-message".into(), actor: Some("person/alex".into()), + program_bundles: Default::default(), }) .unwrap(), ) diff --git a/crates/fractal-kernel/src/model.rs b/crates/fractal-kernel/src/model.rs index 9ba505849f9..5cc768a12b0 100644 --- a/crates/fractal-kernel/src/model.rs +++ b/crates/fractal-kernel/src/model.rs @@ -872,6 +872,10 @@ pub struct StepSpec { /// completes and fails when it fails or is cancelled. #[serde(default, skip_serializing_if = "Option::is_none")] pub after_run: Option, + /// The program bundle this agentless step runs (docs/st3/program-engine.md). The daemon's + /// program engine owns the step's outcome. Omitted when absent, so other steps hash as before. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub program: Option, pub gates: Vec, pub nested_mission: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -879,6 +883,41 @@ pub struct StepSpec { pub definition_hash: String, } +/// A program step's code: one self-contained ES module, pinned by the SHA-256 of its bytes. The +/// hash is part of the step's definition, so a mission revision binds exactly one program. The +/// field is named `bundle_hash` so publishing the declaration promotes the stored blob and every +/// replica receives it with the declaration; `bundle` is the author's path, kept as provenance. +#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] +pub struct ProgramSpec { + pub bundle: String, + pub bundle_hash: String, + /// How long the program may go without a new journal entry before its run reports it stalled. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub stalled_after_ms: Option, +} + +impl MissionSpec { + /// Every program this mission declares, with its step's path, including nested missions and + /// loop rounds. + pub fn programs(&self) -> Vec<(&str, &ProgramSpec)> { + let mut programs = Vec::new(); + for step in self.steps.values() { + if let Some(program) = &step.program { + programs.push((step.path.as_str(), program)); + } + if let Some(nested) = &step.nested_mission { + programs.extend(nested.programs()); + } + if let Some(loop_spec) = &step.loop_spec { + for mission in [Some(&loop_spec.round), loop_spec.on_keep.as_ref(), loop_spec.on_discard.as_ref()].into_iter().flatten() { + programs.extend(mission.programs()); + } + } + } + programs + } +} + /// How the resource edge was authored. Older stored URI edges predate this discriminator. #[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)] #[serde(rename_all = "snake_case")] @@ -1745,6 +1784,10 @@ pub struct ApplyRequest { pub idempotency_key: String, #[serde(default)] pub actor: Option, + /// The bytes of each program bundle the intent declares, base64 by sha256 (the + /// `ProgramSpec::bundle_hash`). The daemon verifies and stores them before it publishes. + #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] + pub program_bundles: BTreeMap, } #[derive(Clone, Debug, Deserialize, Serialize)] diff --git a/crates/fractal-missions-base/src/mission.rs b/crates/fractal-missions-base/src/mission.rs index d8f53486697..2f6fa27e4c0 100644 --- a/crates/fractal-missions-base/src/mission.rs +++ b/crates/fractal-missions-base/src/mission.rs @@ -9,8 +9,8 @@ use crate::declaration_syntax::*; use crate::model::{ BaselineSpec, CompletionSpec, DependencySpec, GateSpec, LoopAttentionSpec, LoopExhaustionSpec, LoopSpec, LoopStopSpec, MetricSource, MetricSpec, MissionInputKind, MissionInputSpec, - MissionSpec, MissionState, ProductSpec, RetrySpec, RevisionCutover, FractalError, StepSpec, - UsedMissionSpec, WorkSelector, + MissionSpec, MissionState, ProductSpec, ProgramSpec, RetrySpec, RevisionCutover, FractalError, + StepSpec, UsedMissionSpec, WorkSelector, }; pub const LOOP_ROUND_INPUT: &str = "__st3_loop_round"; @@ -843,6 +843,7 @@ fn parse_loop_group( produces_mission: None, uses_mission: None, after_run: None, + program: None, gates: Vec::new(), nested_mission: None, loop_spec: Some(Box::new(loop_spec)), @@ -1327,6 +1328,7 @@ fn parse_step( let mut produces_mission = None; let mut uses_mission = None; let mut after_run = None; + let mut program = None; let mut gates = Vec::new(); let mut nested_mission = None; let mut retry = RetrySpec::default(); @@ -1426,6 +1428,7 @@ fn parse_step( "produces-mission" => produces_mission = Some(parse_produced_mission(child)?), "uses-mission" => uses_mission = Some(parse_used_mission(child)?), "after-run" => after_run = Some(parse_after_run(child)?), + "program" => program = Some(parse_program(child)?), "gate" => { let gate = crate::gate_parse::parse_gate(child, default_host)?; if matches!(gate, GateSpec::Deadline { .. }) { @@ -1480,6 +1483,36 @@ fn parse_step( } agentless = true; } + if program.is_some() { + // The program engine owns the outcome: nothing else may complete or fail the step. + if assigned_to.is_some() || !available_to.is_empty() { + return Err(FractalError::new( + "conflicting-work-selector", + format!("step `{path}` runs a program, so it cannot select an agent"), + )); + } + if !gates.is_empty() + || !products.is_empty() + || produces_mission.is_some() + || uses_mission.is_some() + || after_run.is_some() + || nested_mission.is_some() + { + return Err(FractalError::new( + "program-step-outcome", + format!("step `{path}` runs a program, which alone decides its outcome; remove its gates, products, nested or used missions and after-run"), + )); + } + if finally { + // Cancellation cleanup ends agentless final work that has no runtime process; a + // program compensates inside its body instead. + return Err(FractalError::new( + "program-step-outcome", + format!("step `{path}` runs a program, so it cannot be a finally step; compensate inside the program"), + )); + } + agentless = true; + } if agentless && gates .iter() @@ -1530,6 +1563,7 @@ fn parse_step( produces_mission, uses_mission, after_run, + program, gates, nested_mission, loop_spec: None, @@ -2326,6 +2360,31 @@ fn parse_after_run(node: &KdlNode) -> Result { Ok(run) } +/// `program "/abs/bundle.mjs" sha256="HEX" stalled-after="10m"?`: the bundle's path, the exact +/// bytes it must have, and how long it may go without journal progress. +fn parse_program(node: &KdlNode) -> Result { + ensure_only_properties(node, &["sha256", "stalled-after"])?; + let bundle = first_string(node)?; + if !bundle.starts_with('/') { + return Err(FractalError::new( + "invalid-program", + format!("program bundle `{bundle}` must be an absolute path"), + )); + } + let bundle_hash = property_string(node, "sha256")?.unwrap_or_default(); + if bundle_hash.len() != 64 || !bundle_hash.bytes().all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) { + return Err(FractalError::new( + "invalid-program", + "a program needs sha256=\"<64 lowercase hex digits>\" of its bundle", + )); + } + let stalled_after_ms = property_string(node, "stalled-after")?.map(|value| parse_duration(&value)).transpose()?; + if stalled_after_ms == Some(0) { + return Err(FractalError::new("invalid-program", "a program's stalled-after must be greater than zero")); + } + Ok(ProgramSpec { bundle, bundle_hash, stalled_after_ms }) +} + /// The step that a run started with `--after RUN` waits in before its other work starts. pub const AFTER_RUN_STEP: &str = "after-run"; @@ -2375,6 +2434,7 @@ pub fn mission_after_run(mut mission: MissionSpec, run: &str) -> Result Result { goals, constraints, agent_constraints, timeout_ms, capacity, retry, finally: _, work_selector, revision_owners, revisions_human_only, revision_reviewer, dependencies: after, baselines, documents, declarations_kdl, products, produces_mission, uses_mission, after_run, - gates, nested_mission, loop_spec: _, definition_hash: _ } = step; + program, gates, nested_mission, loop_spec: _, definition_hash: _ } = step; let mut root = text("step", id); protection(&mut root, *revisions_human_only, revision_reviewer.as_deref(), *timeout_ms); annotations(&mut root, declarations_kdl.as_deref(), revision_owners, agent_constraints); @@ -155,6 +155,12 @@ fn step_node(step: &StepSpec) -> Result { }); } if let Some(run) = after_run { children.push(text("after-run", run)); } + if let Some(program) = program { + let mut program_node = text("program", &program.bundle); + property(&mut program_node, "sha256", program.bundle_hash.as_str()); + if let Some(ms) = program.stalled_after_ms { property(&mut program_node, "stalled-after", format!("{ms}ms")); } + children.push(program_node); + } if let Some(nested) = nested_mission { children.push(mission_node(nested)?); } Ok(block(root, children)) } @@ -303,6 +309,36 @@ mod tests { assert!(render_mission_kdl(&spec).is_err()); } + #[test] + fn program_step_round_trips_and_owns_its_outcome() { + let sha = "ab".repeat(32); + let source = format!(r#"mission "test" state="ready" {{ goal "Land."; input "change" kind="text" + step "program" timeout="1h" {{ program "/bundles/land.mjs" sha256="{sha}" stalled-after="10m"; }} }}"#); + round_trip(&source); + let step = &parse(&source).steps["program"]; + let program = step.program.as_ref().unwrap(); + assert_eq!((program.bundle_hash.as_str(), program.stalled_after_ms), (sha.as_str(), Some(600_000))); + assert_eq!(step.work_selector, Some(crate::model::WorkSelector::Agentless)); + // The definition names the blob by `bundle_hash`, so publishing it promotes the blob. + assert_eq!(serde_json::to_value(step).unwrap()["program"]["bundle_hash"], sha.as_str()); + round_trip(&format!(r#"mission "test" state="ready" {{ goal "Land."; step "program" {{ program "/b.mjs" sha256="{sha}"; }} }}"#)); + let error = |body: &str| { + let source = format!(r#"mission "test" state="ready" {{ goal "Land."; step "program" {{ {body} }} }}"#); + crate::mission::parse_missions(&source.parse().unwrap(), "node").unwrap_err().code + }; + assert_eq!(error(&format!(r#"program "/b.mjs" sha256="{sha}"; assigned-to "agent/test";"#)), "conflicting-work-selector"); + assert_eq!(error(&format!(r#"program "/b.mjs" sha256="{sha}"; gate "g" {{ exists "resource/x"; }};"#)), "program-step-outcome"); + assert_eq!(error(&format!(r#"program "/b.mjs" sha256="{sha}"; uses-mission "other@{sha}";"#)), "program-step-outcome"); + assert_eq!(error(&format!(r#"program "/b.mjs" sha256="{sha}"; after-run "mission-run/x";"#)), "program-step-outcome"); + assert_eq!(error(&format!(r#"program "/b.mjs" sha256="{sha}"; mission "n" state="ready" {{ goal "N."; step "s" {{ agentless; }}; }};"#)), "program-step-outcome"); + assert_eq!(error(r#"program "/b.mjs" sha256="ABC";"#), "invalid-program"); + assert_eq!(error(&format!(r#"program "b.mjs" sha256="{sha}";"#)), "invalid-program"); + assert_eq!(error(&format!(r#"program "/b.mjs" sha256="{sha}" stalled-after="0s";"#)), "invalid-program"); + let in_finally = format!(r#"mission "test" state="ready" {{ goal "Land."; step "work" {{ agentless; }} + finally {{ step "program" {{ program "/b.mjs" sha256="{sha}"; }} }} }}"#); + assert_eq!(crate::mission::parse_missions(&in_finally.parse().unwrap(), "node").unwrap_err().code, "program-step-outcome"); + } + #[test] fn canonical_legacy_flag_and_unicode_annotation_are_safe() { let mut mission = parse(r#"mission "test" state="ready" { goal "test"; loop "old" { max-rounds 1; round { completion { when "all-steps-exhausted"; }; }; }; }"#); diff --git a/crates/fractal-schema/retention.toml b/crates/fractal-schema/retention.toml index 4300b393d00..0e8be2c71cb 100644 --- a/crates/fractal-schema/retention.toml +++ b/crates/fractal-schema/retention.toml @@ -151,6 +151,8 @@ "planning-session.started" = { class = "durable" } "principal.key-granted" = { class = "durable" } "principal.key-revoked" = { class = "durable" } +# A program run's journal: replay reads every completed and failed entry of its step run. +"program.step" = { class = "durable" } "publication.operation" = { class = "durable" } "reconcile.fault" = { class = "transition", window = "7d", pending = "no reader audit yet" } "record.repaired" = { class = "durable" } diff --git a/crates/fractal-schema/src/lib.rs b/crates/fractal-schema/src/lib.rs index 8b822a5387e..950fd2c2e62 100644 --- a/crates/fractal-schema/src/lib.rs +++ b/crates/fractal-schema/src/lib.rs @@ -1778,6 +1778,15 @@ fn claim_specs() -> BTreeMap { true, &["step"], ), + ( + "program.step", + &["step-run"], + WritePolicy::SystemOnly, + Cardinality::Append, + None, + false, + &["step", "program"], + ), ( "work.person-asked", &["step-run"], @@ -3315,6 +3324,16 @@ fn claim_fields(kind: &str) -> BTreeMap { ("claim_incarnation", string()), ("claim_expires_at_unix_ms", integer()), ], + "program.step" => &[ + ("key", required_string()), + ("status", required_enum(&["started", "completed", "failed"])), + ("attempt", required_integer()), + ("program", required_string()), + ("value", any()), + ("error", any()), + ("ms", integer()), + ("child", string()), + ], "work.person-asked" => &[ ("run", reference()), ("generation", reference()), diff --git a/crates/fractal-store/src/store.rs b/crates/fractal-store/src/store.rs index 5c06094825e..bbcc0e80d67 100644 --- a/crates/fractal-store/src/store.rs +++ b/crates/fractal-store/src/store.rs @@ -66,6 +66,7 @@ pub mod schedule_active_run_tests; pub mod seat_queue_plan_tests; pub mod schedule_standby; pub mod mission_capacity; +mod program_bundles; pub mod marks_switch; pub mod glasses; pub mod mailbox_wakes; @@ -3367,6 +3368,7 @@ impl Store { schedule_standby::validate_publication(transaction, &self.origin, intent)?; mission_capacity::validate_publication(transaction, &self.origin, intent)?; crate::provenance::validate_publication(transaction, intent)?; + program_bundles::validate_publication(transaction, intent)?; message_subscriptions::validate(transaction, intent, current_index_tx(transaction).map_err(internal)?)?; let owned_plan = owned.map(|options| owned_sets::plan_tx(transaction, intent, options)).transpose()?; let mut one_shot_sets = BTreeMap::new(); diff --git a/crates/fractal-store/src/store/owned_sets.rs b/crates/fractal-store/src/store/owned_sets.rs index a364eb69256..c6ad320ef49 100644 --- a/crates/fractal-store/src/store/owned_sets.rs +++ b/crates/fractal-store/src/store/owned_sets.rs @@ -101,6 +101,9 @@ pub struct Request { pub options: Options, pub actor: String, pub idempotency_key: String, + /// The program bundles the set declares, base64 by sha256, as `ApplyRequest` carries them. + #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] + pub program_bundles: BTreeMap, } #[derive(Clone, Debug, Deserialize, Serialize)] diff --git a/crates/fractal-store/src/store/program_bundles.rs b/crates/fractal-store/src/store/program_bundles.rs new file mode 100644 index 00000000000..4089b176eee --- /dev/null +++ b/crates/fractal-store/src/store/program_bundles.rs @@ -0,0 +1,29 @@ +//! A mission that runs a program publishes only with its bundle's bytes in this store +//! (docs/st3/program-engine.md §4). The step definition names the bytes by `bundle_hash`, so the +//! `mission.published` claim promotes the staged blob and replicates it; a claim naming a blob +//! this member never held would be refused by every replica as `missing-replicated-blob`. +use super::*; + +pub(super) fn validate_publication(connection: &Connection, intent: &NormalizedIntent) -> Result<(), FractalError> { + for mission in intent.missions.values() { + for (step, program) in mission.programs() { + let held: bool = connection + .query_row( + "SELECT EXISTS(SELECT 1 FROM blobs WHERE hash=?1) OR EXISTS(SELECT 1 FROM local_blobs WHERE hash=?1)", + [&program.bundle_hash], + |row| row.get(0), + ) + .map_err(internal)?; + if !held { + return Err(FractalError::new( + "missing-program-bundle", + format!( + "mission `{}` step `{step}` runs program `{}` with sha256 {}, whose bytes this member does not hold; publish it with `fractal apply`, which uploads the bundle", + mission.id, program.bundle, program.bundle_hash + ), + )); + } + } + } + Ok(()) +} diff --git a/crates/fractal/src/main.rs b/crates/fractal/src/main.rs index c74d4983c76..e684dde80f2 100644 --- a/crates/fractal/src/main.rs +++ b/crates/fractal/src/main.rs @@ -105,6 +105,7 @@ mod replication_cli; mod schedules_cli; mod terminals_cli; mod uninstall_cli; +mod program_bundles; mod validate_cli; mod work_cli; mod waiting_on_cli; @@ -3489,11 +3490,14 @@ async fn run_owned_set_apply( confirm_retire: args.confirm_retire, expected_subjects: Default::default(), }; + // Read and check the bundles first, so a dry run refuses a stale bundle too. + let program_bundles = program_bundles::program_bundles(&intent.kdl)?; let mut request = Request { intent, options, actor: args.actor, idempotency_key: uuid::Uuid::now_v7().to_string(), + program_bundles: BTreeMap::new(), }; let preview: Preview = client.post("/v1/sets/preview", &request).await?; if args.dry_run { @@ -3519,6 +3523,7 @@ async fn run_owned_set_apply( return Ok(()); } request.options.expected_subjects = preview.expected_subjects; + request.program_bundles = program_bundles; let response: Value = client.post("/v1/sets/apply", &request).await?; print_value(&response, json_output) } @@ -8010,6 +8015,8 @@ async fn publish_mission_intent( args: MissionPublishArgs, json_output: bool, ) -> Result<()> { + // Read and check the bundles first, so a dry run refuses a stale bundle too. + let program_bundles = program_bundles::program_bundles(&intent.kdl)?; let mission: MissionResponse = client .post( "/v1/intent/mission", @@ -8050,6 +8057,7 @@ async fn publish_mission_intent( intent: resolved, expected_subjects: mission.subject_tokens, actor: Some(args.actor), + program_bundles, }, ) .await?; @@ -8654,6 +8662,7 @@ async fn publish_text_with_expected( actor: String, expected: Option<(&str, &[String])>, ) -> Result { + let program_bundles = program_bundles::program_bundles(&kdl)?; let intent = IntentInput { kdl, source_name: Some(source_name), @@ -8688,6 +8697,7 @@ async fn publish_text_with_expected( intent: resolved, expected_subjects: mission.subject_tokens, actor: Some(actor.clone()), + program_bundles, }, ) .await diff --git a/crates/fractal/src/onboarding.rs b/crates/fractal/src/onboarding.rs index a8ffb590a66..3361aca5749 100644 --- a/crates/fractal/src/onboarding.rs +++ b/crates/fractal/src/onboarding.rs @@ -425,6 +425,7 @@ async fn apply( expected_subjects: preview.subject_tokens, idempotency_key: hex::encode(hash.finalize()), actor: config.person.clone(), + program_bundles: Default::default(), }, ) .await diff --git a/crates/fractal/src/program_bundles.rs b/crates/fractal/src/program_bundles.rs new file mode 100644 index 00000000000..52e088e9a8a --- /dev/null +++ b/crates/fractal/src/program_bundles.rs @@ -0,0 +1,67 @@ +//! A publication carries the bytes of each program bundle its missions declare +//! (docs/st3/program-engine.md §4): the CLI reads every declared path, checks it against the +//! declared sha256 and sends the bytes, so the daemon never reads the author's path. +use std::collections::BTreeMap; + +use anyhow::{Context as _, Result}; +use base64::Engine as _; +use fractal_daemon::model::{NormalizedIntent, ProgramSpec}; +use sha2::{Digest as _, Sha256}; + +/// Every program bundle the intent text declares, base64 by sha256. +pub(crate) fn program_bundles(kdl: &str) -> Result> { + // The most permissive parse: it only finds the programs; the daemon validates the intent. + let intent = fractal_store::graph::parse_intent_with_owner(kdl, "local", None, true, true) + .context("find the intent's program bundles")?; + let mut bundles = BTreeMap::new(); + for program in programs(&intent) { + let bytes = read_program_bundle(program)?; + bundles.insert(program.bundle_hash.clone(), base64::engine::general_purpose::STANDARD.encode(bytes)); + } + Ok(bundles) +} + +pub(crate) fn programs(intent: &NormalizedIntent) -> impl Iterator { + intent.missions.values().flat_map(|mission| mission.programs()).map(|(_, program)| program) +} + +/// The bundle's bytes, refused unless they are exactly the ones the mission declares. +pub(crate) fn read_program_bundle(program: &ProgramSpec) -> Result> { + let bytes = std::fs::read(&program.bundle).with_context(|| format!("read program bundle {}", program.bundle))?; + let actual = hex::encode(Sha256::digest(&bytes)); + anyhow::ensure!( + actual == program.bundle_hash, + "program bundle {} has sha256 {actual}, but the mission declares {}", + program.bundle, + program.bundle_hash + ); + Ok(bytes) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_publication_carries_exactly_the_declared_bytes() { + let dir = tempfile::tempdir().unwrap(); + let bundle = dir.path().join("land.mjs"); + std::fs::write(&bundle, b"export default {}").unwrap(); + let hash = hex::encode(Sha256::digest(b"export default {}")); + let kdl = |hash: &str| { + format!( + r#"mission "land" state="ready" {{ goal "Land."; step "program" {{ program "{}" sha256="{hash}"; }} }} + mission "outer" state="ready" {{ goal "Nest."; step "inner" {{ mission "inner" state="ready" {{ goal "In."; step "program" {{ program "{}" sha256="{hash}"; }}; }}; }} }}"#, + bundle.display(), + bundle.display() + ) + }; + let bundles = program_bundles(&kdl(&hash)).unwrap(); + assert_eq!(bundles.len(), 1); + assert_eq!(base64::engine::general_purpose::STANDARD.decode(&bundles[&hash]).unwrap(), b"export default {}"); + let other = "0".repeat(64); + let error = program_bundles(&kdl(&other)).unwrap_err().to_string(); + assert!(error.contains(&hash) && error.contains(&other) && error.contains("land.mjs"), "{error}"); + assert!(program_bundles(r#"mission "plain" state="ready" { goal "None."; step "work" { agentless; } }"#).unwrap().is_empty()); + } +} diff --git a/crates/fractal/src/validate_cli.rs b/crates/fractal/src/validate_cli.rs index 81fb99cb9bf..bc55ce98e40 100644 --- a/crates/fractal/src/validate_cli.rs +++ b/crates/fractal/src/validate_cli.rs @@ -29,6 +29,10 @@ pub(super) fn run_validate(args: &ValidateArgs, json_output: bool) -> Result<()> .with_context(|| format!("read {}", path.display()))?; let intent = fractal_store::graph::parse_intent(&source, "local") .with_context(|| format!("validate {}", path.display()))?; + for program in crate::program_bundles::programs(&intent) { + crate::program_bundles::read_program_bundle(program) + .with_context(|| format!("validate {}", path.display()))?; + } for (id, subject) in intent.subjects { subjects.push(ValidatedSubject { kind: subject.kind, diff --git a/crates/fractal/tests/owned_sets.rs b/crates/fractal/tests/owned_sets.rs index 954d5d1ddbe..a1873ad0530 100644 --- a/crates/fractal/tests/owned_sets.rs +++ b/crates/fractal/tests/owned_sets.rs @@ -147,6 +147,7 @@ async fn request(daemon: &Daemon, sequence: u64, kdl: String) -> Request { }, actor: "person/operator".into(), idempotency_key: format!("publish-{sequence}"), + program_bundles: Default::default(), } } diff --git a/docs/st3/mission-graph-runtime.md b/docs/st3/mission-graph-runtime.md index a060aa19457..980a14bd2d0 100644 --- a/docs/st3/mission-graph-runtime.md +++ b/docs/st3/mission-graph-runtime.md @@ -346,11 +346,12 @@ step "STEP_ID" timeout="20m" revisions="human-only" revision-reviewer="person/re produces-mission "generated-mission" uses-mission output-of="producer-step" after-run "mission-run/RUN_ID" + program "/abs/bundle.mjs" sha256="HEX" stalled-after="10m" gate "NAME" { GATE_BODY } } ``` -`title`, `assigned-to`, `agentless`, `fresh-context`, `keep-open`, `capacity`, `mission`, `retry`, `produces`, `produces-mission`, `uses-mission`, and `after-run` are single fields. +`title`, `assigned-to`, `agentless`, `fresh-context`, `keep-open`, `capacity`, `mission`, `retry`, `produces`, `produces-mission`, `uses-mission`, `after-run` and `program` are single fields. `fresh-context` is a bare node. Before the daemon wakes a seat for that step, it stops the old harness session and starts a new, idle one. The step's work message arrives in the new session. A claim from the old incarnation is refused while the reset is pending. Steps without this option keep the current session unless the seat opts in for every step. A retry is a new attempt and receives its own fresh session. @@ -1215,6 +1216,14 @@ The step is agentless and cannot name an agent. It completes when the named run To make one run wait without changing its mission, start it with `after`. See [Starting after another run](../site/reference/configuration.md#definitions-runs-and-revisions). +### Running a program + +`program` runs a step as a program the daemon's program engine executes: one ES module pinned by +its sha256. The step is agentless and the program alone decides its outcome, so it cannot name +an agent, gates, products, nested or used missions or `after-run`, and it cannot be a `finally` +step. `fractal apply` sends the bundle's bytes with the publication; see [Program +engine](program-engine.md). + ## Run reports A run tells nobody about itself unless its mission or its start names an agent: diff --git a/docs/st3/program-engine.md b/docs/st3/program-engine.md index a7e2526b377..5a9aed9cc87 100644 --- a/docs/st3/program-engine.md +++ b/docs/st3/program-engine.md @@ -167,7 +167,7 @@ mission "factory/land-program" state="ready" timeout="2h" { goal "Land one change on main and prove it live, or leave main as it was." authority { publish "scratch/*"; write "resource/factory/*" } step "program" timeout="1h" { - program "/abs/bundles/land-aff9555cbaf1.mjs" sha256="aff9555c…48f09" + program "/abs/bundles/land-aff9555cbaf1.mjs" sha256="aff9555c…48f09" stalled-after="10m" } } ``` @@ -177,6 +177,11 @@ may not declare an assignee, gates, products, nested or used missions, or `after be a `finally` step: cancellation cleanup ends final agentless work that has no runtime process, so a program compensates inside its body. +`sha256` is the bundle's 64 lowercase hex digits; the path must be absolute. The optional +`stalled-after` is how long the program may go without a new journal entry before its run reports +it stalled (§8). The step definition stores them as `program {bundle, bundle_hash, +stalled_after_ms?}`. + Steps act as the run (R07). The engine starts every effect with a run credential scoped to `(run, step run, attempt)`; the daemon binds a request carrying it to the actor `mission-run/RUN`. That actor holds what the revision's `authority` block grants, intersected with @@ -191,14 +196,21 @@ step's `definition_hash` and the mission revision. A run generation binds one re bundle. 1. `fractal apply` of a mission with a `program` reads the declared path, checks its sha256 and - stores the bytes as a blob keyed by that hash. The step definition names the hash in a - `bundle_hash` field, so the graph replicates the blob with the mission declaration, the way it - replicates every blob a claim's `bundle_hash` names ([attachments](attachments.md#what-travels-and-what-does-not)). - The member that runs the step reads the blob, never the author's path, which stays as provenance. + sends the bytes with the publication (`program_bundles`, base64 by sha256, on the apply and + owned-set apply requests). The daemon checks each against its hash, refuses one no program of + the intent names, and stores the bytes as a blob keyed by that hash before it publishes. The + step definition names the hash in a `bundle_hash` field, so the graph replicates the blob with + the mission declaration, the way it replicates every blob a claim's `bundle_hash` names + ([attachments](attachments.md#what-travels-and-what-does-not)). The member that runs the step + reads the blob, never the author's path, which stays as provenance. 2. Every dispatch and every resume reads the blob of the revision's hash, whatever the source path holds now (R05). -3. A declaration whose source no longer matches its sha256 is refused at `apply`; a step whose blob - is missing fails with `program bundle … is not in this member's store` (R06). +3. A declaration whose source no longer matches its sha256 is refused by `fractal apply`, + `apply --dry-run` and `fractal validate`, which all read the bundle locally. A publication whose + program's blob the member holds neither from this publication nor from an earlier one is + refused with `missing-program-bundle`, whatever path published it (a replica could never read + it). A step whose blob is missing fails with `program bundle … is not in this member's store` + (R06). 4. Revising a running run creates a new generation with a new step run, hence an empty journal: the program restarts under the new code (T03). There is no Temporal-style patching. @@ -215,6 +227,7 @@ Each inner step writes registered `program.step` claims on the program's step ru | `program` | string | the bundle sha256 that wrote it | | `value` / `error` | any | the encoded success value, or the typed error with `_tag` and fields | | `ms` | integer | effect duration | +| `child` | string, optional | the child `mission-run/…` or ask subject the key waits on (§6) | Idempotency key: `program:STEP:ATTEMPT:KEY:result` for both `completed` and `failed`, so a key has one result per attempt whatever its status, and a double execution that produces a different @@ -367,8 +380,8 @@ on a scratch instance at each. | Milestone | Ships | |---|---| -| M1 Engine | `program` steps and the `program.step` journal (§5); the supervised host with a worker per program, replay, eager cancellation, recorded effect process groups (DQ2) and liveness pings (DQ8); the step definition names its bundle by `bundle_hash` and publishing the declaration stores the blob, so neither the field nor definition hashes change in later milestones (§4); linked child runs with cancellation cascade and serialized sections (§6, §7); the `effect/workflow` binding (§11); mission-run authority (§3); inner steps in the run view and `waiting-on`, and the `program/stalled` and `program/host` faults (§8). | -| M2 Publication | `fractal apply` carries a program mission's bundle to the daemon it publishes on and validates it (§4); the `fractal` package's loader renders `Fractal.mission(intent, program)` to a bundle and its KDL declaration. Factory's landing mission becomes the first production program. | +| M1 Engine | `program` steps and the `program.step` journal (§5); the supervised host with a worker per program, replay, eager cancellation, recorded effect process groups (DQ2) and liveness pings (DQ8); the step definition names its bundle by `bundle_hash`, `fractal apply` carries and validates the bundle and publishing the declaration stores the blob, so neither the field nor definition hashes change in later milestones (§4); linked child runs with cancellation cascade and serialized sections (§6, §7); the `effect/workflow` binding (§11); mission-run authority (§3); inner steps in the run view and `waiting-on`, and the `program/stalled` and `program/host` faults (§8). | +| M2 Publication | The `fractal` package's loader renders `Fractal.mission(intent, program)` to a bundle and its KDL declaration. Factory's landing mission becomes the first production program. | | M3 One model | The data DSL compiles into programs (§9), with byte and behaviour parity for existing data-DSL missions; published KDL missions keep running on the native graph until they are republished. | ## Spike results (scratch, macOS, load 80–280) diff --git a/docs/st3/schema.md b/docs/st3/schema.md index fcbc51e8263..338b5b348c7 100644 --- a/docs/st3/schema.md +++ b/docs/st3/schema.md @@ -182,6 +182,7 @@ Custom subjects use `custom/NAMESPACE/NAME`. Custom claims use `custom.NAMESPACE | `planning-session.started` | `planning-session` | `authorized-requester` | `once` | `durable` | `mission:subject-reference`, `planner:subject-reference`, `planner_config:object`, `request:subject-reference`, `requester:subject-reference`, `target_generation:subject-reference`, `target_run:subject-reference`, `workspace:string` | `planning-session` | | `principal.key-granted` | `person`, `agent` | `system-only` | `append` | `durable` | `issuer!:string`, `issuer_key!:string`, `key!:string`, `label:string`, `role!:string` | | | `principal.key-revoked` | `person`, `agent` | `system-only` | `append` | `durable` | `key!:string`, `reason:string` | | +| `program.step` | `step-run` | `system-only` | `append` | `durable` | `attempt!:integer`, `child:string`, `error:any`, `key!:string`, `ms:integer`, `program!:string`, `status!:string`, `value:any` | `step`, `program` | | `publication.operation` | `*` | `system-only` | `append` | `durable` | `action:string`, `operation:string`, `status!:string` | `revision`, `reset`, `cancellation`, `refresh`, `feedback` | | `reconcile.fault` | `daemon`, `mission-run`, `observer`, `schedule`, `step-run`, `subscription` | `system-only` | `append` | `durable` | `reason:string`, `scope!:string`, `status!:string` | | | `record.repaired` | `repair` | `ordinary-client` | `once` | `durable` | `reason!:string`, `record!:string`, `replacement!:string` | `repair` | diff --git a/fixtures/convergence/claims-v17.json b/fixtures/convergence/claims-v17.json index 907e6b64e99..bd0801e1cb1 100644 --- a/fixtures/convergence/claims-v17.json +++ b/fixtures/convergence/claims-v17.json @@ -6533,6 +6533,72 @@ "wakes_reconciler": false, "write_policy": "system-only" }, + "program.step": { + "additional_fields": false, + "cardinality": "append", + "fields": { + "attempt": { + "immutable": false, + "reference": false, + "required": true, + "value_type": "integer" + }, + "child": { + "immutable": false, + "reference": false, + "required": false, + "value_type": "string" + }, + "error": { + "immutable": false, + "reference": false, + "required": false, + "value_type": "any" + }, + "key": { + "immutable": false, + "reference": false, + "required": true, + "value_type": "string" + }, + "ms": { + "immutable": false, + "reference": false, + "required": false, + "value_type": "integer" + }, + "program": { + "immutable": false, + "reference": false, + "required": true, + "value_type": "string" + }, + "status": { + "immutable": false, + "reference": false, + "required": true, + "value_type": "string", + "values": [ + "started", + "completed", + "failed" + ] + }, + "value": { + "immutable": false, + "reference": false, + "required": false, + "value_type": "any" + } + }, + "kind": "program.step", + "projection": null, + "subjects": [ + "step-run" + ], + "wakes_reconciler": false, + "write_policy": "system-only" + }, "publication.operation": { "additional_fields": false, "cardinality": "append", diff --git a/release-notes/program-step-declaration.json b/release-notes/program-step-declaration.json new file mode 100644 index 00000000000..aae88d1f965 --- /dev/null +++ b/release-notes/program-step-declaration.json @@ -0,0 +1,11 @@ +{ + "version": 1, + "summary": "Missions can declare a `program` step (`program \"/abs/bundle.mjs\" sha256=\"…\" stalled-after=\"10m\"`), `fractal apply` sends the bundle's bytes with the publication and the daemon stores them as a replicated blob; the `program.step` journal claim kind is registered", + "replay": {"status": "changed", "detail": "New claim kind `program.step` (step-run subject, system-only, append, durable) with fields key, status, attempt, program, value, error, ms and optional child. No writer exists yet; older members refuse it as an unknown kind until they upgrade. Step definitions without `program` serialize and hash exactly as before."}, + "schema": {"status": "none", "detail": "No table, index or migration change. Bundles use the existing local_blobs/blobs tables: put_blob stages them, the mission.published claim's `bundle_hash` promotes them."}, + "rules": {"status": "none", "detail": "No rule or authority change. A publication may only stage bundles its own programs name (`unused-program-bundle`)."}, + "compatibility": {"status": "changed", "detail": "ApplyRequest and the owned-set apply request gain an optional `program_bundles` map (sha256 -> base64), omitted when empty, so older clients and daemons are unaffected unless a mission declares a program. /v1/intent/apply and /v1/sets/apply accept bodies up to 32 MiB. A publication of a program whose blob this member does not hold is refused with `missing-program-bundle`; `fractal apply`, `apply --dry-run` and `fractal validate` refuse a bundle whose bytes no longer match its sha256. A member whose build predates `program` reads a published program mission without the field, so its revision hash differs and it quarantines the revision: publish program missions only once every member runs this build."}, + "downtime": {"status": "none", "detail": "No restart or migration beyond a normal deploy."}, + "manual": {"status": "none", "detail": "No operator action is required."}, + "recovery": {"status": "none", "detail": "A refused publication writes nothing; staged bundle bytes are only promoted by the publication that names them."} +} From a191dbea0f694414c8739b02e12edebd746e28ab Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 15:46:08 +0100 Subject: [PATCH 2/9] Hold program steps until the engine runs them; publication buffers match the route limit Without the engine a program step was an agentless step with no gates, so the first pass completed it. Bound and unverifiable request guards buffer up to the publication limit, so bundles reach the handlers. The release note says refused publications may leave staged, unpromoted bundle bytes. --- crates/fractal-api-core/src/api.rs | 5 ++- crates/fractal-reconcile/src/reconcile.rs | 6 +++ .../src/reconcile/tests/program_step_hold.rs | 37 +++++++++++++++++++ release-notes/program-step-declaration.json | 35 ++++++++++++++---- 4 files changed, 74 insertions(+), 9 deletions(-) create mode 100644 crates/fractal-reconcile/src/reconcile/tests/program_step_hold.rs diff --git a/crates/fractal-api-core/src/api.rs b/crates/fractal-api-core/src/api.rs index 4f378f56e38..f7b4d6c89e1 100644 --- a/crates/fractal-api-core/src/api.rs +++ b/crates/fractal-api-core/src/api.rs @@ -8161,7 +8161,8 @@ pub async fn guard_bound_request( return Ok(request); } let (parts, body) = request.into_parts(); - let bytes = axum::body::to_bytes(body, 16 * 1024 * 1024) + // A publication carries program bundles, so the buffer matches the publication route limit. + let bytes = axum::body::to_bytes(body, PUBLICATION_BODY_LIMIT) .await .map_err(ApiError::internal)?; if let Ok(value) = serde_json::from_slice::(&bytes) { @@ -8203,7 +8204,7 @@ async fn guard_unverifiable_request(request: Request) -> Result(&bytes) && ["actor", "requester"].iter().any(|key| value.get(key).is_some_and(|v| !v.is_null())) { diff --git a/crates/fractal-reconcile/src/reconcile.rs b/crates/fractal-reconcile/src/reconcile.rs index 7313428822b..075364ada3e 100644 --- a/crates/fractal-reconcile/src/reconcile.rs +++ b/crates/fractal-reconcile/src/reconcile.rs @@ -11473,6 +11473,11 @@ impl Reconciler { if !self.step_declarations_hold(run, &view.subject)? { return Ok(changed); } + // The program engine alone decides a program step's outcome: nothing here + // completes it, so it stays working until the engine runs it. + if step.spec.program.is_some() { + return Ok(changed); + } if !view.agentless && !view.worker_reported { return Ok(changed); } @@ -21128,6 +21133,7 @@ pub mod tests { mod start_preemption; mod seat_admission_queue; mod terminal_step_guard; + mod program_step_hold; #[test] fn native_exec_and_gate_shell_resolve_the_declared_path() { use super::{NativeRuntime, RuntimeControl}; diff --git a/crates/fractal-reconcile/src/reconcile/tests/program_step_hold.rs b/crates/fractal-reconcile/src/reconcile/tests/program_step_hold.rs new file mode 100644 index 00000000000..6d72292fe08 --- /dev/null +++ b/crates/fractal-reconcile/src/reconcile/tests/program_step_hold.rs @@ -0,0 +1,37 @@ +//! A program step's outcome is the program engine's: no reconciler pass completes it. +use super::*; + +#[test] +fn a_published_program_step_stays_working_until_the_engine_decides() { + let store = Arc::new(Store::open_memory("node").unwrap()); + let hash = store.put_blob(b"export default {}").unwrap(); + apply_source( + &store, + &format!( + r#"version 2 +mission "program-hold" state="ready" {{ + goal "Run a program." + step "program" {{ program "/bundles/hold.mjs" sha256="{hash}" }} +}}"# + ), + "program-hold-definition", + ); + let run = store + .create_mission_run(&MissionRunRequest { + mission: "program-hold".into(), + revision: None, + workspace: "/tmp".into(), + requester: None, + mode: None, + inputs: BTreeMap::new(), + idempotency_key: "program-hold-run".into(), + }) + .unwrap(); + let step = run.steps.iter().find(|step| step.step == "program").unwrap().subject.clone(); + let reconciler = Reconciler::new(store.clone(), Arc::new(FakeRuntime::default()), "node".into(), Arc::new(Notify::new())); + for _ in 0..4 { + reconciler.reconcile_once().unwrap(); + } + assert_eq!(store.step_run(&step).unwrap().unwrap().status, "working"); + assert_eq!(store.mission_run_status(&run.subject).unwrap().as_deref(), Some("running")); +} diff --git a/release-notes/program-step-declaration.json b/release-notes/program-step-declaration.json index aae88d1f965..61802297e44 100644 --- a/release-notes/program-step-declaration.json +++ b/release-notes/program-step-declaration.json @@ -1,11 +1,32 @@ { "version": 1, "summary": "Missions can declare a `program` step (`program \"/abs/bundle.mjs\" sha256=\"…\" stalled-after=\"10m\"`), `fractal apply` sends the bundle's bytes with the publication and the daemon stores them as a replicated blob; the `program.step` journal claim kind is registered", - "replay": {"status": "changed", "detail": "New claim kind `program.step` (step-run subject, system-only, append, durable) with fields key, status, attempt, program, value, error, ms and optional child. No writer exists yet; older members refuse it as an unknown kind until they upgrade. Step definitions without `program` serialize and hash exactly as before."}, - "schema": {"status": "none", "detail": "No table, index or migration change. Bundles use the existing local_blobs/blobs tables: put_blob stages them, the mission.published claim's `bundle_hash` promotes them."}, - "rules": {"status": "none", "detail": "No rule or authority change. A publication may only stage bundles its own programs name (`unused-program-bundle`)."}, - "compatibility": {"status": "changed", "detail": "ApplyRequest and the owned-set apply request gain an optional `program_bundles` map (sha256 -> base64), omitted when empty, so older clients and daemons are unaffected unless a mission declares a program. /v1/intent/apply and /v1/sets/apply accept bodies up to 32 MiB. A publication of a program whose blob this member does not hold is refused with `missing-program-bundle`; `fractal apply`, `apply --dry-run` and `fractal validate` refuse a bundle whose bytes no longer match its sha256. A member whose build predates `program` reads a published program mission without the field, so its revision hash differs and it quarantines the revision: publish program missions only once every member runs this build."}, - "downtime": {"status": "none", "detail": "No restart or migration beyond a normal deploy."}, - "manual": {"status": "none", "detail": "No operator action is required."}, - "recovery": {"status": "none", "detail": "A refused publication writes nothing; staged bundle bytes are only promoted by the publication that names them."} + "replay": { + "status": "changed", + "detail": "New claim kind `program.step` (step-run subject, system-only, append, durable) with fields key, status, attempt, program, value, error, ms and optional child. No writer exists yet; older members refuse it as an unknown kind until they upgrade. Step definitions without `program` serialize and hash exactly as before." + }, + "schema": { + "status": "none", + "detail": "No table, index or migration change. Bundles use the existing local_blobs/blobs tables: put_blob stages them, the mission.published claim's `bundle_hash` promotes them." + }, + "rules": { + "status": "none", + "detail": "No rule or authority change. A publication may only stage bundles its own programs name (`unused-program-bundle`)." + }, + "compatibility": { + "status": "changed", + "detail": "ApplyRequest and the owned-set apply request gain an optional `program_bundles` map (sha256 -> base64), omitted when empty, so older clients and daemons are unaffected unless a mission declares a program. /v1/intent/apply and /v1/sets/apply accept bodies up to 32 MiB. A publication of a program whose blob this member does not hold is refused with `missing-program-bundle`; `fractal apply`, `apply --dry-run` and `fractal validate` refuse a bundle whose bytes no longer match its sha256. A member whose build predates `program` reads a published program mission without the field, so its revision hash differs and it quarantines the revision: publish program missions only once every member runs this build." + }, + "downtime": { + "status": "none", + "detail": "No restart or migration beyond a normal deploy." + }, + "manual": { + "status": "none", + "detail": "No operator action is required." + }, + "recovery": { + "status": "none", + "detail": "A refused publication writes no claim. Bundle bytes it carried that verified are staged in local_blobs before the store's checks run and stay there unpromoted (local only, never replicated) until a publication that names them promotes them." + } } From e1c0a609de81ad386a23e121ffb1698f8a4457f0 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 16:01:02 +0100 Subject: [PATCH 3/9] Declare KDL version 2 in the program bundle test intent --- crates/fractal/src/program_bundles.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/fractal/src/program_bundles.rs b/crates/fractal/src/program_bundles.rs index 52e088e9a8a..ec669c258e1 100644 --- a/crates/fractal/src/program_bundles.rs +++ b/crates/fractal/src/program_bundles.rs @@ -50,7 +50,8 @@ mod tests { let hash = hex::encode(Sha256::digest(b"export default {}")); let kdl = |hash: &str| { format!( - r#"mission "land" state="ready" {{ goal "Land."; step "program" {{ program "{}" sha256="{hash}"; }} }} + r#"version 2 + mission "land" state="ready" {{ goal "Land."; step "program" {{ program "{}" sha256="{hash}"; }} }} mission "outer" state="ready" {{ goal "Nest."; step "inner" {{ mission "inner" state="ready" {{ goal "In."; step "program" {{ program "{}" sha256="{hash}"; }}; }}; }} }}"#, bundle.display(), bundle.display() @@ -62,6 +63,6 @@ mod tests { let other = "0".repeat(64); let error = program_bundles(&kdl(&other)).unwrap_err().to_string(); assert!(error.contains(&hash) && error.contains(&other) && error.contains("land.mjs"), "{error}"); - assert!(program_bundles(r#"mission "plain" state="ready" { goal "None."; step "work" { agentless; } }"#).unwrap().is_empty()); + assert!(program_bundles("version 2\nmission \"plain\" state=\"ready\" { goal \"None.\"; step \"work\" { agentless; } }").unwrap().is_empty()); } } From 3a368e065d0e3393a9e461a781d69411eab1a9f5 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 16:02:47 +0100 Subject: [PATCH 4/9] Hold program-step revisions until every member reads them; test the publication guard buffer --- crates/fractal-api-core/src/api/tests.rs | 26 +++++++++++ .../src/store/mission_capacity.rs | 44 +++++++++++++++++-- crates/fractal/src/main.rs | 2 +- docs/st3/mission-graph-runtime.md | 5 ++- release-notes/program-step-declaration.json | 2 +- 5 files changed, 72 insertions(+), 7 deletions(-) diff --git a/crates/fractal-api-core/src/api/tests.rs b/crates/fractal-api-core/src/api/tests.rs index cd4dad3c96f..7147167a809 100644 --- a/crates/fractal-api-core/src/api/tests.rs +++ b/crates/fractal-api-core/src/api/tests.rs @@ -6558,6 +6558,32 @@ async fn preview_and_apply_with_bundles( (preview, status, applied) } +/// A publication carries its program bundles as base64, so both caller guards buffer a body up to +/// the publication route limit (32 MiB) and hand a body past 16 MiB on whole. +#[tokio::test] +async fn caller_guards_pass_a_publication_body_past_sixteen_mebibytes() { + let root = tempfile::tempdir().unwrap(); + let state = state(root.path()); + let padding = "a".repeat(20 * 1024 * 1024); + for (bound, body) in [ + (Some("agent/example/publisher"), format!(r#"{{"actor":"agent/example/publisher","pad":"{padding}"}}"#)), + (None, format!(r#"{{"pad":"{padding}"}}"#)), + ] { + let mut request = Request::builder() + .method(axum::http::Method::POST) + .uri("/v1/intent/apply") + .header("content-type", "application/json") + .body(Body::from(body.clone())) + .unwrap(); + if bound.is_none() { + request.extensions_mut().insert(HarnessAncestry::Unavailable); + } + let passed = guard_bound_request(request, bound, &state.store).await.unwrap(); + let bytes = to_bytes(passed.into_body(), PUBLICATION_BODY_LIMIT).await.unwrap(); + assert_eq!(bytes.len(), body.len(), "{bound:?}"); + } +} + #[tokio::test] async fn publication_stores_the_program_bundle_its_declaration_names() { use base64::Engine as _; diff --git a/crates/fractal-store/src/store/mission_capacity.rs b/crates/fractal-store/src/store/mission_capacity.rs index 92a68550095..848719f6f49 100644 --- a/crates/fractal-store/src/store/mission_capacity.rs +++ b/crates/fractal-store/src/store/mission_capacity.rs @@ -1,7 +1,7 @@ //! A mission revision that declares a field an older build cannot read (`capacity` on the -//! mission or a step, or the mission's run `authority`) is published only once every current -//! member reads the field. A member whose build does not checks a replicated revision by hashing -//! the mission as it reads it, without the field, and quarantines the claim +//! mission or a step, the mission's run `authority`, or a `program` step) is published only once +//! every current member reads the field. A member whose build does not checks a replicated +//! revision by hashing the mission as it reads it, without the field, and quarantines the claim //! (docs/st3/seat-lanes.md, "Mixed versions"). Each member advertises each field on its own //! `daemon.started`, as the standby barrier reads `schedule_standby`. use super::*; @@ -10,6 +10,8 @@ use super::*; pub const FEATURE: &str = "mission_capacity"; /// The `daemon.started` feature of a build that reads a mission's run `authority`. pub const AUTHORITY_FEATURE: &str = "mission_authority"; +/// The `daemon.started` feature of a build that reads a step's `program`. +pub const PROGRAM_FEATURE: &str = "mission_program"; /// One mission field behind a fleet barrier: the feature that says a member reads it, the /// refusal code, and what to do once every member is upgraded. @@ -20,7 +22,7 @@ struct Barrier { later: &'static str, } -const BARRIERS: [Barrier; 2] = [ +const BARRIERS: [Barrier; 3] = [ Barrier { feature: FEATURE, code: "mission-capacity-unavailable", @@ -33,6 +35,12 @@ const BARRIERS: [Barrier; 2] = [ declares: |mission| !mission.authority.is_empty(), later: "declare authority on a mission", }, + Barrier { + feature: PROGRAM_FEATURE, + code: "mission-program-unavailable", + declares: |mission| !mission.programs().is_empty(), + later: "declare a program step", + }, ]; const WRITER_TABLES: [(&str, &str); 3] = [ @@ -269,4 +277,32 @@ mission "authorized" state="ready" { assert!(publish(&store, AUTHORIZED, "upgraded").unwrap().is_empty()); assert_eq!(store.mission_spec("authorized", None).unwrap().unwrap().authority.len(), 1); } + + #[test] + fn a_revision_that_declares_a_program_step_waits_until_every_member_reads_it() { + let bundle = b"export default {}"; + let source = format!( + "version 2\nmission \"programmed\" state=\"ready\" {{\n goal \"Work.\"\n step \"run\" {{ program \"/bundles/land.mjs\" sha256=\"{}\"; }}\n}}\n", + hex::encode(Sha256::digest(bundle)) + ); + let alone = Store::open_memory("alder").unwrap(); + alone.put_blob(bundle).unwrap(); + publish(&alone, &source, "alone").unwrap(); + let (store, peer) = two_members(); + store.put_blob(bundle).unwrap(); + // Reading capacity and authority is not reading programs. + claim(&peer, "daemon/birch", "daemon.started", None, + json!({"status": "running", "features": {FEATURE: 1, AUTHORITY_FEATURE: 1}})); + sync(&peer, &store); + let refusal = publish(&store, &source, "older").unwrap_err(); + assert_eq!(refusal.code, "mission-program-unavailable"); + assert!(refusal.message.contains("has not advertised mission_program=1); declare a program step once every member is upgraded"), + "{}", refusal.message); + assert!(store.mission_spec("programmed", None).unwrap().is_none()); + claim(&peer, "daemon/birch", "daemon.started", None, + json!({"status": "running", "features": {FEATURE: 1, AUTHORITY_FEATURE: 1, PROGRAM_FEATURE: 1}})); + sync(&peer, &store); + assert!(publish(&store, &source, "upgraded").unwrap().is_empty()); + assert_eq!(store.mission_spec("programmed", None).unwrap().unwrap().programs().len(), 1); + } } diff --git a/crates/fractal/src/main.rs b/crates/fractal/src/main.rs index e9b9c4cbfa8..d7b4a5f3757 100644 --- a/crates/fractal/src/main.rs +++ b/crates/fractal/src/main.rs @@ -7472,7 +7472,7 @@ async fn run_up(args: UpArgs) -> Result<()> { fields: BTreeMap::from([ ( "features".into(), - serde_json::json!({"owned_sets":1,"seat_rollout":1,"seat_rollout_manual":1,"person_directive_note":1,"declared_admission":1,"declared_attention":1,"agent_charter":1,"schedule_standby":1,"github_plugin":2,"seat_freshness":1,"seat_freshness_reads":1,"message_offsets":1,"message_view_reads":1,"message_staged_reads":1,"mission_capacity":1,"mission_authority":1, + serde_json::json!({"owned_sets":1,"seat_rollout":1,"seat_rollout_manual":1,"person_directive_note":1,"declared_admission":1,"declared_attention":1,"agent_charter":1,"schedule_standby":1,"github_plugin":2,"seat_freshness":1,"seat_freshness_reads":1,"message_offsets":1,"message_view_reads":1,"message_staged_reads":1,"mission_capacity":1,"mission_authority":1,"mission_program":1, "harness_access_auto": u8::from(config.active_access_mode() == fractal_drivers::access::AccessMode::Auto), "messages_stream": u8::from(messages_shard.is_ok()), // Counts its stream mail in its idle, unread, held and usage indexes. It diff --git a/docs/st3/mission-graph-runtime.md b/docs/st3/mission-graph-runtime.md index 2efc9c5c41f..2d71f976fae 100644 --- a/docs/st3/mission-graph-runtime.md +++ b/docs/st3/mission-graph-runtime.md @@ -1238,7 +1238,10 @@ To make one run wait without changing its mission, start it with `after`. See [S its sha256. The step is agentless and the program alone decides its outcome, so it cannot name an agent, gates, products, nested or used missions or `after-run`, and it cannot be a `finally` step. `fractal apply` sends the bundle's bytes with the publication; see [Program -engine](program-engine.md). +engine](program-engine.md). An older member would quarantine a revision with a program step (it +hashes the mission without the field), so publication holds such a revision until every member +advertises `mission_program=1` on its `daemon.started` (`mission-program-unavailable`, also an +`apply --dry-run` blocker), as for `capacity` ([seat lanes](seat-lanes.md)). ## Run reports diff --git a/release-notes/program-step-declaration.json b/release-notes/program-step-declaration.json index 61802297e44..e52a30c876b 100644 --- a/release-notes/program-step-declaration.json +++ b/release-notes/program-step-declaration.json @@ -15,7 +15,7 @@ }, "compatibility": { "status": "changed", - "detail": "ApplyRequest and the owned-set apply request gain an optional `program_bundles` map (sha256 -> base64), omitted when empty, so older clients and daemons are unaffected unless a mission declares a program. /v1/intent/apply and /v1/sets/apply accept bodies up to 32 MiB. A publication of a program whose blob this member does not hold is refused with `missing-program-bundle`; `fractal apply`, `apply --dry-run` and `fractal validate` refuse a bundle whose bytes no longer match its sha256. A member whose build predates `program` reads a published program mission without the field, so its revision hash differs and it quarantines the revision: publish program missions only once every member runs this build." + "detail": "ApplyRequest and the owned-set apply request gain an optional `program_bundles` map (sha256 -> base64), omitted when empty, so older clients and daemons are unaffected unless a mission declares a program. /v1/intent/apply and /v1/sets/apply accept bodies up to 32 MiB. A publication of a program whose blob this member does not hold is refused with `missing-program-bundle`; `fractal apply`, `apply --dry-run` and `fractal validate` refuse a bundle whose bytes no longer match its sha256. A member whose build predates `program` would read a published program mission without the field and quarantine the revision, so each daemon now advertises `mission_program=1` on `daemon.started` and a revision with a program step is refused with `mission-program-unavailable` (also an `apply --dry-run` blocker) until every current member advertises it." }, "downtime": { "status": "none", From 9aa1096557b6f3b466c631e76dbbd6d81556e8f7 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 17:02:33 +0100 Subject: [PATCH 5/9] Record program.step in a new convergence corpus v19; keep v17 frozen --- crates/fractal/tests/convergence.rs | 2 +- fixtures/convergence/README.md | 8 + fixtures/convergence/claims-v17.json | 66 - fixtures/convergence/claims-v19.json | 11016 +++++++++++++++++++++++++ 4 files changed, 11025 insertions(+), 67 deletions(-) create mode 100644 fixtures/convergence/claims-v19.json diff --git a/crates/fractal/tests/convergence.rs b/crates/fractal/tests/convergence.rs index 17c3c87b821..94fceee534f 100644 --- a/crates/fractal/tests/convergence.rs +++ b/crates/fractal/tests/convergence.rs @@ -79,7 +79,7 @@ const SEEDS: &[u64] = &[ fn corpus() -> &'static BTreeMap { static CORPUS: std::sync::LazyLock> = std::sync::LazyLock::new(|| { - serde_json::from_str(include_str!("../../../fixtures/convergence/claims-v18.json")) + serde_json::from_str(include_str!("../../../fixtures/convergence/claims-v19.json")) .expect("versioned convergence input schema") }); &CORPUS diff --git a/fixtures/convergence/README.md b/fixtures/convergence/README.md index 7f2ad6ae876..89bb0083614 100644 --- a/fixtures/convergence/README.md +++ b/fixtures/convergence/README.md @@ -247,3 +247,11 @@ subject order and use `daemon/runtime`; native admission still rejects mail with terminal receipt. The focused expiry regression generates the outcome through the same path as random schedules and checks native admission and replication to the oracle, rather than treating corpus membership as write coverage. + +`claims-v19.json` captures the complete registry with `program.step`, the system-only, append-only +journal entry of a program step run (docs/st3/program-engine.md §5). Versions 1 through 18 stay +frozen. Generate it from the merged registry with +`cargo run -p fractal-schema --example claims_json -- fixtures/convergence/claims-v19.json`; +do not hand-edit the snapshot. The simulation selects v19. Draws use the existing `step-run` +subject family and the generic system-only append path. The never-trim set is characterized by +hosted CI: seed runs on a loaded shared host diverge from CI at the same commit (#6210). diff --git a/fixtures/convergence/claims-v17.json b/fixtures/convergence/claims-v17.json index bd0801e1cb1..907e6b64e99 100644 --- a/fixtures/convergence/claims-v17.json +++ b/fixtures/convergence/claims-v17.json @@ -6533,72 +6533,6 @@ "wakes_reconciler": false, "write_policy": "system-only" }, - "program.step": { - "additional_fields": false, - "cardinality": "append", - "fields": { - "attempt": { - "immutable": false, - "reference": false, - "required": true, - "value_type": "integer" - }, - "child": { - "immutable": false, - "reference": false, - "required": false, - "value_type": "string" - }, - "error": { - "immutable": false, - "reference": false, - "required": false, - "value_type": "any" - }, - "key": { - "immutable": false, - "reference": false, - "required": true, - "value_type": "string" - }, - "ms": { - "immutable": false, - "reference": false, - "required": false, - "value_type": "integer" - }, - "program": { - "immutable": false, - "reference": false, - "required": true, - "value_type": "string" - }, - "status": { - "immutable": false, - "reference": false, - "required": true, - "value_type": "string", - "values": [ - "started", - "completed", - "failed" - ] - }, - "value": { - "immutable": false, - "reference": false, - "required": false, - "value_type": "any" - } - }, - "kind": "program.step", - "projection": null, - "subjects": [ - "step-run" - ], - "wakes_reconciler": false, - "write_policy": "system-only" - }, "publication.operation": { "additional_fields": false, "cardinality": "append", diff --git a/fixtures/convergence/claims-v19.json b/fixtures/convergence/claims-v19.json new file mode 100644 index 00000000000..5b8738baa0f --- /dev/null +++ b/fixtures/convergence/claims-v19.json @@ -0,0 +1,11016 @@ +{ + "agent.account": { + "kind": "agent.account", + "subjects": [ + "agent" + ], + "fields": { + "account": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "account" + ] + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "state-transition", + "projection": "agents", + "wakes_reconciler": false + }, + "agent.helper-launched": { + "kind": "agent.helper-launched", + "subjects": [ + "agent" + ], + "fields": { + "credential_home_label": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "declaration": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "helper_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launcher": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "operation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "agents", + "wakes_reconciler": true, + "retention": "local" + }, + "agent.launcher-bound": { + "kind": "agent.launcher-bound", + "subjects": [ + "agent" + ], + "fields": { + "creation_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "credential_home": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "desired_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "incarnation": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launcher": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "agents", + "wakes_reconciler": true, + "retention": "local" + }, + "agent.placement.source-offline": { + "kind": "agent.placement.source-offline", + "subjects": [ + "agent" + ], + "fields": { + "desired_token": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "destination": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sources": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "agents", + "wakes_reconciler": true + }, + "agent.presence": { + "kind": "agent.presence", + "subjects": [ + "agent" + ], + "fields": { + "presence": { + "value_type": "string", + "required": true, + "values": [ + "available", + "busy", + "dnd", + "offline" + ], + "immutable": false, + "reference": false + }, + "reachability": { + "value_type": "string", + "required": false, + "values": [ + "reachable", + "unreachable", + "indeterminate" + ], + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "agents", + "wakes_reconciler": true + }, + "agent.queue.moved": { + "kind": "agent.queue.moved", + "subjects": [ + "agent" + ], + "fields": { + "anchor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "mission-run" + ] + }, + "placement": { + "value_type": "string", + "required": true, + "values": [ + "top", + "bottom", + "before", + "after" + ], + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "run": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission-run" + ] + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "agents", + "wakes_reconciler": true + }, + "agent.renamed": { + "kind": "agent.renamed", + "subjects": [ + "agent" + ], + "fields": { + "declaration": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "from": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "mission" + ] + }, + "owner_host": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "preserved_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "previous_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "to": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "mission" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "agents", + "wakes_reconciler": true + }, + "agent.retired": { + "kind": "agent.retired", + "subjects": [ + "agent" + ], + "fields": { + "declaration": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "desired_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "owner_host": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "retired_by": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person", + "daemon" + ] + }, + "runtime_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "successor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "transfer": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "agents", + "wakes_reconciler": true + }, + "arrangement.edited": { + "kind": "arrangement.edited", + "subjects": [ + "arrangement" + ], + "fields": { + "action_digest": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "action_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operations": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "owner": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "version": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "ordinary-client", + "cardinality": "append", + "projection": "arrangements", + "wakes_reconciler": false + }, + "attention.requested": { + "kind": "attention.requested", + "subjects": [ + "attention" + ], + "fields": { + "closed_by": { + "value_type": "string", + "required": false, + "values": [ + "person", + "st" + ], + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "severity": { + "value_type": "string", + "required": true, + "values": [ + "warning", + "error" + ], + "immutable": false, + "reference": false + }, + "step": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "step-run" + ] + }, + "step_attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "targets": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "title": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "until": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "once", + "projection": "attention", + "wakes_reconciler": false + }, + "attention.resolved": { + "kind": "attention.resolved", + "subjects": [ + "attention" + ], + "fields": { + "outcome": { + "value_type": "string", + "required": true, + "values": [ + "resolved", + "dismissed", + "withdrawn" + ], + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "once", + "projection": "attention", + "wakes_reconciler": false + }, + "checkpoint.excused": { + "kind": "checkpoint.excused", + "subjects": [ + "checkpoint-excusal" + ], + "fields": { + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "writer": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "checkpoints", + "wakes_reconciler": false + }, + "checkpoint.sealed": { + "kind": "checkpoint.sealed", + "subjects": [ + "checkpoint" + ], + "fields": { + "build": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "checkpoint_protocol": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "cut_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "participants": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "rules_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sealed_count": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "sealed_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "checkpoints", + "wakes_reconciler": false + }, + "checkpoint.verified": { + "kind": "checkpoint.verified", + "subjects": [ + "checkpoint" + ], + "fields": { + "build": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "checkpoint_protocol": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "cut_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "drop_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "dropped_claims": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "dropped_envelopes": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "graph_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "participants": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "reader_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "retained_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "rules_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sealed_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "checkpoints", + "wakes_reconciler": false + }, + "client.action-result": { + "kind": "client.action-result", + "subjects": [ + "custom" + ], + "fields": { + "authority_actor": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "result": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": true, + "retention": "local" + }, + "client.hang": { + "kind": "client.hang", + "subjects": [ + "client" + ], + "fields": { + "app_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "capture_source": { + "value_type": "string", + "required": true, + "values": [ + "js", + "native-marker", + "metrickit" + ], + "immutable": false, + "reference": false + }, + "captured_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "event_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id_basis": { + "value_type": "string", + "required": true, + "values": [ + "process", + "metric-interval" + ], + "immutable": false, + "reference": false + }, + "native_build": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "occurred_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "occurrence_time_basis": { + "value_type": "string", + "required": true, + "values": [ + "exact", + "metric-interval-end" + ], + "immutable": false, + "reference": false + }, + "os_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "paired_device": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "pairing_grant": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "payload": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "person_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "platform": { + "value_type": "string", + "required": true, + "values": [ + "ios" + ], + "immutable": false, + "reference": false + }, + "runtime_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "severity": { + "value_type": "string", + "required": true, + "values": [ + "info", + "warning", + "error", + "fatal" + ], + "immutable": false, + "reference": false + }, + "update_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "local" + }, + "client.js-error": { + "kind": "client.js-error", + "subjects": [ + "client" + ], + "fields": { + "app_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "capture_source": { + "value_type": "string", + "required": true, + "values": [ + "js", + "native-marker", + "metrickit" + ], + "immutable": false, + "reference": false + }, + "captured_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "event_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id_basis": { + "value_type": "string", + "required": true, + "values": [ + "process", + "metric-interval" + ], + "immutable": false, + "reference": false + }, + "native_build": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "occurred_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "occurrence_time_basis": { + "value_type": "string", + "required": true, + "values": [ + "exact", + "metric-interval-end" + ], + "immutable": false, + "reference": false + }, + "os_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "paired_device": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "pairing_grant": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "payload": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "person_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "platform": { + "value_type": "string", + "required": true, + "values": [ + "ios" + ], + "immutable": false, + "reference": false + }, + "runtime_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "severity": { + "value_type": "string", + "required": true, + "values": [ + "info", + "warning", + "error", + "fatal" + ], + "immutable": false, + "reference": false + }, + "update_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "local" + }, + "client.launch": { + "kind": "client.launch", + "subjects": [ + "client" + ], + "fields": { + "app_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "capture_source": { + "value_type": "string", + "required": true, + "values": [ + "js", + "native-marker", + "metrickit" + ], + "immutable": false, + "reference": false + }, + "captured_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "event_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id_basis": { + "value_type": "string", + "required": true, + "values": [ + "process", + "metric-interval" + ], + "immutable": false, + "reference": false + }, + "native_build": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "occurred_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "occurrence_time_basis": { + "value_type": "string", + "required": true, + "values": [ + "exact", + "metric-interval-end" + ], + "immutable": false, + "reference": false + }, + "os_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "paired_device": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "pairing_grant": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "payload": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "person_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "platform": { + "value_type": "string", + "required": true, + "values": [ + "ios" + ], + "immutable": false, + "reference": false + }, + "runtime_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "severity": { + "value_type": "string", + "required": true, + "values": [ + "info", + "warning", + "error", + "fatal" + ], + "immutable": false, + "reference": false + }, + "update_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "local" + }, + "client.native-crash": { + "kind": "client.native-crash", + "subjects": [ + "client" + ], + "fields": { + "app_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "capture_source": { + "value_type": "string", + "required": true, + "values": [ + "js", + "native-marker", + "metrickit" + ], + "immutable": false, + "reference": false + }, + "captured_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "event_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "launch_id_basis": { + "value_type": "string", + "required": true, + "values": [ + "process", + "metric-interval" + ], + "immutable": false, + "reference": false + }, + "native_build": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "occurred_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "occurrence_time_basis": { + "value_type": "string", + "required": true, + "values": [ + "exact", + "metric-interval-end" + ], + "immutable": false, + "reference": false + }, + "os_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "paired_device": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "pairing_grant": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "payload": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "person_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "platform": { + "value_type": "string", + "required": true, + "values": [ + "ios" + ], + "immutable": false, + "reference": false + }, + "runtime_version": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "severity": { + "value_type": "string", + "required": true, + "values": [ + "info", + "warning", + "error", + "fatal" + ], + "immutable": false, + "reference": false + }, + "update_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "local" + }, + "client.operation-authorized": { + "kind": "client.operation-authorized", + "subjects": [ + "custom" + ], + "fields": { + "completion_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "record_hash": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "record_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": true + }, + "custom.client.action-result": { + "kind": "custom.client.action-result", + "subjects": [ + "custom" + ], + "fields": { + "authority_actor": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request_digest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "result": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": true + }, + "daemon.diagnostic": { + "kind": "daemon.diagnostic", + "subjects": [ + "daemon" + ], + "fields": { + "code": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "severity": { + "value_type": "string", + "required": true, + "values": [ + "warning", + "error" + ], + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "daemons", + "wakes_reconciler": true, + "retention": "local" + }, + "daemon.started": { + "kind": "daemon.started", + "subjects": [ + "daemon" + ], + "fields": { + "features": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "pid": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "schema": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "schema_digest": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "running" + ], + "immutable": false, + "reference": false + }, + "version": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "daemons", + "wakes_reconciler": true, + "source_kdl": [ + "reset" + ] + }, + "delivery.hold": { + "kind": "delivery.hold", + "subjects": [ + "agent" + ], + "fields": { + "held": { + "value_type": "boolean", + "required": true, + "immutable": false, + "reference": false + }, + "legacy_adoption": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "until_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "state-transition", + "projection": "delivery-holds", + "wakes_reconciler": false + }, + "deploy.compat-signoff": { + "kind": "deploy.compat-signoff", + "subjects": [ + "resource" + ], + "fields": { + "newCommit": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "oldCommit": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "trainId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "deploy.go": { + "kind": "deploy.go", + "subjects": [ + "resource" + ], + "fields": { + "actor": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "combined": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "compatSignoffId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "expiresAt": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "failureRestore": { + "value_type": "boolean", + "required": true, + "immutable": false, + "reference": false + }, + "host": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "issuedAt": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "new": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "old": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": true, + "values": [ + "install", + "rollback" + ], + "immutable": false, + "reference": false + }, + "previewDigest": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "trainId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "deploy.go-consumed": { + "kind": "deploy.go-consumed", + "subjects": [ + "resource" + ], + "fields": { + "goId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": true, + "values": [ + "install", + "rollback" + ], + "immutable": false, + "reference": false + }, + "result": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "deploy.go-revoked": { + "kind": "deploy.go-revoked", + "subjects": [ + "resource" + ], + "fields": { + "goId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "deploy.stop": { + "kind": "deploy.stop", + "subjects": [ + "resource" + ], + "fields": { + "hosts": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "liftCondition": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "scope": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "stopId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "deploy.stop-lifted": { + "kind": "deploy.stop-lifted", + "subjects": [ + "resource" + ], + "fields": { + "releaseGoId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "stopId": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "doc.bound": { + "kind": "doc.bound", + "subjects": [ + "doc" + ], + "fields": { + "executable": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "name": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "size": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "documents", + "wakes_reconciler": true, + "source_kdl": [ + "doc" + ] + }, + "eval.verdict": { + "kind": "eval.verdict", + "subjects": [ + "mission-run" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "residue": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "verdict": { + "value_type": "string", + "required": true, + "values": [ + "pass", + "fail", + "void" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "evals", + "wakes_reconciler": true + }, + "fault.dismissed": { + "kind": "fault.dismissed", + "subjects": [ + "agent", + "exec", + "pty", + "observer", + "subscription", + "schedule", + "daemon", + "machine", + "step-run", + "mission-run", + "loop-run", + "resource", + "checkpoint" + ], + "fields": { + "episode": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "operational", + "wakes_reconciler": true + }, + "file.observed": { + "kind": "file.observed", + "subjects": [ + "file" + ], + "fields": { + "blob_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "content": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "content_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "path": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "observed", + "unreadable" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "files", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "fleet.invite-created": { + "kind": "fleet.invite-created", + "subjects": [ + "fleet-invite" + ], + "fields": { + "created_by": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "expires_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "name": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "sponsor": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "host" + ] + }, + "transports": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.invite-redeemed": { + "kind": "fleet.invite-redeemed", + "subjects": [ + "fleet-invite" + ], + "fields": { + "member_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "name": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.invite-revoked": { + "kind": "fleet.invite-revoked", + "subjects": [ + "fleet-invite" + ], + "fields": { + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "revoked_by": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.member-admitted": { + "kind": "fleet.member-admitted", + "subjects": [ + "host" + ], + "fields": { + "admitted_by": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "fleet_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "invite": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "fleet-invite" + ] + }, + "member_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "string", + "required": true, + "values": [ + "listening", + "dial-out" + ], + "immutable": false, + "reference": false + }, + "node_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "sponsor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "host" + ] + }, + "via": { + "value_type": "string", + "required": true, + "values": [ + "anchor", + "invite", + "migration" + ], + "immutable": false, + "reference": false + }, + "writer_floor": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.member-endpoints": { + "kind": "fleet.member-endpoints", + "subjects": [ + "host" + ], + "fields": { + "build": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "endpoints": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "member_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "string", + "required": true, + "values": [ + "listening", + "dial-out" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.member-left": { + "kind": "fleet.member-left", + "subjects": [ + "host" + ], + "fields": { + "high_water": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "member_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.member-removed": { + "kind": "fleet.member-removed", + "subjects": [ + "host" + ], + "fields": { + "high_water": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "member_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "removed_by": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "fleet.shard-bounds": { + "kind": "fleet.shard-bounds", + "subjects": [ + "host" + ], + "fields": { + "member_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "shard_high_water": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": false + }, + "gate.head-bound": { + "kind": "gate.head-bound", + "subjects": [ + "gate-operation" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "author": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "boundary": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "change": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "generation": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "run-generation" + ] + }, + "head": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "mission_revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "observation": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "owner": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "previous_binding": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "request_operation": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "gate-operation" + ] + }, + "review_targets": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "scope": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "step_definition": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "gate.remediation-attached": { + "kind": "gate.remediation-attached", + "subjects": [ + "gate-operation" + ], + "fields": { + "attempt_receipt": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "author_attempt": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "author_generation": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "run-generation" + ] + }, + "author_step": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "step-run" + ] + }, + "binding_claim": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "boundary_attempt": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "evidence": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "finding_refs": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "gate_subject": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "gate-operation" + ] + }, + "generation": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "run-generation" + ] + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reviewed_head": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "verdict": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "gate.requested": { + "kind": "gate.requested", + "subjects": [ + "gate-operation" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "author": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "baseline": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "binding_claim": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "capability_expires_at": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "capability_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "change": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "decisions": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "delta_ref": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "gate": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "gate_subject": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "gate-operation" + ] + }, + "generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "run-generation" + ] + }, + "head": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "mission_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "string", + "required": false, + "values": [ + "approve", + "feedback" + ], + "immutable": false, + "reference": false + }, + "model": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "owner": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "question": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "review_targets": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "runner": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "scope": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "step_definition": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "token_budget": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "tools": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "gate.result": { + "kind": "gate.result", + "subjects": [ + "gate-operation" + ], + "fields": { + "acted_for": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "baseline": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "decision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "delegation": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "field": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "gate": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "stage": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "token_usage": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "value": { + "value_type": "any", + "required": false, + "immutable": false, + "reference": false + }, + "verdict": { + "value_type": "string", + "required": true, + "values": [ + "pass", + "fail", + "error", + "feedback" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "capability-holder", + "cardinality": "append", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "gate.review-verdict": { + "kind": "gate.review-verdict", + "subjects": [ + "gate-operation" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "binding_claim": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "carry_forward_from": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "change": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "evidence": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "finding_refs": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "gate_subject": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "gate-operation" + ] + }, + "generation": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "run-generation" + ] + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "review_targets": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "reviewed_head": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "scope": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "source": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "verdict": { + "value_type": "string", + "required": true, + "values": [ + "approved", + "changes-requested", + "abstained" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "capability-holder", + "cardinality": "append", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "gate.review-withdrawn": { + "kind": "gate.review-withdrawn", + "subjects": [ + "gate-operation" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "authorization_evidence": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "binding_claim": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "gate_subject": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "gate-operation" + ] + }, + "generation": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "run-generation" + ] + }, + "previous_binding": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "verdict": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "withdrawing_actor": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "gate.reviewer-reassigned": { + "kind": "gate.reviewer-reassigned", + "subjects": [ + "gate-operation" + ], + "fields": { + "owner": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "previous_reviewer": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "request": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "gates", + "wakes_reconciler": true, + "source_kdl": [ + "gate" + ] + }, + "github.event": { + "kind": "github.event", + "subjects": [ + "github-event" + ], + "fields": { + "at": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "detail": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "event": { + "value_type": "string", + "required": true, + "values": [ + "opened", + "closed", + "merged", + "reopened", + "head-changed", + "became-draft", + "became-ready", + "merge-queue-entered", + "merge-queue-left", + "checks-passed", + "checks-failed", + "comment", + "review" + ], + "immutable": false, + "reference": false + }, + "head_sha": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "item": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "resource" + ] + }, + "observer": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "observer" + ] + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "resources", + "wakes_reconciler": true + }, + "github.posted": { + "kind": "github.posted", + "subjects": [ + "github-post" + ], + "fields": { + "agent": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "id": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "item": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "kind": { + "value_type": "string", + "required": true, + "values": [ + "comment", + "review" + ], + "immutable": false, + "reference": false + }, + "login": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "repository": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "url": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "subscriptions", + "wakes_reconciler": true + }, + "glass.deleted": { + "kind": "glass.deleted", + "subjects": [ + "glass" + ], + "fields": { + "base_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "replaced_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "glasses", + "wakes_reconciler": false + }, + "glass.upserted": { + "kind": "glass.upserted", + "subjects": [ + "glass" + ], + "fields": { + "base_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "body": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "replaced_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "glasses", + "wakes_reconciler": false + }, + "harness-question.observed": { + "kind": "harness-question.observed", + "subjects": [ + "harness-question" + ], + "fields": { + "agent": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "native_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "questions": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "runtime_incarnation": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "session": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "harness-question.resolved": { + "kind": "harness-question.resolved", + "subjects": [ + "harness-question" + ], + "fields": { + "answers": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "receipt": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "answered", + "answered_elsewhere", + "expired", + "cancelled" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "harness.context-clear.requested": { + "kind": "harness.context-clear.requested", + "subjects": [ + "agent" + ], + "fields": { + "context_epoch": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation_status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "harness-control", + "wakes_reconciler": true + }, + "harness.context-clear.result": { + "kind": "harness.context-clear.result", + "subjects": [ + "agent" + ], + "fields": { + "context_epoch": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "result": { + "value_type": "string", + "required": true, + "values": [ + "confirmed", + "failed", + "indeterminate" + ], + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "harness-control", + "wakes_reconciler": true + }, + "harness.diagnostic": { + "kind": "harness.diagnostic", + "subjects": [ + "agent" + ], + "fields": { + "acted_for": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "auth_attention_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "code": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "delegation": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "matched_line": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "observed_since_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "ownership_sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "provider_auth_sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "retry_after_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "retry_attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "selector_scope": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "severity": { + "value_type": "string", + "required": false, + "values": [ + "warning", + "error" + ], + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "step_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "step-run" + ] + }, + "wake_attempts": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "harnesses", + "wakes_reconciler": false + }, + "harness.inventory.observed": { + "kind": "harness.inventory.observed", + "subjects": [ + "agent" + ], + "fields": { + "commands": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "dynamic_commands": { + "value_type": "string", + "required": true, + "values": [ + "supported", + "unsupported", + "unavailable" + ], + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": true, + "values": [ + "omp" + ], + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "observed_at": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "session_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "latest" + }, + "harness.limits": { + "kind": "harness.limits", + "subjects": [ + "agent" + ], + "fields": { + "account": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "account_ref": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "five_hour_percent": { + "value_type": "number", + "required": false, + "immutable": false, + "reference": false + }, + "five_hour_resets_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "measured_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "plan": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "weekly_percent": { + "value_type": "number", + "required": false, + "immutable": false, + "reference": false + }, + "weekly_resets_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "harnesses", + "wakes_reconciler": false + }, + "harness.observed": { + "kind": "harness.observed", + "subjects": [ + "agent" + ], + "fields": { + "ask": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "background_jobs": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "blocked_on": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "blocking": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "evidence_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "exit": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "input_buffer": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "observed_at_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "observed_since_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "ownership_sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "provider_auth": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "provider_auth_sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "quiescent": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "rollout_operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "string", + "required": true, + "values": [ + "starting", + "ready", + "idle", + "working", + "blocked", + "ended", + "indeterminate" + ], + "immutable": false, + "reference": false + }, + "status_transition": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "transition_sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "transport": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "harnesses", + "wakes_reconciler": true, + "retention": "latest" + }, + "harness.session-file": { + "kind": "harness.session-file", + "subjects": [ + "agent" + ], + "fields": { + "account_ref": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "agent": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "desired_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "discovery_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "modified_at": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "path": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "session_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "source_session": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "values": [ + "active", + "inactive", + "missing", + "unknown" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "harnesses", + "wakes_reconciler": false + }, + "harness.telemetry": { + "kind": "harness.telemetry", + "subjects": [ + "agent" + ], + "fields": { + "driver": { + "value_type": "string", + "required": true, + "values": [ + "claude" + ], + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "signals": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "unit": { + "value_type": "string", + "required": true, + "values": [ + "hook" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "local" + }, + "harness.timeline": { + "kind": "harness.timeline", + "subjects": [ + "agent" + ], + "fields": { + "body": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "entry_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "entry_type": { + "value_type": "string", + "required": true, + "values": [ + "message", + "content", + "tool_call", + "tool_result", + "status", + "error", + "usage", + "redaction", + "truncation" + ], + "immutable": false, + "reference": false + }, + "final": { + "value_type": "boolean", + "required": true, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "observed_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": true, + "values": [ + "append", + "replace", + "finalize" + ], + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "role": { + "value_type": "string", + "required": true, + "values": [ + "system", + "user", + "assistant", + "tool" + ], + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "source_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "harnesses", + "wakes_reconciler": false, + "retention": "local" + }, + "harness.todo.observed": { + "kind": "harness.todo.observed", + "subjects": [ + "agent" + ], + "fields": { + "harness": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "observed_at": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "phases": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "session_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "source_op": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "totals": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "truncated": { + "value_type": "boolean", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "retention": "latest" + }, + "harness.usage": { + "kind": "harness.usage", + "subjects": [ + "agent" + ], + "fields": { + "account": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "cache_write_1h_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "cache_write_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "cached_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "compactions": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "context_used_percent": { + "value_type": "number", + "required": false, + "immutable": false, + "reference": false + }, + "context_used_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "context_window_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "cost": { + "value_type": "number", + "required": false, + "immutable": false, + "reference": false + }, + "cost_microusd": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "currency": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "input_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "last_compaction_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "last_compaction_trigger": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "model": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "native_session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "observed_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "output_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "owner_run": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "owner_step": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "pricing": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "pricing_provenance": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "reported_cost_microusd": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "semantics": { + "value_type": "string", + "required": true, + "values": [ + "context_occupancy", + "session_cumulative", + "response", + "response_rollup" + ], + "immutable": false, + "reference": false + }, + "total_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "unpriced_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "harnesses", + "wakes_reconciler": false, + "retention": "latest" + }, + "intent.desired": { + "kind": "intent.desired", + "subjects": [ + "*" + ], + "fields": { + "accountable": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "desired": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "kind": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "state-transition", + "projection": "desired", + "wakes_reconciler": true, + "source_kdl": [ + "account", + "agent", + "doc", + "exec", + "host", + "lane", + "message", + "observer", + "mission", + "mission-run", + "planning-session", + "pty", + "resource", + "schedule", + "step", + "stop", + "subscription" + ] + }, + "lane.approved": { + "kind": "lane.approved", + "subjects": [ + "lane" + ], + "fields": { + "entry": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "lanes", + "wakes_reconciler": false + }, + "lane.joined": { + "kind": "lane.joined", + "subjects": [ + "lane" + ], + "fields": { + "entry": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "lanes", + "wakes_reconciler": false + }, + "lane.left": { + "kind": "lane.left", + "subjects": [ + "lane" + ], + "fields": { + "entry": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "outcome": { + "value_type": "string", + "required": true, + "values": [ + "completed", + "removed" + ], + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "lanes", + "wakes_reconciler": false + }, + "lane.marked": { + "kind": "lane.marked", + "subjects": [ + "lane" + ], + "fields": { + "detail": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "entry": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "head": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "string", + "required": true, + "values": [ + "waiting", + "held", + "ready", + "running" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "lanes", + "wakes_reconciler": false + }, + "lane.moved": { + "kind": "lane.moved", + "subjects": [ + "lane" + ], + "fields": { + "anchor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "entry": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true + }, + "placement": { + "value_type": "string", + "required": true, + "values": [ + "top", + "bottom", + "before", + "after" + ], + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "lanes", + "wakes_reconciler": false + }, + "loop.round-dispatch": { + "kind": "loop.round-dispatch", + "subjects": [ + "loop-run" + ], + "fields": { + "candidate": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "dispatch": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "item_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "mission_run": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission-run" + ] + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "round": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "rescheduled" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "loops", + "wakes_reconciler": true, + "source_kdl": [ + "loop", + "round" + ] + }, + "loop.round-result": { + "kind": "loop.round-result", + "subjects": [ + "loop-run" + ], + "fields": { + "candidate": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "feedback": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "doc" + ] + }, + "item": { + "value_type": "any", + "required": false, + "immutable": false, + "reference": false + }, + "metrics": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "mission_run": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission-run" + ] + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "round": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "completed", + "failed", + "discarded" + ], + "immutable": false, + "reference": false + }, + "token_usage": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "loops", + "wakes_reconciler": true, + "source_kdl": [ + "loop", + "round" + ] + }, + "loop.state": { + "kind": "loop.state", + "subjects": [ + "loop-run" + ], + "fields": { + "best_metrics": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "best_round": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "feedback": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "doc" + ] + }, + "items": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "round": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "running", + "completed", + "failed", + "exhausted" + ], + "immutable": false, + "reference": false + }, + "winner": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "loops", + "wakes_reconciler": true, + "source_kdl": [ + "loop" + ] + }, + "member.admission-override": { + "kind": "member.admission-override", + "subjects": [ + "host" + ], + "fields": { + "peers": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "start": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "fleet", + "wakes_reconciler": true + }, + "message.closed": { + "kind": "message.closed", + "subjects": [ + "message" + ], + "fields": { + "acted_for": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "acting_for": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "delegation": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "closed" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "once-per-actor", + "projection": "messages", + "wakes_reconciler": true + }, + "message.delivered": { + "kind": "message.delivered", + "subjects": [ + "message" + ], + "fields": { + "recipient": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "delivered" + ], + "immutable": false, + "reference": false + }, + "transport": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once-per-actor", + "projection": "messages", + "wakes_reconciler": true, + "source_kdl": [ + "message" + ] + }, + "message.expired": { + "kind": "message.expired", + "subjects": [ + "message" + ], + "fields": { + "reason": { + "value_type": "string", + "required": true, + "values": [ + "cutoff-never-offered", + "cutoff-uncertain-attempt", + "no-live-recipient" + ], + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "expired" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "messages", + "wakes_reconciler": true + }, + "message.read": { + "kind": "message.read", + "subjects": [ + "message" + ], + "fields": { + "acting_for": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent" + ] + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "read" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "once-per-actor", + "projection": "messages", + "wakes_reconciler": true + }, + "message.sent": { + "kind": "message.sent", + "subjects": [ + "message" + ], + "fields": { + "assistant_grant_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "assistant_owner": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "assistant_session_actor": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "attachments": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "content": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "from": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "in_reply_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "sender_class": { + "value_type": "string", + "required": false, + "values": [ + "external-assistant" + ], + "immutable": false, + "reference": false + }, + "session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "sent" + ], + "immutable": false, + "reference": false + }, + "tags": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "title": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "ordinary-client", + "cardinality": "once", + "projection": "messages", + "wakes_reconciler": true, + "source_kdl": [ + "message" + ] + }, + "message.staged": { + "kind": "message.staged", + "subjects": [ + "message" + ], + "fields": { + "recipient": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "staged" + ], + "immutable": false, + "reference": false + }, + "transport": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once-per-actor", + "projection": "messages", + "wakes_reconciler": true, + "source_kdl": [ + "message" + ] + }, + "mission-run.created": { + "kind": "mission-run.created", + "subjects": [ + "mission-run" + ], + "fields": { + "ad_hoc_title": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "after": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "current_generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "deadline_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "default_selector": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "initial_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "inputs": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "mission": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "mission_spec": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "parent_step_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "report_completed": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "report_stalls": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "report_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "root_mission_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "root_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "stalled_after_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "timeout_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "workspace": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "mission-runs", + "wakes_reconciler": true, + "source_kdl": [ + "mission-run" + ] + }, + "mission-run.report-to": { + "kind": "mission-run.report-to", + "subjects": [ + "mission-run" + ], + "fields": { + "report_completed": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "report_stalls": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "report_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "stalled_after_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "mission-runs", + "wakes_reconciler": true + }, + "mission-run.state": { + "kind": "mission-run.state", + "subjects": [ + "mission-run" + ], + "fields": { + "completion": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "finally": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "phase": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "previous_phase": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "mission-runs", + "wakes_reconciler": true, + "source_kdl": [ + "mission-run", + "completion", + "finally", + "cancellation" + ] + }, + "mission.produced": { + "kind": "mission.produced", + "subjects": [ + "mission", + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "mission": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "name": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "step_definition": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "capability-holder", + "cardinality": "append", + "projection": "mission-products", + "wakes_reconciler": true, + "source_kdl": [ + "produces" + ] + }, + "mission.provenance": { + "kind": "mission.provenance", + "subjects": [ + "mission" + ], + "fields": { + "mission": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission" + ] + }, + "provenance": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "missions", + "wakes_reconciler": true, + "source_kdl": [ + "provenance" + ] + }, + "mission.published": { + "kind": "mission.published", + "subjects": [ + "mission" + ], + "fields": { + "body": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "missions", + "wakes_reconciler": true, + "source_kdl": [ + "mission" + ] + }, + "mission.renamed": { + "kind": "mission.renamed", + "subjects": [ + "mission" + ], + "fields": { + "declaration": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "from": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "mission" + ] + }, + "owner_host": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "preserved_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "previous_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "to": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "mission" + ] + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "missions", + "wakes_reconciler": true + }, + "observer.observed": { + "kind": "observer.observed", + "subjects": [ + "observer" + ], + "fields": { + "attempt": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "changed": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "changed_fields": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "cursor": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "locator": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "next_check_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "observation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "provider": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "resource": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "observers", + "wakes_reconciler": true, + "source_kdl": [ + "observer" + ] + }, + "observer.refresh-requested": { + "kind": "observer.refresh-requested", + "subjects": [ + "observer" + ], + "fields": { + "attempt": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "observers", + "wakes_reconciler": true, + "source_kdl": [ + "refresh" + ] + }, + "observer.state": { + "kind": "observer.state", + "subjects": [ + "observer" + ], + "fields": { + "attempt": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "error_code": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "next_check_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "string", + "required": true, + "values": [ + "healthy", + "degraded", + "unreachable", + "stopped" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "observers", + "wakes_reconciler": true, + "source_kdl": [ + "observer" + ] + }, + "operational.failure": { + "kind": "operational.failure", + "subjects": [ + "agent", + "exec", + "pty", + "observer", + "subscription", + "schedule", + "daemon", + "machine", + "step-run", + "mission-run", + "loop-run", + "resource", + "checkpoint" + ], + "fields": { + "condition": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reproduction": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "severity": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "source_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "targets": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "title": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "operational", + "wakes_reconciler": true + }, + "operational.recovered": { + "kind": "operational.recovered", + "subjects": [ + "agent", + "exec", + "pty", + "observer", + "subscription", + "schedule", + "daemon", + "machine", + "step-run", + "mission-run", + "loop-run", + "resource", + "checkpoint" + ], + "fields": { + "episode": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "failure": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "operational", + "wakes_reconciler": true + }, + "ordered-membership.edited": { + "kind": "ordered-membership.edited", + "subjects": [ + "arrangement" + ], + "fields": { + "action_digest": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "action_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operations": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "owner": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + } + }, + "additional_fields": false, + "write_policy": "ordinary-client", + "cardinality": "append", + "projection": "ordered-memberships", + "wakes_reconciler": false + }, + "owned-set.revised": { + "kind": "owned-set.revised", + "subjects": [ + "owned-set" + ], + "fields": { + "body": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "owned-sets", + "wakes_reconciler": true + }, + "person.delegation-set": { + "kind": "person.delegation-set", + "subjects": [ + "person" + ], + "fields": { + "actions": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "state-transition", + "projection": null, + "wakes_reconciler": false + }, + "person.directive-note-set": { + "kind": "person.directive-note-set", + "subjects": [ + "person" + ], + "fields": { + "expires_at": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "text": { + "value_type": "string", + "required": true, + "nullable": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "state-transition", + "projection": "directive-notes", + "wakes_reconciler": false + }, + "person.rename.completed": { + "kind": "person.rename.completed", + "subjects": [ + "person" + ], + "fields": { + "new_person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "old_person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "report": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "planning-session.approved": { + "kind": "planning-session.approved", + "subjects": [ + "planning-session" + ], + "fields": { + "candidate_revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "kdl": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "markdown": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "mission_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "preview_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "preview_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "variant": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "once", + "projection": "planning", + "wakes_reconciler": true + }, + "planning-session.cancelled": { + "kind": "planning-session.cancelled", + "subjects": [ + "planning-session" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "once", + "projection": "planning", + "wakes_reconciler": true, + "source_kdl": [ + "cancellation" + ] + }, + "planning-session.candidate-submitted": { + "kind": "planning-session.candidate-submitted", + "subjects": [ + "planning-session" + ], + "fields": { + "candidate_revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "kdl": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "markdown": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "mission_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "variant": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "planning", + "wakes_reconciler": true + }, + "planning-session.previewed": { + "kind": "planning-session.previewed", + "subjects": [ + "planning-session" + ], + "fields": { + "candidate_revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "diff": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "graph": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "mission": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "preview_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "store_index": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "variant": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "planning", + "wakes_reconciler": true + }, + "planning-session.question-answered": { + "kind": "planning-session.question-answered", + "subjects": [ + "planning-session" + ], + "fields": { + "decision_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "expected_revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "explanation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "response": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "planning", + "wakes_reconciler": true + }, + "planning-session.question-requested": { + "kind": "planning-session.question-requested", + "subjects": [ + "planning-session" + ], + "fields": { + "decision_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "decision_type": { + "value_type": "string", + "required": true, + "values": [ + "boolean", + "single-choice", + "multiple-choice", + "rank" + ], + "immutable": false, + "reference": false + }, + "options": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "planner": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "question": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "planning", + "wakes_reconciler": true + }, + "planning-session.revision-requested": { + "kind": "planning-session.revision-requested", + "subjects": [ + "planning-session" + ], + "fields": { + "candidate_revision": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "feedback": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "variant": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "planning", + "wakes_reconciler": true, + "source_kdl": [ + "feedback" + ] + }, + "planning-session.started": { + "kind": "planning-session.started", + "subjects": [ + "planning-session" + ], + "fields": { + "mission": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "planner": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "planner_config": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "target_generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "target_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "workspace": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "once", + "projection": "planning", + "wakes_reconciler": true, + "source_kdl": [ + "planning-session" + ] + }, + "principal.key-granted": { + "kind": "principal.key-granted", + "subjects": [ + "person", + "agent" + ], + "fields": { + "issuer": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "issuer_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "label": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "role": { + "value_type": "string", + "required": true, + "values": [ + "root", + "device", + "agent", + "plugin" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "principals", + "wakes_reconciler": false + }, + "principal.key-revoked": { + "kind": "principal.key-revoked", + "subjects": [ + "person", + "agent" + ], + "fields": { + "key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "principals", + "wakes_reconciler": false + }, + "program.step": { + "kind": "program.step", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "child": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "error": { + "value_type": "any", + "required": false, + "immutable": false, + "reference": false + }, + "key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "program": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "started", + "completed", + "failed" + ], + "immutable": false, + "reference": false + }, + "value": { + "value_type": "any", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false, + "source_kdl": [ + "step", + "program" + ] + }, + "publication.operation": { + "kind": "publication.operation", + "subjects": [ + "*" + ], + "fields": { + "action": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "accepted" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": true, + "source_kdl": [ + "revision", + "reset", + "cancellation", + "refresh", + "feedback" + ] + }, + "reconcile.fault": { + "kind": "reconcile.fault", + "subjects": [ + "daemon", + "mission-run", + "observer", + "schedule", + "step-run", + "subscription" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "scope": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "faulted", + "recovered" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "daemons", + "wakes_reconciler": false + }, + "record.repaired": { + "kind": "record.repaired", + "subjects": [ + "repair" + ], + "fields": { + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "record": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "replacement": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "ordinary-client", + "cardinality": "once", + "projection": "replication", + "wakes_reconciler": false, + "source_kdl": [ + "repair" + ] + }, + "render.applied": { + "kind": "render.applied", + "subjects": [ + "agent", + "exec", + "pty" + ], + "fields": { + "warnings": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "writes": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtimes", + "wakes_reconciler": false, + "retention": "local" + }, + "repair.applied": { + "kind": "repair.applied", + "subjects": [ + "repair" + ], + "fields": { + "affected_subjects": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "item_count": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "token": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "repairs", + "wakes_reconciler": true + }, + "resource.observed": { + "kind": "resource.observed", + "subjects": [ + "resource" + ], + "fields": { + "attribution_only": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "kind": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "observed_at": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "any", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": true, + "write_policy": "ordinary-client", + "cardinality": "append", + "projection": "resources", + "wakes_reconciler": true, + "source_kdl": [ + "resource" + ] + }, + "revision-proposal.applied": { + "kind": "revision-proposal.applied", + "subjects": [ + "revision-proposal" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "successor_generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "revision-proposals", + "wakes_reconciler": true + }, + "revision-proposal.approved": { + "kind": "revision-proposal.approved", + "subjects": [ + "revision-proposal" + ], + "fields": { + "all_approved": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "preview_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reviewer": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "once-per-actor", + "projection": "revision-proposals", + "wakes_reconciler": true + }, + "revision-proposal.cancelled": { + "kind": "revision-proposal.cancelled", + "subjects": [ + "revision-proposal" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "once", + "projection": "revision-proposals", + "wakes_reconciler": true + }, + "revision-proposal.created": { + "kind": "revision-proposal.created", + "subjects": [ + "revision-proposal" + ], + "fields": { + "candidate_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "compatible_steps": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "cutover": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "preview_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reviewers": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "source_generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "once", + "projection": "revision-proposals", + "wakes_reconciler": true + }, + "rule.audited": { + "kind": "rule.audited", + "subjects": [ + "rule" + ], + "fields": { + "action": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "actor": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "rule": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "target": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "rules", + "wakes_reconciler": false + }, + "rule.set": { + "kind": "rule.set", + "subjects": [ + "rule" + ], + "fields": { + "actors": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "description": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "except": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "kinds": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "string", + "required": true, + "values": [ + "off", + "audit", + "enforce" + ], + "immutable": false, + "reference": false + }, + "subjects": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "unless_subjects": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "rules", + "wakes_reconciler": false + }, + "run-generation.created": { + "kind": "run-generation.created", + "subjects": [ + "run-generation" + ], + "fields": { + "compatible_steps": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "predecessor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "run-generations", + "wakes_reconciler": true, + "source_kdl": [ + "mission-run", + "revision" + ] + }, + "run-generation.state": { + "kind": "run-generation.state", + "subjects": [ + "run-generation" + ], + "fields": { + "phase": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "previous_phase": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "successor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "run-generations", + "wakes_reconciler": true, + "source_kdl": [ + "mission-run", + "step", + "completion", + "finally", + "revision", + "cancellation" + ] + }, + "run-generation.superseded": { + "kind": "run-generation.superseded", + "subjects": [ + "run-generation" + ], + "fields": { + "phase": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "previous_phase": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "successor": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "run-generations", + "wakes_reconciler": true, + "source_kdl": [ + "revision" + ] + }, + "runtime.action.deadline-reached": { + "kind": "runtime.action.deadline-reached", + "subjects": [ + "agent", + "exec", + "pty", + "gate-operation" + ], + "fields": { + "action": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "blocking": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "code": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "credential_home": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "deadline_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "desired_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "launch_contract": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "native_session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation_status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "rollout": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "rollout_operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_pid": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_pid_start_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "signal": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "source_host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "terminal": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtime-actions", + "wakes_reconciler": true, + "source_kdl": [ + "stop", + "gate" + ], + "retention": "system-local" + }, + "runtime.action.failed": { + "kind": "runtime.action.failed", + "subjects": [ + "agent", + "exec", + "pty", + "gate-operation" + ], + "fields": { + "action": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "blocking": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "code": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "credential_home": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "deadline_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "desired_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "launch_contract": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "native_session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation_status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "rollout": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "rollout_operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_pid": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_pid_start_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "signal": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "source_host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "terminal": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtime-actions", + "wakes_reconciler": true, + "source_kdl": [ + "stop", + "gate" + ], + "retention": "system-local" + }, + "runtime.action.requested": { + "kind": "runtime.action.requested", + "subjects": [ + "agent", + "exec", + "pty", + "gate-operation" + ], + "fields": { + "action": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "deadline_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "fresh_session": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "ignore_fit": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "rollout": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "signal": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "source_host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "terminal": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "runtime-actions", + "wakes_reconciler": true, + "source_kdl": [ + "stop", + "gate" + ], + "retention": "system-local" + }, + "runtime.action.succeeded": { + "kind": "runtime.action.succeeded", + "subjects": [ + "agent", + "exec", + "pty", + "gate-operation" + ], + "fields": { + "action": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "blocking": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "code": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "credential_home": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "deadline_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "desired_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "harness": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "launch_contract": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "native_session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "operation_status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "rollout": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "rollout_operation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_pid": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_pid_start_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "signal": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "source_host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "terminal": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtime-actions", + "wakes_reconciler": true, + "source_kdl": [ + "stop", + "gate" + ], + "retention": "system-local" + }, + "runtime.observed": { + "kind": "runtime.observed", + "subjects": [ + "agent", + "exec", + "pty", + "gate-operation" + ], + "fields": { + "adopted": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "exit_code": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "exit_signal": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "host": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reachability": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "restarting_from": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "shutdown_timeout_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "terminal": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "runtimes", + "wakes_reconciler": true + }, + "runtime.readiness-deadline-reached": { + "kind": "runtime.readiness-deadline-reached", + "subjects": [ + "agent" + ], + "fields": { + "deadline_unix_ms": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtimes", + "wakes_reconciler": true, + "retention": "local" + }, + "runtime.reconcile-decision": { + "kind": "runtime.reconcile-decision", + "subjects": [ + "agent", + "exec", + "pty", + "schedule" + ], + "fields": { + "decision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "gate": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "input_number": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "owner_run": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reachability": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "restart_at_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtimes", + "wakes_reconciler": true + }, + "runtime.refresh": { + "kind": "runtime.refresh", + "subjects": [ + "agent" + ], + "fields": { + "episode": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtimes", + "wakes_reconciler": true + }, + "runtime.restart-window-reset": { + "kind": "runtime.restart-window-reset", + "subjects": [ + "agent", + "exec", + "pty" + ], + "fields": { + "desired_token": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "runtimes", + "wakes_reconciler": true, + "source_kdl": [ + "reset" + ] + }, + "schedule.occurrence-cancelled": { + "kind": "schedule.occurrence-cancelled", + "subjects": [ + "schedule" + ], + "fields": { + "occurrence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "schedules", + "wakes_reconciler": true, + "source_kdl": [ + "schedule" + ] + }, + "schedule.occurrence-reached": { + "kind": "schedule.occurrence-reached", + "subjects": [ + "schedule" + ], + "fields": { + "at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "occurrence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "scheduled": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "scheduled_at_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "standby": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "schedules", + "wakes_reconciler": true, + "source_kdl": [ + "schedule" + ] + }, + "schedule.occurrence-scheduled": { + "kind": "schedule.occurrence-scheduled", + "subjects": [ + "schedule" + ], + "fields": { + "at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "occurrence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "scheduled_at_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "standby": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "schedules", + "wakes_reconciler": true, + "source_kdl": [ + "schedule" + ] + }, + "schedule.work-failed": { + "kind": "schedule.work-failed", + "subjects": [ + "schedule" + ], + "fields": { + "code": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "schedules", + "wakes_reconciler": true, + "source_kdl": [ + "schedule" + ] + }, + "schedule.work-requested": { + "kind": "schedule.work-requested", + "subjects": [ + "schedule" + ], + "fields": { + "inputs": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + }, + "mission": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission" + ] + }, + "mission_revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "occurrence": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "revision": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "workspace": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "schedules", + "wakes_reconciler": true, + "source_kdl": [ + "schedule" + ] + }, + "schedule.work-started": { + "kind": "schedule.work-started", + "subjects": [ + "schedule" + ], + "fields": { + "mission_run": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission-run" + ] + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "schedules", + "wakes_reconciler": true, + "source_kdl": [ + "schedule" + ] + }, + "sekret.called": { + "kind": "sekret.called", + "subjects": [ + "sekret" + ], + "fields": { + "argv": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "caller": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "cwd": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "grant": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "login": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "person": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "profile": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "seq": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "tty": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "sekrets", + "wakes_reconciler": false, + "retention": "local" + }, + "sekret.changed": { + "kind": "sekret.changed", + "subjects": [ + "sekret" + ], + "fields": { + "at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "caller": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "change": { + "value_type": "string", + "required": true, + "values": [ + "profile-created", + "profile-removed", + "policy-set", + "put", + "unset", + "grant-added", + "grant-removed", + "locked", + "unlocked", + "daemon-registered" + ], + "immutable": false, + "reference": false + }, + "detail": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "person": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "profile": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "seq": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "sekrets", + "wakes_reconciler": false, + "retention": "local" + }, + "sekret.exited": { + "kind": "sekret.exited", + "subjects": [ + "sekret" + ], + "fields": { + "at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "call": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "caller": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "error": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "exit_code": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "person": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "profile": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "seq": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "signal": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "sekrets", + "wakes_reconciler": false, + "retention": "local" + }, + "sekret.refused": { + "kind": "sekret.refused", + "subjects": [ + "sekret" + ], + "fields": { + "argv": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "caller": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "person": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "profile": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "seq": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "sekrets", + "wakes_reconciler": false, + "retention": "local" + }, + "slo.breach-transition": { + "kind": "slo.breach-transition", + "subjects": [ + "resource" + ], + "fields": { + "record": { + "value_type": "object", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "slo-breaches", + "wakes_reconciler": true + }, + "step-run.carried": { + "kind": "step-run.carried", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "definition_hash": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "source": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "source_generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "source_step_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "once", + "projection": "step-runs", + "wakes_reconciler": true, + "source_kdl": [ + "step" + ] + }, + "step-run.retried": { + "kind": "step-run.retried", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "goals": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "not_before_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "step-runs", + "wakes_reconciler": true, + "source_kdl": [ + "step" + ] + }, + "step-run.state": { + "kind": "step-run.state", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "step-runs", + "wakes_reconciler": true, + "source_kdl": [ + "step" + ] + }, + "subagent.appeared": { + "kind": "subagent.appeared", + "subjects": [ + "agent" + ], + "fields": { + "description": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "driver": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "lease_expires_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "session_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "started_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "step_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "step-run" + ] + }, + "subagent_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "subagent_type": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "subagents", + "wakes_reconciler": false + }, + "subagent.ended": { + "kind": "subagent.ended", + "subjects": [ + "agent" + ], + "fields": { + "cache_write_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "cached_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "duration_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "ended_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "input_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "outcome": { + "value_type": "string", + "required": true, + "values": [ + "completed", + "failed", + "interrupted", + "expired", + "session-ended", + "harness-exited", + "seat-stopped" + ], + "immutable": false, + "reference": false + }, + "output_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "subagent_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "total_tokens": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "subagents", + "wakes_reconciler": false + }, + "subagent.renewed": { + "kind": "subagent.renewed", + "subjects": [ + "agent" + ], + "fields": { + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "lease_expires_at_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "subagent_id": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": "subagents", + "wakes_reconciler": false + }, + "subscription.batch-sent": { + "kind": "subscription.batch-sent", + "subjects": [ + "subscription" + ], + "fields": { + "entries": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "message": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "message" + ] + }, + "through": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.batched": { + "kind": "subscription.batched", + "subjects": [ + "subscription" + ], + "fields": { + "delivery_key": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "entries": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.mission-deferred": { + "kind": "subscription.mission-deferred", + "subjects": [ + "subscription" + ], + "fields": { + "not_before_unix_ms": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.mission-failed": { + "kind": "subscription.mission-failed", + "subjects": [ + "subscription" + ], + "fields": { + "code": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.mission-request-cancelled": { + "kind": "subscription.mission-request-cancelled", + "subjects": [ + "subscription" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.mission-request-released": { + "kind": "subscription.mission-request-released", + "subjects": [ + "subscription" + ], + "fields": { + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.mission-requested": { + "kind": "subscription.mission-requested", + "subjects": [ + "subscription" + ], + "fields": { + "delivery_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "discovery": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "held": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "mission": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission" + ] + }, + "mission_revision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "requester": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "agent", + "person" + ] + }, + "resource": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "resource" + ] + }, + "resource_input": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "text": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "text_input": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "workspace": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.mission-started": { + "kind": "subscription.mission-started", + "subjects": [ + "subscription" + ], + "fields": { + "mission_run": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "mission-run" + ] + }, + "request": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.state": { + "kind": "subscription.state", + "subjects": [ + "subscription" + ], + "fields": { + "fields": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + }, + "observer": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "string", + "required": true, + "values": [ + "pending", + "active", + "stopped" + ], + "immutable": false, + "reference": false + }, + "to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "state-transition", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "subscription.watch-ended": { + "kind": "subscription.watch-ended", + "subjects": [ + "subscription" + ], + "fields": { + "message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "message" + ] + }, + "reason": { + "value_type": "string", + "required": true, + "values": [ + "closed", + "merged", + "deadline", + "unwatched", + "seat-ended" + ], + "immutable": false, + "reference": false + }, + "since_unix_ms": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "subscriptions", + "wakes_reconciler": true, + "source_kdl": [ + "subscription" + ] + }, + "terminal.input.requested": { + "kind": "terminal.input.requested", + "subjects": [ + "agent", + "pty" + ], + "fields": { + "byte_count": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "intent": { + "value_type": "string", + "required": false, + "values": [ + "context-compaction" + ], + "immutable": false, + "reference": false + }, + "mode": { + "value_type": "string", + "required": false, + "values": [ + "line", + "raw", + "key", + "text", + "binary" + ], + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "sha256": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "terminal-control", + "wakes_reconciler": true + }, + "terminal.input.result": { + "kind": "terminal.input.result", + "subjects": [ + "agent", + "pty" + ], + "fields": { + "incarnation_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "result": { + "value_type": "string", + "required": true, + "values": [ + "written", + "failed" + ], + "immutable": false, + "reference": false + }, + "runtime_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "sequence": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "terminal-control", + "wakes_reconciler": true + }, + "terminal.launch-geometry": { + "kind": "terminal.launch-geometry", + "subjects": [ + "person" + ], + "fields": { + "columns": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + }, + "rows": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "transport.observed": { + "kind": "transport.observed", + "subjects": [ + "host" + ], + "fields": { + "last_success_at": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "protocol": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "remote_heads": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": true, + "values": [ + "up", + "down", + "unknown" + ], + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "transport", + "wakes_reconciler": true + }, + "usage.limits.observed": { + "kind": "usage.limits.observed", + "subjects": [ + "agent" + ], + "fields": { + "credit_readings": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + }, + "readings": { + "value_type": "array", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "same-subject-actor", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "vcs.item.state": { + "kind": "vcs.item.state", + "subjects": [ + "resource" + ], + "fields": { + "checks_state": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "draft": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "head_sha": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "item_kind": { + "value_type": "string", + "required": true, + "values": [ + "vcs.pull-request", + "vcs.issue" + ], + "immutable": false, + "reference": false + }, + "merge_queue": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "merged": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + }, + "observer": { + "value_type": "subject-reference", + "required": true, + "immutable": false, + "reference": true, + "reference_families": [ + "observer" + ] + }, + "required_checks": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "review_decision": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "state": { + "value_type": "string", + "required": true, + "values": [ + "open", + "closed" + ], + "immutable": false, + "reference": false + }, + "version": { + "value_type": "integer", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": "resources", + "wakes_reconciler": true + }, + "work.claimed": { + "kind": "work.claimed", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "state-transition", + "projection": "work", + "wakes_reconciler": true + }, + "work.extended": { + "kind": "work.extended", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.failed": { + "kind": "work.failed", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "once-per-attempt", + "projection": "work", + "wakes_reconciler": true + }, + "work.handoff-returned": { + "kind": "work.handoff-returned", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "disposition": { + "value_type": "string", + "required": false, + "values": [ + "withdrawn", + "declined" + ], + "immutable": false, + "reference": false + }, + "handoff_claim": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "return_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.nudged": { + "kind": "work.nudged", + "subjects": [ + "step-run" + ], + "fields": { + "agent": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "idle_since_unix_ms": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "waits": { + "value_type": "array", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": false + }, + "work.person-asked": { + "kind": "work.person-asked", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "deadline_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "deadline_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "default_answer": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "legacy_request": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "mission_spec": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "origin_attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "origin_step": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "owner_generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "owner_run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "requester_declaration": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "title": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "waiting_since": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.person-cancelled": { + "kind": "work.person-cancelled", + "subjects": [ + "step-run" + ], + "fields": { + "answer": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "resolved_by": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.person-done": { + "kind": "work.person-done", + "subjects": [ + "step-run" + ], + "fields": { + "acted_for": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "answer": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "assistant_grant_id": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "assistant_owner": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true, + "reference_families": [ + "person" + ] + }, + "assistant_session_actor": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "delegation": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "resolved_by": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "sender_class": { + "value_type": "string", + "required": false, + "values": [ + "external-assistant" + ], + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.person-reassigned": { + "kind": "work.person-reassigned", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "episode": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "generation": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "previous_person": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "run": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + } + }, + "additional_fields": false, + "write_policy": "authorized-requester", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.progress": { + "kind": "work.progress", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.released": { + "kind": "work.released", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.renewed": { + "kind": "work.renewed", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "append", + "projection": "work", + "wakes_reconciler": true + }, + "work.submitted": { + "kind": "work.submitted", + "subjects": [ + "step-run" + ], + "fields": { + "attempt": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_expires_at_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "claim_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "claimant": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "clock": { + "value_type": "string", + "required": false, + "values": [ + "paused", + "running" + ], + "immutable": false, + "reference": false + }, + "extend_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_acknowledged": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_key": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_message": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "handoff_request": { + "value_type": "object", + "required": false, + "immutable": false, + "reference": false + }, + "handoff_to": { + "value_type": "subject-reference", + "required": false, + "immutable": false, + "reference": true + }, + "readiness_epoch": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "reason": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "status": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "submitted_incarnation": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "summary": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "wait_until_unix_ms": { + "value_type": "integer", + "required": false, + "immutable": false, + "reference": false + }, + "worker_reported": { + "value_type": "boolean", + "required": false, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "authorized-participant", + "cardinality": "once-per-attempt", + "projection": "work", + "wakes_reconciler": true + }, + "workspace.observed": { + "kind": "workspace.observed", + "subjects": [ + "agent" + ], + "fields": { + "host": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + }, + "repository": { + "value_type": "string", + "required": false, + "immutable": false, + "reference": false + }, + "workspace": { + "value_type": "string", + "required": true, + "immutable": false, + "reference": false + } + }, + "additional_fields": false, + "write_policy": "system-only", + "cardinality": "append", + "projection": null, + "wakes_reconciler": true, + "retention": "latest" + } +} From d0928e85af78fba6ab2ec4d34327395c530a37c5 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 19:34:19 +0100 Subject: [PATCH 6/9] convergence: draw no keyed-only kind in the unkeyed simulated fleet Every replica admits client.operation-authorized only from a keyed member's signed envelope and holds an unkeyed writer's as unsigned. The simulated nodes have no member keys, so a generated one stayed pending on every other node and the oracle, and held every later checkpoint back. Corpus v19 moves the draws so seeds 1 and 34 write one. Name the kind, subject and writer of a claim the oracle never saw in the report. --- crates/fractal/tests/convergence.rs | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/crates/fractal/tests/convergence.rs b/crates/fractal/tests/convergence.rs index 94fceee534f..0d30f5cd930 100644 --- a/crates/fractal/tests/convergence.rs +++ b/crates/fractal/tests/convergence.rs @@ -85,6 +85,15 @@ fn corpus() -> &'static BTreeMap { &CORPUS } +/// Whether every replica admits `kind` only from a keyed member's signed envelope, by the +/// daemon's own admission rule. +fn keyed_only(kind: &str) -> bool { + use smallclaims::store::Runtime as _; + static RUNTIME: std::sync::LazyLock = + std::sync::LazyLock::new(Default::default); + RUNTIME.requires_keyed_envelope(kind) +} + #[test] fn the_corpus_includes_every_registry_kind() { for kind in fractal_schema::registry().claims.keys() { @@ -989,7 +998,13 @@ impl World { }) .collect::>(); let spec = *self.rng.pick(&kinds); - self.claim_of(spec, index) + let input = self.claim_of(spec, index)?; + // Every replica admits some kinds, such as an operation authorization, only from a keyed + // member's signed envelope and holds an unkeyed writer's as unsigned. These nodes have no + // member keys, so such a claim would stay pending on every other node and hold every later + // checkpoint back; production writes it only on keyed members. The input is still drawn, + // so a seed whose store refused it keeps its schedule. + (!keyed_only(&input.kind)).then_some(input) } fn claim_of(&mut self, spec: &fractal_schema::ClaimSpec, index: usize) -> Option { @@ -1601,9 +1616,12 @@ impl World { None => {} } } - for id in held.keys() { + for (id, claim) in &held { if !oracle_claims.contains_key(id) { - failures.push(format!("{name}: holds {id}, which the oracle never saw")); + failures.push(format!( + "{name}: holds {id} ({} on {}, from {}), which the oracle never saw", + claim.kind, claim.subject, claim.origin + )); } } if node.old_build { From af81d6d1883eec2c5f7f7d263520e64996b27255 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 20:23:47 +0100 Subject: [PATCH 7/9] schema: leave program.step out of the assistant principal digest transition The transition test rebuilds the registry from before kinds added later; program.step is one, so the reconstructed digests changed (hosted run 42865212282). --- crates/fractal-schema/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/fractal-schema/src/lib.rs b/crates/fractal-schema/src/lib.rs index 0e70ca27f36..8d65c3de566 100644 --- a/crates/fractal-schema/src/lib.rs +++ b/crates/fractal-schema/src/lib.rs @@ -4974,6 +4974,7 @@ mod tests { current.subjects.remove("objective").unwrap(); current.claims.get_mut("intent.desired").unwrap().source_kdl.retain(|kind| kind != "objective"); current.claims.remove("message.expired").unwrap(); + current.claims.remove("program.step").unwrap(); assert_eq!(current.subjects["assistant"].pattern, "assistant/{chatgpt|mcp}[/session/assistant-grant/ID]"); let mut previous = current.clone(); previous.subjects.get_mut("assistant").unwrap().pattern = From c2eed2b436057aacca2c75d37558d9afff4ab873 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 20:23:47 +0100 Subject: [PATCH 8/9] convergence: regenerate v19 from the merged registry; empty never-trim set Merging main adds objective to intent.desired's source_kdl. With keyed-only claims no longer written, every fixed seed trims on hosted CI. --- crates/fractal/tests/convergence.rs | 8 +++++--- fixtures/convergence/README.md | 15 +++++++++++++-- fixtures/convergence/claims-v19.json | 1 + 3 files changed, 19 insertions(+), 5 deletions(-) diff --git a/crates/fractal/tests/convergence.rs b/crates/fractal/tests/convergence.rs index 0d30f5cd930..2334df46178 100644 --- a/crates/fractal/tests/convergence.rs +++ b/crates/fractal/tests/convergence.rs @@ -1873,9 +1873,11 @@ fn run_seeds(seeds: impl IntoIterator) { assert!(trimmed * 2 >= runs, "only {trimmed} of {runs} runs trimmed"); } -/// Corpus v18 adds durable expiry to kind selection, shifting the shared RNG schedule. -/// Hosted run 42793993503 observed seeds 2 and 34 converge without trimming; the other fixed seeds trim. -const NEVER_TRIMS: &[u64] = &[2, 34]; +/// Corpus v19 adds `program.step` to kind selection, shifting the shared RNG schedule. Hosted run +/// 42865212282 observed every fixed seed trim but seeds 1 and 34, which wrote a keyed-only claim; +/// burst run 42882912660 observed them trim once they no longer write one. That burst left seeds 55 +/// and 610 untrimmed: a lightly loaded runner diverges from hosted CI at the same commit (#6210). +const NEVER_TRIMS: &[u64] = &[]; /// One fixed seed: it converges, and its checkpoints trim unless it is a seed that never does. fn seed_converges(seed: u64) { diff --git a/fixtures/convergence/README.md b/fixtures/convergence/README.md index 89bb0083614..fde5e272a89 100644 --- a/fixtures/convergence/README.md +++ b/fixtures/convergence/README.md @@ -253,5 +253,16 @@ journal entry of a program step run (docs/st3/program-engine.md §5). Versions 1 frozen. Generate it from the merged registry with `cargo run -p fractal-schema --example claims_json -- fixtures/convergence/claims-v19.json`; do not hand-edit the snapshot. The simulation selects v19. Draws use the existing `step-run` -subject family and the generic system-only append path. The never-trim set is characterized by -hosted CI: seed runs on a loaded shared host diverge from CI at the same commit (#6210). +subject family and the generic system-only append path. + +A drawn `client.operation-authorized` (in the corpus since v17) is not written. Every replica +admits that kind only from a keyed member's signed envelope and holds an unkeyed writer's as +unsigned; the simulated nodes have no member keys. Written, it stayed pending on every other node +and the oracle and held every later checkpoint back, so the run never settled and the writer held +a claim the oracle never saw. On hosted CI, v19's draws first wrote one, in seeds 1 and 34; off +CI, schedules diverge and more seeds wrote one (seeds 3, 13, 17, 277 and 1597 in burst run +42880734602). The input is still drawn, so a seed whose store refused it keeps its schedule. +With v19 every fixed seed converges and trims, so the never-trim set is empty. The +never-trim set is characterized by hosted CI: seed runs on a loaded shared host or a lightly +loaded burst runner diverge from CI at the same commit (#6210); burst run 42882912660 leaves seeds +55 and 610 untrimmed. diff --git a/fixtures/convergence/claims-v19.json b/fixtures/convergence/claims-v19.json index 5b8738baa0f..40d3eb6e2ee 100644 --- a/fixtures/convergence/claims-v19.json +++ b/fixtures/convergence/claims-v19.json @@ -4490,6 +4490,7 @@ "lane", "message", "observer", + "objective", "mission", "mission-run", "planning-session", From e574d7dafbb26746a3c1720f52431a87f1408214 Mon Sep 17 00:00:00 2001 From: Johannes Schickling Date: Tue, 10 Nov 2026 21:20:04 +0100 Subject: [PATCH 9/9] convergence: cite the hosted run that characterizes the v19 never-trim set --- crates/fractal/tests/convergence.rs | 6 +++--- fixtures/convergence/README.md | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/crates/fractal/tests/convergence.rs b/crates/fractal/tests/convergence.rs index 1a10b52643d..f091ae6d24b 100644 --- a/crates/fractal/tests/convergence.rs +++ b/crates/fractal/tests/convergence.rs @@ -1874,9 +1874,9 @@ fn run_seeds(seeds: impl IntoIterator) { } /// Corpus v19 adds `program.step` to kind selection, shifting the shared RNG schedule. Hosted run -/// 42865212282 observed every fixed seed trim but seeds 1 and 34, which wrote a keyed-only claim; -/// burst run 42882912660 observed them trim once they no longer write one. That burst left seeds 55 -/// and 610 untrimmed: a lightly loaded runner diverges from hosted CI at the same commit (#6210). +/// 42884923668 observed every fixed seed converge and trim once no seed writes a keyed-only claim. +/// Burst run 42884913070 left seeds 55 and 610 untrimmed at the same commit: a lightly loaded +/// runner diverges from hosted CI (#6210). const NEVER_TRIMS: &[u64] = &[]; // Growth beyond three non-trimming seeds needs review. const _: () = assert!(NEVER_TRIMS.len() <= 3); diff --git a/fixtures/convergence/README.md b/fixtures/convergence/README.md index fde5e272a89..2abbccb1e25 100644 --- a/fixtures/convergence/README.md +++ b/fixtures/convergence/README.md @@ -262,7 +262,7 @@ and the oracle and held every later checkpoint back, so the run never settled an a claim the oracle never saw. On hosted CI, v19's draws first wrote one, in seeds 1 and 34; off CI, schedules diverge and more seeds wrote one (seeds 3, 13, 17, 277 and 1597 in burst run 42880734602). The input is still drawn, so a seed whose store refused it keeps its schedule. -With v19 every fixed seed converges and trims, so the never-trim set is empty. The -never-trim set is characterized by hosted CI: seed runs on a loaded shared host or a lightly -loaded burst runner diverge from CI at the same commit (#6210); burst run 42882912660 leaves seeds -55 and 610 untrimmed. +With v19 every fixed seed converges and trims (hosted run 42884923668), so the never-trim set is +empty. The never-trim set is characterized by hosted CI: seed runs on a loaded shared host or a +lightly loaded burst runner diverge from CI at the same commit (#6210); burst run 42884913070 +leaves seeds 55 and 610 untrimmed.