From bf23d3e15c11b91cac2051eeb2631d7984be2b78 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 17:19:20 +0000 Subject: [PATCH 01/10] refactor(mcp): serve hook runtime through the project owner --- .../src/agents/hermes/templates.rs | 1 + .../agents/hermes/templates/plugin_init.py | 4 +- .../src/hooks/analytics/tests.rs | 3 +- .../src/hooks/claude.rs | 11 +- .../tracedecay-agent-hosts/src/hooks/codex.rs | 21 +- .../src/hooks/cursor.rs | 18 +- .../src/hooks/cursor_compact.rs | 8 +- .../src/hooks/daemon_ports.rs | 259 ++++++++------ .../src/hooks/dispatch.rs | 37 +- .../src/hooks/dispatch/tests.rs | 20 +- .../src/hooks/hook_boundary_failure_matrix.rs | 3 +- .../tracedecay-agent-hosts/src/hooks/mod.rs | 82 ++--- .../src/http/application_operation_owner.rs | 3 +- crates/tracedecay-cli/src/tool_command.rs | 6 +- .../tests/core_cli_suite/tool_daemon_test.rs | 3 +- crates/tracedecay-contracts/src/graph_tool.rs | 7 +- .../src/hook_orchestration.rs | 5 +- crates/tracedecay-contracts/src/policy.rs | 3 +- .../src/retrieval/catalog.rs | 13 +- .../src/retrieval/hook_runtime_surface.rs | 298 ++++++++++++++++ .../retrieval/hook_runtime_surface/tests.rs | 167 +++++++++ .../tracedecay-contracts/src/retrieval/mod.rs | 8 + .../tracedecay-contracts/src/sdk_catalog.rs | 3 +- .../src/application_surface.rs | 3 +- .../src/application_surface/invocation.rs | 1 + .../src/contract/mod.rs | 3 +- .../tracedecay-mcp-catalog/src/definitions.rs | 15 - .../src/definitions/tests.rs | 15 - crates/tracedecay-mcp-catalog/src/lib.rs | 6 +- .../src/application_output/tool_result.rs | 26 +- .../src/handlers/hook_runtime/admission.rs | 137 ++++---- .../handlers/hook_runtime/admission/tests.rs | 88 +++-- .../handlers/hook_runtime/context_scout.rs | 302 +++------------- .../hook_runtime/context_scout/tests.rs | 43 +-- .../src/handlers/hook_runtime/entry_tests.rs | 71 ++-- .../src/handlers/hook_runtime/envelope.rs | 20 +- .../src/handlers/hook_runtime/hermes.rs | 111 +----- .../src/handlers/hook_runtime/hermes/tests.rs | 15 +- .../src/handlers/hook_runtime/ingest.rs | 328 ++++++++---------- .../handlers/hook_runtime/ingest/kernels.rs | 32 +- .../src/handlers/hook_runtime/ingest/tests.rs | 55 +-- .../src/handlers/hook_runtime/mod.rs | 309 +++++++++-------- .../src/handlers/hook_runtime/terminal.rs | 133 ------- crates/tracedecay-mcp/src/lib.rs | 7 +- .../src/server/live_transcript_refresh.rs | 135 +++---- crates/tracedecay-mcp/src/server/mod.rs | 2 +- crates/tracedecay-mcp/src/tools/binding.rs | 4 +- .../tracedecay-tool-catalog/src/manifest.rs | 8 +- .../tracedecay-tool-catalog/src/operation.rs | 4 +- .../src/owner_side_effect.rs | 13 + .../src/daemon/invocation_dispatch.rs | 12 +- .../src/daemon/project_open_admission.rs | 22 +- crates/tracedecay/src/daemon/projectless.rs | 123 ++----- .../src/mcp/server/graph_tool_owner.rs | 34 +- .../mcp/tools/handlers/application_surface.rs | 5 + .../src/mcp/tools/handlers/dispatch_groups.rs | 24 +- .../handlers/hook_runtime_behavior_tests.rs | 198 ----------- .../tracedecay/src/mcp/tools/handlers/mod.rs | 9 - crates/tracedecay/src/runtime_ports.rs | 13 +- .../tests/hermes_suite/lcm_bridge.rs | 5 +- .../tests/mcp_suite/mcp_handler_test.rs | 1 + .../hook_runtime_request_test.rs | 130 +++++++ .../mcp_handler_test/session_search_test.rs | 4 +- .../session_runtime/temporal_refresh.rs | 15 +- scripts/hermes_plugin_unit_check.py | 9 +- 65 files changed, 1698 insertions(+), 1775 deletions(-) create mode 100644 crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs create mode 100644 crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs delete mode 100644 crates/tracedecay-mcp/src/handlers/hook_runtime/terminal.rs delete mode 100644 crates/tracedecay/src/mcp/tools/handlers/hook_runtime_behavior_tests.rs create mode 100644 crates/tracedecay/tests/mcp_suite/mcp_handler_test/hook_runtime_request_test.rs diff --git a/crates/tracedecay-agent-hosts/src/agents/hermes/templates.rs b/crates/tracedecay-agent-hosts/src/agents/hermes/templates.rs index d3cf32b024..aba852798e 100644 --- a/crates/tracedecay-agent-hosts/src/agents/hermes/templates.rs +++ b/crates/tracedecay-agent-hosts/src/agents/hermes/templates.rs @@ -211,6 +211,7 @@ def call_tracedecay_tool(name: str, args: dict, **kwargs) -> str: user_scoped = ( tool_args.get("memory_scope") == "user" or tool_args.get("storage_scope") == "user" + or tool_args.get("user_scope") is True ) if user_scoped: project_root = None diff --git a/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py b/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py index d2cac65b0e..7199b9928e 100644 --- a/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py +++ b/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py @@ -2420,13 +2420,13 @@ def sync_turn(self, user_content, assistant_content, *, session_id="", messages= # so one turn can be searched from every repository it actually touched # without binding the long-lived host session to any one project. for project_root in [None, *project_roots]: - args = _lcm_store_args({ + args = { "action": "ingest_transcript", "provider": STANDARD_HERMES_LCM_PROVIDER, "session_id": sid, "messages": turn_messages, "user_scope": project_root is None, - }, project_root) + } try: result = call_tracedecay_json( "tracedecay_hook_runtime", diff --git a/crates/tracedecay-agent-hosts/src/hooks/analytics/tests.rs b/crates/tracedecay-agent-hosts/src/hooks/analytics/tests.rs index 7fb849a275..6b4d10af4e 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/analytics/tests.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/analytics/tests.rs @@ -1,5 +1,6 @@ use super::*; use std::time::Duration; +use tracedecay_contracts::retrieval::HookRuntimeSurfaceRequestV1; use tracedecay_runtime_core::config::ProfileRoot; fn enroll_project(project_root: &Path, profile_root: &Path, project_id: &str) -> PathBuf { @@ -244,7 +245,7 @@ fn daemon_hook_action_records_completed_rtt_and_wire_length() { let result = crate::hooks::daemon_hook_action( &crate::ports::hook_runtime::crate_test_runtime(profile.clone()), Some(&project_root), - serde_json::json!({ "action": "reset_counter" }), + HookRuntimeSurfaceRequestV1::ResetCounter {}, Some(&span), ) .await; diff --git a/crates/tracedecay-agent-hosts/src/hooks/claude.rs b/crates/tracedecay-agent-hosts/src/hooks/claude.rs index a91d422407..db3099f3bc 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/claude.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/claude.rs @@ -6,15 +6,15 @@ use std::path::PathBuf; use std::time::Instant; use serde_json::Value; +use tracedecay_contracts::retrieval::HookRuntimeSurfaceRequestV1; use crate::ports::hook_runtime::HookRuntimeV1; use super::post_tool_use::is_post_tool_use_failure_event; use super::tool_hints::{ToolHintInput, decide_hint}; use super::{ - additional_context_json, compact_daemon_args, event_project_root_with_identity, - event_session_id, prompt_like_text, read_hook_event, record_hook_invoked_parsed, - research_block_reason, + additional_context_json, event_project_root_with_identity, event_session_id, prompt_like_text, + read_hook_event, record_hook_invoked_parsed, research_block_reason, }; use tracedecay_domain::HostIntegrationIdV1; @@ -110,7 +110,10 @@ pub async fn hook_claude_post_compact(runtime: &HookRuntimeV1) -> i32 { &event, &parsed, ); - let args = compact_daemon_args("claude_compact", "claude", root.is_none(), &event, None); + let args = HookRuntimeSurfaceRequestV1::ClaudeCompact { + event_json: event.clone(), + user_scope: root.is_none(), + }; if let Err(error) = super::daemon_hook_action(runtime, root.as_deref(), args, Some(&hook_telemetry)).await { diff --git a/crates/tracedecay-agent-hosts/src/hooks/codex.rs b/crates/tracedecay-agent-hosts/src/hooks/codex.rs index 346eb7cf87..ef3e12a5b3 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/codex.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/codex.rs @@ -5,6 +5,7 @@ use std::collections::BTreeMap; use std::path::{Path, PathBuf}; use std::time::Instant; +use tracedecay_contracts::retrieval::HookRuntimeSurfaceRequestV1; use serde_json::Value; @@ -15,11 +16,10 @@ use super::claude::is_code_research_prompt; use super::steering::{HookWorkspaceStatus, index_status_line}; use super::tool_hints::{HintCategory, ToolHint, ToolHintInput, decide_hint}; use super::{ - additional_context_json, append_tool_hint, compact_daemon_args, deduped_project_hint_with_id, - event_cwd_from_parsed, event_project_root, event_project_root_from_json, - event_project_root_with_identity, event_session_id, format_tool_hint, - is_project_like_workspace, mint_hint_id, prompt_like_text, read_hook_event, - record_hint_analytics, record_hook_analytics, record_hook_invoked_parsed, + additional_context_json, append_tool_hint, deduped_project_hint_with_id, event_cwd_from_parsed, + event_project_root, event_project_root_from_json, event_project_root_with_identity, + event_session_id, format_tool_hint, is_project_like_workspace, mint_hint_id, prompt_like_text, + read_hook_event, record_hint_analytics, record_hook_analytics, record_hook_invoked_parsed, record_workspace_status_analytics, rel_under_root, text_field, }; use tracedecay_domain::HostIntegrationIdV1; @@ -545,14 +545,9 @@ async fn codex_post_compact( let Some(root) = event_project_root_with_identity(runtime, &parsed).await else { return; }; - let session_id = event_session_id(&parsed); - let args = compact_daemon_args( - "codex_compact", - "codex", - false, - event_json, - session_id.as_deref(), - ); + let args = HookRuntimeSurfaceRequestV1::CodexCompact { + event_json: event_json.to_owned(), + }; if let Err(error) = super::daemon_hook_action(runtime, Some(&root), args, telemetry).await { tracing::warn!(%error, "Codex PostCompact daemon call failed"); } diff --git a/crates/tracedecay-agent-hosts/src/hooks/cursor.rs b/crates/tracedecay-agent-hosts/src/hooks/cursor.rs index 52826f35f0..0045fd57f5 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/cursor.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/cursor.rs @@ -422,7 +422,7 @@ mod tests { use tracedecay_runtime_core::config::ProfileRoot; #[tokio::test] - async fn transcript_ingest_forwards_its_budget_to_the_daemon() { + async fn transcript_ingest_forwards_its_byte_budget_to_the_daemon() { let daemon = crate::hooks::TestDaemonHookActionGuard::install([ serde_json::json!({ "user_scope": true, "messages_upserted": 2 }), ]); @@ -453,9 +453,19 @@ mod tests { assert_eq!(calls[0].0, None); assert_eq!(calls[0].1["action"], "ingest_transcript"); assert_eq!(calls[0].1["provider"], "cursor"); - assert_eq!(calls[0].1["max_new_bytes"], 4_096); - assert_eq!(calls[0].1["timeout_budget_ms"], 250); - assert_eq!(calls[0].1["format"], "json"); + assert_eq!( + calls[0].1, + serde_json::json!({ + "action": "ingest_transcript", + "provider": "cursor", + "user_scope": true, + "session_id": null, + "event_json": event, + "messages": null, + "max_new_bytes": 4_096, + "format": "json", + }) + ); } #[tokio::test] diff --git a/crates/tracedecay-agent-hosts/src/hooks/cursor_compact.rs b/crates/tracedecay-agent-hosts/src/hooks/cursor_compact.rs index 3491fc8177..7a3d7ab17c 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/cursor_compact.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/cursor_compact.rs @@ -7,6 +7,7 @@ use std::time::Duration; +use tracedecay_contracts::retrieval::HookRuntimeSurfaceRequestV1; use tracedecay_lcm::LcmRelationProjectionStatus; use crate::ports::hook_runtime::HookRuntimeV1; @@ -100,10 +101,9 @@ async fn cursor_pre_compact_via_daemon_inner( let result = match super::daemon_hook_action( runtime, Some(&root), - serde_json::json!({ - "action": "cursor_compact", - "event_json": event_json, - }), + HookRuntimeSurfaceRequestV1::CursorCompact { + event_json: event_json.to_owned(), + }, telemetry, ) .await diff --git a/crates/tracedecay-agent-hosts/src/hooks/daemon_ports.rs b/crates/tracedecay-agent-hosts/src/hooks/daemon_ports.rs index e35e0f5db5..33cccc4a07 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/daemon_ports.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/daemon_ports.rs @@ -11,12 +11,16 @@ use std::time::Duration; use serde::Deserialize; use tracedecay_contracts::context_scout::{ContextScoutAddressV1, ContextScoutDeliveryReceiptV1}; +use tracedecay_contracts::retrieval::{ + ContextScoutStoreStatusV1, HookRuntimeAcceptedV1, HookRuntimeDispositionV1, + HookRuntimeResultV1, HookRuntimeSurfaceRequestV1, HookV2AdmissionResultV1, + HookV2AdmitRequestV1, HookV2NoticeDeliveryResultV1, +}; use tracedecay_domain::UtcMicros; use tracedecay_hooks::{ AsyncHookAdmissionPortV1, AsyncHookFeedbackDeliveryPortV1, HookAdmissionFutureV1, HookDeliveryFutureV1, HookEventEnvelopeV2, HookFeedbackDeliveryOutcomeV1, HookImmediateAdmissionV1, HookReadyGuidanceV1, HookSynchronousDeadlineV1, - HookTransportDispositionV1, }; use crate::agents::context_scout::ContextScoutDeliveryReceiptHookV1; @@ -97,31 +101,6 @@ pub(crate) struct DaemonAdmissionResponseV1 { pub(crate) github_stack_signal_available: bool, } -#[derive(Clone, Copy, Deserialize)] -#[serde(rename_all = "snake_case")] -enum DaemonAdmissionStatusV1 { - Accepted, - Committed, - ExactDuplicate, - Backpressured, - Rejected, - Unavailable, -} - -#[derive(Deserialize)] -#[serde(deny_unknown_fields)] -struct DaemonAdmissionResponseWireV1 { - action: String, - status: DaemonAdmissionStatusV1, - disposition: Option, - orchestration: Option, - context_scout_address: Option, - ready_guidance: Option, - feedback_notice: Option, - github_stack_signal_available: Option, - reason: Option, -} - pub(crate) fn now_utc() -> UtcMicros { UtcMicros( tracedecay_runtime_core::tracedecay::saturating_utc_now() @@ -138,53 +117,81 @@ pub(crate) fn daemon_admission_response(response: &serde_json::Value) -> DaemonA feedback_notice: None, github_stack_signal_available: false, }; - let Ok(wire) = DaemonAdmissionResponseWireV1::deserialize(response) else { + let Ok(HookRuntimeResultV1::HookV2Admit(admission)) = + HookRuntimeResultV1::deserialize(response) + else { return unavailable(); }; - if wire.action != "hook_v2_admit" { - return unavailable(); - } - let _ = (&wire.orchestration, &wire.reason); - match (wire.status, wire.disposition) { - (DaemonAdmissionStatusV1::Rejected, Some(HookTransportDispositionV1::CatchupRequired)) => { - DaemonAdmissionResponseV1 { - immediate: HookImmediateAdmissionV1::CatchupRequired, - context_scout_address: None, - feedback_notice: None, - github_stack_signal_available: false, - } - } - ( - DaemonAdmissionStatusV1::Accepted - | DaemonAdmissionStatusV1::Committed - | DaemonAdmissionStatusV1::ExactDuplicate, - Some(HookTransportDispositionV1::Accepted), - ) => { - if wire - .feedback_notice - .as_ref() - .is_some_and(|notice| notice.validate().is_err()) - { - return unavailable(); + let (ready_guidance, context_scout_address, feedback_notice, github_stack_signal_available) = + match admission { + HookV2AdmissionResultV1::Rejected { + disposition: HookRuntimeDispositionV1::CatchupRequired, + .. + } => { + return DaemonAdmissionResponseV1 { + immediate: HookImmediateAdmissionV1::CatchupRequired, + context_scout_address: None, + feedback_notice: None, + github_stack_signal_available: false, + }; } - DaemonAdmissionResponseV1 { - immediate: HookImmediateAdmissionV1::Accepted { - admitted_at: now_utc(), - ready_guidance: wire.ready_guidance, - }, - context_scout_address: wire.context_scout_address, - feedback_notice: wire.feedback_notice, - github_stack_signal_available: wire.github_stack_signal_available.unwrap_or(false), + HookV2AdmissionResultV1::Backpressured {} => { + return DaemonAdmissionResponseV1 { + immediate: HookImmediateAdmissionV1::Backpressured, + context_scout_address: None, + feedback_notice: None, + github_stack_signal_available: false, + }; } - } - (DaemonAdmissionStatusV1::Backpressured, None) => DaemonAdmissionResponseV1 { - immediate: HookImmediateAdmissionV1::Backpressured, - context_scout_address: None, - feedback_notice: None, - github_stack_signal_available: false, + HookV2AdmissionResultV1::Accepted { + disposition: HookRuntimeDispositionV1::Accepted, + context_scout_address, + ready_guidance, + feedback_notice, + github_stack_signal_available, + .. + } => ( + ready_guidance, + context_scout_address, + feedback_notice, + github_stack_signal_available, + ), + HookV2AdmissionResultV1::ExactDuplicate { + disposition: HookRuntimeDispositionV1::Accepted, + context_scout_address, + ready_guidance, + } => (ready_guidance, context_scout_address, None, false), + HookV2AdmissionResultV1::Accepted { .. } + | HookV2AdmissionResultV1::ExactDuplicate { .. } + | HookV2AdmissionResultV1::Rejected { .. } + | HookV2AdmissionResultV1::Unavailable {} => return unavailable(), + }; + let Ok(ready_guidance) = ready_guidance + .map(serde_json::from_value::) + .transpose() + else { + return unavailable(); + }; + let Ok(feedback_notice) = feedback_notice + .map(serde_json::from_value::) + .transpose() + else { + return unavailable(); + }; + if feedback_notice + .as_ref() + .is_some_and(|notice| notice.validate().is_err()) + { + return unavailable(); + } + DaemonAdmissionResponseV1 { + immediate: HookImmediateAdmissionV1::Accepted { + admitted_at: now_utc(), + ready_guidance, }, - (DaemonAdmissionStatusV1::Unavailable, None) => unavailable(), - _ => unavailable(), + context_scout_address, + feedback_notice, + github_stack_signal_available, } } @@ -198,16 +205,18 @@ impl AsyncHookAdmissionPortV1 for DaemonAdmissionPort<'_> { let Ok(envelope) = serde_json::to_value(envelope) else { return HookImmediateAdmissionV1::Unavailable; }; + let Ok(native_lifecycle) = self.lifecycle.map(serde_json::to_value).transpose() else { + return HookImmediateAdmissionV1::Unavailable; + }; let response = tokio::time::timeout( Duration::from_micros(deadline.remaining_micros()), super::daemon_hook_action( self.runtime, Some(self.project_root), - serde_json::json!({ - "action": "hook_v2_admit", - "envelope": envelope, - "native_session_id": self.session_id, - "native_lifecycle": self.lifecycle, + HookRuntimeSurfaceRequestV1::HookV2Admit(HookV2AdmitRequestV1 { + envelope, + native_session_id: self.session_id.map(str::to_owned), + native_lifecycle, }), self.telemetry, ), @@ -238,12 +247,21 @@ impl AsyncHookAdmissionPortV1 for DaemonAdmissionPort<'_> { } } -fn delivery_outcome_from_status(status: Option<&str>) -> HookFeedbackDeliveryOutcomeV1 { - match status { - Some("stored") => HookFeedbackDeliveryOutcomeV1::Delivered, +fn delivery_outcome(response: &serde_json::Value) -> HookFeedbackDeliveryOutcomeV1 { + match HookRuntimeResultV1::deserialize(response) { + Ok( + HookRuntimeResultV1::HookV2DeliveryReceipt { + status: ContextScoutStoreStatusV1::Stored, + } + | HookRuntimeResultV1::HookV2FeedbackNoticeDelivery( + HookV2NoticeDeliveryResultV1::Stored {}, + ), + ) => HookFeedbackDeliveryOutcomeV1::Delivered, // Exact-address commits that lost a compare-and-swap still prove the // daemon retained an authoritative row for this receipt/feedback. - Some("duplicate" | "superseded") => HookFeedbackDeliveryOutcomeV1::Duplicate, + Ok(HookRuntimeResultV1::HookV2DeliveryReceipt { + status: ContextScoutStoreStatusV1::Duplicate | ContextScoutStoreStatusV1::Superseded, + }) => HookFeedbackDeliveryOutcomeV1::Duplicate, _ => HookFeedbackDeliveryOutcomeV1::Unavailable, } } @@ -252,7 +270,7 @@ fn delivery_outcome_from_status(status: Option<&str>) -> HookFeedbackDeliveryOut async fn timed_daemon_hook_action( runtime: &HookRuntimeV1, project_root: &Path, - action: serde_json::Value, + action: HookRuntimeSurfaceRequestV1, deadline: HookSynchronousDeadlineV1, telemetry: Option<&HookTimingSpan>, ) -> HookFeedbackDeliveryOutcomeV1 { @@ -264,7 +282,7 @@ async fn timed_daemon_hook_action( let Ok(Ok(response)) = response else { return HookFeedbackDeliveryOutcomeV1::Unavailable; }; - delivery_outcome_from_status(response.get("status").and_then(|value| value.as_str())) + delivery_outcome(&response) } /// Daemon-backed Hook feedback-notice delivery. Acknowledgement crosses the @@ -293,14 +311,19 @@ impl AsyncHookFeedbackDeliveryPortV1 HookDeliveryFutureV1<'a> { Box::pin(async move { + let (Ok(envelope), Ok(feedback_notice)) = ( + serde_json::to_value(envelope), + serde_json::to_value(feedback), + ) else { + return HookFeedbackDeliveryOutcomeV1::Unavailable; + }; timed_daemon_hook_action( self.runtime, self.project_root, - serde_json::json!({ - "action": "hook_v2_feedback_notice_delivery", - "envelope": envelope, - "feedback_notice": feedback, - }), + HookRuntimeSurfaceRequestV1::HookV2FeedbackNoticeDelivery { + envelope, + feedback_notice, + }, deadline, None, ) @@ -329,13 +352,13 @@ impl<'a> DaemonDeliveryReceiptPort<'a> { receipt: &ContextScoutDeliveryReceiptV1, deadline: HookSynchronousDeadlineV1, ) -> HookFeedbackDeliveryOutcomeV1 { + let Ok(receipt) = serde_json::to_value(receipt) else { + return HookFeedbackDeliveryOutcomeV1::Unavailable; + }; timed_daemon_hook_action( self.runtime, self.project_root, - serde_json::json!({ - "action": "hook_v2_delivery_receipt", - "receipt": receipt, - }), + HookRuntimeSurfaceRequestV1::HookV2DeliveryReceipt { receipt }, deadline, None, ) @@ -381,22 +404,20 @@ impl<'a> DaemonOpenCodeLspUpdatePort<'a> { let response = super::daemon_hook_action( self.runtime, Some(self.project_root), - serde_json::json!({ - "action": "opencode_lsp_updated", - "event": event, - }), + HookRuntimeSurfaceRequestV1::OpencodeLspUpdated { + event: event.clone(), + }, self.telemetry, ) .await; - response - .ok() - .and_then(|value| { - value - .get("status") - .and_then(serde_json::Value::as_str) - .map(str::to_owned) - }) - .is_some_and(|status| status == "accepted") + response.is_ok_and(|response| { + matches!( + HookRuntimeResultV1::deserialize(&response), + Ok(HookRuntimeResultV1::OpencodeLspUpdated { + status: HookRuntimeAcceptedV1::Accepted, + }) + ) + }) } } @@ -406,17 +427,29 @@ mod tests { #[test] fn delivery_outcome_maps_superseded_as_duplicate() { - assert_eq!( - delivery_outcome_from_status(Some("superseded")), - HookFeedbackDeliveryOutcomeV1::Duplicate - ); - assert_eq!( - delivery_outcome_from_status(Some("stored")), - HookFeedbackDeliveryOutcomeV1::Delivered - ); - assert_eq!( - delivery_outcome_from_status(Some("unavailable")), - HookFeedbackDeliveryOutcomeV1::Unavailable - ); + for (response, outcome) in [ + ( + serde_json::json!({"action": "hook_v2_delivery_receipt", "status": "superseded"}), + HookFeedbackDeliveryOutcomeV1::Duplicate, + ), + ( + serde_json::json!({"action": "hook_v2_delivery_receipt", "status": "stored"}), + HookFeedbackDeliveryOutcomeV1::Delivered, + ), + ( + serde_json::json!({"action": "hook_v2_feedback_notice_delivery", "status": "stored"}), + HookFeedbackDeliveryOutcomeV1::Delivered, + ), + ( + serde_json::json!({"action": "hook_v2_delivery_receipt", "status": "unavailable"}), + HookFeedbackDeliveryOutcomeV1::Unavailable, + ), + ( + serde_json::json!({"status": "stored"}), + HookFeedbackDeliveryOutcomeV1::Unavailable, + ), + ] { + assert_eq!(delivery_outcome(&response), outcome, "{response}"); + } } } diff --git a/crates/tracedecay-agent-hosts/src/hooks/dispatch.rs b/crates/tracedecay-agent-hosts/src/hooks/dispatch.rs index 71bf137de7..469fa83a59 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/dispatch.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/dispatch.rs @@ -7,6 +7,10 @@ use tracedecay_contracts::ResolvedScope; use tracedecay_contracts::context_scout::{ ContextScoutAddressV1, ContextScoutDeliveryOutcomeV1, ContextScoutDeliveryReceiptV1, }; +use tracedecay_contracts::retrieval::{ + HookRuntimeDispositionV1, HookRuntimeResultV1, HookRuntimeSurfaceRequestV1, + HookV2ProfileAdmissionResultV1, +}; use tracedecay_domain::NativeHostIdentityV1; use tracedecay_domain::{ProjectId, UtcMicros}; #[cfg(test)] @@ -529,13 +533,14 @@ async fn dispatch_profile_scoped( super::daemon_hook_action( runtime, None, - serde_json::json!({ - "action": "hook_v2_profile_admit", - "admission": tracedecay_hooks::ProfileScopedNativeHookAdmissionV1 { - decoded, - material, + HookRuntimeSurfaceRequestV1::HookV2ProfileAdmit { + admission: match serde_json::to_value( + tracedecay_hooks::ProfileScopedNativeHookAdmissionV1 { decoded, material }, + ) { + Ok(admission) => admission, + Err(_) => return unavailable(), }, - }), + }, telemetry, ), ) @@ -543,16 +548,16 @@ async fn dispatch_profile_scoped( let Ok(Ok(response)) = response else { return unavailable(); }; - let accepted = response.get("action").and_then(serde_json::Value::as_str) - == Some("hook_v2_profile_admit") - && matches!( - response.get("status").and_then(serde_json::Value::as_str), - Some("accepted" | "exact_duplicate") - ) - && response - .get("disposition") - .and_then(serde_json::Value::as_str) - == Some("accepted"); + let accepted = matches!( + HookRuntimeResultV1::deserialize(&response), + Ok(HookRuntimeResultV1::HookV2ProfileAdmit( + HookV2ProfileAdmissionResultV1::Accepted { + disposition: HookRuntimeDispositionV1::Accepted, + } | HookV2ProfileAdmissionResultV1::ExactDuplicate { + disposition: HookRuntimeDispositionV1::Accepted, + } + )) + ); if accepted { HookDispatch::Handled { guidance: None, diff --git a/crates/tracedecay-agent-hosts/src/hooks/dispatch/tests.rs b/crates/tracedecay-agent-hosts/src/hooks/dispatch/tests.rs index d2734f2e17..09f3125598 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/dispatch/tests.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/dispatch/tests.rs @@ -88,11 +88,7 @@ fn daemon_catchup_disposition_is_not_reclassified_as_unavailable() { let response = serde_json::json!({ "action": "hook_v2_admit", "status": "rejected", - "disposition": HookTransportDispositionV1::CatchupRequired, - "orchestration": null, - "ready_guidance": null, - "feedback_notice": null, - "reason": null, + "disposition": "catchup_required", }); assert!(matches!( @@ -183,11 +179,12 @@ fn daemon_feedback_notice_survives_into_host_delivery() { let response = serde_json::json!({ "action": "hook_v2_admit", "status": "accepted", - "disposition": HookTransportDispositionV1::Accepted, - "orchestration": null, + "disposition": "accepted", + "orchestration": "enqueued", + "context_scout_address": null, "ready_guidance": null, "feedback_notice": notice, - "reason": null, + "github_stack_signal_available": false, }); let admitted = daemon_admission_response(&response); @@ -243,12 +240,12 @@ fn github_stack_wakeup_is_content_free() { let response = serde_json::json!({ "action": "hook_v2_admit", "status": "accepted", - "disposition": HookTransportDispositionV1::Accepted, - "orchestration": null, + "disposition": "accepted", + "orchestration": "enqueued", + "context_scout_address": null, "ready_guidance": null, "feedback_notice": null, "github_stack_signal_available": true, - "reason": null, }); let admitted = daemon_admission_response(&response); assert!(admitted.github_stack_signal_available); @@ -515,6 +512,7 @@ async fn delivery_receipt_withheld_when_ineligible_or_foreign_envelope() { }; let deadline = HookSynchronousDeadlineV1::after_elapsed(0); let guard = crate::hooks::TestDaemonHookActionGuard::install([serde_json::json!({ + "action": "hook_v2_delivery_receipt", "status": "stored" })]); diff --git a/crates/tracedecay-agent-hosts/src/hooks/hook_boundary_failure_matrix.rs b/crates/tracedecay-agent-hosts/src/hooks/hook_boundary_failure_matrix.rs index dc942b03bd..71c4099c8f 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/hook_boundary_failure_matrix.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/hook_boundary_failure_matrix.rs @@ -10,6 +10,7 @@ use std::path::{Path, PathBuf}; use serde_json::Value; +use tracedecay_contracts::retrieval::HookRuntimeSurfaceRequestV1; use super::analytics::{HOOK_ANALYTICS_FILENAME, record_hook_invoked}; use super::{TestDaemonHookActionGuard, daemon_hook_action}; @@ -194,7 +195,7 @@ fn matrix_daemon_unavailable_transport_does_not_invent_success() { let result = daemon_hook_action( &crate::ports::hook_runtime::crate_test_runtime(profile.clone()), Some(&project_root), - serde_json::json!({ "action": "reset_counter" }), + HookRuntimeSurfaceRequestV1::ResetCounter {}, Some(&span), ) .await; diff --git a/crates/tracedecay-agent-hosts/src/hooks/mod.rs b/crates/tracedecay-agent-hosts/src/hooks/mod.rs index 8bdb8e44df..eea8786153 100644 --- a/crates/tracedecay-agent-hosts/src/hooks/mod.rs +++ b/crates/tracedecay-agent-hosts/src/hooks/mod.rs @@ -9,6 +9,7 @@ use std::path::{Component, Path, PathBuf}; use std::time::{Duration, Instant}; use serde_json::Value; +use tracedecay_contracts::retrieval::{HookIngestTranscriptRequestV1, HookRuntimeSurfaceRequestV1}; use tracedecay_hooks::DaemonHookEvent; use crate::ports::hook_runtime::HookRuntimeV1; @@ -533,9 +534,10 @@ async fn native_event_project_root(runtime: &HookRuntimeV1, event: &str) -> Opti pub(crate) async fn daemon_hook_action( runtime: &HookRuntimeV1, project_root: Option<&Path>, - mut arguments: Value, + request: HookRuntimeSurfaceRequestV1, telemetry: Option<&analytics::HookTimingSpan>, ) -> tracedecay_domain::errors::Result { + let mut arguments = serde_json::to_value(request)?; arguments["format"] = serde_json::json!("json"); let payload_bytes = analytics::measure_json_payload_bytes(&arguments); #[cfg(test)] @@ -577,11 +579,13 @@ pub(crate) async fn ingest_user_session( match daemon_hook_action( runtime, None, - serde_json::json!({ - "action": "ingest_transcript", - "provider": provider.to_lowercase(), - "user_scope": true, - "session_id": session_id, + HookRuntimeSurfaceRequestV1::IngestTranscript(HookIngestTranscriptRequestV1 { + provider: provider.to_lowercase(), + user_scope: true, + session_id, + event_json: None, + messages: None, + max_new_bytes: None, }), telemetry, ) @@ -686,16 +690,14 @@ pub(crate) async fn ingest_transcript_for_event( budget: Duration, telemetry: Option<&analytics::HookTimingSpan>, ) -> TranscriptIngestOutcome { - let mut args = serde_json::json!({ - "action": "ingest_transcript", - "provider": provider, - "user_scope": project_root.is_none(), - "event_json": event_json, + let args = HookRuntimeSurfaceRequestV1::IngestTranscript(HookIngestTranscriptRequestV1 { + provider: provider.to_owned(), + user_scope: project_root.is_none(), + session_id: None, + event_json: Some(event_json.to_owned()), + messages: None, + max_new_bytes, }); - if let Some(max_new_bytes) = max_new_bytes { - args["max_new_bytes"] = serde_json::json!(max_new_bytes); - } - args["timeout_budget_ms"] = serde_json::json!(budget.as_millis() as u64); match await_within_stop_budget( async { match daemon_hook_action(runtime, project_root, args, telemetry).await { @@ -729,7 +731,7 @@ pub(crate) async fn reset_counter_for_project( if let Err(error) = daemon_hook_action( runtime, Some(project_root), - serde_json::json!({ "action": "reset_counter" }), + HookRuntimeSurfaceRequestV1::ResetCounter {}, telemetry, ) .await @@ -750,25 +752,6 @@ pub fn additional_context_json(event_name: &str, additional_context: &str) -> St .to_string() } -pub(crate) fn compact_daemon_args( - action: &str, - provider: &str, - user_scope: bool, - event_json: &str, - session_id: Option<&str>, -) -> Value { - let mut args = serde_json::json!({ - "action": action, - "provider": provider, - "user_scope": user_scope, - "event_json": event_json, - }); - if let Some(session_id) = session_id { - args["session_id"] = serde_json::json!(session_id); - } - args -} - #[hotpath::measure(future = true, label = "hosts.hooks.notify_event")] pub(crate) async fn notify_hook_event_with_telemetry( runtime: &HookRuntimeV1, @@ -841,14 +824,18 @@ pub async fn hook_hermes_terminal_receipt(runtime: &HookRuntimeV1) -> i32 { { if let Some(project_root) = project_root.as_ref() { notify_hook_event_with_telemetry(runtime, project_root, event, &hook_telemetry).await; - } else if let Err(error) = daemon_hook_action( - runtime, - None, - serde_json::json!({ "action": "hermes_receipt", "event": event }), - Some(&hook_telemetry), - ) - .await - { + } else if let Err(error) = match serde_json::to_value(&event) { + Ok(event) => { + daemon_hook_action( + runtime, + None, + HookRuntimeSurfaceRequestV1::HermesReceipt { event }, + Some(&hook_telemetry), + ) + .await + } + Err(error) => Err(error.into()), + } { tracing::warn!(%error, "user Hermes receipt daemon call failed"); } } @@ -878,11 +865,10 @@ pub async fn schedule_user_session_review( let hint = daemon_hook_action( runtime, None, - serde_json::json!({ - "action": "user_review", - "provider": provider, - "session_id": session_id, - }), + HookRuntimeSurfaceRequestV1::UserReview { + provider: provider.to_owned(), + session_id: session_id.map(str::to_owned), + }, None, ); let _ = tokio::time::timeout(std::time::Duration::from_millis(25), hint).await; diff --git a/crates/tracedecay-api/src/http/application_operation_owner.rs b/crates/tracedecay-api/src/http/application_operation_owner.rs index 883b20d0d9..10ce836213 100644 --- a/crates/tracedecay-api/src/http/application_operation_owner.rs +++ b/crates/tracedecay-api/src/http/application_operation_owner.rs @@ -167,7 +167,8 @@ pub const fn http_application_owner_kind( | ApplicationSurfaceOperation::ProjectList | ApplicationSurfaceOperation::ProjectSearch | ApplicationSurfaceOperation::ProjectContext - | ApplicationSurfaceOperation::AdminSync => return None, + | ApplicationSurfaceOperation::AdminSync + | ApplicationSurfaceOperation::HookRuntime => return None, ApplicationSurfaceOperation::FactStoreCurate | ApplicationSurfaceOperation::FactStoreAdd | ApplicationSurfaceOperation::FactStoreSearch diff --git a/crates/tracedecay-cli/src/tool_command.rs b/crates/tracedecay-cli/src/tool_command.rs index e1af057135..7d65020918 100644 --- a/crates/tracedecay-cli/src/tool_command.rs +++ b/crates/tracedecay-cli/src/tool_command.rs @@ -70,8 +70,8 @@ use tracedecay_mcp::tools::response_trailers::{ TOKEN_ACCOUNTING_FOOTER_PREFIX, account_tool_result, }; use tracedecay_mcp::{ - RESERVED_FLAGS_FOOTER, ToolDefinition, get_tool_definitions, internal_daemon_tool_definition, - render_tool_cli_help, short_tool_name, + RESERVED_FLAGS_FOOTER, ToolDefinition, get_tool_definitions, render_tool_cli_help, + short_tool_name, }; use tracedecay_tool_catalog::ApplicationSurfaceOperation; @@ -295,11 +295,9 @@ fn run_inner( Some(operation) => operation.mcp_tool_name(), None => canonical.as_str(), }; - let internal_def = internal_daemon_tool_definition(advertised_name); let Some(def) = defs .iter() .find(|definition| definition.name == advertised_name) - .or(internal_def.as_ref()) else { let suggestion = nearest_tool_name(&canonical, &defs) .map(|name| format!(" Did you mean '{name}'?")) diff --git a/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs b/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs index 5086d2eb33..351734c457 100644 --- a/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs +++ b/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs @@ -2423,7 +2423,7 @@ fn user_scoped_transcript_ingest_handshakes_projectless_from_filesystem_root_cwd "action": "ingest_transcript", "provider": "hermes", "session_id": "stock-check-session", - "storage_scope": "user", + "user_scope": true, "messages": [ {"role": "user", "content": "hello", "id": "m1"}, {"role": "assistant", "content": "hi there", "id": "m2"} @@ -2523,6 +2523,7 @@ fn hermes_read_only_preflight_keeps_project_lcm_grep_available() { "action": "ingest_transcript", "provider": "hermes", "session_id": "stock-check-session", + "user_scope": false, "messages": [ { "role": "user", diff --git a/crates/tracedecay-contracts/src/graph_tool.rs b/crates/tracedecay-contracts/src/graph_tool.rs index 8683491dd4..eb6a0bf92c 100644 --- a/crates/tracedecay-contracts/src/graph_tool.rs +++ b/crates/tracedecay-contracts/src/graph_tool.rs @@ -8,8 +8,8 @@ use serde::{Deserialize, Serialize}; use crate::InvocationAnalyticsV1; use crate::remote::status::RemoteOperationalStatusReadV1; use crate::retrieval::{ - ActiveProjectResultV1, ProjectContextResultV1, ProjectRegistryListingResultV1, RuntimeResultV1, - StatusResultV1, + ActiveProjectResultV1, HookRuntimeResultV1, ProjectContextResultV1, + ProjectRegistryListingResultV1, RuntimeResultV1, StatusResultV1, }; use crate::retrieval::{ AdminSyncResultV1, AffectedResultV1, AnalyticsResultV1, AstGrepSearchResultV1, @@ -99,6 +99,7 @@ pub enum GraphToolResultV1 { ProjectSearch(ProjectRegistryListingResultV1), ProjectContext(ProjectContextResultV1), AdminSync(AdminSyncResultV1), + HookRuntime(HookRuntimeResultV1), } impl GraphToolResultV1 { @@ -178,6 +179,7 @@ impl GraphToolResultV1 { Operation::ProjectSearch => Self::ProjectSearch(serde_json::from_value(value)?), Operation::ProjectContext => Self::ProjectContext(serde_json::from_value(value)?), Operation::AdminSync => Self::AdminSync(serde_json::from_value(value)?), + Operation::HookRuntime => Self::HookRuntime(serde_json::from_value(value)?), operation => { return Err(serde::de::Error::custom(format!( "{} is not a graph-tool operation", @@ -256,6 +258,7 @@ impl GraphToolResultV1 { Self::ProjectList(result) | Self::ProjectSearch(result) => serde_json::to_value(result), Self::ProjectContext(result) => serde_json::to_value(result), Self::AdminSync(result) => serde_json::to_value(result), + Self::HookRuntime(result) => serde_json::to_value(result), } } } diff --git a/crates/tracedecay-contracts/src/hook_orchestration.rs b/crates/tracedecay-contracts/src/hook_orchestration.rs index e2874bdd33..76e074a5d3 100644 --- a/crates/tracedecay-contracts/src/hook_orchestration.rs +++ b/crates/tracedecay-contracts/src/hook_orchestration.rs @@ -1,7 +1,8 @@ -use serde::Serialize; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; /// Outcome of admitting one hook envelope into the registered orchestrator. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[serde(rename_all = "snake_case")] pub enum HookOrchestrationAdmissionV1 { Enqueued, diff --git a/crates/tracedecay-contracts/src/policy.rs b/crates/tracedecay-contracts/src/policy.rs index dd1dcc9291..59d8ae78a5 100644 --- a/crates/tracedecay-contracts/src/policy.rs +++ b/crates/tracedecay-contracts/src/policy.rs @@ -541,7 +541,8 @@ fn route_effect(effect: EffectClass) -> Result Err(ApplicationContractError::Inconsistent { + | EffectClass::SchedulesWork + | EffectClass::RecordsHostEvidence => Err(ApplicationContractError::Inconsistent { field: "capability routing effect class", }), } diff --git a/crates/tracedecay-contracts/src/retrieval/catalog.rs b/crates/tracedecay-contracts/src/retrieval/catalog.rs index b2dc79edc4..093729099f 100644 --- a/crates/tracedecay-contracts/src/retrieval/catalog.rs +++ b/crates/tracedecay-contracts/src/retrieval/catalog.rs @@ -1,3 +1,4 @@ +use crate::retrieval::hook_runtime_surface::{HookRuntimeResultV1, HookRuntimeSurfaceRequestV1}; use crate::retrieval::owner_effect_surface::{ AdminSyncResultV1, AdminSyncSurfaceRequestV1, DashboardResultV1, DashboardSurfaceRequestV1, RunAffectedTestsResultV1, RunAffectedTestsSurfaceRequestV1, @@ -279,6 +280,7 @@ const PRIMITIVE_READ_SPECS: &[PrimitiveReadSpec] = &[ graph_report_spec("project_search"), graph_report_spec("project_context"), owner_side_effect_spec(ApplicationSurfaceOperation::AdminSync), + owner_side_effect_spec(ApplicationSurfaceOperation::HookRuntime), git_context_spec("affected"), git_context_spec("diff_context"), git_context_spec("changelog"), @@ -386,7 +388,8 @@ fn primitive_read_surfaces(spec: &PrimitiveReadSpec) -> &'static [BindingSurface | "project_list" | "project_search" | "project_context" - | "admin_sync" => &CLI_MCP_PRIMITIVE_SURFACES, + | "admin_sync" + | "hook_runtime" => &CLI_MCP_PRIMITIVE_SURFACES, "health_read" | "storage_status" | "diagnostics_read" => &DASHBOARD_PRIMITIVE_SURFACES, _ => &PRE_DASHBOARD_PRIMITIVE_SURFACES, } @@ -636,6 +639,9 @@ fn primitive_read_description(operation: &str) -> &'static str { "admin_sync" => { "Queue the operator's code-index reconcile of the served project and report the scheduler's admission." } + "hook_runtime" => { + "Record one agent-host hook's session evidence (a transcript, a hook admission, or a receipt) in the daemon-owned session stores." + } _ => "Read bounded data from the admitted project's current retained state.", } } @@ -1195,6 +1201,11 @@ fn primitive_executable_schemas( ProjectContextResultV1 ); add!("admin_sync", AdminSyncSurfaceRequestV1, AdminSyncResultV1); + add!( + "hook_runtime", + HookRuntimeSurfaceRequestV1, + HookRuntimeResultV1 + ); Ok(schemas) } diff --git a/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs new file mode 100644 index 0000000000..baa718cbce --- /dev/null +++ b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs @@ -0,0 +1,298 @@ +//! Canonical CLI/MCP wire contract of `tracedecay_hook_runtime`, the internal +//! operation agent-host hooks call to record session evidence in the daemon. +//! +//! Each action is exactly what a shipped host sends. Host-native payloads +//! (hook envelopes, receipts, events, transcript messages) stay JSON here and +//! are decoded by the hook domain types that own them. Presentation-only +//! transport keys such as `format` are removed before these request bodies +//! are decoded. + +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +use crate::HookOrchestrationAdmissionV1; +use crate::context_scout::ContextScoutAddressV1; + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)] +pub enum HookRuntimeSurfaceRequestV1 { + /// Reset the project's local token counter. + ResetCounter {}, + /// Admit one Hook V2 envelope for the bound project. + HookV2Admit(HookV2AdmitRequestV1), + /// Commit a Context Scout delivery receipt for guidance the last + /// admission handed out. + HookV2DeliveryReceipt { receipt: Value }, + /// Acknowledge delivery of an advisory feedback notice. + HookV2FeedbackNoticeDelivery { + envelope: Value, + feedback_notice: Value, + }, + /// Record an `OpenCode` `lsp.updated` event. + OpencodeLspUpdated { event: Value }, + /// Land a host transcript in the owning session store. + IngestTranscript(HookIngestTranscriptRequestV1), + /// Codex `PostCompact` pressure evidence. + CodexCompact { event_json: String }, + /// Claude `PostCompact` pressure evidence; `user_scope` routes it to the + /// profile. + ClaudeCompact { + event_json: String, + user_scope: bool, + }, + /// Cursor `preCompact` pressure evidence. + CursorCompact { event_json: String }, + /// Review a finished user session. + UserReview { + provider: String, + session_id: Option, + }, + /// Record a Hermes terminal receipt without a project route. + HermesReceipt { event: Value }, + /// Admit a native event without a project route into the profile's + /// Hook V2 ledger. + HookV2ProfileAdmit { admission: Value }, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct HookV2AdmitRequestV1 { + pub envelope: Value, + /// The host's native session id; it binds only when it hashes to the + /// envelope's protected session. + pub native_session_id: Option, + pub native_lifecycle: Option, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct HookIngestTranscriptRequestV1 { + pub provider: String, + /// Land the transcript in the profile's user store instead of the + /// project's. + pub user_scope: bool, + pub session_id: Option, + /// The host's raw hook event, for providers that locate the transcript + /// from it. + pub event_json: Option, + /// One turn the host inlined instead of a source to scan. + pub messages: Option>, + /// Byte budget for this pass across every scanned source. + pub max_new_bytes: Option, +} + +/// How the hook transport should treat a Hook V2 envelope. +#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum HookRuntimeDispositionV1 { + Accepted, + /// The published binding no longer authorizes the envelope; the host + /// must catch up before sending again. + CatchupRequired, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)] +pub enum HookRuntimeResultV1 { + ResetCounter { reset: bool }, + HookV2Admit(HookV2AdmissionResultV1), + HookV2DeliveryReceipt { status: ContextScoutStoreStatusV1 }, + HookV2FeedbackNoticeDelivery(HookV2NoticeDeliveryResultV1), + OpencodeLspUpdated { status: HookRuntimeAcceptedV1 }, + IngestTranscript(Box), + CodexCompact(HookCompactionResultV1), + ClaudeCompact(HookCompactionResultV1), + CursorCompact(HookCompactionResultV1), + HermesReceipt { status: HermesReceiptStatusV1 }, + HookV2ProfileAdmit(HookV2ProfileAdmissionResultV1), +} + +#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum HookRuntimeAcceptedV1 { + Accepted, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(tag = "status", rename_all = "snake_case", deny_unknown_fields)] +pub enum HookV2AdmissionResultV1 { + Accepted { + disposition: HookRuntimeDispositionV1, + orchestration: HookOrchestrationAdmissionV1, + context_scout_address: Option, + /// The hook's `HookReadyGuidanceV1`, when admission claimed one. + ready_guidance: Option, + /// The advisory `AdvisoryHookLookupNoticeV1` waiting for this + /// worktree. + feedback_notice: Option, + github_stack_signal_available: bool, + }, + /// This exact envelope was already admitted; a retry may still receive + /// guidance retained before a lost host response. + ExactDuplicate { + disposition: HookRuntimeDispositionV1, + context_scout_address: Option, + ready_guidance: Option, + }, + Rejected { + disposition: HookRuntimeDispositionV1, + #[serde(default, skip_serializing_if = "Option::is_none")] + reason: Option, + }, + /// Idempotency could not be recorded, so nothing was admitted. + Backpressured {}, + Unavailable {}, +} + +#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum HookV2RejectionReasonV1 { + /// The same event identity previously carried different bytes. + AdmissionIdentityConflict, +} + +#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum ContextScoutStoreStatusV1 { + Stored, + Duplicate, + Superseded, + Unavailable, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(tag = "status", rename_all = "snake_case", deny_unknown_fields)] +pub enum HookV2NoticeDeliveryResultV1 { + Stored {}, + Unavailable {}, + Rejected { + disposition: HookRuntimeDispositionV1, + }, +} + +/// The admission authority's verdict on one transcript ingest. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct HookIngestAdmissionV1 { + /// The session host-admission status, in its wire spelling. + pub status: String, + pub retryable: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub reason_code: Option, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct HookIngestTranscriptResultV1 { + pub provider: String, + pub user_scope: bool, + /// False when the byte budget left work for a later pass. + pub completed: bool, + pub status: String, + pub admission: HookIngestAdmissionV1, + pub messages_upserted: u64, + /// How emitted hook hints settled against the new project activity. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub hint_outcomes: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub observations_committed: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub bytes_consumed: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub deferred_by_byte_cap: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub observation_duplicates: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub cursor_advances: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub cursor_duplicates: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub records_rejected: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub records_quarantined: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub projections_completed: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub projections_skipped: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub projection_duplicates: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub deferred_sources: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_bytes_scanned: Option, +} + +/// A compaction hook's outcome. Variants are distinguished by the fields +/// they carry. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(untagged, deny_unknown_fields)] +pub enum HookCompactionResultV1 { + /// The LCM authority settled the compaction. + Settled { + status: String, + reason: String, + summary_nodes_created: u64, + summary_node_ids: Vec, + relation_projection_status: Value, + retry_status: Option, + authority_outcome: Value, + committed_state: Value, + messages_upserted: u64, + }, + /// The LCM authority answered without a compaction. + Refused { + status: String, + reason: String, + authority_outcome: Value, + committed_state: Value, + summary_nodes_created: u64, + summary_node_ids: Vec, + messages_upserted: u64, + }, + /// No compaction ran: the authority is absent, the host supplied nothing + /// to compact, or its summaries have no provenance. + NotRun { + status: String, + reason: String, + summary_nodes_created: u64, + summary_node_ids: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + relation_projection_status: Option, + }, + /// The host event named no session to compact. + NoSession { + status: String, + reason: String, + messages_upserted: u64, + }, +} + +#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum HermesReceiptStatusV1 { + /// A terminal receipt was recorded. + Recorded, + /// The turn was marked ingested and no receipt awaits review. + Ingested, + /// A receipt awaits a transcript that has not landed yet. + AwaitingTranscript, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] +#[serde(tag = "status", rename_all = "snake_case", deny_unknown_fields)] +pub enum HookV2ProfileAdmissionResultV1 { + Accepted { + disposition: HookRuntimeDispositionV1, + }, + ExactDuplicate { + disposition: HookRuntimeDispositionV1, + }, + Rejected { + disposition: HookRuntimeDispositionV1, + }, + Unavailable {}, +} + +#[cfg(test)] +mod tests; diff --git a/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs new file mode 100644 index 0000000000..6e0bb161d1 --- /dev/null +++ b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs @@ -0,0 +1,167 @@ +use serde_json::{Value, json}; + +use super::{HookCompactionResultV1, HookRuntimeResultV1, HookRuntimeSurfaceRequestV1}; + +fn result_round_trips(wire: Value) -> HookRuntimeResultV1 { + let decoded: HookRuntimeResultV1 = serde_json::from_value(wire.clone()) + .unwrap_or_else(|error| panic!("{wire} does not decode: {error}")); + assert_eq!(serde_json::to_value(&decoded).unwrap(), wire); + decoded +} + +#[test] +fn every_emitted_result_shape_round_trips_exactly() { + for wire in [ + json!({"action": "reset_counter", "reset": true}), + json!({ + "action": "hook_v2_admit", + "status": "accepted", + "disposition": "accepted", + "orchestration": "enqueued", + "context_scout_address": null, + "ready_guidance": null, + "feedback_notice": null, + "github_stack_signal_available": false, + }), + json!({ + "action": "hook_v2_admit", + "status": "exact_duplicate", + "disposition": "accepted", + "context_scout_address": null, + "ready_guidance": null, + }), + json!({ + "action": "hook_v2_admit", + "status": "rejected", + "disposition": "catchup_required", + "reason": "admission_identity_conflict", + }), + json!({"action": "hook_v2_admit", "status": "rejected", "disposition": "catchup_required"}), + json!({"action": "hook_v2_admit", "status": "backpressured"}), + json!({"action": "hook_v2_delivery_receipt", "status": "superseded"}), + json!({"action": "hook_v2_feedback_notice_delivery", "status": "stored"}), + json!({ + "action": "hook_v2_feedback_notice_delivery", + "status": "rejected", + "disposition": "catchup_required", + }), + json!({"action": "opencode_lsp_updated", "status": "accepted"}), + json!({ + "action": "ingest_transcript", + "provider": "cursor", + "user_scope": false, + "completed": true, + "status": "committed", + "admission": {"status": "committed", "retryable": false}, + "messages_upserted": 2, + "hint_outcomes": {"status": "unavailable", "reason": "profile_root_unavailable"}, + "observations_committed": 2, + }), + json!({"action": "hermes_receipt", "status": "awaiting_transcript"}), + json!({"action": "hook_v2_profile_admit", "status": "exact_duplicate", "disposition": "accepted"}), + json!({"action": "hook_v2_profile_admit", "status": "unavailable"}), + ] { + result_round_trips(wire); + } +} + +#[test] +fn each_compaction_outcome_decodes_to_the_variant_that_carries_its_fields() { + let settled = json!({ + "action": "codex_compact", + "status": "compressed", + "reason": "pressure", + "summary_nodes_created": 1, + "summary_node_ids": ["node-1"], + "relation_projection_status": "projected", + "retry_status": null, + "authority_outcome": "ready", + "committed_state": null, + "messages_upserted": 3, + }); + let refused = json!({ + "action": "cursor_compact", + "status": "unavailable", + "reason": "lcm_daemon_authority_rejected", + "authority_outcome": "denied", + "committed_state": null, + "summary_nodes_created": 0, + "summary_node_ids": [], + "messages_upserted": 0, + }); + let skipped = json!({ + "action": "cursor_compact", + "status": "skipped", + "reason": "no messages to compact", + "summary_nodes_created": 0, + "summary_node_ids": [], + "relation_projection_status": "not_applicable", + }); + let no_session = json!({ + "action": "codex_compact", + "status": "unavailable", + "reason": "host_session_identity_unavailable", + "messages_upserted": 0, + }); + + assert!(matches!( + result_round_trips(settled), + HookRuntimeResultV1::CodexCompact(HookCompactionResultV1::Settled { .. }) + )); + assert!(matches!( + result_round_trips(refused), + HookRuntimeResultV1::CursorCompact(HookCompactionResultV1::Refused { .. }) + )); + assert!(matches!( + result_round_trips(skipped), + HookRuntimeResultV1::CursorCompact(HookCompactionResultV1::NotRun { .. }) + )); + assert!(matches!( + result_round_trips(no_session), + HookRuntimeResultV1::CodexCompact(HookCompactionResultV1::NoSession { .. }) + )); +} + +fn request_error(wire: Value) -> String { + serde_json::from_value::(wire) + .expect_err("request must be refused") + .to_string() +} + +#[test] +fn requests_accept_what_hosts_send_and_refuse_anything_else() { + let admit = json!({ + "action": "hook_v2_admit", + "envelope": {"schema_version": 2}, + "native_session_id": null, + "native_lifecycle": null, + }); + let decoded: HookRuntimeSurfaceRequestV1 = serde_json::from_value(admit.clone()).unwrap(); + assert_eq!(serde_json::to_value(decoded).unwrap(), admit); + let reset: HookRuntimeSurfaceRequestV1 = + serde_json::from_value(json!({"action": "reset_counter"})).unwrap(); + assert_eq!(reset, HookRuntimeSurfaceRequestV1::ResetCounter {}); + + assert_eq!( + request_error(json!({"action": "reset_counter", "project_root": "/elsewhere"})), + "unknown field `project_root`, there are no fields" + ); + assert!( + request_error(json!({ + "action": "ingest_transcript", + "provider": "cursor", + "user_scope": false, + "event_json": "{}", + "timeout_budget_ms": 250, + })) + .starts_with("unknown field `timeout_budget_ms`"), + ); + assert!( + request_error(json!({"action": "codex_compact", "event_json": "{}", "provider": "codex"})) + .starts_with("unknown field `provider`"), + ); + assert!( + request_error(json!({"action": "hook_v2_status", "control": {}})) + .contains("unknown variant `hook_v2_status`") + ); +} diff --git a/crates/tracedecay-contracts/src/retrieval/mod.rs b/crates/tracedecay-contracts/src/retrieval/mod.rs index 5c4d173aed..f5822bdef8 100644 --- a/crates/tracedecay-contracts/src/retrieval/mod.rs +++ b/crates/tracedecay-contracts/src/retrieval/mod.rs @@ -10,6 +10,7 @@ mod git_topology_anchor; mod graph_lookup_surface; mod graph_report_surface; pub mod grep_analysis; +mod hook_runtime_surface; mod owner_effect_surface; mod ports; mod primitive_surface; @@ -177,6 +178,13 @@ pub use graph_report_surface::{ TestRiskResultV1, TestRiskSummaryV1, TestRiskSurfaceRequestV1, }; pub use grep_analysis::{DependencyDepthChainV1, DependencyDepthResultV1}; +pub use hook_runtime_surface::{ + ContextScoutStoreStatusV1, HermesReceiptStatusV1, HookCompactionResultV1, + HookIngestAdmissionV1, HookIngestTranscriptRequestV1, HookIngestTranscriptResultV1, + HookRuntimeAcceptedV1, HookRuntimeDispositionV1, HookRuntimeResultV1, + HookRuntimeSurfaceRequestV1, HookV2AdmissionResultV1, HookV2AdmitRequestV1, + HookV2NoticeDeliveryResultV1, HookV2ProfileAdmissionResultV1, HookV2RejectionReasonV1, +}; pub use owner_effect_surface::{ AdminSyncAdmissionV1, AdminSyncReconcileScopeV1, AdminSyncResultV1, AdminSyncSurfaceRequestV1, AffectedTestErrorV1, AffectedTestOutcomeV1, AffectedTestRunV1, AffectedTestsNotRunV1, diff --git a/crates/tracedecay-contracts/src/sdk_catalog.rs b/crates/tracedecay-contracts/src/sdk_catalog.rs index d99cf2a4f4..c78e7ee627 100644 --- a/crates/tracedecay-contracts/src/sdk_catalog.rs +++ b/crates/tracedecay-contracts/src/sdk_catalog.rs @@ -175,7 +175,8 @@ pub fn application_http_route_path(operation: ApplicationSurfaceOperation) -> St | ApplicationSurfaceOperation::ProjectList | ApplicationSurfaceOperation::ProjectSearch | ApplicationSurfaceOperation::ProjectContext - | ApplicationSurfaceOperation::AdminSync) => { + | ApplicationSurfaceOperation::AdminSync + | ApplicationSurfaceOperation::HookRuntime) => { format!("/primitives/{}", operation.as_str()) } operation @ (ApplicationSurfaceOperation::ConfigurationList diff --git a/crates/tracedecay-daemon-protocol/src/application_surface.rs b/crates/tracedecay-daemon-protocol/src/application_surface.rs index c754f3b8fc..244cb2c2a4 100644 --- a/crates/tracedecay-daemon-protocol/src/application_surface.rs +++ b/crates/tracedecay-daemon-protocol/src/application_surface.rs @@ -951,7 +951,8 @@ pub fn parse_application_surface_request( | ApplicationSurfaceOperation::ProjectList | ApplicationSurfaceOperation::ProjectSearch | ApplicationSurfaceOperation::ProjectContext - | ApplicationSurfaceOperation::AdminSync => match value { + | ApplicationSurfaceOperation::AdminSync + | ApplicationSurfaceOperation::HookRuntime => match value { Value::Object(arguments) => Ok(ApplicationSurfaceRequest::GraphTool(arguments)), _ => Err(ApplicationSurfaceAdapterError::invalid_request(format!( "invalid arguments: {} expects a JSON object", diff --git a/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs b/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs index 5c17563014..e10e77006f 100644 --- a/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs +++ b/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs @@ -928,6 +928,7 @@ pub fn application_surface_feedback_operation( | ApplicationSurfaceOperation::ProjectSearch | ApplicationSurfaceOperation::ProjectContext | ApplicationSurfaceOperation::AdminSync + | ApplicationSurfaceOperation::HookRuntime | ApplicationSurfaceOperation::HealthRead | ApplicationSurfaceOperation::HealthDelta | ApplicationSurfaceOperation::StorageStatus diff --git a/crates/tracedecay-daemon-protocol/src/contract/mod.rs b/crates/tracedecay-daemon-protocol/src/contract/mod.rs index 4954c677c0..eacde65a19 100644 --- a/crates/tracedecay-daemon-protocol/src/contract/mod.rs +++ b/crates/tracedecay-daemon-protocol/src/contract/mod.rs @@ -1084,7 +1084,8 @@ impl DaemonInvocationRequest { | ApplicationSurfaceOperation::ProjectList | ApplicationSurfaceOperation::ProjectSearch | ApplicationSurfaceOperation::ProjectContext - | ApplicationSurfaceOperation::AdminSync => { + | ApplicationSurfaceOperation::AdminSync + | ApplicationSurfaceOperation::HookRuntime => { unreachable!("graph-tool operations use their typed constructor") } ApplicationSurfaceOperation::FactStoreCurate diff --git a/crates/tracedecay-mcp-catalog/src/definitions.rs b/crates/tracedecay-mcp-catalog/src/definitions.rs index e7c7dbfaca..c07f79e577 100644 --- a/crates/tracedecay-mcp-catalog/src/definitions.rs +++ b/crates/tracedecay-mcp-catalog/src/definitions.rs @@ -517,21 +517,6 @@ pub fn retain_host_available_tool_definitions(definitions: &mut Vec Option { - match name { - "tracedecay_hook_runtime" => Some(def_rw( - "tracedecay_hook_runtime", - "Internal Host Ingest", - "Forward one exact host-ingest envelope to the daemon. The handler validates the action-specific payload.", - json!({ "type": "object" }), - )), - _ => None, - } -} - fn add_lcm_storage_scope_property(definitions: &mut [ToolDefinition]) { for definition in definitions.iter_mut().filter(|definition| { definition.name.starts_with("tracedecay_lcm_") diff --git a/crates/tracedecay-mcp-catalog/src/definitions/tests.rs b/crates/tracedecay-mcp-catalog/src/definitions/tests.rs index 2150194569..6ec9aeb5b1 100644 --- a/crates/tracedecay-mcp-catalog/src/definitions/tests.rs +++ b/crates/tracedecay-mcp-catalog/src/definitions/tests.rs @@ -39,21 +39,6 @@ fn work_and_workflow_advertise_every_executable_request_schema() { } } -#[test] -fn internal_host_ingest_is_cli_resolvable_but_not_advertised() { - assert!( - get_tool_definitions() - .expect("tool definitions") - .iter() - .all(|definition| definition.name != "tracedecay_hook_runtime") - ); - let definition = internal_daemon_tool_definition("tracedecay_hook_runtime") - .expect("internal host-ingest definition"); - assert_eq!(definition.name, "tracedecay_hook_runtime"); - assert_eq!(definition.input_schema, json!({ "type": "object" })); - assert!(internal_daemon_tool_definition("tracedecay_unknown").is_none()); -} - #[test] fn stack_snapshot_requires_an_exact_selection_binding() { let definition = get_tool_definitions() diff --git a/crates/tracedecay-mcp-catalog/src/lib.rs b/crates/tracedecay-mcp-catalog/src/lib.rs index d30e43d868..a7e882e77d 100644 --- a/crates/tracedecay-mcp-catalog/src/lib.rs +++ b/crates/tracedecay-mcp-catalog/src/lib.rs @@ -39,9 +39,9 @@ pub use definitions::{ ToolRegistryMode, apply_context_warming_budget, context_description, context_warming_description, explore_call_budget, format_capable_tool_names, get_maximal_tool_definitions, get_maximal_tool_definitions_with_budget, get_tool_definitions, - get_tool_definitions_with_budget, get_tool_definitions_with_warming_budget, - internal_daemon_tool_definition, mcp_input_schema, project_catalog_discovery_scope, - retain_host_available_tool_definitions, tool_defaults_to_markdown, + get_tool_definitions_with_budget, get_tool_definitions_with_warming_budget, mcp_input_schema, + project_catalog_discovery_scope, retain_host_available_tool_definitions, + tool_defaults_to_markdown, }; pub use project_access::registered_project_reader_tool_names; diff --git a/crates/tracedecay-mcp/src/application_output/tool_result.rs b/crates/tracedecay-mcp/src/application_output/tool_result.rs index 8855883df4..85e0ff6b7d 100644 --- a/crates/tracedecay-mcp/src/application_output/tool_result.rs +++ b/crates/tracedecay-mcp/src/application_output/tool_result.rs @@ -41,17 +41,23 @@ impl ApplicationRefusal { /// The refusal as the error a first-party command returns: the owner's /// reason code, retryability, and typed detail or diagnostic. pub fn into_error(self) -> TraceDecayError { - let record = *self.problem.problem; - let (reason_code, message) = match record.diagnostic { - Some(diagnostic) => (diagnostic.code, diagnostic.message), - None => (record.code, record.message), - }; - match record.detail { - Some(detail) => { - TraceDecayError::project_route_with_detail(reason_code, record.retryable, detail) - } - None => TraceDecayError::project_route(reason_code, record.retryable, message), + problem_error(self.problem) + } +} + +/// An owner's refusal as the error its first-party caller returns: the +/// owner's reason code, retryability, and typed detail or diagnostic. +pub fn problem_error(problem: ApplicationProblemEnvelope) -> TraceDecayError { + let record = *problem.problem; + let (reason_code, message) = match record.diagnostic { + Some(diagnostic) => (diagnostic.code, diagnostic.message), + None => (record.code, record.message), + }; + match record.detail { + Some(detail) => { + TraceDecayError::project_route_with_detail(reason_code, record.retryable, detail) } + None => TraceDecayError::project_route(reason_code, record.retryable, message), } } diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/admission.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/admission.rs index 3baca1642d..621a28c1fc 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/admission.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/admission.rs @@ -1,4 +1,4 @@ -use serde_json::{Value, json}; +use serde_json::Value; use sha2::{Digest, Sha256}; use std::collections::BTreeMap; use std::collections::btree_map::Entry; @@ -22,6 +22,10 @@ use super::envelope::{ }; use super::required_project_db; use crate::handlers::SessionAuthorities; +use tracedecay_contracts::retrieval::{ + HookRuntimeDispositionV1, HookV2AdmissionResultV1, HookV2AdmitRequestV1, + HookV2ProfileAdmissionResultV1, HookV2RejectionReasonV1, +}; pub(super) enum HookV2BindingAdmission { Bound(tracedecay_hooks::HookConfigurationSnapshotV1), @@ -61,14 +65,6 @@ pub(super) fn hook_v2_binding_admission( classify_hook_v2_binding(envelope, subscriber.load_current(envelope.producer, now)) } -pub(super) fn hook_v2_catchup_response(action: &str) -> Value { - json!({ - "action": action, - "status": "rejected", - "disposition": tracedecay_hooks::HookTransportDispositionV1::CatchupRequired, - }) -} - /// Where the daemon keeps the durable admission idempotency ledgers. One /// ledger per (hook data root, producing host), the same daemon-owned hook /// data root that already holds the published bindings and the replay spool. @@ -746,15 +742,16 @@ async fn admit_hook_v2_envelope_with_lifecycle_inner( pub(super) async fn hook_v2_admit( cg: &TraceDecay, - args: &Value, - action: &str, + request: HookV2AdmitRequestV1, session_authorities: SessionAuthorities<'_>, -) -> Result { +) -> Result { let project_sessions = required_project_db(&session_authorities)?; - let envelope = hook_v2_envelope(args, action)?; + let envelope = hook_v2_envelope(request.envelope)?; let now = hook_now(); - let native_session_id = hook_v2_native_session_id(args, &envelope); - let native_lifecycle = hook_v2_native_context_scout_lifecycle(args, &envelope); + let native_session_id = + hook_v2_native_session_id(request.native_session_id.as_deref(), &envelope); + let native_lifecycle = + hook_v2_native_context_scout_lifecycle(request.native_lifecycle, &envelope); Ok( match admit_hook_v2_envelope_with_lifecycle( cg, @@ -776,55 +773,49 @@ pub(super) async fn hook_v2_admit( ready_guidance, feedback_notice, github_stack_signal_available, - } => json!({ - "action": action, - "status": "accepted", - "disposition": tracedecay_hooks::HookTransportDispositionV1::Accepted, - "orchestration": orchestration, - "context_scout_address": context_scout_address, - "ready_guidance": ready_guidance, - "feedback_notice": feedback_notice, - "github_stack_signal_available": github_stack_signal_available, - }), + } => HookV2AdmissionResultV1::Accepted { + disposition: HookRuntimeDispositionV1::Accepted, + orchestration, + context_scout_address: context_scout_address.map(|address| *address), + ready_guidance: present(ready_guidance), + feedback_notice: present(feedback_notice), + github_stack_signal_available, + }, HookV2AdmissionOutcomeV1::ExactDuplicate { context_scout_address, ready_guidance, - } => json!({ - "action": action, - "status": "exact_duplicate", - "disposition": tracedecay_hooks::HookTransportDispositionV1::Accepted, - "context_scout_address": context_scout_address, - "ready_guidance": ready_guidance, - }), - HookV2AdmissionOutcomeV1::Conflict => json!({ - "action": action, - "status": "rejected", - "disposition": tracedecay_hooks::HookTransportDispositionV1::CatchupRequired, - "reason": "admission_identity_conflict", - }), - HookV2AdmissionOutcomeV1::CatchupRequired => hook_v2_catchup_response(action), - HookV2AdmissionOutcomeV1::Backpressured => json!({ - "action": action, - "status": "backpressured", - }), - HookV2AdmissionOutcomeV1::Unavailable => json!({ - "action": action, - "status": "unavailable", - }), + } => HookV2AdmissionResultV1::ExactDuplicate { + disposition: HookRuntimeDispositionV1::Accepted, + context_scout_address: context_scout_address.map(|address| *address), + ready_guidance: present(ready_guidance), + }, + HookV2AdmissionOutcomeV1::Conflict => HookV2AdmissionResultV1::Rejected { + disposition: HookRuntimeDispositionV1::CatchupRequired, + reason: Some(HookV2RejectionReasonV1::AdmissionIdentityConflict), + }, + HookV2AdmissionOutcomeV1::CatchupRequired => HookV2AdmissionResultV1::Rejected { + disposition: HookRuntimeDispositionV1::CatchupRequired, + reason: None, + }, + HookV2AdmissionOutcomeV1::Backpressured => HookV2AdmissionResultV1::Backpressured {}, + HookV2AdmissionOutcomeV1::Unavailable => HookV2AdmissionResultV1::Unavailable {}, }, ) } +fn present(value: Value) -> Option { + (!value.is_null()).then_some(value) +} + /// Admits a native event that has no project route into the authenticated /// profile's V2 ledger. The hook supplies only decoded, content-free native /// material; the daemon owns the profile scope binding and all durable writes. #[hotpath::measure(label = "mcp.hook_runtime.profile_admit")] pub(super) fn hook_v2_profile_admit( - args: &Value, - action: &str, + admission: Value, profile_root: &Path, profile_identity: &dyn tracedecay_contracts::ProfileIdentityReadPort, -) -> Result { +) -> Result { let routed_profile_root = std::fs::canonicalize(profile_root).map_err(|error| { tracedecay_automation_runtime::automation::config_error(format!( "failed to resolve authenticated Hook V2 profile route: {error}" @@ -836,21 +827,12 @@ pub(super) fn hook_v2_profile_admit( )); } let profile_root = profile_identity.profile_root(); - let admission = args - .get("admission") - .cloned() - .ok_or_else(|| { + let admission = + serde_json::from_value::(admission) + .map_err(|error| { tracedecay_automation_runtime::automation::config_error(format!( - "{action} requires admission" + "invalid profile-scoped Hook V2 admission: {error}" )) - }) - .and_then(|value| { - serde_json::from_value::(value) - .map_err(|error| { - tracedecay_automation_runtime::automation::config_error(format!( - "invalid profile-scoped Hook V2 admission: {error}" - )) - }) })?; let binding = profile_hook_v2_binding(profile_identity, admission.decoded.host); let envelope = admission.into_envelope(&binding).map_err(|error| { @@ -866,23 +848,22 @@ pub(super) fn hook_v2_profile_admit( ledger.admit(&envelope, now) }); Ok(match outcome { - Some(Ok(tracedecay_hooks::HookAdmissionDecisionV1::Admitted)) => json!({ - "action": action, - "status": "accepted", - "disposition": tracedecay_hooks::HookTransportDispositionV1::Accepted, - }), - Some(Ok(tracedecay_hooks::HookAdmissionDecisionV1::ExactDuplicate)) => json!({ - "action": action, - "status": "exact_duplicate", - "disposition": tracedecay_hooks::HookTransportDispositionV1::Accepted, - }), + Some(Ok(tracedecay_hooks::HookAdmissionDecisionV1::Admitted)) => { + HookV2ProfileAdmissionResultV1::Accepted { + disposition: HookRuntimeDispositionV1::Accepted, + } + } + Some(Ok(tracedecay_hooks::HookAdmissionDecisionV1::ExactDuplicate)) => { + HookV2ProfileAdmissionResultV1::ExactDuplicate { + disposition: HookRuntimeDispositionV1::Accepted, + } + } Some(Ok(tracedecay_hooks::HookAdmissionDecisionV1::Conflict)) => { - hook_v2_catchup_response(action) + HookV2ProfileAdmissionResultV1::Rejected { + disposition: HookRuntimeDispositionV1::CatchupRequired, + } } - None | Some(Err(_)) => json!({ - "action": action, - "status": "unavailable", - }), + None | Some(Err(_)) => HookV2ProfileAdmissionResultV1::Unavailable {}, }) } diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/admission/tests.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/admission/tests.rs index a4e158283e..46732bac87 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/admission/tests.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/admission/tests.rs @@ -257,13 +257,6 @@ fn github_stack_wakeup_is_cursor_desktop_only_and_first_admission_only() { } } -#[test] -fn hook_v2_catchup_response_propagates_transport_disposition() { - let response = hook_v2_catchup_response("hook_v2_admit"); - assert_eq!(response["status"], "rejected"); - assert_eq!(response["disposition"], "catchup_required"); -} - /// A private profile root under `dir`, as profile identity requires. fn private_profile_root(dir: &std::path::Path) -> std::path::PathBuf { let profile_root = dir.join(".tracedecay"); @@ -283,29 +276,33 @@ fn profile_scoped_native_admission_is_idempotent_in_the_authenticated_profile() br#"{"hook_event_name":"SessionStart"}"#, ) .unwrap(); - let args = serde_json::json!({ - "admission": tracedecay_hooks::ProfileScopedNativeHookAdmissionV1 { - decoded, - material: tracedecay_hooks::NativeEnvelopeMaterialV1 { - event_id: [7; 16], - protected_session_id: [8; 32], - observed_at: UtcMicros(1_000), - tool_id: None, - effect_receipt_id: None, - file_id: None, - changed_range_count: 0, - }, + let admission = serde_json::json!(tracedecay_hooks::ProfileScopedNativeHookAdmissionV1 { + decoded, + material: tracedecay_hooks::NativeEnvelopeMaterialV1 { + event_id: [7; 16], + protected_session_id: [8; 32], + observed_at: UtcMicros(1_000), + tool_id: None, + effect_receipt_id: None, + file_id: None, + changed_range_count: 0, }, }); - let first = - hook_v2_profile_admit(&args, "hook_v2_profile_admit", &profile_root, &identity).unwrap(); - let duplicate = - hook_v2_profile_admit(&args, "hook_v2_profile_admit", &profile_root, &identity).unwrap(); - assert_eq!(first["status"], "accepted"); - assert_eq!(first["disposition"], "accepted"); - assert_eq!(duplicate["status"], "exact_duplicate"); - assert_eq!(duplicate["disposition"], "accepted"); + let first = hook_v2_profile_admit(admission.clone(), &profile_root, &identity).unwrap(); + let duplicate = hook_v2_profile_admit(admission, &profile_root, &identity).unwrap(); + assert_eq!( + first, + HookV2ProfileAdmissionResultV1::Accepted { + disposition: HookRuntimeDispositionV1::Accepted, + } + ); + assert_eq!( + duplicate, + HookV2ProfileAdmissionResultV1::ExactDuplicate { + disposition: HookRuntimeDispositionV1::Accepted, + } + ); assert!( profile_root .join("hook-v2-profile-admissions") @@ -326,22 +323,20 @@ fn concurrent_profile_scoped_admissions_are_all_recorded() { let identity = tracedecay_daemon_identity::profile_identity::load_or_create(&profile_root).unwrap(); let admission = |event: u8| { - serde_json::json!({ - "admission": tracedecay_hooks::ProfileScopedNativeHookAdmissionV1 { - decoded: tracedecay_hooks::decode_native_hook_event( - tracedecay_domain::NativeHostIdentityV1::ClaudeCode, - br#"{"hook_event_name":"SessionStart"}"#, - ) - .unwrap(), - material: tracedecay_hooks::NativeEnvelopeMaterialV1 { - event_id: [event; 16], - protected_session_id: [8; 32], - observed_at: UtcMicros(1_000), - tool_id: None, - effect_receipt_id: None, - file_id: None, - changed_range_count: 0, - }, + serde_json::json!(tracedecay_hooks::ProfileScopedNativeHookAdmissionV1 { + decoded: tracedecay_hooks::decode_native_hook_event( + tracedecay_domain::NativeHostIdentityV1::ClaudeCode, + br#"{"hook_event_name":"SessionStart"}"#, + ) + .unwrap(), + material: tracedecay_hooks::NativeEnvelopeMaterialV1 { + event_id: [event; 16], + protected_session_id: [8; 32], + observed_at: UtcMicros(1_000), + tool_id: None, + effect_receipt_id: None, + file_id: None, + changed_range_count: 0, }, }) }; @@ -354,11 +349,8 @@ fn concurrent_profile_scoped_admissions_are_all_recorded() { let args = admission(event); scope.spawn(move || { barrier.wait(); - hook_v2_profile_admit( - &args, - "hook_v2_profile_admit", - profile_root, - identity, + serde_json::to_value( + hook_v2_profile_admit(args, profile_root, identity).unwrap(), ) .unwrap()["status"] .as_str() diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout.rs index 3a091a8ca9..6a8fe43b2d 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout.rs @@ -1,16 +1,14 @@ -use serde_json::{Value, json}; +use serde_json::Value; use std::collections::BTreeMap; use std::sync::{Mutex as StdMutex, OnceLock}; -use tracedecay_agent_hosts::agents::context_scout::address_registry::{ - AdmittedContextScoutHookV1, ContextScoutLifecycleAddressV1, -}; -use tracedecay_agent_hosts::agents::context_scout::{ - ContextScoutControlV1, ContextScoutDurableStoreOutcomeV1, ContextScoutErrorV1, -}; +use tracedecay_agent_hosts::agents::context_scout::ContextScoutDurableStoreOutcomeV1; +use tracedecay_agent_hosts::agents::context_scout::address_registry::ContextScoutLifecycleAddressV1; use tracedecay_automation_runtime::automation::config_error; use tracedecay_contracts::context_scout::{ - ContextScoutDeliveryReceiptV1, ContextScoutDurableClaimV1, ContextScoutFeedbackV1, - ContextScoutWorkV1, + ContextScoutDeliveryReceiptV1, ContextScoutDurableClaimV1, +}; +use tracedecay_contracts::retrieval::{ + ContextScoutStoreStatusV1, HookRuntimeDispositionV1, HookV2NoticeDeliveryResultV1, }; use tracedecay_domain::errors::Result; use tracedecay_domain::{ @@ -30,19 +28,8 @@ use tracedecay_sessions::observation::{ }; use tracedecay_store::{ObservationPersistOutcome, StoreShardScopeV1}; -use super::admission::{ - HookV2BindingAdmission, hook_v2_binding_admission, hook_v2_catchup_response, -}; -use super::envelope::{hook_now, hook_v2_envelope, hook_v2_native_session_id}; -use super::required_value; - -async fn hook_v2_context_scout_lifecycle( - args: &Value, - envelope: &tracedecay_hooks::HookEventEnvelopeV2, -) -> Option { - hook_v2_context_scout_lifecycle_for_session(envelope, hook_v2_native_session_id(args, envelope)) - .await -} +use super::admission::{HookV2BindingAdmission, hook_v2_binding_admission}; +use super::envelope::{hook_now, hook_v2_envelope}; pub(super) async fn hook_v2_context_scout_lifecycle_for_session( envelope: &tracedecay_hooks::HookEventEnvelopeV2, @@ -58,11 +45,11 @@ pub(super) async fn hook_v2_context_scout_lifecycle_for_session( } pub(super) fn hook_v2_native_context_scout_lifecycle( - args: &Value, + native_lifecycle: Option, envelope: &tracedecay_hooks::HookEventEnvelopeV2, ) -> Option { let lifecycle: tracedecay_agent_hosts::hooks::NativeContextScoutLifecycleV1 = - serde_json::from_value(args.get("native_lifecycle")?.clone()).ok()?; + serde_json::from_value(native_lifecycle?).ok()?; lifecycle.matches_envelope(envelope).then_some(lifecycle) } @@ -284,257 +271,72 @@ fn release_hook_v2_delivery_claim( outcome == ContextScoutDurableStoreOutcomeV1::Unavailable } -#[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_prepare")] -pub(super) async fn hook_v2_scout_prepare(cg: &TraceDecay, args: &Value) -> Result { - let envelope = hook_v2_envelope(args, "hook_v2_scout_prepare")?; - let now = hook_now(); - let snapshot = match hook_v2_binding_admission(cg, &envelope, now) { - HookV2BindingAdmission::Bound(snapshot) => snapshot, - HookV2BindingAdmission::Unavailable => { - return Ok(json!({ - "action": "hook_v2_scout_prepare", - "status": "unavailable", - })); - } - HookV2BindingAdmission::CatchupRequired => { - return Ok(hook_v2_catchup_response("hook_v2_scout_prepare")); - } - }; - let lifecycle = hook_v2_context_scout_lifecycle(args, &envelope).await; - Ok(orchestration_response( - "hook_v2_scout_prepare", - tracedecay_daemon_service::admit_registered_hook_orchestration( - envelope.clone(), - snapshot.binding, - lifecycle, - snapshot.revision, - true, - None, - ), - )) -} - -fn orchestration_response( - action: &str, - outcome: tracedecay_daemon_service::HookOrchestrationAdmissionV1, -) -> Value { - use tracedecay_daemon_service::HookOrchestrationAdmissionV1 as Admission; - match outcome { - Admission::Enqueued => json!({ "action": action, "status": "accepted" }), - Admission::Backpressured => json!({ "action": action, "status": "deferred" }), - Admission::UnsupportedTrigger => json!({ "action": action, "status": "unsupported" }), - Admission::Unavailable => json!({ - "action": action, - "status": "unavailable", - "reason": "orchestration_unavailable", - }), - } -} - #[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_delivery")] -pub(super) async fn hook_v2_delivery_receipt(cg: &TraceDecay, args: &Value) -> Result { - let receipt = required_value(args, "receipt")?; +pub(super) async fn hook_v2_delivery_receipt( + cg: &TraceDecay, + receipt: Value, +) -> Result { let receipt = serde_json::from_value::(receipt) .map_err(|error| config_error(format!("invalid Context Scout receipt: {error}")))?; let Some(owner) = cg.context_scout_owner() else { - return Ok(json!({ "status": "unavailable" })); + return Ok(ContextScoutStoreStatusV1::Unavailable); }; - let mut retained_project_id = None; - let claim = match args.get("claim").cloned() { - Some(claim) => serde_json::from_value::(claim) - .map_err(|error| config_error(format!("invalid Context Scout claim: {error}")))?, - None => { - let Some(project_id) = - tracedecay_agent_hosts::hooks::hook_project_id_for_layout(cg.hook_store_layout()) - else { - return Ok(json!({ "status": "unavailable" })); - }; - let Some(claim) = lookup_hook_v2_delivery_claim(project_id, receipt.envelope_id) else { - return Ok(json!({ "status": "unavailable" })); - }; - retained_project_id = Some(project_id); - claim - } + let Some(project_id) = + tracedecay_agent_hosts::hooks::hook_project_id_for_layout(cg.hook_store_layout()) + else { + return Ok(ContextScoutStoreStatusV1::Unavailable); + }; + let Some(claim) = lookup_hook_v2_delivery_claim(project_id, receipt.envelope_id) else { + return Ok(ContextScoutStoreStatusV1::Unavailable); }; let outcome = owner.record_delivery(&claim, &receipt).await; - if let Some(project_id) = retained_project_id - && release_hook_v2_delivery_claim(project_id, receipt.envelope_id, outcome) - { + if release_hook_v2_delivery_claim(project_id, receipt.envelope_id, outcome) { let _ = owner.requeue(claim).await; } - Ok(json!({ "status": scout_store_outcome(outcome) })) + Ok(scout_store_outcome(outcome)) } -#[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_notice")] -pub(super) async fn hook_v2_feedback_notice_delivery( +#[hotpath::measure(label = "mcp.hook_runtime.scout_notice")] +pub(super) fn hook_v2_feedback_notice_delivery( cg: &TraceDecay, - args: &Value, -) -> Result { - const ACTION: &str = "hook_v2_feedback_notice_delivery"; - let envelope = hook_v2_envelope(args, ACTION)?; + envelope: Value, + feedback_notice: Value, +) -> Result { + let envelope = hook_v2_envelope(envelope)?; match hook_v2_binding_admission(cg, &envelope, hook_now()) { HookV2BindingAdmission::Bound(_) => {} HookV2BindingAdmission::Unavailable => { - return Ok(json!({ "status": "unavailable" })); + return Ok(HookV2NoticeDeliveryResultV1::Unavailable {}); } HookV2BindingAdmission::CatchupRequired => { - return Ok(hook_v2_catchup_response(ACTION)); + return Ok(HookV2NoticeDeliveryResultV1::Rejected { + disposition: HookRuntimeDispositionV1::CatchupRequired, + }); } } let notice = serde_json::from_value::< tracedecay_application::advisory::AdvisoryHookLookupNoticeV1, - >(required_value(args, "feedback_notice")?) + >(feedback_notice) .map_err(|error| config_error(format!("invalid advisory feedback notice: {error}")))?; - let status = if tracedecay_application::advisory::acknowledge_advisory_hook_notice( - envelope.project_id, - envelope.worktree_id, - ¬ice, - ) { - "stored" - } else { - "unavailable" - }; - Ok(json!({ "status": status })) -} - -#[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_feedback")] -pub(super) async fn hook_v2_feedback(cg: &TraceDecay, args: &Value) -> Result { - let receipt = - serde_json::from_value::(required_value(args, "receipt")?) - .map_err(|error| config_error(format!("invalid Context Scout receipt: {error}")))?; - let feedback = - serde_json::from_value::(required_value(args, "feedback")?) - .map_err(|error| config_error(format!("invalid Context Scout feedback: {error}")))?; - let Some(owner) = cg.context_scout_owner() else { - return Ok(json!({ "status": "unavailable" })); - }; - Ok(json!({ - "status": scout_store_outcome(owner.record_feedback(&receipt, feedback).await), - })) -} - -#[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_cancel")] -pub(super) async fn hook_v2_cancel(cg: &TraceDecay, args: &Value) -> Result { - let work = serde_json::from_value::(required_value(args, "work")?) - .map_err(|error| config_error(format!("invalid Context Scout work: {error}")))?; - let Some(owner) = cg.context_scout_owner() else { - return Ok(json!({ "status": "unavailable" })); - }; - let status = owner - .cancel(work) - .await - .map_or("unavailable", scout_store_outcome); - Ok(json!({ "status": status })) -} - -#[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_status")] -pub(super) async fn hook_v2_status(cg: &TraceDecay, args: &Value) -> Result { - let control = serde_json::from_value::(required_value(args, "control")?) - .map_err(|error| config_error(format!("invalid Context Scout control: {error}")))?; - let Some(owner) = cg.context_scout_owner() else { - return Ok(json!({ "status": "unavailable" })); - }; - let status = owner - .status(control) - .await - .map_err(|error| config_error(format!("Context Scout status unavailable: {error}")))?; - serde_json::to_value(status) - .map_err(|error| config_error(format!("Context Scout status encoding failed: {error}"))) -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(super) enum ContextScoutReadSurfaceV1 { - Recent, - Explain, - Capability, - Budget, -} - -impl ContextScoutReadSurfaceV1 { - pub(super) fn from_action(action: &str) -> Option { - match action { - "hook_v2_scout_recent" => Some(Self::Recent), - "hook_v2_scout_explain" => Some(Self::Explain), - "hook_v2_scout_capability" => Some(Self::Capability), - "hook_v2_scout_budget" => Some(Self::Budget), - _ => None, - } - } -} - -#[hotpath::measure(future = true, label = "mcp.hook_runtime.scout_read")] -pub(super) async fn hook_v2_scout_read( - cg: &TraceDecay, - args: &Value, - action: &str, -) -> Result { - let surface = ContextScoutReadSurfaceV1::from_action(action) - .ok_or_else(|| config_error("unknown Context Scout read surface"))?; - let envelope = hook_v2_envelope(args, action)?; - let observed_at = hook_now(); - let snapshot = match hook_v2_binding_admission(cg, &envelope, observed_at) { - HookV2BindingAdmission::Bound(snapshot) => snapshot, - HookV2BindingAdmission::Unavailable => { - return Ok(json!({ "action": action, "status": "unavailable" })); - } - HookV2BindingAdmission::CatchupRequired => { - return Ok(hook_v2_catchup_response(action)); - } - }; - let Some(lifecycle) = hook_v2_context_scout_lifecycle(args, &envelope).await else { - return Ok(json!({ "action": action, "status": "unavailable" })); - }; - let Some(hook) = AdmittedContextScoutHookV1::new(envelope, &snapshot.binding) else { - return Ok(json!({ "action": action, "status": "unavailable" })); - }; - let Some((address, _)) = cg - .resolve_current_context_scout_claim_authority(&hook, &lifecycle, observed_at) - .await - else { - return Ok(json!({ "action": action, "status": "unavailable" })); - }; - let Some(owner) = cg.context_scout_owner() else { - return Ok(json!({ "action": action, "status": "unavailable" })); - }; - let limit = args - .get("limit") - .and_then(Value::as_u64) - .and_then(|limit| usize::try_from(limit).ok()) - .unwrap_or(8); - let value = match surface { - ContextScoutReadSurfaceV1::Recent => { - owner.recent_exact(address, limit).await.and_then(|recent| { - serde_json::to_value(recent).map_err(|_| ContextScoutErrorV1::InvalidLimits) - }) - } - ContextScoutReadSurfaceV1::Explain => { - owner - .explain_exact(address, limit) - .await - .and_then(|explanation| { - serde_json::to_value(explanation) - .map_err(|_| ContextScoutErrorV1::InvalidLimits) - }) - } - ContextScoutReadSurfaceV1::Capability => owner.capability().await.and_then(|capability| { - serde_json::to_value(capability).map_err(|_| ContextScoutErrorV1::InvalidLimits) - }), - ContextScoutReadSurfaceV1::Budget => owner.budget().await.and_then(|budget| { - serde_json::to_value(budget).map_err(|_| ContextScoutErrorV1::InvalidLimits) - }), - }; - match value { - Ok(value) => Ok(json!({ "action": action, "status": "ready", "value": value })), - Err(_) => Ok(json!({ "action": action, "status": "unavailable" })), - } + Ok( + if tracedecay_application::advisory::acknowledge_advisory_hook_notice( + envelope.project_id, + envelope.worktree_id, + ¬ice, + ) { + HookV2NoticeDeliveryResultV1::Stored {} + } else { + HookV2NoticeDeliveryResultV1::Unavailable {} + }, + ) } -fn scout_store_outcome(outcome: ContextScoutDurableStoreOutcomeV1) -> &'static str { +fn scout_store_outcome(outcome: ContextScoutDurableStoreOutcomeV1) -> ContextScoutStoreStatusV1 { match outcome { - ContextScoutDurableStoreOutcomeV1::Stored => "stored", - ContextScoutDurableStoreOutcomeV1::Duplicate => "duplicate", - ContextScoutDurableStoreOutcomeV1::Superseded => "superseded", - ContextScoutDurableStoreOutcomeV1::Unavailable => "unavailable", + ContextScoutDurableStoreOutcomeV1::Stored => ContextScoutStoreStatusV1::Stored, + ContextScoutDurableStoreOutcomeV1::Duplicate => ContextScoutStoreStatusV1::Duplicate, + ContextScoutDurableStoreOutcomeV1::Superseded => ContextScoutStoreStatusV1::Superseded, + ContextScoutDurableStoreOutcomeV1::Unavailable => ContextScoutStoreStatusV1::Unavailable, } } diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout/tests.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout/tests.rs index 049424af2d..bfb731d1be 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout/tests.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/context_scout/tests.rs @@ -1,6 +1,5 @@ use std::sync::Mutex as StdMutex; -use serde_json::json; use tracedecay_agent_hosts::agents::context_scout::ContextScoutDurableStoreOutcomeV1; use tracedecay_daemon_service::context_scout_lifecycle::AuthorityRegistrationV1; use tracedecay_domain::{ObservationSourceRangeV1, ProjectId, ProviderId, SessionId, UtcMicros}; @@ -123,42 +122,6 @@ fn receipt_outcomes_release_claims_and_only_retry_unavailable() { } } -#[test] -fn scout_read_actions_are_closed_and_read_only() { - assert_eq!( - ContextScoutReadSurfaceV1::from_action("hook_v2_scout_recent"), - Some(ContextScoutReadSurfaceV1::Recent) - ); - assert_eq!( - ContextScoutReadSurfaceV1::from_action("hook_v2_scout_explain"), - Some(ContextScoutReadSurfaceV1::Explain) - ); - assert_eq!( - ContextScoutReadSurfaceV1::from_action("hook_v2_scout_capability"), - Some(ContextScoutReadSurfaceV1::Capability) - ); - assert_eq!( - ContextScoutReadSurfaceV1::from_action("hook_v2_scout_budget"), - Some(ContextScoutReadSurfaceV1::Budget) - ); - assert_eq!( - ContextScoutReadSurfaceV1::from_action("hook_v2_scout_apply"), - None - ); -} - -#[test] -fn hook_v2_scout_prepare_accepts_no_caller_candidates() { - let response = orchestration_response( - "hook_v2_scout_prepare", - tracedecay_daemon_service::HookOrchestrationAdmissionV1::Unavailable, - ); - assert_eq!(response["status"], "unavailable"); - assert_eq!(response["reason"], "orchestration_unavailable"); - assert!(!response.to_string().contains("candidate")); - assert!(!response.to_string().contains("control")); -} - #[test] fn hook_v2_native_session_requires_exact_protected_locator() { let session_id = "native-session-1"; @@ -166,16 +129,14 @@ fn hook_v2_native_session_requires_exact_protected_locator() { envelope.protected_session_id = tracedecay_agent_hosts::hooks::protected_native_session_id(session_id); assert_eq!( - hook_v2_native_session_id(&json!({ "native_session_id": session_id }), &envelope) + hook_v2_native_session_id(Some(session_id), &envelope) .as_ref() .map(SessionId::as_str), Some(session_id) ); envelope.protected_session_id = [9; 32]; - assert!( - hook_v2_native_session_id(&json!({ "native_session_id": session_id }), &envelope).is_none() - ); + assert!(hook_v2_native_session_id(Some(session_id), &envelope).is_none()); } #[tokio::test] diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/entry_tests.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/entry_tests.rs index 8e1686878a..bf35ff66a7 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/entry_tests.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/entry_tests.rs @@ -1,38 +1,41 @@ use super::*; +use serde_json::json; +use tracedecay_contracts::retrieval::HookIngestTranscriptRequestV1; #[test] -fn required_str_rejects_missing_and_empty_values() { - assert!(required_str(&json!({}), "action").is_err()); - assert!(required_str(&json!({ "action": "" }), "action").is_err()); +fn decode_keeps_the_session_payload_and_drops_only_presentation_keys() { + let request = decode_hook_runtime_request(&json!({ + "action": "ingest_transcript", + "provider": "codex", + "user_scope": true, + "session_id": "codex-session", + "format": "json", + })) + .unwrap(); assert_eq!( - required_str(&json!({ "action": "reset_counter" }), "action").unwrap(), - "reset_counter" + request, + HookRuntimeSurfaceRequestV1::IngestTranscript(HookIngestTranscriptRequestV1 { + provider: "codex".to_owned(), + user_scope: true, + session_id: Some("codex-session".to_owned()), + event_json: None, + messages: None, + max_new_bytes: None, + }) + ); + assert_eq!( + decode_hook_runtime_request(&json!({"action": "reset_counter", "reset": true})) + .unwrap_err() + .to_string(), + "config error: invalid arguments for tracedecay_hook_runtime: unknown field `reset`, there are no fields" ); } #[test] -fn projectless_runtime_rejects_project_database_actions() { - assert!(!projectless_action_allowed("reset_counter", &json!({}))); - assert!(projectless_action_allowed( - "codex_stop", - &json!({ "session_id": "codex-terminal" }), - )); - assert!(!projectless_action_allowed( - "ingest_transcript", - &json!({ "user_scope": false }), - )); - assert!(projectless_action_allowed( - "ingest_transcript", - &json!({ "user_scope": true }), - )); - assert!(!projectless_action_allowed( - "claude_compact", - &json!({ "user_scope": false }), - )); - assert!(projectless_action_allowed( - "claude_compact", - &json!({ "user_scope": true }), - )); +fn required_field_rejects_missing_and_empty_values() { + assert!(required_field(None, "session_id").is_err()); + assert!(required_field(Some(""), "session_id").is_err()); + assert_eq!(required_field(Some("s"), "session_id").unwrap(), "s"); } #[test] @@ -41,17 +44,3 @@ fn session_authority_roles_fail_closed_independently() { assert!(required_project_db(&none).is_err()); assert!(required_user_db(&none).is_err()); } - -#[tokio::test] -async fn terminal_review_operation_stops_when_its_receipt_is_superseded() { - let cancellation = tracedecay_sessions::observation::ObservationCancellation::default(); - cancellation.cancel(); - - let output = super::terminal::await_terminal_operation(&cancellation, async { - tokio::time::sleep(std::time::Duration::from_secs(1)).await; - "completed" - }) - .await; - - assert!(output.is_none()); -} diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/envelope.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/envelope.rs index 8ff918f0b7..419710bee6 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/envelope.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/envelope.rs @@ -8,26 +8,16 @@ pub(super) fn hook_now() -> UtcMicros { tracedecay_runtime_core::tracedecay::utc_now_or_one() } -pub(super) fn hook_v2_envelope( - args: &Value, - action: &str, -) -> Result { - let envelope = args - .get("envelope") - .cloned() - .ok_or_else(|| config_error(format!("{action} requires envelope"))) - .and_then(|value| { - serde_json::from_value::(value) - .map_err(|error| config_error(format!("invalid Hook V2 envelope: {error}"))) - })?; - Ok(envelope) +pub(super) fn hook_v2_envelope(envelope: Value) -> Result { + serde_json::from_value::(envelope) + .map_err(|error| config_error(format!("invalid Hook V2 envelope: {error}"))) } pub(super) fn hook_v2_native_session_id( - args: &Value, + native_session_id: Option<&str>, envelope: &tracedecay_hooks::HookEventEnvelopeV2, ) -> Option { - let session = SessionId::new(args.get("native_session_id")?.as_str()?.to_owned()).ok()?; + let session = SessionId::new(native_session_id?.to_owned()).ok()?; (tracedecay_agent_hosts::hooks::protected_native_session_id(session.as_str()) == envelope.protected_session_id) .then_some(session) diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes.rs index 12c580103f..3272342095 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes.rs @@ -1,64 +1,21 @@ -use serde_json::{Value, json}; +use serde_json::Value; use std::collections::HashSet; use std::path::Path; -use std::sync::Arc; use tracedecay_automation_runtime::automation::config_error; -use tracedecay_automation_runtime::automation::run_ledger::AutomationRunStatus; +use tracedecay_contracts::retrieval::HermesReceiptStatusV1; use tracedecay_domain::errors::Result; use tracedecay_global_db::RegisteredGlobalDb; use tracedecay_host_admission::{SharedHostAdmissionBroker, TerminalReason}; use tracedecay_sessions::admission::HostAdmissionOutcome; -use tracedecay_store_runtime::DaemonSessionRuntimeRegistryV1; -use super::required_str; use crate::map_host_admission_outcome; -#[hotpath::measure(future = true, label = "mcp.hook_runtime.review")] -pub(super) async fn user_review( - args: &Value, - profile_root: &Path, - session_runtime_registry: &Arc, -) -> Result { - use tracedecay_automation_runtime::automation::run_ledger::AutomationTrigger; - - let provider = required_str(args, "provider")?; - let session_id = args - .get("session_id") - .and_then(Value::as_str) - .filter(|value| !value.is_empty()) - .map(str::to_string); - let run_id = args - .get("run_id") - .and_then(Value::as_str) - .map(str::to_string); - let run = run_user_review( - profile_root, - Arc::clone(session_runtime_registry), - provider, - session_id, - run_id, - AutomationTrigger::HostReceipt, - )?; - Ok(json!({ - "action": "user_review", - "status": "completed", - "session_reflector": run.session_reflector.ledger_record.status, - "memory_curator": run.memory_curator.ledger_record.status, - "skill_writer": run.skill_writer.ledger_record.status, - })) -} - -fn run_user_review( - _profile_root: &std::path::Path, - _session_runtime_registry: Arc, - _provider: &str, - _session_id: Option, - _run_id: Option, - _trigger: tracedecay_automation_runtime::automation::run_ledger::AutomationTrigger, -) -> Result { - Err(config_error( +/// Session review needs automation, which only a pinned project +/// configuration carries; a projectless route can never run it. +pub(super) fn user_review_unavailable() -> tracedecay_domain::errors::TraceDecayError { + config_error( "projectless Hermes review is unavailable: automation requires a pinned project configuration", - )) + ) } async fn apply_projectless_hermes_receipt_plan( @@ -236,16 +193,15 @@ pub async fn replay_projectless_hermes_host_admission( async fn continue_projectless_hermes_review( profile_root: &Path, - session_runtime_registry: &Arc, session_db: &RegisteredGlobalDb, -) -> Result { +) -> Result { let dashboard_root = tracedecay_automation_runtime::automation::runner::user_automation_root(profile_root); let Some(ready) = tracedecay_automation_runtime::automation::host_receipts::oldest_ready(&dashboard_root) .await? else { - return Ok(json!({ "action": "hermes_receipt", "status": "ingested" })); + return Ok(HermesReceiptStatusV1::Ingested); }; if session_db .lcm_raw_message_store_id("hermes", &ready.transcript_watermark) @@ -258,47 +214,18 @@ async fn continue_projectless_hermes_review( )? .is_none() { - return Ok(json!({ "action": "hermes_receipt", "status": "awaiting_transcript" })); + return Ok(HermesReceiptStatusV1::AwaitingTranscript); } - let session_id = ready - .pending - .route - .as_ref() - .and_then(|route| route.session_id.clone()); - let run = run_user_review( - profile_root, - Arc::clone(session_runtime_registry), - "hermes", - session_id, - Some(format!("user_host_receipt_{}", ready.pending.generation)), - tracedecay_automation_runtime::automation::run_ledger::AutomationTrigger::HostReceipt, - )?; - if run.session_reflector.ledger_record.status == AutomationRunStatus::Succeeded - && run.memory_curator.ledger_record.status != AutomationRunStatus::Failed - && run.skill_writer.ledger_record.status == AutomationRunStatus::Succeeded - { - tracedecay_automation_runtime::automation::host_receipts::mark_consumed( - &dashboard_root, - &ready.pending.session_key, - ready.pending.generation, - ) - .await?; - } - Ok(json!({ "action": "hermes_receipt", "status": "reviewed" })) + Err(user_review_unavailable()) } #[hotpath::measure(future = true, label = "mcp.hook_runtime.hermes")] pub(super) async fn hermes_receipt( - args: &Value, + event_value: Value, profile_root: &Path, - session_runtime_registry: Option<&Arc>, session_db: &RegisteredGlobalDb, broker: &SharedHostAdmissionBroker, -) -> Result { - let event_value = args - .get("event") - .cloned() - .ok_or_else(|| config_error("missing required parameter `event`"))?; +) -> Result { let event: tracedecay_hooks::core_events::DaemonHookEvent = serde_json::from_value(event_value.clone())?; if event.receipt.is_none() { @@ -346,17 +273,9 @@ pub(super) async fn hermes_receipt( return Err(map_host_admission_outcome(&outcome)); } if is_turn_ingested { - let session_runtime_registry = session_runtime_registry.ok_or_else(|| { - config_error("Hermes review requires retained profile runtime registry authority") - })?; - return continue_projectless_hermes_review( - profile_root, - session_runtime_registry, - session_db, - ) - .await; + return continue_projectless_hermes_review(profile_root, session_db).await; } - Ok(json!({ "action": "hermes_receipt", "status": "recorded" })) + Ok(HermesReceiptStatusV1::Recorded) } #[cfg(test)] diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes/tests.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes/tests.rs index ea9dc8a296..f0049f8419 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes/tests.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/hermes/tests.rs @@ -22,20 +22,15 @@ async fn projectless_hermes_receipt_uses_user_profile_without_local_writer() { .unwrap(); let result = hermes_receipt( - &json!({ - "action": "hermes_receipt", - "event": hermes_turn_completed_event("session-local-writer", "wm-local-1"), - }), + hermes_turn_completed_event("session-local-writer", "wm-local-1"), &profile_root, - None, required_user_db(&crate::handlers::mcp_session_authorities(&fixture)).unwrap(), &broker, ) .await .expect("projectless Hermes receipt should commit through the user-profile broker"); - assert_eq!(result["action"], "hermes_receipt"); - assert_eq!(result["status"], "recorded"); + assert_eq!(result, HermesReceiptStatusV1::Recorded); assert_eq!(broker.pending_count().await, 0); let automation_root = tracedecay_automation_runtime::automation::runner::user_automation_root(&profile_root); @@ -75,12 +70,8 @@ async fn projectless_hermes_receipt_is_durable_before_apply_and_replays_after_re .host_admission_broker_for_test(HostAdmissionScope::Profile) .unwrap(); let err = hermes_receipt( - &json!({ - "action": "hermes_receipt", - "event": hermes_turn_completed_event("session-restart", "wm-restart-1"), - }), + hermes_turn_completed_event("session-restart", "wm-restart-1"), &profile_root, - None, required_user_db(&crate::handlers::mcp_session_authorities(&fixture)).unwrap(), &broker, ) diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest.rs index 565997c6db..1e2ae53891 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest.rs @@ -2,6 +2,10 @@ use serde_json::{Value, json}; use std::path::Path; use std::time::Duration; use tracedecay_automation_runtime::automation::config_error; +use tracedecay_contracts::retrieval::{ + HookCompactionResultV1, HookIngestAdmissionV1, HookIngestTranscriptRequestV1, + HookIngestTranscriptResultV1, +}; use tracedecay_domain::errors::{Result, TraceDecayError}; use tracedecay_domain::{ObservationScopeV1, ProjectId}; use tracedecay_global_db::RegisteredGlobalDb; @@ -19,7 +23,7 @@ use tracedecay_sessions::runtime::source::TranscriptSource; use crate::handlers::SessionAuthorities; -use super::required_str; +use super::required_field; use crate::{ hook_admission_error, map_claude_observation_ingest_error, map_transcript_ingest_error, }; @@ -193,12 +197,12 @@ async fn drain_host_observation_projections( #[hotpath::measure(future = true, label = "mcp.hook_runtime.compact")] pub(super) async fn codex_compact( cg: &TraceDecay, - args: &Value, + event_json: &str, session_authorities: SessionAuthorities<'_>, -) -> Result { - let event_json = required_str(args, "event_json")?; +) -> Result { + let event_json = required_field(Some(event_json), "event_json")?; let Some(authority) = session_authorities.project_lcm else { - return Ok(compaction_authority_unavailable("codex_compact")); + return Ok(compaction_authority_unavailable()); }; let parsed = serde_json::from_str::(event_json).ok(); let session_id = parsed.as_ref().and_then(|value| { @@ -208,18 +212,17 @@ pub(super) async fn codex_compact( .map(str::to_string) }); let Some(session_id) = session_id else { - return Ok(json!({ - "action": "codex_compact", - "status": "unavailable", - "reason": "host_session_identity_unavailable", - "messages_upserted": 0, - })); + return Ok(HookCompactionResultV1::NoSession { + status: "unavailable".to_owned(), + reason: "host_session_identity_unavailable".to_owned(), + messages_upserted: 0, + }); }; // The daemon compaction compresses the session's durable history, so the // rollout must land in the owning store through the canonical ingest // route before pressure evidence is evaluated; compacting an unfilled // store would report an empty success. - let messages_upserted = hotpath::future!( + let ingested = hotpath::future!( admit_codex_rollouts_for_compaction(cg, session_authorities), label = "mcp.hook_runtime.compact_ingest" ) @@ -248,11 +251,19 @@ pub(super) async fn codex_compact( ) .await else { - return Ok(compaction_authority_unavailable("codex_compact")); + return Ok(compaction_authority_unavailable()); }; - let mut output = compaction_response_json("codex_compact", &response); - output["messages_upserted"] = json!(messages_upserted); - Ok(output) + let mut result = compaction_response(&response)?; + if let HookCompactionResultV1::Settled { + messages_upserted, .. + } + | HookCompactionResultV1::Refused { + messages_upserted, .. + } = &mut result + { + *messages_upserted = ingested; + } + Ok(result) } /// The project-open catch-up scans the same Codex sources concurrently, so a @@ -353,29 +364,27 @@ async fn admit_codex_rollouts_once( drain_host_observation_projections(&facade, &scope, &cancellation).await } -pub(super) async fn claude_compact( - args: &Value, - _session_authorities: SessionAuthorities<'_>, -) -> Result { - required_str(args, "event_json")?; - Ok(json!({ - "action": "claude_compact", - "status": "unavailable", - "reason": "claude_postcompact_provenance_unavailable", - "summary_nodes_created": 0, - "summary_node_ids": [], - })) +/// Claude's `PostCompact` summaries carry no machine provenance, so the +/// daemon records nothing for them. +pub(super) fn claude_compact(event_json: &str) -> Result { + required_field(Some(event_json), "event_json")?; + Ok(HookCompactionResultV1::NotRun { + status: "unavailable".to_owned(), + reason: "claude_postcompact_provenance_unavailable".to_owned(), + summary_nodes_created: 0, + summary_node_ids: Vec::new(), + relation_projection_status: None, + }) } #[hotpath::measure(future = true, label = "mcp.hook_runtime.compact")] pub(super) async fn cursor_compact( - _cg: &TraceDecay, - args: &Value, + event_json: &str, session_authorities: SessionAuthorities<'_>, -) -> Result { - let event_json = required_str(args, "event_json")?; +) -> Result { + let event_json = required_field(Some(event_json), "event_json")?; let Some(authority) = session_authorities.project_lcm else { - return Ok(compaction_authority_unavailable("cursor_compact")); + return Ok(compaction_authority_unavailable()); }; let parsed: Value = serde_json::from_str(event_json)?; let session_id = ["session_id", "conversation_id", "chat_id"] @@ -385,7 +394,7 @@ pub(super) async fn cursor_compact( .ok_or_else(|| config_error("Cursor preCompact event omitted session id"))?; let messages_to_compact = event_usize(&parsed, &["messages_to_compact", "compact_count"]); if messages_to_compact == Some(0) { - return Ok(cursor_compact_skipped("no messages to compact")); + return Ok(cursor_compact_skipped()); } let message_count = event_usize(&parsed, &["message_count", "messages_count"]); let fresh_tail_count = message_count @@ -412,64 +421,65 @@ pub(super) async fn cursor_compact( ) .await else { - return Ok(compaction_authority_unavailable("cursor_compact")); + return Ok(compaction_authority_unavailable()); }; - Ok(compaction_response_json("cursor_compact", &response)) + compaction_response(&response) } -fn compaction_authority_unavailable(action: &str) -> Value { - json!({ - "action": action, - "status": "unavailable", - "reason": "lcm_daemon_authority_unavailable", - "summary_nodes_created": 0, - "summary_node_ids": [], - }) +fn cursor_compact_skipped() -> HookCompactionResultV1 { + HookCompactionResultV1::NotRun { + status: "skipped".to_owned(), + reason: "no messages to compact".to_owned(), + summary_nodes_created: 0, + summary_node_ids: Vec::new(), + relation_projection_status: Some(Value::String("not_applicable".to_owned())), + } +} + +fn compaction_authority_unavailable() -> HookCompactionResultV1 { + HookCompactionResultV1::NotRun { + status: "unavailable".to_owned(), + reason: "lcm_daemon_authority_unavailable".to_owned(), + summary_nodes_created: 0, + summary_node_ids: Vec::new(), + relation_projection_status: None, + } } -fn compaction_response_json( - action: &str, +fn compaction_response( response: &tracedecay_session_memory::session::lcm::LcmAuthorityResponse, -) -> Value { +) -> Result { + let authority_outcome = serde_json::to_value(&response.outcome)?; + let committed_state = serde_json::to_value(&response.receipt.committed_state)?; if let (LcmAuthorityOutcome::Ready, Some(LcmAuthorityPayload::Compaction(compression))) = (&response.outcome, &response.payload) { - return json!({ - "action": action, - "status": compression.status, - "reason": compression.reason, - "summary_nodes_created": compression.summary_nodes_created, - "summary_node_ids": compression + return Ok(HookCompactionResultV1::Settled { + status: compression.status.clone(), + reason: compression.reason.clone(), + summary_nodes_created: compression.summary_nodes_created as u64, + summary_node_ids: compression .summary_nodes .iter() .map(|node| node.node_id.clone()) - .collect::>(), - "relation_projection_status": compression.relation_projection_status, - "retry_status": compression.retry_status, - "authority_outcome": response.outcome, - "committed_state": response.receipt.committed_state, - "messages_upserted": 0, + .collect(), + relation_projection_status: serde_json::to_value( + compression.relation_projection_status, + )?, + retry_status: compression.retry_status.clone(), + authority_outcome, + committed_state, + messages_upserted: 0, }); } - json!({ - "action": action, - "status": "unavailable", - "reason": "lcm_daemon_authority_rejected", - "authority_outcome": response.outcome, - "committed_state": response.receipt.committed_state, - "summary_nodes_created": 0, - "summary_node_ids": [], - "messages_upserted": 0, - }) -} - -fn cursor_compact_skipped(reason: impl Into) -> Value { - json!({ - "status": "skipped", - "reason": reason.into(), - "summary_nodes_created": 0, - "summary_node_ids": [], - "relation_projection_status": "not_applicable", + Ok(HookCompactionResultV1::Refused { + status: "unavailable".to_owned(), + reason: "lcm_daemon_authority_rejected".to_owned(), + authority_outcome, + committed_state, + summary_nodes_created: 0, + summary_node_ids: Vec::new(), + messages_upserted: 0, }) } @@ -520,99 +530,28 @@ fn pressure_only_command( })) } -#[hotpath::measure(future = true, label = "mcp.hook_runtime.accounting")] -pub(super) async fn accounting_receipt( - cg: &TraceDecay, - provider_usage_db: &RegisteredGlobalDb, -) -> Result { - let scope = ObservationScopeV1::Project { - project_id: project_observation_id(cg)?, - }; - let usage = tracedecay_session_memory::provider_usage::provider_usage_aggregate( - provider_usage_db, - &scope, - None, - None, - ) - .await; - let prices = tracedecay_session_memory::provider_pricing::load_table(); - let priced = tracedecay_session_memory::provider_usage::price_provider_usage(&usage, prices, 0); - let complete = priced.coverage - == tracedecay_session_memory::provider_usage::ProviderUsageCoverageV1::Complete; - let tokens_consumed = complete - .then(|| { - priced - .total_input_tokens? - .checked_add(priced.total_output_tokens?) - }) - .flatten(); - let tokens_saved = cg - .get_tokens_saved() - .await - .map_err(|error| config_error(format!("failed to read saved tokens: {error}")))?; - let efficiency = tokens_consumed.and_then(|consumed| { - let denominator = tokens_saved.checked_add(consumed)?; - (denominator > 0).then_some((tokens_saved as f64 / denominator as f64) * 100.0) - }); - Ok(json!({ - "action": "accounting_receipt", - "coverage": priced.coverage, - "watermark": usage.upper_observation_sequence, - "provider_usage_events": priced.usage_events, - "cost_usd": priced.total_cost_usd, - "pricing_status": if priced.total_cost_usd.is_some() { "priced" } else { "unavailable" }, - "pricing_revision": priced.pricing_revision, - "tokens_consumed": tokens_consumed, - "tokens_saved": tokens_saved, - "efficiency": efficiency, - })) -} - -pub(super) async fn ingest_transcript( - cg: Option<&TraceDecay>, - args: &Value, - profile_root: Option<&Path>, - global_db: Option<&RegisteredGlobalDb>, - accounting_db: Option<&RegisteredGlobalDb>, - session_authorities: SessionAuthorities<'_>, -) -> Result { - let cancellation = ObservationCancellation::default(); - ingest_transcript_with_cancellation( - cg, - args, - profile_root, - global_db, - accounting_db, - session_authorities, - &cancellation, - ) - .await -} - #[hotpath::measure(future = true, label = "mcp.hook_runtime.ingest")] #[cfg_attr( not(feature = "hotpath"), expect( clippy::too_many_lines, - reason = "Transcript ingest is one cancelled-aware write through the capture authority." + reason = "Transcript ingest is one write through the capture authority." ) )] -pub async fn ingest_transcript_with_cancellation( +pub(super) async fn ingest_transcript( cg: Option<&TraceDecay>, - args: &Value, + request: &HookIngestTranscriptRequestV1, profile_root: Option<&Path>, global_db: Option<&RegisteredGlobalDb>, accounting_db: Option<&RegisteredGlobalDb>, session_authorities: SessionAuthorities<'_>, - cancellation: &ObservationCancellation, -) -> Result { - let provider = required_str(args, "provider")?; - let user_scope = args - .get("user_scope") - .and_then(Value::as_bool) - .unwrap_or(false); - let payload_route = TranscriptPayloadRouteV1::from_args(args); - let max_new_bytes = args.get("max_new_bytes").and_then(Value::as_u64); +) -> Result { + let cancellation = ObservationCancellation::default(); + let cancellation = &cancellation; + let provider = required_field(Some(&request.provider), "provider")?; + let user_scope = request.user_scope; + let payload_route = TranscriptPayloadRouteV1::from_request(request); + let max_new_bytes = request.max_new_bytes; let admission_scope = if user_scope { HostAdmissionScope::Profile } else { @@ -641,7 +580,7 @@ pub async fn ingest_transcript_with_cancellation( let capture = hotpath::future!( kernel.capture(TranscriptCaptureContext { cg, - args, + request, user_scope, profile_root, global_db, @@ -695,15 +634,32 @@ pub async fn ingest_transcript_with_cancellation( exact_duplicate, deferred_by_byte_cap, ); - let mut output = json!({ - "action": "ingest_transcript", - "provider": provider, - "user_scope": user_scope, - "completed": !deferred_by_byte_cap, - "status": admission.status, - "admission": admission, - "messages_upserted": messages_upserted, - }); + let mut output = HookIngestTranscriptResultV1 { + provider: provider.to_owned(), + user_scope, + completed: !deferred_by_byte_cap, + status: admission.status.as_wire().to_owned(), + admission: HookIngestAdmissionV1 { + status: admission.status.as_wire().to_owned(), + retryable: admission.retryable, + reason_code: admission.reason_code.map(str::to_owned), + }, + messages_upserted, + hint_outcomes: None, + observations_committed: None, + bytes_consumed: None, + deferred_by_byte_cap: None, + observation_duplicates: None, + cursor_advances: None, + cursor_duplicates: None, + records_rejected: None, + records_quarantined: None, + projections_completed: None, + projections_skipped: None, + projection_duplicates: None, + deferred_sources: None, + source_bytes_scanned: None, + }; // Project-scope ingest is the production moment new post-hint session // activity becomes durable, so settle emitted hook hints into // `hint_outcome` analytics events here. Best-effort: unavailable or @@ -712,7 +668,7 @@ pub async fn ingest_transcript_with_cancellation( if let Some(cg) = cg && !user_scope { - output["hint_outcomes"] = match profile_root.map(|profile_root| { + output.hint_outcomes = Some(match profile_root.map(|profile_root| { tracedecay_application::analytics_bridge::hook_import_sources( profile_root, Some(cg.project_root()), @@ -736,31 +692,31 @@ pub async fn ingest_transcript_with_cancellation( ) .await .as_json(), - }; + }); } // Routes that admit observations directly report what they committed, so a // `messages_upserted: 0` pass is readable without guessing which drainer // won. The snapshot and Claude blocks below own the key for their routes. if route_observations_committed > 0 { - output["observations_committed"] = json!(route_observations_committed); + output.observations_committed = Some(route_observations_committed); } if let Some(capture) = snapshot_capture { - output["observations_committed"] = json!(capture.stats.messages_upserted); - output["bytes_consumed"] = json!(capture.bytes_consumed); - output["deferred_by_byte_cap"] = json!(capture.deferred_by_byte_cap); + output.observations_committed = Some(capture.stats.messages_upserted); + output.bytes_consumed = Some(capture.bytes_consumed); + output.deferred_by_byte_cap = Some(capture.deferred_by_byte_cap); } if let Some(stats) = claude_observation_stats { - output["observations_committed"] = json!(stats.observations_committed); - output["observation_duplicates"] = json!(stats.observation_duplicates); - output["cursor_advances"] = json!(stats.cursor_advances); - output["cursor_duplicates"] = json!(stats.cursor_duplicates); - output["records_rejected"] = json!(stats.records_rejected); - output["records_quarantined"] = json!(stats.records_quarantined); - output["projections_completed"] = json!(stats.projections_completed); - output["projections_skipped"] = json!(stats.projections_skipped); - output["projection_duplicates"] = json!(stats.projection_duplicates); - output["deferred_sources"] = json!(stats.deferred_sources); - output["source_bytes_scanned"] = json!(stats.source_bytes_scanned); + output.observations_committed = Some(stats.observations_committed); + output.observation_duplicates = Some(stats.observation_duplicates); + output.cursor_advances = Some(stats.cursor_advances); + output.cursor_duplicates = Some(stats.cursor_duplicates); + output.records_rejected = Some(stats.records_rejected); + output.records_quarantined = Some(stats.records_quarantined); + output.projections_completed = Some(stats.projections_completed); + output.projections_skipped = Some(stats.projections_skipped); + output.projection_duplicates = Some(stats.projection_duplicates); + output.deferred_sources = Some(stats.deferred_sources); + output.source_bytes_scanned = Some(stats.source_bytes_scanned); } Ok(output) } diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/kernels.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/kernels.rs index f6690a54ab..b3fd0cfe15 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/kernels.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/kernels.rs @@ -18,6 +18,7 @@ use std::path::{Path, PathBuf}; use std::pin::Pin; use serde_json::Value; +use tracedecay_contracts::retrieval::HookIngestTranscriptRequestV1; use tracedecay_domain::ObservationScopeV1; use tracedecay_automation_runtime::automation::config_error; @@ -31,7 +32,7 @@ use tracedecay_sessions::runtime::hosts::claude_observation::ClaudeObservationIn use tracedecay_sessions::runtime::hosts::hermes::HermesSweepOutcome; use tracedecay_sessions::runtime::snapshot_observation::SnapshotCaptureOutcome; -use super::super::{required_str, required_user_db}; +use super::super::{required_field, required_user_db}; use super::{ admit_codex_project_rollouts, drain_host_observation_projections, project_observation_id, }; @@ -53,8 +54,8 @@ pub(super) enum TranscriptPayloadRouteV1 { } impl TranscriptPayloadRouteV1 { - pub(super) fn from_args(args: &Value) -> Self { - if args.get("messages").is_some() { + pub(super) fn from_request(request: &HookIngestTranscriptRequestV1) -> Self { + if request.messages.is_some() { Self::InlineMessages } else { Self::SourceScan @@ -66,7 +67,7 @@ impl TranscriptPayloadRouteV1 { #[derive(Clone)] pub(super) struct TranscriptCaptureContext<'a> { pub(super) cg: Option<&'a TraceDecay>, - pub(super) args: &'a Value, + pub(super) request: &'a HookIngestTranscriptRequestV1, pub(super) user_scope: bool, pub(super) profile_root: Option<&'a Path>, pub(super) global_db: Option<&'a RegisteredGlobalDb>, @@ -270,7 +271,7 @@ async fn capture_claude_profile( ) -> Result { let profile_root = ctx.profile_root()?; let global_db = ctx.global_db()?; - let session_id = required_str(ctx.args, "session_id")?.to_string(); + let session_id = required_field(ctx.request.session_id.as_deref(), "session_id")?.to_string(); required_user_db(&ctx.session_authorities)?; let roots = registered_project_roots(global_db).await?; let stats = @@ -298,7 +299,7 @@ async fn capture_codex_profile( ) -> Result { let profile_root = ctx.profile_root()?; let global_db = ctx.global_db()?; - let session_id = required_str(ctx.args, "session_id")?.to_string(); + let session_id = required_field(ctx.request.session_id.as_deref(), "session_id")?.to_string(); let roots = registered_project_roots(global_db).await?; let outcome = tracedecay_sessions::runtime::try_ingest_user_codex_sessions_with_db_and_admission( @@ -326,7 +327,7 @@ async fn capture_cursor_profile( ) -> Result { ctx.profile_root()?; let global_db = ctx.global_db()?; - let event_json = required_str(ctx.args, "event_json")?; + let event_json = required_field(ctx.request.event_json.as_deref(), "event_json")?; let roots = registered_project_roots(global_db).await?; let stats = tracedecay_sessions::runtime::hosts::cursor::try_ingest_cursor_user_transcript_event_capped_with_admission( @@ -441,7 +442,7 @@ async fn capture_cursor_project( ctx: TranscriptCaptureContext<'_>, ) -> Result { let cg = ctx.project()?; - let event_json = required_str(ctx.args, "event_json")?; + let event_json = required_field(ctx.request.event_json.as_deref(), "event_json")?; let stats = tracedecay_sessions::runtime::hosts::cursor::try_ingest_cursor_transcript_event_capped_with_admission( event_json, project_observation_id(cg)?, @@ -497,11 +498,11 @@ fn hermes_capture_outcome(outcome: &HermesSweepOutcome) -> Result, ) -> Result { - let session_id = required_str(ctx.args, "session_id")?; + let session_id = required_field(ctx.request.session_id.as_deref(), "session_id")?; let messages = ctx - .args - .get("messages") - .and_then(Value::as_array) + .request + .messages + .as_ref() .filter(|messages| !messages.is_empty()) .ok_or_else(|| config_error("Hermes turn callback requires non-empty messages"))?; let (scope, project_root) = if ctx.user_scope { @@ -569,8 +570,11 @@ async fn capture_kiro_project( /// never an empty success. async fn capture_pi_project(ctx: TranscriptCaptureContext<'_>) -> Result { let cg = ctx.project()?; - let event: Value = serde_json::from_str(required_str(ctx.args, "event_json")?) - .map_err(|error| config_error(format!("invalid Pi event: {error}")))?; + let event: Value = serde_json::from_str(required_field( + ctx.request.event_json.as_deref(), + "event_json", + )?) + .map_err(|error| config_error(format!("invalid Pi event: {error}")))?; let event_str = |key: &str| { event .get(key) diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/tests.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/tests.rs index 9963dd2df8..7200aa4a2a 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/tests.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/ingest/tests.rs @@ -96,7 +96,9 @@ fn message_counted_route_still_commits_from_its_own_upserts() { #[test] fn cursor_compaction_response_matches_hook_contract() { - let value = cursor_compact_skipped("no messages to compact"); + let value = + serde_json::to_value(HookRuntimeResultV1::CursorCompact(cursor_compact_skipped())).unwrap(); + assert_eq!(value["action"], "cursor_compact"); let outcome: tracedecay_agent_hosts::hooks::CursorPreCompactOutcome = serde_json::from_value(value).unwrap(); assert_eq!(outcome.status, "skipped"); @@ -186,10 +188,14 @@ async fn transcript_admission_rejects_unknown_provider_without_echoing_hook_payl let secret = "hook-secret-unknown-provider"; let error = ingest_transcript( None, - &json!({ - "provider": "unknown-provider-v99", - "event_json": format!("{{\"raw_source\":\"{secret}\"}}"), - }), + &HookIngestTranscriptRequestV1 { + provider: "unknown-provider-v99".to_owned(), + user_scope: false, + session_id: None, + event_json: Some(format!("{{\"raw_source\":\"{secret}\"}}")), + messages: None, + max_new_bytes: None, + }, None, None, None, @@ -211,10 +217,14 @@ async fn supported_transcript_admission_requires_its_authority_without_echoing_p let secret = "hook-secret-unavailable-authority"; let error = ingest_transcript( None, - &json!({ - "provider": "claude", - "event_json": format!("{{\"malformed\":\"{secret}\"}}"), - }), + &HookIngestTranscriptRequestV1 { + provider: "claude".to_owned(), + user_scope: false, + session_id: None, + event_json: Some(format!("{{\"malformed\":\"{secret}\"}}")), + messages: None, + max_new_bytes: None, + }, None, None, None, @@ -235,24 +245,21 @@ async fn supported_transcript_admission_requires_its_authority_without_echoing_p assert!(!data.to_string().contains(secret)); } -#[tokio::test] -async fn claude_postcompact_without_machine_provenance_is_read_only_unavailable() { - let outcome = claude_compact( - &json!({ - "event_json": r#"{"compact_summary":"self-asserted","digest":"self-asserted"}"#, - }), - SessionAuthorities::default(), - ) - .await - .unwrap(); +#[test] +fn claude_postcompact_without_machine_provenance_is_read_only_unavailable() { + let outcome = + claude_compact(r#"{"compact_summary":"self-asserted","digest":"self-asserted"}"#).unwrap(); - assert_eq!(outcome["status"], "unavailable"); assert_eq!( - outcome["reason"], - "claude_postcompact_provenance_unavailable" + serde_json::to_value(HookRuntimeResultV1::ClaudeCompact(outcome)).unwrap(), + json!({ + "action": "claude_compact", + "status": "unavailable", + "reason": "claude_postcompact_provenance_unavailable", + "summary_nodes_created": 0, + "summary_node_ids": [], + }) ); - assert_eq!(outcome["summary_nodes_created"], 0); - assert_eq!(outcome["summary_node_ids"], json!([])); } #[test] diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/mod.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/mod.rs index ad1892c0ad..939d21d734 100644 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/mod.rs +++ b/crates/tracedecay-mcp/src/handlers/hook_runtime/mod.rs @@ -1,25 +1,22 @@ -use crate::ToolResult; -use serde_json::{Value, json}; +use serde_json::Value; use std::path::Path; -use std::sync::Arc; use tracedecay_automation_runtime::automation::config_error; +use tracedecay_contracts::retrieval::{ + HookRuntimeAcceptedV1, HookRuntimeResultV1, HookRuntimeSurfaceRequestV1, +}; use tracedecay_domain::errors::Result; use tracedecay_global_db::RegisteredGlobalDb; use tracedecay_host_admission::SharedHostAdmissionBroker; use tracedecay_project::project::TraceDecay; use tracedecay_sessions::admission::HostAdmissionOutcome; -use tracedecay_sessions::serving::SessionRefreshWorkerPort; -use tracedecay_store_runtime::DaemonSessionRuntimeRegistryV1; use crate::handlers::SessionAuthorities; -use crate::handlers::tool_json; mod admission; mod context_scout; mod envelope; mod hermes; mod ingest; -mod terminal; #[cfg(test)] mod entry_tests; @@ -35,57 +32,75 @@ pub use hermes::replay_projectless_hermes_host_admission; use crate::map_host_admission_outcome; use admission::{hook_v2_admit, hook_v2_profile_admit}; -use context_scout::{ - ContextScoutReadSurfaceV1, hook_v2_cancel, hook_v2_delivery_receipt, hook_v2_feedback, - hook_v2_feedback_notice_delivery, hook_v2_scout_prepare, hook_v2_scout_read, hook_v2_status, -}; -use hermes::{hermes_receipt, user_review}; -use ingest::{ - accounting_receipt, claude_compact, codex_compact, cursor_compact, ingest_transcript, -}; -use terminal::retain_codex_stop; +use context_scout::{hook_v2_delivery_receipt, hook_v2_feedback_notice_delivery}; +use hermes::{hermes_receipt, user_review_unavailable}; +use ingest::{claude_compact, codex_compact, cursor_compact, ingest_transcript}; + +const TOOL_NAME: &str = "tracedecay_hook_runtime"; -fn required_str<'a>(args: &'a Value, key: &str) -> Result<&'a str> { - args.get(key) - .and_then(Value::as_str) +/// Decodes a `tracedecay_hook_runtime` call against its typed request. +/// `session_id` is a payload field here, so only presentation keys are +/// removed first. +pub fn decode_hook_runtime_request(args: &Value) -> Result { + let mut request = args.clone(); + if let Some(object) = request.as_object_mut() { + for key in ["format", "__mcp_request_id", "_meta"] { + object.remove(key); + } + } + serde_json::from_value(request) + .map_err(|error| config_error(format!("invalid arguments for {TOOL_NAME}: {error}"))) +} + +fn required_field<'a>(value: Option<&'a str>, key: &str) -> Result<&'a str> { + value .filter(|value| !value.is_empty()) .ok_or_else(|| config_error(format!("missing required parameter `{key}`"))) } +fn requires_projectless_routing(action: &str) -> tracedecay_domain::errors::TraceDecayError { + config_error(format!( + "hook action `{action}` requires projectless daemon routing" + )) +} + +/// Runs one hook-runtime action for the served project. #[hotpath::measure(future = true, label = "mcp.hook_runtime.total")] -pub async fn handle_hook_runtime( +pub async fn compute_hook_runtime( cg: &TraceDecay, - args: Value, + request: HookRuntimeSurfaceRequestV1, global_db: Option<&RegisteredGlobalDb>, accounting_db: Option<&RegisteredGlobalDb>, session_authorities: SessionAuthorities<'_>, -) -> Result { - let action = required_str(&args, "action")?; - let output = match action { - "reset_counter" => { +) -> Result { + use HookRuntimeSurfaceRequestV1 as Request; + Ok(match request { + Request::ResetCounter {} => { cg.reset_local_counter().await?; - json!({ "action": action, "reset": true }) - } - "accounting_receipt" => { - accounting_receipt(cg, required_project_db(&session_authorities)?).await? - } - "hook_v2_admit" | "hook_v2_guidance_lookup" => { - hook_v2_admit(cg, &args, action, session_authorities).await? + HookRuntimeResultV1::ResetCounter { reset: true } } - "hook_v2_scout_prepare" => hook_v2_scout_prepare(cg, &args).await?, - "hook_v2_delivery_receipt" => hook_v2_delivery_receipt(cg, &args).await?, - "hook_v2_feedback_notice_delivery" => hook_v2_feedback_notice_delivery(cg, &args).await?, - "hook_v2_feedback" => hook_v2_feedback(cg, &args).await?, - "hook_v2_cancel" => hook_v2_cancel(cg, &args).await?, - "hook_v2_status" => hook_v2_status(cg, &args).await?, - "opencode_lsp_updated" => { - opencode_lsp_updated(cg, &args, required_project_db(&session_authorities)?).await? + Request::HookV2Admit(request) => { + HookRuntimeResultV1::HookV2Admit(hook_v2_admit(cg, request, session_authorities).await?) } - action if ContextScoutReadSurfaceV1::from_action(action).is_some() => { - hook_v2_scout_read(cg, &args, action).await? + Request::HookV2DeliveryReceipt { receipt } => HookRuntimeResultV1::HookV2DeliveryReceipt { + status: hook_v2_delivery_receipt(cg, receipt).await?, + }, + Request::HookV2FeedbackNoticeDelivery { + envelope, + feedback_notice, + } => HookRuntimeResultV1::HookV2FeedbackNoticeDelivery(hook_v2_feedback_notice_delivery( + cg, + envelope, + feedback_notice, + )?), + Request::OpencodeLspUpdated { event } => { + opencode_lsp_updated(cg, &event, required_project_db(&session_authorities)?).await?; + HookRuntimeResultV1::OpencodeLspUpdated { + status: HookRuntimeAcceptedV1::Accepted, + } } - "ingest_transcript" => { - if args.get("user_scope").and_then(Value::as_bool) == Some(true) { + Request::IngestTranscript(request) => { + if request.user_scope { return Err(config_error( "user transcript ingest requires projectless daemon routing", )); @@ -93,46 +108,49 @@ pub async fn handle_hook_runtime( // Boxed: transcript ingest composes the deepest session-runtime // future in the handler tree; inlining it into the dispatch frame // overflows the perf-profile worker stack. - Box::pin(ingest_transcript( - Some(cg), - &args, - None, - global_db, - accounting_db, - session_authorities, + HookRuntimeResultV1::IngestTranscript(Box::new( + Box::pin(ingest_transcript( + Some(cg), + &request, + None, + global_db, + accounting_db, + session_authorities, + )) + .await?, )) - .await? } - "codex_stop" | "user_review" | "hermes_receipt" => { - return Err(config_error(format!( - "hook action `{action}` requires projectless daemon routing" - ))); + Request::CodexCompact { event_json } => HookRuntimeResultV1::CodexCompact( + codex_compact(cg, &event_json, session_authorities).await?, + ), + Request::ClaudeCompact { + event_json, + user_scope, + } => { + if user_scope { + return Err(requires_projectless_routing("claude_compact")); + } + HookRuntimeResultV1::ClaudeCompact(claude_compact(&event_json)?) + } + Request::CursorCompact { event_json } => HookRuntimeResultV1::CursorCompact( + cursor_compact(&event_json, session_authorities).await?, + ), + Request::UserReview { .. } => return Err(requires_projectless_routing("user_review")), + Request::HermesReceipt { .. } => { + return Err(requires_projectless_routing("hermes_receipt")); } - "codex_compact" => codex_compact(cg, &args, session_authorities).await?, - "claude_compact" => claude_compact(&args, session_authorities).await?, - "cursor_compact" => cursor_compact(cg, &args, session_authorities).await?, - other => { - return Err(config_error(format!( - "unknown hook runtime action: {other}" - ))); + Request::HookV2ProfileAdmit { .. } => { + return Err(requires_projectless_routing("hook_v2_profile_admit")); } - }; - Ok(tool_json( - Some(&cg.store_layout().response_handle_root), - &args, - &output, - )) + }) } #[hotpath::measure(future = true, label = "mcp.hook_runtime.lsp")] async fn opencode_lsp_updated( cg: &TraceDecay, - args: &Value, + event: &Value, project_sessions: &RegisteredGlobalDb, -) -> Result { - let event = args - .get("event") - .ok_or_else(|| config_error("missing required parameter `event`"))?; +) -> Result<()> { let payload = serde_json::to_vec(event) .map_err(|error| config_error(format!("invalid OpenCode LSP event: {error}")))?; tracedecay_hooks::decode_opencode_lsp_event(&payload) @@ -146,96 +164,83 @@ async fn opencode_lsp_updated( Some("opencode_lsp_updated"), ) .await; - Ok(json!({ - "action": "opencode_lsp_updated", - "status": "accepted", - })) + Ok(()) } +/// Runs one hook-runtime action that has no project route: it lands in the +/// authenticated profile's stores. #[hotpath::measure(future = true, label = "mcp.hook_runtime.projectless")] -pub async fn handle_projectless_hook_runtime( - args: Value, +pub async fn compute_projectless_hook_runtime( + request: HookRuntimeSurfaceRequestV1, profile_root: &Path, - session_runtime_registry: Arc, global_db: &RegisteredGlobalDb, session_authorities: SessionAuthorities<'_>, host_admission_broker: std::result::Result<&SharedHostAdmissionBroker, HostAdmissionOutcome>, - user_refresh: Arc, -) -> Result { - let action = required_str(&args, "action")?; - if !projectless_action_allowed(action, &args) { - return Err(config_error(format!( - "projectless hook runtime action `{action}` is forbidden" - ))); - } - let output = match action { - "ingest_transcript" => { - // Projectless (user-scope) ingest has no project session store to - // correlate hint outcomes against; the settlement runs on - // project-scope ingests only. - ingest_transcript( - None, - &args, - Some(profile_root), - Some(global_db), - None, - session_authorities, - ) - .await? +) -> Result { + use HookRuntimeSurfaceRequestV1 as Request; + Ok(match request { + // Projectless (user-scope) ingest has no project session store to + // correlate hint outcomes against; the settlement runs on + // project-scope ingests only. + Request::IngestTranscript(request) if request.user_scope => { + HookRuntimeResultV1::IngestTranscript(Box::new( + ingest_transcript( + None, + &request, + Some(profile_root), + Some(global_db), + None, + session_authorities, + ) + .await?, + )) } - "user_review" => user_review(&args, profile_root, &session_runtime_registry).await?, - "codex_stop" => retain_codex_stop( - &args, - profile_root, - &session_runtime_registry, - &session_authorities, - Arc::clone(&user_refresh), - )?, - "hermes_receipt" => { + Request::UserReview { .. } => return Err(user_review_unavailable()), + Request::HermesReceipt { event } => { let host_admission_broker = host_admission_broker.map_err(|outcome| map_host_admission_outcome(&outcome))?; - hermes_receipt( - &args, + HookRuntimeResultV1::HermesReceipt { + status: hermes_receipt( + event, + profile_root, + required_user_db(&session_authorities)?, + host_admission_broker, + ) + .await?, + } + } + Request::HookV2ProfileAdmit { admission } => { + HookRuntimeResultV1::HookV2ProfileAdmit(hook_v2_profile_admit( + admission, profile_root, - Some(&session_runtime_registry), - required_user_db(&session_authorities)?, - host_admission_broker, - ) - .await? + session_authorities + .profile_identity + .as_deref() + .ok_or_else(|| { + config_error( + "authenticated profile identity is unavailable for Hook V2 admission", + ) + })?, + )?) } - "hook_v2_profile_admit" => hook_v2_profile_admit( - &args, - action, - profile_root, - session_authorities - .profile_identity - .as_deref() - .ok_or_else(|| { - config_error( - "authenticated profile identity is unavailable for Hook V2 admission", - ) - })?, - )?, - "claude_compact" => claude_compact(&args, session_authorities).await?, - _ => unreachable!("projectless hook action validated above"), - }; - Ok(tool_json(None, &args, &output)) -} - -fn projectless_action_allowed(action: &str, args: &Value) -> bool { - matches!( - action, - "codex_stop" | "user_review" | "hermes_receipt" | "hook_v2_profile_admit" - ) || (action == "claude_compact" - && args.get("user_scope").and_then(Value::as_bool) == Some(true)) - || (action == "ingest_transcript" - && args.get("user_scope").and_then(Value::as_bool) == Some(true)) -} - -fn required_value(args: &Value, key: &str) -> Result { - args.get(key) - .cloned() - .ok_or_else(|| config_error(format!("missing required field `{key}`"))) + Request::ClaudeCompact { + event_json, + user_scope: true, + } => HookRuntimeResultV1::ClaudeCompact(claude_compact(&event_json)?), + Request::ResetCounter {} + | Request::HookV2Admit(_) + | Request::HookV2DeliveryReceipt { .. } + | Request::HookV2FeedbackNoticeDelivery { .. } + | Request::OpencodeLspUpdated { .. } + | Request::IngestTranscript(_) + | Request::CodexCompact { .. } + | Request::ClaudeCompact { .. } + | Request::CursorCompact { .. } => { + return Err(config_error( + "projectless hook runtime action requires a project route", + )); + } + }) } fn required_project_db<'a>(authorities: &SessionAuthorities<'a>) -> Result<&'a RegisteredGlobalDb> { diff --git a/crates/tracedecay-mcp/src/handlers/hook_runtime/terminal.rs b/crates/tracedecay-mcp/src/handlers/hook_runtime/terminal.rs deleted file mode 100644 index 24ea5b86af..0000000000 --- a/crates/tracedecay-mcp/src/handlers/hook_runtime/terminal.rs +++ /dev/null @@ -1,133 +0,0 @@ -use crate::handlers::SessionAuthorities; -use serde_json::{Value, json}; -use std::future::Future; -use std::path::Path; -use std::sync::Arc; -use std::time::Duration; -use tracedecay_automation_runtime::automation::config_error; -use tracedecay_domain::errors::Result; -use tracedecay_sessions::serving::SessionRefreshWorkerPort; - -use super::hermes::user_review; -use super::ingest::ingest_transcript_with_cancellation; -use super::required_str; - -/// Admit a Codex terminal receipt by retaining its follow-up work in -/// the daemon. The hook only receives this acknowledgement; transcript ingest -/// and review are cancellable daemon-owned work for that exact session. -#[hotpath::measure(label = "mcp.hook_runtime.terminal")] -pub(super) fn retain_codex_stop( - args: &Value, - profile_root: &Path, - session_runtime_registry: &Arc, - session_authorities: &SessionAuthorities<'_>, - user_refresh: Arc, -) -> Result { - let session_id = required_str(args, "session_id")?.to_owned(); - let user_sessions = session_authorities - .user - .cloned() - .ok_or_else(|| config_error("daemon user session database is unavailable"))?; - let profile_identity = session_authorities - .profile_identity - .clone() - .ok_or_else(|| config_error("daemon profile identity is unavailable"))?; - let background_cpu = session_authorities.background_cpu.clone(); - let profile_root = profile_root.to_path_buf(); - let weak_registry = Arc::downgrade(session_runtime_registry); - let task_session_id = session_id.clone(); - let accepted = - session_runtime_registry.retain_hook_task("codex", &session_id, move |cancellation| { - hotpath::future!( - async move { - if cancellation.is_cancelled() { - return; - } - let Some(session_runtime_registry) = weak_registry.upgrade() else { - return; - }; - let Ok(global_db) = session_runtime_registry.profile_database().await else { - return; - }; - let ingest_args = json!({ - "action": "ingest_transcript", - "provider": "codex", - "user_scope": true, - "session_id": task_session_id.clone(), - }); - let authorities = SessionAuthorities::new(None, Some(&user_sessions)) - .with_profile_identity(Some(std::sync::Arc::clone(&profile_identity))) - .with_background_cpu(background_cpu.clone()); - let ingested = ingest_transcript_with_cancellation( - None, - &ingest_args, - Some(&profile_root), - Some(global_db.as_ref()), - None, - authorities, - &cancellation, - ) - .await; - // The parent `codex_stop` acknowledgement returns before - // this task writes. Wake the profile scheduler that owns - // the user store, or the new effects sit until some other - // pass happens to run. - if !user_refresh.wake() { - tracing::warn!( - session_id = %task_session_id, - "retained hook ingest did not wake session temporal refresh" - ); - } - let ingested = ingested - .ok() - .and_then(|result| result.get("messages_upserted").and_then(Value::as_u64)) - .is_some_and(|count| count > 0); - if ingested - && !cancellation.is_cancelled() - && let Some(session_id) = ingest_args.get("session_id").cloned() - { - let _ = await_terminal_operation( - &cancellation, - user_review( - &json!({ - "action": "user_review", - "provider": "codex", - "session_id": session_id, - }), - &profile_root, - &session_runtime_registry, - ), - ) - .await; - } - }, - label = "mcp.hook_runtime.terminal_followup" - ) - }); - if !accepted { - return Err(config_error( - "daemon retained terminal-hook task is unavailable", - )); - } - Ok(json!({ - "action": "codex_stop", - "status": "accepted", - "session_id": session_id, - })) -} - -pub(super) async fn await_terminal_operation( - cancellation: &tracedecay_sessions::observation::ObservationCancellation, - operation: impl Future, -) -> Option { - tokio::pin!(operation); - loop { - if cancellation.is_cancelled() { - return None; - } - tokio::select! { - output = &mut operation => return Some(output), - () = tokio::time::sleep(Duration::from_millis(10)) => {} - } - } -} diff --git a/crates/tracedecay-mcp/src/lib.rs b/crates/tracedecay-mcp/src/lib.rs index 8629edf1cd..2ece99ec70 100644 --- a/crates/tracedecay-mcp/src/lib.rs +++ b/crates/tracedecay-mcp/src/lib.rs @@ -113,10 +113,9 @@ pub use tracedecay_mcp_catalog::{ context_description, context_warming_description, explore_call_budget, format_capable_tool_names, get_maximal_tool_definitions, get_maximal_tool_definitions_with_budget, get_tool_definitions, - get_tool_definitions_with_budget, get_tool_definitions_with_warming_budget, - internal_daemon_tool_definition, mcp_input_schema, project_catalog_discovery_scope, - registered_project_reader_tool_names, retain_host_available_tool_definitions, - tool_defaults_to_markdown, + get_tool_definitions_with_budget, get_tool_definitions_with_warming_budget, mcp_input_schema, + project_catalog_discovery_scope, registered_project_reader_tool_names, + retain_host_available_tool_definitions, tool_defaults_to_markdown, }; pub use workflow::{ MAX_TEST_TIMEOUT_SECS, MAX_TESTS_HARD_CAP, RunAffectedArgs, TestProfile, TestRunControl, diff --git a/crates/tracedecay-mcp/src/server/live_transcript_refresh.rs b/crates/tracedecay-mcp/src/server/live_transcript_refresh.rs index 242d2aae05..b769ce9878 100644 --- a/crates/tracedecay-mcp/src/server/live_transcript_refresh.rs +++ b/crates/tracedecay-mcp/src/server/live_transcript_refresh.rs @@ -23,22 +23,13 @@ fn required_refresh_scope( tool_name: &str, arguments: &Value, ) -> Option { - let required = match tool_name { - "tracedecay_hook_runtime" => { - arguments.get("action").and_then(Value::as_str) == Some("ingest_transcript") - } - "tracedecay_lcm_preflight" => { - arguments - .get("transcript_projection") - .and_then(Value::as_bool) - == Some(true) - } - _ => false, - }; + let required = tool_name == "tracedecay_lcm_preflight" + && arguments + .get("transcript_projection") + .and_then(Value::as_bool) + == Some(true); required.then(|| { - if arguments.get("user_scope").and_then(Value::as_bool) == Some(true) - || arguments.get("storage_scope").and_then(Value::as_str) == Some("user") - { + if arguments.get("storage_scope").and_then(Value::as_str) == Some("user") { LiveTranscriptRefreshScope::User } else { LiveTranscriptRefreshScope::Project @@ -46,21 +37,7 @@ fn required_refresh_scope( }) } -fn refresh_unavailable(tool_name: &str) -> TraceDecayError { - const DETAIL: &str = "session temporal refresh did not publish before hook completion"; - if tool_name == "tracedecay_hook_runtime" { - TraceDecayError::hook_runtime_with_status( - "temporal_refresh_unavailable", - true, - DETAIL, - tracedecay_sessions::admission::HostAdmissionStatus::Unavailable.as_wire(), - ) - } else { - TraceDecayError::Config { - message: DETAIL.to_owned(), - } - } -} +const REFRESH_UNAVAILABLE: &str = "session temporal refresh did not publish before hook completion"; /// Joins the refresh owner of the store this call wrote. /// @@ -77,18 +54,55 @@ pub async fn join_required_live_transcript_refresh( let Some(scope) = required_refresh_scope(tool_name, arguments) else { return Ok(LiveTranscriptRefreshJoin::NotRequired); }; + join_scope(scope, project_wake, user_wake, || TraceDecayError::Config { + message: REFRESH_UNAVAILABLE.to_owned(), + }) + .await +} + +/// Joins the refresh owner of the store a completed hook transcript ingest +/// wrote: the user store's for a `user_scope` ingest, the project's +/// otherwise. +pub async fn join_hook_ingest_refresh( + user_scope: bool, + project_wake: Option<&dyn SessionRefreshWorkerPort>, + user_wake: Option<&dyn SessionRefreshWorkerPort>, +) -> Result<()> { + let scope = if user_scope { + LiveTranscriptRefreshScope::User + } else { + LiveTranscriptRefreshScope::Project + }; + join_scope(scope, project_wake, user_wake, || { + TraceDecayError::hook_runtime_with_status( + "temporal_refresh_unavailable", + true, + REFRESH_UNAVAILABLE, + tracedecay_sessions::admission::HostAdmissionStatus::Unavailable.as_wire(), + ) + }) + .await + .map(|_| ()) +} + +async fn join_scope( + scope: LiveTranscriptRefreshScope, + project_wake: Option<&dyn SessionRefreshWorkerPort>, + user_wake: Option<&dyn SessionRefreshWorkerPort>, + unavailable: impl Fn() -> TraceDecayError, +) -> Result { let wake = match scope { LiveTranscriptRefreshScope::Project => project_wake, LiveTranscriptRefreshScope::User => user_wake, } - .ok_or_else(|| refresh_unavailable(tool_name))?; + .ok_or_else(&unavailable)?; if wake .wake_and_wait_until_idle(LIVE_TRANSCRIPT_REFRESH_DEADLINE) .await { Ok(LiveTranscriptRefreshJoin::PublicationJoined) } else { - Err(refresh_unavailable(tool_name)) + Err(unavailable()) } } @@ -158,9 +172,8 @@ mod tests { #[tokio::test] async fn completed_hook_ingest_fails_when_its_refresh_owner_is_unavailable() { - let error = super::join_required_live_transcript_refresh( - "tracedecay_hook_runtime", - &json!({"action": "ingest_transcript"}), + let error = super::join_hook_ingest_refresh( + false, Some(&UnavailableSessionTemporalRefreshWake), None, ) @@ -183,14 +196,9 @@ mod tests { #[tokio::test] async fn user_scope_never_falls_back_to_the_project_refresh_owner() { let project = PublishingRefresh::idle(); - let error = super::join_required_live_transcript_refresh( - "tracedecay_hook_runtime", - &json!({"action": "ingest_transcript", "user_scope": true}), - Some(&project), - None, - ) - .await - .expect_err("user ingest must require the user refresh owner"); + let error = super::join_hook_ingest_refresh(true, Some(&project), None) + .await + .expect_err("user ingest must require the user refresh owner"); assert_eq!( error.hook_runtime_context().map(|context| context.0), @@ -205,14 +213,9 @@ mod tests { #[tokio::test] async fn project_ingest_does_not_publish_through_the_user_refresh_owner() { let user = PublishingRefresh::idle(); - let error = super::join_required_live_transcript_refresh( - "tracedecay_hook_runtime", - &json!({"action": "ingest_transcript"}), - None, - Some(&user), - ) - .await - .expect_err("project ingest must require the project refresh owner"); + let error = super::join_hook_ingest_refresh(false, None, Some(&user)) + .await + .expect_err("project ingest must require the project refresh owner"); assert_eq!( error.hook_runtime_context().map(|context| context.0), @@ -228,16 +231,10 @@ mod tests { async fn hook_ingest_joins_the_project_refresh_owner() { let project = PublishingRefresh::idle(); let user = PublishingRefresh::idle(); - let joined = super::join_required_live_transcript_refresh( - "tracedecay_hook_runtime", - &json!({"action": "ingest_transcript"}), - Some(&project), - Some(&user), - ) - .await - .expect("project hook ingest must join its refresh owner"); + super::join_hook_ingest_refresh(false, Some(&project), Some(&user)) + .await + .expect("project hook ingest must join its refresh owner"); - assert_eq!(joined, LiveTranscriptRefreshJoin::PublicationJoined); assert!( project.published(), "hook ingest must publish through the project refresh owner" @@ -247,4 +244,22 @@ mod tests { "project hook ingest must not also publish through the user owner" ); } + + #[tokio::test] + async fn projected_lcm_preflight_joins_its_user_refresh_owner() { + let project = PublishingRefresh::idle(); + let user = PublishingRefresh::idle(); + let joined = super::join_required_live_transcript_refresh( + "tracedecay_lcm_preflight", + &json!({"transcript_projection": true, "storage_scope": "user"}), + Some(&project), + Some(&user), + ) + .await + .expect("projected preflight must join its refresh owner"); + + assert_eq!(joined, LiveTranscriptRefreshJoin::PublicationJoined); + assert!(user.published()); + assert!(!project.published()); + } } diff --git a/crates/tracedecay-mcp/src/server/mod.rs b/crates/tracedecay-mcp/src/server/mod.rs index 83b1ecb33c..7c2f28b74b 100644 --- a/crates/tracedecay-mcp/src/server/mod.rs +++ b/crates/tracedecay-mcp/src/server/mod.rs @@ -20,7 +20,7 @@ pub use dispatch::{ needs_lazy_sync_before_dispatch, }; pub use live_transcript_refresh::{ - LiveTranscriptRefreshJoin, join_required_live_transcript_refresh, + LiveTranscriptRefreshJoin, join_hook_ingest_refresh, join_required_live_transcript_refresh, }; pub use project_host_admission_replay::{ ProjectHostAdmissionReplayTask, ProjectHostAdmissionReplayWorker, diff --git a/crates/tracedecay-mcp/src/tools/binding.rs b/crates/tracedecay-mcp/src/tools/binding.rs index 3054437d46..b26925f2aa 100644 --- a/crates/tracedecay-mcp/src/tools/binding.rs +++ b/crates/tracedecay-mcp/src/tools/binding.rs @@ -38,7 +38,6 @@ pub const INTERNAL_DAEMON_TOOL_NAMES: &[&str] = &[ "tracedecay_admin_branch_add", "tracedecay_admin_cli", "tracedecay_admin_project", - "tracedecay_hook_runtime", ]; /// Which dispatch family owns a tool once the surface predicates decline it. @@ -299,6 +298,7 @@ fn application_surface_branch_sensitivity( | ApplicationSurfaceOperation::ProjectSearch | ApplicationSurfaceOperation::ProjectContext | ApplicationSurfaceOperation::AdminSync + | ApplicationSurfaceOperation::HookRuntime | HealthRead | HealthDelta | DiagnosticsRead @@ -349,7 +349,7 @@ macro_rules! binding_groups { #[rustfmt::skip] const BINDING_GROUPS: &[BindingGroup] = binding_groups![ [Some(McpToolDispatchGroup::Admin), RegisteredProjectAccess::ActiveProjectOnly, - "tracedecay_hook_runtime", "tracedecay_admin_cli", "tracedecay_admin_project"], + "tracedecay_admin_cli", "tracedecay_admin_project"], [Some(McpToolDispatchGroup::Git), RegisteredProjectAccess::ActiveProjectOnly, "tracedecay_admin_branch_add"], [Some(McpToolDispatchGroup::MultiRoot), RegisteredProjectAccess::ActiveProjectOnly, diff --git a/crates/tracedecay-tool-catalog/src/manifest.rs b/crates/tracedecay-tool-catalog/src/manifest.rs index 54a5d4981b..1feaced15a 100644 --- a/crates/tracedecay-tool-catalog/src/manifest.rs +++ b/crates/tracedecay-tool-catalog/src/manifest.rs @@ -142,6 +142,9 @@ pub enum EffectClass { /// Queues work on a daemon-owned scheduler; the call answers with the /// scheduler's admission, not the finished work. SchedulesWork, + /// Records a host's session evidence (transcripts, hook admissions, + /// receipts) in daemon-owned session stores. + RecordsHostEvidence, } impl EffectClass { @@ -154,7 +157,10 @@ impl EffectClass { pub const fn is_owner_side_effect(self) -> bool { matches!( self, - Self::SpawnsProcess | Self::BindsServer | Self::SchedulesWork + Self::SpawnsProcess + | Self::BindsServer + | Self::SchedulesWork + | Self::RecordsHostEvidence ) } diff --git a/crates/tracedecay-tool-catalog/src/operation.rs b/crates/tracedecay-tool-catalog/src/operation.rs index c7fd11cc95..f5f060a1d1 100644 --- a/crates/tracedecay-tool-catalog/src/operation.rs +++ b/crates/tracedecay-tool-catalog/src/operation.rs @@ -219,6 +219,7 @@ application_surface_operations! { ProjectSearch => "project_search"; ProjectContext => "project_context"; AdminSync => "admin_sync"; + HookRuntime => "hook_runtime"; HealthRead => "health_read"; HealthDelta => "health_delta"; StorageStatus => "storage_status"; @@ -353,6 +354,7 @@ impl ApplicationSurfaceOperation { Self::RemoteStatus, Self::Runtime, Self::AdminSync, + Self::HookRuntime, ]; /// Reads of the authenticated profile's project registry. They name no @@ -364,7 +366,7 @@ impl ApplicationSurfaceOperation { /// Owner-served operations that first-party CLI commands and host hooks /// call by name. They are never advertised in `tools/list` or mounted on /// HTTP, so an agent cannot discover or select them. - pub const INTERNAL_OPERATIONS: &[Self] = &[Self::AdminSync]; + pub const INTERNAL_OPERATIONS: &[Self] = &[Self::AdminSync, Self::HookRuntime]; pub fn is_graph_tool(self) -> bool { Self::GRAPH_TOOL_OPERATIONS.contains(&self) diff --git a/crates/tracedecay-tool-catalog/src/owner_side_effect.rs b/crates/tracedecay-tool-catalog/src/owner_side_effect.rs index 1623ecd39d..f8b3988cd6 100644 --- a/crates/tracedecay-tool-catalog/src/owner_side_effect.rs +++ b/crates/tracedecay-tool-catalog/src/owner_side_effect.rs @@ -48,6 +48,11 @@ impl ApplicationSurfaceOperation { ceiling_millis: LONG_RUNNING_CEILING_MILLIS, identical_calls: IdenticalCallPolicyV1::RunEach, }), + Self::HookRuntime => Some(OwnerSideEffectEntryV1 { + effect: EffectClass::RecordsHostEvidence, + ceiling_millis: INTERACTIVE_CEILING_MILLIS, + identical_calls: IdenticalCallPolicyV1::RunEach, + }), _ => None, } } @@ -94,6 +99,14 @@ mod tests { identical_calls: IdenticalCallPolicyV1::RunEach, } ), + ( + "hook_runtime", + OwnerSideEffectEntryV1 { + effect: EffectClass::RecordsHostEvidence, + ceiling_millis: 120_000, + identical_calls: IdenticalCallPolicyV1::RunEach, + } + ), ] ); assert_eq!(ApplicationSurfaceOperation::Files.owner_side_effect(), None); diff --git a/crates/tracedecay/src/daemon/invocation_dispatch.rs b/crates/tracedecay/src/daemon/invocation_dispatch.rs index da12492793..981b510e66 100644 --- a/crates/tracedecay/src/daemon/invocation_dispatch.rs +++ b/crates/tracedecay/src/daemon/invocation_dispatch.rs @@ -379,6 +379,14 @@ pub(super) async fn execute_portable_daemon_invocation( DaemonInvocationPayload::ProfileGraphTool { .. } => handshake.project_path.clone(), _ => None, }; + let requirement = match &request.payload { + DaemonInvocationPayload::GraphTool { + surface_operation: tracedecay_tool_catalog::ApplicationSurfaceOperation::HookRuntime, + arguments, + .. + } => super::project_open_admission::hook_runtime_requirement(arguments.get("action")), + _ => ProjectServerRequirement::Core, + }; if request.requires_project() { let project_server = hotpath::measure_block!( "daemon.invocation.project_open", @@ -389,7 +397,7 @@ pub(super) async fn execute_portable_daemon_invocation( invocation.clone(), http_application_registry.clone(), handshake, - ProjectServerRequirement::Core, + requirement, #[cfg(test)] project_open_attempts.clone(), )) @@ -449,7 +457,7 @@ pub(super) async fn execute_portable_daemon_invocation( invocation.clone(), http_application_registry.clone(), handshake, - ProjectServerRequirement::Core, + requirement, #[cfg(test)] lsp_project_open_attempts, ), diff --git a/crates/tracedecay/src/daemon/project_open_admission.rs b/crates/tracedecay/src/daemon/project_open_admission.rs index bde2ec2a22..111e662042 100644 --- a/crates/tracedecay/src/daemon/project_open_admission.rs +++ b/crates/tracedecay/src/daemon/project_open_admission.rs @@ -1073,19 +1073,31 @@ pub(super) fn project_server_requirement( match classify_mcp_method(&request.method) { McpMethod::HookEvent => ProjectServerRequirement::RegisteredHostIngest, McpMethod::ToolsCall => match projectless_tool_call(request.params.as_ref()) { - Ok(("tracedecay_hook_runtime", arguments)) - if arguments.get("action").and_then(serde_json::Value::as_str) - == Some("reset_counter") => + Ok((tool_name, arguments)) + if tool_name + == tracedecay_tool_catalog::ApplicationSurfaceOperation::HookRuntime + .mcp_tool_name() => { - ProjectServerRequirement::Core + hook_runtime_requirement(arguments.get("action")) } - Ok(("tracedecay_hook_runtime", _)) => ProjectServerRequirement::RegisteredHostIngest, _ => ProjectServerRequirement::Core, }, _ => ProjectServerRequirement::Core, } } +/// A hook action records host evidence through the session stores only the +/// full server mounts; resetting the local counter needs only the core one. +pub(super) fn hook_runtime_requirement( + action: Option<&serde_json::Value>, +) -> ProjectServerRequirement { + if action.and_then(serde_json::Value::as_str) == Some("reset_counter") { + ProjectServerRequirement::Core + } else { + ProjectServerRequirement::RegisteredHostIngest + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(super) enum ProjectServerPublication { Pending, diff --git a/crates/tracedecay/src/daemon/projectless.rs b/crates/tracedecay/src/daemon/projectless.rs index 0c9f474e2e..6809c57976 100644 --- a/crates/tracedecay/src/daemon/projectless.rs +++ b/crates/tracedecay/src/daemon/projectless.rs @@ -1,23 +1,18 @@ //! Projectless client handling: tool calls served without a mounted project //! (user-scoped LCM, message search, dashboard, doctor, version). -use std::sync::Arc; - use serde_json::json; use tracedecay_daemon_identity::authority; use tracedecay_daemon_protocol::DaemonClientIdentity; use tracedecay_domain::errors::Result; -use tracedecay_mcp::server::{LiveTranscriptRefreshJoin, join_required_live_transcript_refresh}; use tracedecay_mcp::tools::catalog_discovery::{ catalog_discovery_tools_list_payload, default_catalog_discovery_authority, }; use tracedecay_mcp::{ ErrorCode, JsonRpcRequest, JsonRpcResponse, McpTransport, ToolRegistryMode, explore_call_budget, project_catalog_discovery_scope, tool_error_response, - tool_result_has_semantic_error, }; -use tracedecay_sessions::serving::SessionRefreshWorkerPort; use super::*; use tracedecay_daemon_service::shutdown::DaemonLifecycle; @@ -521,13 +516,6 @@ async fn projectless_hook_runtime_response( return JsonRpcResponse::error(id, ErrorCode::InternalError, error.to_string()); } }; - let session_runtime_registry = - match boxed_projectless_phase(store_administration.registered_runtime_registry()).await { - Ok(registry) => registry, - Err(error) => { - return JsonRpcResponse::error(id, ErrorCode::InternalError, error.to_string()); - } - }; let user_session_db = match boxed_projectless_phase(store_administration.registered_profile_session_database()) .await @@ -562,12 +550,17 @@ async fn projectless_hook_runtime_response( ), ) .await; - let user_refresh: Arc = Arc::new(refresh_wake.clone()); - match boxed_projectless_phase( - tracedecay_mcp::handlers::hook_runtime::handle_projectless_hook_runtime( - arguments.clone(), + let request = + match tracedecay_mcp::handlers::hook_runtime::decode_hook_runtime_request(&arguments) { + Ok(request) => request, + Err(error) => { + return JsonRpcResponse::error(id, ErrorCode::InternalError, error.to_string()); + } + }; + let result = match boxed_projectless_phase( + tracedecay_mcp::handlers::hook_runtime::compute_projectless_hook_runtime( + request, &connection.client_identity.profile_root, - session_runtime_registry, global_db.as_ref(), tracedecay_mcp::handlers::SessionAuthorities::new(None, Some(&user_session_db)) .with_profile_identity(Some(std::sync::Arc::new(profile_identity.clone()))) @@ -577,31 +570,35 @@ async fn projectless_hook_runtime_response( .background_cpu(), ), host_admission_broker, - Arc::clone(&user_refresh), ), ) .await { - Ok(result) if tool_result_has_semantic_error(&result) => { - JsonRpcResponse::success(id, result.value) + Ok(result) => result, + Err(error) => { + return JsonRpcResponse::error(id, ErrorCode::InternalError, error.to_string()); } - Ok(result) => match boxed_projectless_phase(join_required_live_transcript_refresh( - "tracedecay_hook_runtime", - &arguments, - None, - Some(&refresh_wake), - )) - .await + }; + if let tracedecay_contracts::retrieval::HookRuntimeResultV1::IngestTranscript(ingest) = &result + { + if let Err(error) = + boxed_projectless_phase(tracedecay_mcp::server::join_hook_ingest_refresh( + ingest.user_scope, + None, + Some(&refresh_wake), + )) + .await { - Ok(LiveTranscriptRefreshJoin::PublicationJoined) => { - JsonRpcResponse::success(id, result.value) - } - Ok(LiveTranscriptRefreshJoin::NotRequired) => { - refresh_wake.wake(); - JsonRpcResponse::success(id, result.value) - } - Err(error) => tool_error_response(id, "tracedecay_hook_runtime", &error), - }, + return tool_error_response(id, "tracedecay_hook_runtime", &error); + } + } else { + refresh_wake.wake(); + } + match serde_json::to_value(&result) { + Ok(output) => JsonRpcResponse::success( + id, + tracedecay_mcp::handlers::tool_json(None, &arguments, &output).value, + ), Err(error) => JsonRpcResponse::error(id, ErrorCode::InternalError, error.to_string()), } } @@ -900,58 +897,4 @@ mod projectless_admission_tests { "retargeting the client symlink must never redirect durable receipt writes" ); } - - #[tokio::test] - async fn removed_client_profile_symlink_keeps_retained_codex_path_pinned() { - let temp = tempfile::tempdir().expect("tempdir"); - let (real_root, linked_root) = linked_profile_root(temp.path()); - tracedecay_project::product_runtime::register_fixture_product_runtime(); - tracedecay_project::test_support::host_admission::ensure_process_background_cpu_authority() - .expect("install fixture worker authority"); - let identity = tracedecay_daemon_identity::profile_identity::load_or_create(&real_root) - .expect("pin profile identity"); - let administration = StoreAdministration::default().with_profile_identity(identity); - let _database_scope = tracedecay_runtime_core::db::enter_daemon_database_scope( - &real_root, - 1, - "projectless-removed-codex-test", - ) - .expect("enter fixture database scope"); - let client = DaemonClientIdentity::new(linked_root.clone(), linked_root.join("global.db")); - let connection = admit_projectless_connection(&client, &administration) - .expect("admit symlinked client profile"); - let runtime_registry = administration - .registered_runtime_registry() - .await - .expect("open profile runtime registry"); - - std::fs::remove_file(linked_root.parent().expect("linked profile parent")) - .expect("remove client profile symlink after admission"); - let retained_profile_root = connection.client_identity.profile_root.clone(); - let retained_global_db_path = connection.client_identity.global_db_path.clone(); - - let response = projectless_hook_runtime_response( - json!(2), - json!({ - "action": "codex_stop", - "session_id": "pinned-codex-session" - }), - &connection, - &administration, - ) - .await; - let terminal_shutdown = runtime_registry.shutdown_terminal_tasks().await; - administration.shutdown_host_admission_replay().await; - - assert_eq!(retained_profile_root, real_root); - assert_eq!( - retained_global_db_path, - retained_profile_root.join("global.db") - ); - assert!( - response.error.is_none(), - "retained Codex stop failed after client symlink removal: {response:?}" - ); - terminal_shutdown.expect("join retained Codex task"); - } } diff --git a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs index 719c05476b..b1ab80756e 100644 --- a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs +++ b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs @@ -6,11 +6,14 @@ use std::path::Path; use std::sync::{Arc, Weak}; use tracedecay_contracts::ResolvedScope; +use tracedecay_contracts::graph_tool::GraphToolResultV1; +use tracedecay_contracts::retrieval::HookRuntimeResultV1; use tracedecay_daemon_service::{ DaemonInvocationService, GraphToolFuture, GraphToolInvocationV1, ProjectGraphToolPortV1, RegisteredGraphToolOwnerV1, }; use tracedecay_domain::errors::{Result, TraceDecayError}; +use tracedecay_mcp::server::join_hook_ingest_refresh; use tracedecay_tool_catalog::ApplicationSurfaceOperation; use super::McpServer; @@ -57,7 +60,10 @@ impl McpServer { session_authorities: tracedecay_mcp::handlers::SessionAuthorities::new( self.project_session_db.as_ref(), self.profile_session_db.as_ref(), - ), + ) + .with_profile_identity(self.profile_identity.clone()) + .with_background_cpu(self.background_cpu.clone()) + .with_project_lcm_authority(self.project_lcm_authority.as_deref()), server_stats, code_index_readiness_waiter: self.code_index_readiness_waiter.clone(), generation_census_reader: self.generation_census_reader(), @@ -109,14 +115,34 @@ impl McpServer { retained_project_server_resolver: self.retained_project_server_resolver.clone(), ..ToolCallRegistryOptions::default() }; - compute_graph_tool_for_owner( + let computed = compute_graph_tool_for_owner( cg.as_ref(), invocation.operation, serde_json::Value::Object(invocation.arguments), self.scope_prefix(), options, - ) - .await + ); + // This server's profile owns every transcript a hook action ingests. + let completion = match self.profile.clone() { + Some(profile) => { + tracedecay_sessions::runtime::with_transcript_source_profile(profile, computed) + .await + } + None => computed.await, + }?; + if let GraphToolResultV1::HookRuntime(HookRuntimeResultV1::IngestTranscript(ingest)) = + &completion.result + { + // The ingest wrote through this server's session stores; answer + // only once their refresh owner has published it. + join_hook_ingest_refresh( + ingest.user_scope, + self.project_session_refresh_wake.as_deref(), + self.user_session_refresh_wake.as_deref(), + ) + .await?; + } + Ok(completion) } /// Registers this server as its project's graph-tool owner, replacing an diff --git a/crates/tracedecay/src/mcp/tools/handlers/application_surface.rs b/crates/tracedecay/src/mcp/tools/handlers/application_surface.rs index 9c04422c82..b7b94e5877 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/application_surface.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/application_surface.rs @@ -589,6 +589,11 @@ pub(crate) fn graph_tool_error_problem( { return tracedecay_contracts::ApplicationProblem::from_detail(detail); } + // A hook's admission authority names its own reason and retry verdict; + // they travel as the problem's code and retry directive. + if let Some((reason_code, retryable, detail)) = error.hook_runtime_context() { + return graph_tool_unavailable(reason_code, retryable, detail); + } match error { TraceDecayError::Config { message } => { tracedecay_contracts::ApplicationProblem::invalid_request_without_action( diff --git a/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs b/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs index e3dce36fe0..57eae1a2d0 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs @@ -109,8 +109,8 @@ async fn admitted_graph_query_for_operation( Ok(query) } -/// Dispatch administrative tools (`tracedecay_hook_runtime`, -/// `tracedecay_admin_cli`, `tracedecay_admin_project`). +/// Dispatch administrative tools (`tracedecay_admin_cli`, +/// `tracedecay_admin_project`). #[hotpath::measure(future = true, label = "mcp.dispatch.admin")] pub(super) async fn dispatch_admin_tools( tool_name: &str, @@ -131,16 +131,6 @@ fn dispatch_admin_tools_inner<'a>( // measured wrapper so every profiling feature can compute its layout. Box::pin(async move { match tool_name { - "tracedecay_hook_runtime" => { - hook_runtime::handle_hook_runtime( - cg, - args, - options.global_db.map(RegisteredGlobalDbLeaseV1::as_ref), - options.accounting_db, - options.session_authorities, - ) - .await - } "tracedecay_admin_cli" => { admin_cli::handle_admin_cli( cg, @@ -743,6 +733,16 @@ async fn compute_owner_side_effect( info::admin_sync(cg, options.code_index_reconcile_sink.as_ref()).await?, ) } + ApplicationSurfaceOperation::HookRuntime => GraphToolResultV1::HookRuntime( + hook_runtime::compute_hook_runtime( + cg, + hook_runtime::decode_hook_runtime_request(&args)?, + options.global_db.map(RegisteredGlobalDbLeaseV1::as_ref), + options.accounting_db, + options.session_authorities.clone(), + ) + .await?, + ), ApplicationSurfaceOperation::Dashboard => { let request = tracedecay_mcp::handlers::decode_primitive_request( &args, diff --git a/crates/tracedecay/src/mcp/tools/handlers/hook_runtime_behavior_tests.rs b/crates/tracedecay/src/mcp/tools/handlers/hook_runtime_behavior_tests.rs deleted file mode 100644 index 1d7ff2bd71..0000000000 --- a/crates/tracedecay/src/mcp/tools/handlers/hook_runtime_behavior_tests.rs +++ /dev/null @@ -1,198 +0,0 @@ -//! `tracedecay_hook_runtime` the way an MCP client calls it. -//! -//! Each case is one `tools/call` on the project server. The local counter and -//! saved-token metadata are the durable effects; the JSON-RPC body is what -//! the client reads. Expected values are those observations, not a schema -//! restatement or a digest the subject computed. - -use std::fs; -use std::sync::Arc; - -use serde_json::{Value, json}; -use tempfile::TempDir; -use tracedecay_mcp::{JsonRpcRequest, JsonRpcResponse}; - -use super::dispatch_test_support::SelectorProfile; -use crate::mcp::McpServer; -use tracedecay_project::project::TraceDecay; - -async fn open_server() -> (TempDir, SelectorProfile, Arc) { - let dir = TempDir::new().expect("temp dir"); - let profile = SelectorProfile::new(dir.path()); - let project = dir.path().join("hook-runtime"); - fs::create_dir_all(project.join("src")).expect("project src"); - fs::write(project.join("src/lib.rs"), "pub fn probe() {}\n").expect("probe source"); - let (cg, runtime) = TraceDecay::init_test_fixture_with_registered_runtime( - profile.data_dir(), - &project, - "project.hook-runtime.proof", - ) - .await - .expect("enrolled project"); - cg.add_local_counter(41).await.expect("seed local counter"); - cg.set_tokens_saved(12).await.expect("seed saved tokens"); - let scoped = - tracedecay_project::test_support::host_admission::ProjectScopedTestRuntimeV1::new(runtime) - .expect("project-scoped runtime"); - let server = McpServer::new_with_host_admission_test_runtime_for_test(cg, None, scoped) - .await - .expect("project MCP server"); - (dir, profile, server) -} - -async fn counters(server: &McpServer) -> (u64, u64) { - let cg = server.cg().await; - ( - cg.get_local_counter().await.expect("local counter"), - cg.get_tokens_saved().await.expect("tokens saved"), - ) -} - -async fn call_hook(server: &McpServer, id: i64, arguments: Value) -> JsonRpcResponse { - let line = json!({ - "jsonrpc": "2.0", - "id": id, - "method": "tools/call", - "params": { - "name": "tracedecay_hook_runtime", - "arguments": arguments - } - }) - .to_string(); - let request = JsonRpcRequest::decode(&line).expect("tools/call line"); - server - .handle_request(&request) - .await - .expect("tools/call response") -} - -fn success_payload(response: &JsonRpcResponse, id: i64) -> Value { - assert_eq!(response.jsonrpc, "2.0"); - assert_eq!(response.id, json!(id)); - assert!( - response.error.is_none(), - "tools/call failed: {:?}", - response.error - ); - let result = response.result.as_ref().expect("success result"); - let content = result["content"].as_array().expect("content"); - assert_eq!(content.len(), 1, "unexpected content: {result}"); - assert_eq!(content[0]["type"], "text"); - let text = content[0]["text"].as_str().expect("text content"); - serde_json::from_str(text).unwrap_or_else(|error| panic!("payload JSON ({error}): {text}")) -} - -fn assert_missing_action(response: &JsonRpcResponse, id: i64) { - assert_eq!(response.jsonrpc, "2.0"); - assert_eq!(response.id, json!(id)); - assert!(response.result.is_none()); - let error = response.error.as_ref().expect("refusal"); - assert_eq!(error.code, -32602); - assert_eq!(error.message, "missing required parameter `action`"); - assert_eq!( - error.data.as_ref(), - Some(&json!({ - "detail": "missing required parameter `action`", - "reason_code": "missing_required_parameter", - "retryable": false, - "tool": "tracedecay_hook_runtime" - })) - ); -} - -fn assert_execution_refused(response: &JsonRpcResponse, id: i64, message: &str) { - assert_eq!(response.jsonrpc, "2.0"); - assert_eq!(response.id, json!(id)); - assert!(response.result.is_none()); - let error = response.error.as_ref().expect("refusal"); - assert_eq!(error.code, -32603); - assert_eq!(error.message, message); - assert_eq!( - error.data.as_ref().and_then(|data| data.get("tool")), - Some(&json!("tracedecay_hook_runtime")) - ); -} - -#[tokio::test] -async fn hook_runtime_resets_the_local_counter_and_refuses_the_other_inputs() { - let (_dir, _env, server) = open_server().await; - - let removed = call_hook( - &server, - 1, - json!({ - "action": "reset_counter", - "format": "json", - "hermes_home": "/tmp/not-a-profile" - }), - ) - .await; - assert_execution_refused( - &removed, - 1, - "tool execution failed: config error: unknown parameter `hermes_home` for `tracedecay_hook_runtime`", - ); - - let missing = call_hook(&server, 2, json!({})).await; - assert_missing_action(&missing, 2); - let blank = call_hook(&server, 3, json!({"action": ""})).await; - assert_missing_action(&blank, 3); - let numeric = call_hook(&server, 4, json!({"action": 42})).await; - assert_missing_action(&numeric, 4); - - let unknown = call_hook(&server, 5, json!({"action": "not-a-hook-action"})).await; - assert_execution_refused( - &unknown, - 5, - "tool execution failed: config error: unknown hook runtime action: not-a-hook-action", - ); - let user_scope = call_hook( - &server, - 6, - json!({"action": "ingest_transcript", "user_scope": true}), - ) - .await; - assert_execution_refused( - &user_scope, - 6, - "tool execution failed: config error: user transcript ingest requires projectless daemon routing", - ); - let projectless = call_hook(&server, 7, json!({"action": "codex_stop"})).await; - assert_execution_refused( - &projectless, - 7, - "tool execution failed: config error: hook action `codex_stop` requires projectless daemon routing", - ); - - assert_eq!(counters(&server).await, (41, 12)); - - let reset = call_hook( - &server, - 8, - json!({"action": "reset_counter", "format": "json"}), - ) - .await; - assert_eq!( - success_payload(&reset, 8), - json!({"action": "reset_counter", "reset": true}) - ); - assert_eq!(counters(&server).await, (0, 12)); - - let receipt = call_hook( - &server, - 9, - json!({"action": "accounting_receipt", "format": "json"}), - ) - .await; - let receipt = success_payload(&receipt, 9); - assert_eq!(receipt["action"], "accounting_receipt"); - assert_eq!(receipt["coverage"], "unavailable"); - assert_eq!(receipt["pricing_status"], "unavailable"); - assert_eq!(receipt["provider_usage_events"], 0); - assert_eq!(receipt["tokens_saved"], 12); - assert_eq!(receipt["tokens_consumed"], Value::Null); - assert_eq!(receipt["cost_usd"], Value::Null); - assert_eq!(receipt["efficiency"], Value::Null); - assert_eq!(receipt["watermark"], json!(0)); - assert_eq!(counters(&server).await, (0, 12)); -} diff --git a/crates/tracedecay/src/mcp/tools/handlers/mod.rs b/crates/tracedecay/src/mcp/tools/handlers/mod.rs index 968391ec60..dfe4224f24 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/mod.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/mod.rs @@ -71,15 +71,6 @@ mod dispatch_tests; clippy::uninlined_format_args )] mod graph_search_dispatch_tests; -#[cfg(test)] -#[allow( - clippy::unwrap_used, - clippy::expect_used, - clippy::await_holding_lock, - clippy::redundant_closure_for_method_calls, - clippy::uninlined_format_args -)] -mod hook_runtime_behavior_tests; pub mod info; pub(crate) mod retained_catalog; #[cfg(test)] diff --git a/crates/tracedecay/src/runtime_ports.rs b/crates/tracedecay/src/runtime_ports.rs index 096402924c..f1a332e4e8 100644 --- a/crates/tracedecay/src/runtime_ports.rs +++ b/crates/tracedecay/src/runtime_ports.rs @@ -106,7 +106,18 @@ fn daemon_tool_json<'a>( require_project_identity, )?; let result = crate::daemon::call_default_tool(&handshake, tool_name, arguments).await?; - crate::daemon::tool_json_payload(&result, tool_name) + let payload = crate::daemon::tool_json_payload(&result, tool_name)?; + // An owner refusal is a semantic result carrying its problem + // record; the hook reads it as the owner's typed error. + if result.get("problem").is_some() { + let problem = serde_json::from_value::< + tracedecay_contracts::ApplicationProblemEnvelope, + >(payload)?; + return Err( + tracedecay_mcp::application_output::tool_result::problem_error(problem), + ); + } + Ok(payload) }, label = "runtime_ports.daemon_tool" )) diff --git a/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs b/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs index 095fe4e914..f43ca63098 100644 --- a/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs +++ b/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs @@ -1174,11 +1174,12 @@ for index in range(0, len(calls), 2): user_call, project_call = calls[index:index + 2] assert user_call[0] == "tracedecay_hook_runtime" assert user_call[1]["action"] == "ingest_transcript" - assert user_call[1]["storage_scope"] == "user" + assert user_call[1]["user_scope"] is True + assert "storage_scope" not in user_call[1] assert user_call[2] == {} assert project_call[0] == "tracedecay_hook_runtime" assert project_call[1]["action"] == "ingest_transcript" - assert "storage_scope" not in project_call[1] + assert project_call[1]["user_scope"] is False assert project_call[2]["project_root"] == "/tmp/project" assert user_call[1]["messages"] == project_call[1]["messages"] diff --git a/crates/tracedecay/tests/mcp_suite/mcp_handler_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_handler_test.rs index 2c27f29dd6..6c25950004 100644 --- a/crates/tracedecay/tests/mcp_suite/mcp_handler_test.rs +++ b/crates/tracedecay/tests/mcp_suite/mcp_handler_test.rs @@ -79,6 +79,7 @@ mod grep_behavior_test; mod health_behavior_test; #[cfg(feature = "test-transport")] mod hermes_skill_bridge_test; +mod hook_runtime_request_test; mod impact_behavior_test; mod implementations_test; mod info_file_request_test; diff --git a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/hook_runtime_request_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/hook_runtime_request_test.rs new file mode 100644 index 0000000000..de5d49830d --- /dev/null +++ b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/hook_runtime_request_test.rs @@ -0,0 +1,130 @@ +//! `tracedecay_hook_runtime` over the production MCP `tools/call` path, the +//! way agent-host hooks call it: the project's owner answers each action's +//! typed result, and a request outside what hosts send is refused through the +//! owner's problem record instead of being ignored. + +#![cfg(feature = "test-transport")] + +use serde_json::{Value, json}; + +use crate::support::{ProductionCompositionFixture, production_composition_fixture}; + +const TOOL: &str = "tracedecay_hook_runtime"; + +async fn call(fixture: &ProductionCompositionFixture, arguments: Value) -> Value { + let response = fixture + .harness + .call_tool(&fixture.project_root, TOOL, arguments) + .await + .unwrap_or_else(|error| panic!("hook runtime production invocation failed: {error}")); + assert!( + response.error.is_none(), + "hook runtime answers through its owner, never a JSON-RPC error: {:?}", + response.error + ); + response.result.expect("hook runtime result") +} + +async fn answer(fixture: &ProductionCompositionFixture, mut arguments: Value) -> Value { + arguments["format"] = json!("json"); + let result = call(fixture, arguments).await; + assert_eq!(result.get("isError"), None, "hook action refused: {result}"); + let text = result["content"][0]["text"] + .as_str() + .unwrap_or_else(|| panic!("hook runtime returned no text: {result}")); + serde_json::from_str(text).unwrap_or_else(|error| panic!("hook runtime JSON: {error}: {text}")) +} + +async fn refusal(fixture: &ProductionCompositionFixture, arguments: Value) -> Value { + let result = call(fixture, arguments).await; + assert_eq!(result["isError"], true, "hook action must refuse: {result}"); + let problem = &result["problem"]; + json!({ + "kind": problem["kind"], + "code": problem["code"], + "message": problem["message"], + }) +} + +fn invalid(detail: &str) -> Value { + json!({ + "kind": "invalid_request", + "code": "application.surface.invalid_request", + "message": detail, + }) +} + +#[tokio::test] +async fn hook_runtime_answers_typed_results_and_refuses_what_no_host_sends() { + let fixture = production_composition_fixture().await; + + assert_eq!( + answer(&fixture, json!({"action": "reset_counter"})).await, + json!({"action": "reset_counter", "reset": true}) + ); + assert_eq!( + answer( + &fixture, + json!({"action": "claude_compact", "event_json": "{}", "user_scope": false}) + ) + .await, + json!({ + "action": "claude_compact", + "status": "unavailable", + "reason": "claude_postcompact_provenance_unavailable", + "summary_nodes_created": 0, + "summary_node_ids": [], + }) + ); + + assert_eq!( + refusal( + &fixture, + json!({"action": "reset_counter", "project_root": "/elsewhere"}) + ) + .await, + invalid( + "invalid arguments for tracedecay_hook_runtime: unknown field `project_root`, there are no fields" + ) + ); + assert_eq!( + refusal( + &fixture, + json!({ + "action": "ingest_transcript", + "provider": "cursor", + "user_scope": false, + "event_json": "{}", + "timeout_budget_ms": 250, + }) + ) + .await, + invalid( + "invalid arguments for tracedecay_hook_runtime: unknown field `timeout_budget_ms`, expected one of `provider`, `user_scope`, `session_id`, `event_json`, `messages`, `max_new_bytes`" + ) + ); + assert_eq!( + refusal(&fixture, json!({"action": "codex_stop", "session_id": "s"})).await, + invalid( + "invalid arguments for tracedecay_hook_runtime: unknown variant `codex_stop`, expected one of `reset_counter`, `hook_v2_admit`, `hook_v2_delivery_receipt`, `hook_v2_feedback_notice_delivery`, `opencode_lsp_updated`, `ingest_transcript`, `codex_compact`, `claude_compact`, `cursor_compact`, `user_review`, `hermes_receipt`, `hook_v2_profile_admit`" + ) + ); + assert_eq!( + refusal( + &fixture, + json!({"action": "ingest_transcript", "provider": "codex", "user_scope": true}) + ) + .await, + invalid("user transcript ingest requires projectless daemon routing") + ); + assert_eq!( + refusal( + &fixture, + json!({"action": "hermes_receipt", "event": {"agent": "hermes"}}) + ) + .await, + invalid("hook action `hermes_receipt` requires projectless daemon routing") + ); + + fixture.harness.shutdown().await; +} diff --git a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/session_search_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/session_search_test.rs index 848b47fe3c..d6c55337c6 100644 --- a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/session_search_test.rs +++ b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/session_search_test.rs @@ -512,7 +512,7 @@ async fn production_codex_hook_ingest_survives_message_search_reopen() { .call_tool( &project, "tracedecay_hook_runtime", - json!({"action": "ingest_transcript", "provider": "codex", "format": "json"}), + json!({"action": "ingest_transcript", "provider": "codex", "user_scope": false, "format": "json"}), ) .await .expect("production Codex hook ingest invocation"); @@ -742,7 +742,7 @@ async fn production_hook_ingest_reads_only_the_pinned_transcript_home() { &harness, &project, "tracedecay_hook_runtime", - json!({"action": "ingest_transcript", "provider": "codex", "format": "json"}), + json!({"action": "ingest_transcript", "provider": "codex", "user_scope": false, "format": "json"}), ) .await; assert_eq!(ingest["completed"], true, "{ingest}"); diff --git a/crates/tracedecay/tests/session_suite/session_runtime/temporal_refresh.rs b/crates/tracedecay/tests/session_suite/session_runtime/temporal_refresh.rs index 5f7c590812..0aa50da074 100644 --- a/crates/tracedecay/tests/session_suite/session_runtime/temporal_refresh.rs +++ b/crates/tracedecay/tests/session_suite/session_runtime/temporal_refresh.rs @@ -1071,19 +1071,10 @@ async fn hook_ingest_join_runs_the_bound_refresh_worker() { let wake = authority.ensure_profile(®istry).await; let before = registry.profile_pass_count(db.db_path()).await; - let joined = tracedecay_mcp::server::join_required_live_transcript_refresh( - "tracedecay_hook_runtime", - &json!({"action": "ingest_transcript"}), - Some(&wake), - None, - ) - .await - .expect("hook ingest must join the refresh worker that owns the written store"); + tracedecay_mcp::server::join_hook_ingest_refresh(false, Some(&wake), None) + .await + .expect("hook ingest must join the refresh worker that owns the written store"); - assert_eq!( - joined, - tracedecay_mcp::server::LiveTranscriptRefreshJoin::PublicationJoined - ); assert!( registry.profile_pass_count(db.db_path()).await > before, "hook ingest must advance the refresh worker, not wait for an unrelated wake" diff --git a/scripts/hermes_plugin_unit_check.py b/scripts/hermes_plugin_unit_check.py index 7faf25f8e9..0c5932b2c1 100644 --- a/scripts/hermes_plugin_unit_check.py +++ b/scripts/hermes_plugin_unit_check.py @@ -949,7 +949,8 @@ def _check_provider_verbs(plugin, ctx, host_home: Path, messages: list): user_name, user_args, user_kwargs = turn_calls[0] assert user_name == "tracedecay_hook_runtime" assert user_args["action"] == "ingest_transcript" - assert user_args["storage_scope"] == "user", user_args + assert user_args["user_scope"] is True, user_args + assert "storage_scope" not in user_args, user_args assert "project_root" not in user_kwargs, user_kwargs name, args, kwargs = turn_calls[1] assert name == "tracedecay_hook_runtime", transcript_calls @@ -973,7 +974,7 @@ def _check_provider_verbs(plugin, ctx, host_home: Path, messages: list): provider.sync_turn("only user", "and assistant", session_id="s2", messages=None) turn_calls = transcript_calls[before:] assert len(turn_calls) == 2, turn_calls - assert turn_calls[0][1]["storage_scope"] == "user", turn_calls + assert turn_calls[0][1]["user_scope"] is True, turn_calls assert "project_root" not in turn_calls[0][2], turn_calls name, args, kwargs = turn_calls[1] assert name == "tracedecay_hook_runtime", transcript_calls @@ -1003,7 +1004,7 @@ def _check_provider_verbs(plugin, ctx, host_home: Path, messages: list): assert len(transcript_calls) == before + 1 name, args, kwargs = transcript_calls[-1] assert name == "tracedecay_hook_runtime" - assert args["storage_scope"] == "user", args + assert args["user_scope"] is True, args assert "project_root" not in kwargs, kwargs provider.handle_tool_call("fact_store", {"action": "add", "content": "pref"}) name, args, kwargs = calls[-1] @@ -1033,7 +1034,7 @@ def _check_provider_verbs(plugin, ctx, host_home: Path, messages: list): ) turn_calls = transcript_calls[before:] assert len(turn_calls) == 2, turn_calls - assert turn_calls[0][1]["storage_scope"] == "user", turn_calls + assert turn_calls[0][1]["user_scope"] is True, turn_calls assert "project_root" not in turn_calls[0][2], turn_calls name, args, kwargs = turn_calls[1] assert name == "tracedecay_hook_runtime" From 7cf34cdeb7af94c0af3ca0b88b1fa28e0e9e02d2 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 17:38:19 +0000 Subject: [PATCH 02/10] refactor(mcp): classify and regenerate the hook runtime contract --- .../src/adoption_observation.rs | 1 + .../schemas/dashboard-contracts.schema.json | 5 + dashboard/src/contracts/generated.ts | 2 +- sdks/typescript/src/operations.ts | 428 +++++++++--------- 4 files changed, 232 insertions(+), 204 deletions(-) diff --git a/crates/tracedecay-daemon-service/src/adoption_observation.rs b/crates/tracedecay-daemon-service/src/adoption_observation.rs index 965f8b1bbb..0ad759325b 100644 --- a/crates/tracedecay-daemon-service/src/adoption_observation.rs +++ b/crates/tracedecay-daemon-service/src/adoption_observation.rs @@ -406,6 +406,7 @@ mod tests { "capability.application.primitive.hermes-skill-bridge", "available", ), + ("capability.application.primitive.hook-runtime", "available"), ("capability.application.primitive.hotspots", "available"), ("capability.application.primitive.impact", "available"), ( diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json index fb806d063a..3e328fcae3 100644 --- a/dashboard/codegen/schemas/dashboard-contracts.schema.json +++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json @@ -11231,6 +11231,11 @@ "const": "schedules_work", "description": "Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.", "type": "string" + }, + { + "const": "records_host_evidence", + "description": "Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.", + "type": "string" } ] }, diff --git a/dashboard/src/contracts/generated.ts b/dashboard/src/contracts/generated.ts index 62749908a8..3f94c4be52 100644 --- a/dashboard/src/contracts/generated.ts +++ b/dashboard/src/contracts/generated.ts @@ -2390,7 +2390,7 @@ export type DuplicateEffortKindV1 = z.infer; Git index writes remain separate classes so policy cannot accidentally substitute one index mutation for another. */ -export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work")]); +export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work"), z.literal("records_host_evidence")]); export type EffectClass = z.infer; /** Durable effect proof. It records identities and receipts, never credentials diff --git a/sdks/typescript/src/operations.ts b/sdks/typescript/src/operations.ts index b32557898c..6c00186264 100644 --- a/sdks/typescript/src/operations.ts +++ b/sdks/typescript/src/operations.ts @@ -258,6 +258,7 @@ export type ContextScoutServiceStateV1 = "active" | "paused" | "disabled"; export type ContextScoutSettingsV1 = { readonly limits: ContextScoutConfigurationLimitsV1; readonly mode: ContextScoutConfigurationModeV1; readonly model_id?: string | null; readonly model_path?: ContextScoutConfiguredModelPathV1 | null; readonly model_timeout_secs?: number | null; readonly schema_version: number; readonly state: ContextScoutConfigurationStateV1 }; export type ContextScoutStatusResultV1 = { readonly active_suggestions: number; readonly configuration_revision: readonly number[]; readonly last_delivery_outcome?: ContextScoutDeliveryOutcomeV1 | null; readonly last_feedback?: ContextScoutFeedbackKindV1 | null; readonly last_model_outcome?: ContextScoutModelOutcomeV1 | null; readonly last_model_receipt?: ContextScoutModelReceiptV1 | null; readonly last_route?: ContextScoutRouteV1 | null; readonly last_suppression?: ContextScoutSuppressionV1 | null; readonly limits: ContextScoutLimitsV1; readonly mode: ContextScoutRuntimeModeV1; readonly model_path?: ContextScoutModelBackendV1 | null; readonly state: ContextScoutServiceStateV1 }; export type ContextScoutStoreOutcomeV1 = "stored" | "duplicate" | "superseded"; +export type ContextScoutStoreStatusV1 = "stored" | "duplicate" | "superseded" | "unavailable"; export type ContextScoutSuggestionProjectionV1 = { readonly category: ContextScoutCategoryV1; readonly configuration_revision: readonly number[]; readonly dedupe_key: readonly number[]; readonly delivery_window: ContextScoutDeliveryWindowV1; readonly envelope_id: readonly number[]; readonly evidence: ContextScoutEvidenceProjectionV1; readonly expires_at: UtcMicros; readonly model_outcome: ContextScoutModelOutcomeV1; readonly model_receipt?: ContextScoutModelReceiptV1 | null; readonly relevance_score: number; readonly route: ContextScoutRouteV1; readonly suggestion_text: string; readonly work: ContextScoutWorkV1 }; export type ContextScoutSuppressionV1 = "disabled" | "paused" | "dirty_overlay" | "quiet_or_unreceptive" | "no_eligible_candidate" | "expired" | "duplicate" | "cancelled" | "model_output_invalid" | "evidence_partial" | "evidence_stale" | "evidence_unavailable"; export type ContextScoutWorkV1 = { readonly address: ContextScoutAddressV1; readonly generation: number; readonly input_watermark: readonly number[] }; @@ -326,7 +327,7 @@ export type DsmStatsV1 = { readonly clusters: number; readonly density: number; export type DuplicateEffectOutcomeV1 = "prevented" | "committed" | "unknown" | "not_applicable"; export type DuplicateEffortKindV1 = "exact_duplicate" | "superseded_overlap" | "repeated_investigation" | "duplicate_effect" | "not_duplicate" | "censored" | "unknown"; export type EditResult = { readonly diff?: string | null; readonly dry_run?: boolean; readonly file_path: string; readonly matched_str: string; readonly message: string; readonly new_str: string; readonly replaced_span?: string | null; readonly success: boolean; readonly [key: string]: unknown }; -export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work"; +export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work" | "records_host_evidence"; export type EffectReceipt_2 = { readonly actor: ActorId; readonly catalog_digest: ManifestDigest; readonly committed_state?: ManifestDigest | null; readonly configuration_digest: ManifestDigest; readonly effect_class: EffectClass; readonly expected_state: ManifestDigest; readonly external_proof?: RetrievalAnchorId | null; readonly idempotency_key: string; readonly input_digest: ManifestDigest; readonly operation: UseCaseId; readonly outcome: EffectTermination_2; readonly policy_digest: ManifestDigest; readonly privacy_digest: ManifestDigest; readonly request_id: string; readonly scope: ResolvedScope }; export type EffectResult_2 = { readonly authority: AuthorityReceipt; readonly effect_class: EffectClass; readonly effect_id: string; readonly execution: OperationReceipt_2; readonly expected_state: ManifestDigest; readonly idempotency_key: string; readonly payload?: SourceEditDurableEffectPayloadV1 | null; readonly receipt: EffectReceipt_2; readonly reconciliation: ReconciliationState }; export type EffectTermination_2 = "completed" | "cancelled" | "timed_out" | "failed" | "partial" | "effect_unknown"; @@ -516,10 +517,16 @@ export type HealthModularityV1 = { readonly components_after_hub_removal: number export type HealthRedundancyV1 = { readonly dead_count: number; readonly score: number; readonly source: string; readonly total_fns: number }; export type HealthWeightsV1 = { readonly note: string }; export type HermesPendingSkillWrite = { readonly action?: string | null; readonly created_at?: unknown; readonly id: string; readonly name?: string | null; readonly origin?: string | null; readonly payload?: unknown; readonly source_path: string; readonly summary?: string | null; readonly [key: string]: unknown }; +export type HermesReceiptStatusV1 = "recorded" | "ingested" | "awaiting_transcript"; export type HermesSkillBridgeContracts = { readonly discovery_policy: string; readonly lifecycle_owner: string; readonly mutation_policy: string; readonly [key: string]: unknown }; export type HermesSkillBridgeSnapshot = { readonly agent_home: string; readonly archive_count: number; readonly contracts: HermesSkillBridgeContracts; readonly pending_skill_corrupt_count: number; readonly pending_skill_count: number; readonly pending_skills: readonly HermesPendingSkillWrite[]; readonly skill_count: number; readonly skills: readonly HermesSkillSummary[]; readonly skills_dir: string; readonly usage_record_count: number; readonly usage_records: { readonly [key: string]: unknown }; readonly [key: string]: unknown }; export type HermesSkillSummary = { readonly body_markdown?: string | null; readonly category?: string | null; readonly description?: string | null; readonly name: string; readonly path: string; readonly pending_write_ids: readonly string[]; readonly usage?: unknown; readonly [key: string]: unknown }; export type HistoryRewritePolicyV1 = "forbid_force_and_rebase"; +export type HookIngestAdmissionV1 = { readonly reason_code?: string | null; readonly retryable: boolean; readonly status: string }; +export type HookOrchestrationAdmissionV1 = "enqueued" | "backpressured" | "unsupported_trigger" | "unavailable"; +export type HookRuntimeAcceptedV1 = "accepted"; +export type HookRuntimeDispositionV1 = "accepted" | "catchup_required"; +export type HookV2RejectionReasonV1 = "admission_identity_conflict"; export type HostInstanceId = string; export type HotspotV1 = { readonly file: string; readonly id: string; readonly incoming: number; readonly kind: string; readonly line: number; readonly name: string; readonly outgoing: number; readonly total: number }; export type HunkDirectionV1 = "working_tree_to_index" | "index_to_head"; @@ -1479,6 +1486,8 @@ export type OperationApplicationHealthReadRequest = { }; export type OperationApplicationHealthReadResult = { readonly status: string }; export type OperationApplicationHermesSkillBridgeRequest = { readonly include_pending_payloads?: boolean; readonly include_skill_bodies?: boolean }; export type OperationApplicationHermesSkillBridgeResult = { readonly bridge: HermesSkillBridgeSnapshot; readonly status: AutomationReadStatusV1 }; +export type OperationApplicationHookRuntimeRequest = { readonly action: "reset_counter" } | { readonly action: "hook_v2_admit"; readonly envelope: unknown; readonly native_lifecycle?: unknown; readonly native_session_id?: string | null } | { readonly action: "hook_v2_delivery_receipt"; readonly receipt: unknown } | { readonly action: "hook_v2_feedback_notice_delivery"; readonly envelope: unknown; readonly feedback_notice: unknown } | { readonly action: "opencode_lsp_updated"; readonly event: unknown } | { readonly action: "ingest_transcript"; readonly event_json?: string | null; readonly max_new_bytes?: number | null; readonly messages?: readonly unknown[] | null; readonly provider: string; readonly session_id?: string | null; readonly user_scope: boolean } | { readonly action: "codex_compact"; readonly event_json: string } | { readonly action: "claude_compact"; readonly event_json: string; readonly user_scope: boolean } | { readonly action: "cursor_compact"; readonly event_json: string } | { readonly action: "user_review"; readonly provider: string; readonly session_id?: string | null } | { readonly action: "hermes_receipt"; readonly event: unknown } | { readonly action: "hook_v2_profile_admit"; readonly admission: unknown }; +export type OperationApplicationHookRuntimeResult = { readonly action: "reset_counter"; readonly reset: boolean } | { readonly context_scout_address?: ContextScoutAddressV1 | null; readonly disposition: HookRuntimeDispositionV1; readonly feedback_notice?: unknown; readonly github_stack_signal_available: boolean; readonly orchestration: HookOrchestrationAdmissionV1; readonly ready_guidance?: unknown; readonly status: "accepted"; readonly [key: string]: unknown } | { readonly context_scout_address?: ContextScoutAddressV1 | null; readonly disposition: HookRuntimeDispositionV1; readonly ready_guidance?: unknown; readonly status: "exact_duplicate"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly reason?: HookV2RejectionReasonV1 | null; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly status: "backpressured"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown } | { readonly action: "hook_v2_delivery_receipt"; readonly status: ContextScoutStoreStatusV1 } | { readonly status: "stored"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly action: "opencode_lsp_updated"; readonly status: HookRuntimeAcceptedV1 } | { readonly action: "ingest_transcript"; readonly admission: HookIngestAdmissionV1; readonly bytes_consumed?: number | null; readonly completed: boolean; readonly cursor_advances?: number | null; readonly cursor_duplicates?: number | null; readonly deferred_by_byte_cap?: boolean | null; readonly deferred_sources?: number | null; readonly hint_outcomes?: unknown; readonly messages_upserted: number; readonly observation_duplicates?: number | null; readonly observations_committed?: number | null; readonly projection_duplicates?: number | null; readonly projections_completed?: number | null; readonly projections_skipped?: number | null; readonly provider: string; readonly records_quarantined?: number | null; readonly records_rejected?: number | null; readonly source_bytes_scanned?: number | null; readonly status: string; readonly user_scope: boolean } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly action: "hermes_receipt"; readonly status: HermesReceiptStatusV1 } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "accepted"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "exact_duplicate"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown }; export type OperationApplicationHotspotsRequest = { readonly limit?: number | null }; export type OperationApplicationHotspotsResult = { readonly hotspot_count: number; readonly hotspots: readonly HotspotV1[] }; export type OperationApplicationImpactRequest = { readonly max_depth?: number | null; readonly node_id: string }; @@ -1963,6 +1972,7 @@ const DEFINITIONS = { ContextScoutSettingsV1: {"additionalProperties":false,"description":"Canonical Context Scout control-plane value. Disabled is the only stock\nstate; deterministic or configured-model execution requires an explicit\nconfiguration revision.","properties":{"limits":{"$ref":"#/$defs/ContextScoutConfigurationLimitsV1"},"mode":{"$ref":"#/$defs/ContextScoutConfigurationModeV1"},"model_id":{"type":["string","null"]},"model_path":{"anyOf":[{"$ref":"#/$defs/ContextScoutConfiguredModelPathV1"},{"type":"null"}]},"model_timeout_secs":{"format":"uint64","minimum":0,"type":["integer","null"]},"schema_version":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"state":{"$ref":"#/$defs/ContextScoutConfigurationStateV1"}},"required":["schema_version","state","mode","limits"],"type":"object"}, ContextScoutStatusResultV1: {"additionalProperties":false,"properties":{"active_suggestions":{"format":"uint","minimum":0,"type":"integer"},"configuration_revision":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"last_delivery_outcome":{"anyOf":[{"$ref":"#/$defs/ContextScoutDeliveryOutcomeV1"},{"type":"null"}]},"last_feedback":{"anyOf":[{"$ref":"#/$defs/ContextScoutFeedbackKindV1"},{"type":"null"}]},"last_model_outcome":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelOutcomeV1"},{"type":"null"}]},"last_model_receipt":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelReceiptV1"},{"type":"null"}]},"last_route":{"anyOf":[{"$ref":"#/$defs/ContextScoutRouteV1"},{"type":"null"}]},"last_suppression":{"anyOf":[{"$ref":"#/$defs/ContextScoutSuppressionV1"},{"type":"null"}]},"limits":{"$ref":"#/$defs/ContextScoutLimitsV1"},"mode":{"$ref":"#/$defs/ContextScoutRuntimeModeV1"},"model_path":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelBackendV1"},{"type":"null"}]},"state":{"$ref":"#/$defs/ContextScoutServiceStateV1"}},"required":["configuration_revision","state","mode","limits","active_suggestions"],"type":"object"}, ContextScoutStoreOutcomeV1: {"enum":["stored","duplicate","superseded"],"type":"string"}, + ContextScoutStoreStatusV1: {"enum":["stored","duplicate","superseded","unavailable"],"type":"string"}, ContextScoutSuggestionProjectionV1: {"additionalProperties":false,"properties":{"category":{"$ref":"#/$defs/ContextScoutCategoryV1"},"configuration_revision":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"dedupe_key":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"delivery_window":{"$ref":"#/$defs/ContextScoutDeliveryWindowV1"},"envelope_id":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":16,"minItems":16,"type":"array"},"evidence":{"$ref":"#/$defs/ContextScoutEvidenceProjectionV1"},"expires_at":{"$ref":"#/$defs/UtcMicros"},"model_outcome":{"$ref":"#/$defs/ContextScoutModelOutcomeV1"},"model_receipt":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelReceiptV1"},{"type":"null"}]},"relevance_score":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"route":{"$ref":"#/$defs/ContextScoutRouteV1"},"suggestion_text":{"type":"string"},"work":{"$ref":"#/$defs/ContextScoutWorkV1"}},"required":["work","envelope_id","configuration_revision","delivery_window","route","model_outcome","dedupe_key","category","relevance_score","suggestion_text","evidence","expires_at"],"type":"object"}, ContextScoutSuppressionV1: {"enum":["disabled","paused","dirty_overlay","quiet_or_unreceptive","no_eligible_candidate","expired","duplicate","cancelled","model_output_invalid","evidence_partial","evidence_stale","evidence_unavailable"],"type":"string"}, ContextScoutWorkV1: {"additionalProperties":false,"properties":{"address":{"$ref":"#/$defs/ContextScoutAddressV1"},"generation":{"format":"uint64","minimum":0,"type":"integer"},"input_watermark":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"}},"required":["address","generation","input_watermark"],"type":"object"}, @@ -2031,7 +2041,7 @@ const DEFINITIONS = { DuplicateEffectOutcomeV1: {"enum":["prevented","committed","unknown","not_applicable"],"type":"string"}, DuplicateEffortKindV1: {"enum":["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],"type":"string"}, EditResult: {"description":"Result of a single string replacement edit.","properties":{"diff":{"description":"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.","type":["string","null"]},"dry_run":{"description":"True when this was a dry run: validation, spans, and the resulting\ncontent were all computed, but nothing was written to disk.","type":"boolean"},"file_path":{"type":"string"},"matched_str":{"type":"string"},"message":{"type":"string"},"new_str":{"type":"string"},"replaced_span":{"description":"The exact source text that was replaced. For `replace_symbol` this is\nthe item's full span, including any leading doc-comment / attribute\nblock, so callers can recover its docs/attrs if the replacement\ndropped them; for `str_replace` it is the matched `old_str` text.\n`None` only on a failed edit, where nothing was resolved to replace.","type":["string","null"]},"success":{"type":"boolean"}},"required":["success","file_path","matched_str","new_str","message"],"type":"object"}, - EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"}]}, + EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"},{"const":"records_host_evidence","description":"Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.","type":"string"}]}, EffectReceipt_2: {"additionalProperties":false,"description":"Durable effect proof. It records identities and receipts, never credentials\nor arbitrary command text.","properties":{"actor":{"$ref":"#/$defs/ActorId"},"catalog_digest":{"$ref":"#/$defs/ManifestDigest"},"committed_state":{"anyOf":[{"$ref":"#/$defs/ManifestDigest"},{"type":"null"}]},"configuration_digest":{"$ref":"#/$defs/ManifestDigest"},"effect_class":{"$ref":"#/$defs/EffectClass"},"expected_state":{"$ref":"#/$defs/ManifestDigest"},"external_proof":{"anyOf":[{"$ref":"#/$defs/RetrievalAnchorId"},{"type":"null"}]},"idempotency_key":{"type":"string"},"input_digest":{"$ref":"#/$defs/ManifestDigest"},"operation":{"$ref":"#/$defs/UseCaseId"},"outcome":{"$ref":"#/$defs/EffectTermination"},"policy_digest":{"$ref":"#/$defs/ManifestDigest"},"privacy_digest":{"$ref":"#/$defs/ManifestDigest"},"request_id":{"type":"string"},"scope":{"$ref":"#/$defs/ResolvedScope"}},"required":["operation","request_id","actor","scope","effect_class","idempotency_key","input_digest","expected_state","policy_digest","configuration_digest","catalog_digest","privacy_digest","outcome"],"type":"object"}, EffectResult_2: {"additionalProperties":false,"description":"Result of an admitted effect. `EffectUnknown` remains a receipt state and\ncannot be remapped into a pre-admission problem.","properties":{"authority":{"$ref":"#/$defs/AuthorityReceipt"},"effect_class":{"$ref":"#/$defs/EffectClass"},"effect_id":{"type":"string"},"execution":{"$ref":"#/$defs/OperationReceipt"},"expected_state":{"$ref":"#/$defs/ManifestDigest"},"idempotency_key":{"type":"string"},"payload":{"anyOf":[{"$ref":"#/$defs/SourceEditDurableEffectPayloadV1"},{"type":"null"}]},"receipt":{"$ref":"#/$defs/EffectReceipt"},"reconciliation":{"$ref":"#/$defs/ReconciliationState"}},"required":["effect_id","effect_class","idempotency_key","authority","expected_state","execution","reconciliation","receipt"],"type":"object"}, EffectTermination_2: {"description":"Durable effect receipt terminal state.","enum":["completed","cancelled","timed_out","failed","partial","effect_unknown"],"type":"string"}, @@ -2221,10 +2231,16 @@ const DEFINITIONS = { HealthRedundancyV1: {"additionalProperties":false,"properties":{"dead_count":{"format":"uint64","minimum":0,"type":"integer"},"score":{"format":"double","type":"number"},"source":{"type":"string"},"total_fns":{"format":"uint64","minimum":0,"type":"integer"}},"required":["score","dead_count","total_fns","source"],"type":"object"}, HealthWeightsV1: {"additionalProperties":false,"properties":{"note":{"type":"string"}},"required":["note"],"type":"object"}, HermesPendingSkillWrite: {"properties":{"action":{"type":["string","null"]},"created_at":true,"id":{"type":"string"},"name":{"type":["string","null"]},"origin":{"type":["string","null"]},"payload":true,"source_path":{"type":"string"},"summary":{"type":["string","null"]}},"required":["id","source_path"],"type":"object"}, + HermesReceiptStatusV1: {"oneOf":[{"const":"recorded","description":"A terminal receipt was recorded.","type":"string"},{"const":"ingested","description":"The turn was marked ingested and no receipt awaits review.","type":"string"},{"const":"awaiting_transcript","description":"A receipt awaits a transcript that has not landed yet.","type":"string"}]}, HermesSkillBridgeContracts: {"properties":{"discovery_policy":{"type":"string"},"lifecycle_owner":{"type":"string"},"mutation_policy":{"type":"string"}},"required":["lifecycle_owner","mutation_policy","discovery_policy"],"type":"object"}, HermesSkillBridgeSnapshot: {"properties":{"agent_home":{"type":"string"},"archive_count":{"format":"uint","minimum":0,"type":"integer"},"contracts":{"$ref":"#/$defs/HermesSkillBridgeContracts"},"pending_skill_corrupt_count":{"format":"uint","minimum":0,"type":"integer"},"pending_skill_count":{"format":"uint","minimum":0,"type":"integer"},"pending_skills":{"items":{"$ref":"#/$defs/HermesPendingSkillWrite"},"type":"array"},"skill_count":{"format":"uint","minimum":0,"type":"integer"},"skills":{"items":{"$ref":"#/$defs/HermesSkillSummary"},"type":"array"},"skills_dir":{"type":"string"},"usage_record_count":{"format":"uint","minimum":0,"type":"integer"},"usage_records":{"additionalProperties":true,"description":"Hermes-owned usage telemetry keyed by skill name, as Hermes wrote it.","type":"object"}},"required":["agent_home","skills_dir","skill_count","pending_skill_count","pending_skill_corrupt_count","usage_record_count","archive_count","skills","pending_skills","usage_records","contracts"],"type":"object"}, HermesSkillSummary: {"properties":{"body_markdown":{"type":["string","null"]},"category":{"type":["string","null"]},"description":{"type":["string","null"]},"name":{"type":"string"},"path":{"type":"string"},"pending_write_ids":{"items":{"type":"string"},"type":"array"},"usage":true},"required":["name","path","pending_write_ids"],"type":"object"}, HistoryRewritePolicyV1: {"enum":["forbid_force_and_rebase"],"type":"string"}, + HookIngestAdmissionV1: {"additionalProperties":false,"description":"The admission authority's verdict on one transcript ingest.","properties":{"reason_code":{"type":["string","null"]},"retryable":{"type":"boolean"},"status":{"description":"The session host-admission status, in its wire spelling.","type":"string"}},"required":["status","retryable"],"type":"object"}, + HookOrchestrationAdmissionV1: {"description":"Outcome of admitting one hook envelope into the registered orchestrator.","enum":["enqueued","backpressured","unsupported_trigger","unavailable"],"type":"string"}, + HookRuntimeAcceptedV1: {"enum":["accepted"],"type":"string"}, + HookRuntimeDispositionV1: {"description":"How the hook transport should treat a Hook V2 envelope.","oneOf":[{"enum":["accepted"],"type":"string"},{"const":"catchup_required","description":"The published binding no longer authorizes the envelope; the host\nmust catch up before sending again.","type":"string"}]}, + HookV2RejectionReasonV1: {"oneOf":[{"const":"admission_identity_conflict","description":"The same event identity previously carried different bytes.","type":"string"}]}, HostInstanceId: {"description":"Strongly typed canonical identity: `HostInstanceId`.","type":"string"}, HotspotV1: {"additionalProperties":false,"properties":{"file":{"type":"string"},"id":{"type":"string"},"incoming":{"format":"uint64","minimum":0,"type":"integer"},"kind":{"type":"string"},"line":{"format":"uint32","minimum":0,"type":"integer"},"name":{"type":"string"},"outgoing":{"format":"uint64","minimum":0,"type":"integer"},"total":{"format":"uint64","minimum":0,"type":"integer"}},"required":["id","name","kind","file","line","incoming","outgoing","total"],"type":"object"}, HunkDirectionV1: {"description":"`HunkRef` operation direction: working tree to index, or index to\nHEAD/base. No other direction is encodable.","enum":["working_tree_to_index","index_to_head"],"type":"string"}, @@ -3156,6 +3172,8 @@ const SCHEMAS: readonly CanonicalJsonSchema[] = [ {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"status":{"type":"string"}},"required":["status"],"title":"HealthReadResult","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"include_pending_payloads":{"default":false,"description":"Include staged Hermes skill-write payloads (default: false).","type":"boolean"},"include_skill_bodies":{"default":false,"description":"Include bounded SKILL.md contents (default: false).","type":"boolean"}},"title":"HermesSkillBridgeSurfaceRequestV1","type":"object"}, {"$defs":{"AutomationReadStatusV1":DEFINITIONS.AutomationReadStatusV1,"HermesPendingSkillWrite":DEFINITIONS.HermesPendingSkillWrite,"HermesSkillBridgeContracts":DEFINITIONS.HermesSkillBridgeContracts,"HermesSkillBridgeSnapshot":DEFINITIONS.HermesSkillBridgeSnapshot,"HermesSkillSummary":DEFINITIONS.HermesSkillSummary},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"bridge":{"$ref":"#/$defs/HermesSkillBridgeSnapshot"},"status":{"$ref":"#/$defs/AutomationReadStatusV1"}},"required":["status","bridge"],"title":"HermesSkillBridgeResultV1","type":"object"}, + {"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"description":"Reset the project's local token counter.","properties":{"action":{"const":"reset_counter","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"description":"Admit one Hook V2 envelope for the bound project.","properties":{"action":{"const":"hook_v2_admit","type":"string"},"envelope":true,"native_lifecycle":true,"native_session_id":{"description":"The host's native session id; it binds only when it hashes to the\nenvelope's protected session.","type":["string","null"]}},"required":["action","envelope"],"type":"object"},{"additionalProperties":false,"description":"Commit a Context Scout delivery receipt for guidance the last\nadmission handed out.","properties":{"action":{"const":"hook_v2_delivery_receipt","type":"string"},"receipt":true},"required":["action","receipt"],"type":"object"},{"additionalProperties":false,"description":"Acknowledge delivery of an advisory feedback notice.","properties":{"action":{"const":"hook_v2_feedback_notice_delivery","type":"string"},"envelope":true,"feedback_notice":true},"required":["action","envelope","feedback_notice"],"type":"object"},{"additionalProperties":false,"description":"Record an `OpenCode` `lsp.updated` event.","properties":{"action":{"const":"opencode_lsp_updated","type":"string"},"event":true},"required":["action","event"],"type":"object"},{"additionalProperties":false,"description":"Land a host transcript in the owning session store.","properties":{"action":{"const":"ingest_transcript","type":"string"},"event_json":{"description":"The host's raw hook event, for providers that locate the transcript\nfrom it.","type":["string","null"]},"max_new_bytes":{"description":"Byte budget for this pass across every scanned source.","format":"uint64","minimum":0,"type":["integer","null"]},"messages":{"description":"One turn the host inlined instead of a source to scan.","items":true,"type":["array","null"]},"provider":{"type":"string"},"session_id":{"type":["string","null"]},"user_scope":{"description":"Land the transcript in the profile's user store instead of the\nproject's.","type":"boolean"}},"required":["action","provider","user_scope"],"type":"object"},{"additionalProperties":false,"description":"Codex `PostCompact` pressure evidence.","properties":{"action":{"const":"codex_compact","type":"string"},"event_json":{"type":"string"}},"required":["action","event_json"],"type":"object"},{"additionalProperties":false,"description":"Claude `PostCompact` pressure evidence; `user_scope` routes it to the\nprofile.","properties":{"action":{"const":"claude_compact","type":"string"},"event_json":{"type":"string"},"user_scope":{"type":"boolean"}},"required":["action","event_json","user_scope"],"type":"object"},{"additionalProperties":false,"description":"Cursor `preCompact` pressure evidence.","properties":{"action":{"const":"cursor_compact","type":"string"},"event_json":{"type":"string"}},"required":["action","event_json"],"type":"object"},{"additionalProperties":false,"description":"Review a finished user session.","properties":{"action":{"const":"user_review","type":"string"},"provider":{"type":"string"},"session_id":{"type":["string","null"]}},"required":["action","provider"],"type":"object"},{"additionalProperties":false,"description":"Record a Hermes terminal receipt without a project route.","properties":{"action":{"const":"hermes_receipt","type":"string"},"event":true},"required":["action","event"],"type":"object"},{"additionalProperties":false,"description":"Admit a native event without a project route into the profile's\nHook V2 ledger.","properties":{"action":{"const":"hook_v2_profile_admit","type":"string"},"admission":true},"required":["action","admission"],"type":"object"}],"title":"HookRuntimeSurfaceRequestV1"}, + {"$defs":{"ContextScoutAddressV1":DEFINITIONS.ContextScoutAddressV1,"ContextScoutStoreStatusV1":DEFINITIONS.ContextScoutStoreStatusV1,"HermesReceiptStatusV1":DEFINITIONS.HermesReceiptStatusV1,"HookIngestAdmissionV1":DEFINITIONS.HookIngestAdmissionV1,"HookOrchestrationAdmissionV1":DEFINITIONS.HookOrchestrationAdmissionV1,"HookRuntimeAcceptedV1":DEFINITIONS.HookRuntimeAcceptedV1,"HookRuntimeDispositionV1":DEFINITIONS.HookRuntimeDispositionV1,"HookV2RejectionReasonV1":DEFINITIONS.HookV2RejectionReasonV1},"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"properties":{"action":{"const":"reset_counter","type":"string"},"reset":{"type":"boolean"}},"required":["action","reset"],"type":"object"},{"oneOf":[{"properties":{"context_scout_address":{"anyOf":[{"$ref":"#/$defs/ContextScoutAddressV1"},{"type":"null"}]},"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"feedback_notice":{"description":"The advisory `AdvisoryHookLookupNoticeV1` waiting for this\nworktree."},"github_stack_signal_available":{"type":"boolean"},"orchestration":{"$ref":"#/$defs/HookOrchestrationAdmissionV1"},"ready_guidance":{"description":"The hook's `HookReadyGuidanceV1`, when admission claimed one."},"status":{"const":"accepted","type":"string"}},"required":["status","disposition","orchestration","github_stack_signal_available"],"type":"object"},{"description":"This exact envelope was already admitted; a retry may still receive\nguidance retained before a lost host response.","properties":{"context_scout_address":{"anyOf":[{"$ref":"#/$defs/ContextScoutAddressV1"},{"type":"null"}]},"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"ready_guidance":true,"status":{"const":"exact_duplicate","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"reason":{"anyOf":[{"$ref":"#/$defs/HookV2RejectionReasonV1"},{"type":"null"}]},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"},{"description":"Idempotency could not be recorded, so nothing was admitted.","properties":{"status":{"const":"backpressured","type":"string"}},"required":["status"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"}],"properties":{"action":{"const":"hook_v2_admit","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"hook_v2_delivery_receipt","type":"string"},"status":{"$ref":"#/$defs/ContextScoutStoreStatusV1"}},"required":["action","status"],"type":"object"},{"oneOf":[{"properties":{"status":{"const":"stored","type":"string"}},"required":["status"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"}],"properties":{"action":{"const":"hook_v2_feedback_notice_delivery","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"opencode_lsp_updated","type":"string"},"status":{"$ref":"#/$defs/HookRuntimeAcceptedV1"}},"required":["action","status"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"ingest_transcript","type":"string"},"admission":{"$ref":"#/$defs/HookIngestAdmissionV1"},"bytes_consumed":{"format":"uint64","minimum":0,"type":["integer","null"]},"completed":{"description":"False when the byte budget left work for a later pass.","type":"boolean"},"cursor_advances":{"format":"uint64","minimum":0,"type":["integer","null"]},"cursor_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"deferred_by_byte_cap":{"type":["boolean","null"]},"deferred_sources":{"format":"uint64","minimum":0,"type":["integer","null"]},"hint_outcomes":{"description":"How emitted hook hints settled against the new project activity."},"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"observation_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"observations_committed":{"format":"uint64","minimum":0,"type":["integer","null"]},"projection_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"projections_completed":{"format":"uint64","minimum":0,"type":["integer","null"]},"projections_skipped":{"format":"uint64","minimum":0,"type":["integer","null"]},"provider":{"type":"string"},"records_quarantined":{"format":"uint64","minimum":0,"type":["integer","null"]},"records_rejected":{"format":"uint64","minimum":0,"type":["integer","null"]},"source_bytes_scanned":{"format":"uint64","minimum":0,"type":["integer","null"]},"status":{"type":"string"},"user_scope":{"type":"boolean"}},"required":["action","provider","user_scope","completed","status","admission","messages_upserted"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"codex_compact","type":"string"}},"required":["action"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"claude_compact","type":"string"}},"required":["action"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"cursor_compact","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"hermes_receipt","type":"string"},"status":{"$ref":"#/$defs/HermesReceiptStatusV1"}},"required":["action","status"],"type":"object"},{"oneOf":[{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"accepted","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"exact_duplicate","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"}],"properties":{"action":{"const":"hook_v2_profile_admit","type":"string"}},"required":["action"],"type":"object"}],"title":"HookRuntimeResultV1"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"limit":{"description":"Maximum number of hotspots to return (default: 10, at most 100).","format":"uint32","minimum":0,"type":["integer","null"]}},"title":"HotspotsSurfaceRequestV1","type":"object"}, {"$defs":{"HotspotV1":DEFINITIONS.HotspotV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"hotspot_count":{"format":"uint64","minimum":0,"type":"integer"},"hotspots":{"items":{"$ref":"#/$defs/HotspotV1"},"type":"array"}},"required":["hotspot_count","hotspots"],"title":"HotspotsResultV1","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"max_depth":{"format":"uint32","minimum":0,"type":["integer","null"]},"node_id":{"type":"string"}},"required":["node_id"],"title":"NodeDepthSurfaceRequestV1","type":"object"}, @@ -3879,587 +3897,591 @@ export const OPERATIONS = [ requestSchema: { schemaId: "schema.application.primitive.hermes-skill-bridge.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hermes-skill-bridge.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], decodeRequest: decoder(189), decodeResult: decoder(190) }, + { operation: "hook_runtime", operationId: "operation.application.hook_runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_hook_runtime" }, effect: "records_host_evidence", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hook_runtime.v1", + requestSchema: { schemaId: "schema.application.primitive.hook-runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hook-runtime.result", revision: 1 }, + cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","unavailable","partial"], + decodeRequest: decoder(191), decodeResult: decoder(192) }, { operation: "hotspots", operationId: "operation.application.hotspots", transport: { kind: "mcp_tool", toolName: "tracedecay_hotspots" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hotspots.v1", requestSchema: { schemaId: "schema.application.primitive.hotspots.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hotspots.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(191), decodeResult: decoder(192) }, + decodeRequest: decoder(193), decodeResult: decoder(194) }, { operation: "impact", operationId: "operation.application.impact", transport: { kind: "mcp_tool", toolName: "tracedecay_impact" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.impact.v1", requestSchema: { schemaId: "schema.application.primitive.impact.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.impact.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(193), decodeResult: decoder(194) }, + decodeRequest: decoder(195), decodeResult: decoder(196) }, { operation: "inheritance_depth", operationId: "operation.application.inheritance_depth", transport: { kind: "mcp_tool", toolName: "tracedecay_inheritance_depth" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.inheritance_depth.v1", requestSchema: { schemaId: "schema.application.primitive.inheritance-depth.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.inheritance-depth.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(195), decodeResult: decoder(196) }, + decodeRequest: decoder(197), decodeResult: decoder(198) }, { operation: "insert_at", operationId: "operation.application.insert_at", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at.v1", requestSchema: { schemaId: "schema.application.source-edit.insert-at.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(197), decodeResult: decoder(14) }, + decodeRequest: decoder(199), decodeResult: decoder(14) }, { operation: "insert_at_symbol", operationId: "operation.application.insert_at_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(198), decodeResult: decoder(14) }, + decodeRequest: decoder(200), decodeResult: decoder(14) }, { operation: "largest", operationId: "operation.application.largest", transport: { kind: "mcp_tool", toolName: "tracedecay_largest" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.largest.v1", requestSchema: { schemaId: "schema.application.primitive.largest.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.largest.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(199), decodeResult: decoder(200) }, + decodeRequest: decoder(201), decodeResult: decoder(202) }, { operation: "application_lcm_describe", operationId: "operation.application.lcm_describe", transport: { kind: "http", route: "/application/retained/lcm_describe", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_describe.v1", requestSchema: { schemaId: "schema.application.retained.lcm-describe.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-describe.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(201), decodeResult: decoder(202), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(202)) }, + decodeRequest: decoder(203), decodeResult: decoder(204), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(204)) }, { operation: "application_lcm_doctor", operationId: "operation.application.lcm_doctor", transport: { kind: "http", route: "/application/retained/lcm_doctor", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_doctor.v1", requestSchema: { schemaId: "schema.application.retained.lcm-doctor.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-doctor.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(203), decodeResult: decoder(204), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(204)) }, + decodeRequest: decoder(205), decodeResult: decoder(206), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(206)) }, { operation: "application_lcm_expand", operationId: "operation.application.lcm_expand", transport: { kind: "http", route: "/application/retained/lcm_expand", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_expand.v1", requestSchema: { schemaId: "schema.application.retained.lcm-expand.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-expand.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(205), decodeResult: decoder(206), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(206)) }, + decodeRequest: decoder(207), decodeResult: decoder(208), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(208)) }, { operation: "application_lcm_expand_query", operationId: "operation.application.lcm_expand_query", transport: { kind: "http", route: "/application/retained/lcm_expand_query", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_expand_query.v1", requestSchema: { schemaId: "schema.application.retained.lcm-expand-query.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-expand-query.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(207), decodeResult: decoder(208), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(208)) }, + decodeRequest: decoder(209), decodeResult: decoder(210), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(210)) }, { operation: "application_lcm_grep", operationId: "operation.application.lcm_grep", transport: { kind: "http", route: "/application/retained/lcm_grep", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_grep.v1", requestSchema: { schemaId: "schema.application.retained.lcm-grep.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-grep.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(209), decodeResult: decoder(210), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(210)) }, + decodeRequest: decoder(211), decodeResult: decoder(212), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(212)) }, { operation: "application_lcm_load_session", operationId: "operation.application.lcm_load_session", transport: { kind: "http", route: "/application/retained/lcm_load_session", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_load_session.v1", requestSchema: { schemaId: "schema.application.retained.lcm-load-session.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-load-session.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(211), decodeResult: decoder(212), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(212)) }, + decodeRequest: decoder(213), decodeResult: decoder(214), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(214)) }, { operation: "application_lcm_status", operationId: "operation.application.lcm_status", transport: { kind: "http", route: "/application/retained/lcm_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_status.v1", requestSchema: { schemaId: "schema.application.retained.lcm-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(213), decodeResult: decoder(214), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(214)) }, + decodeRequest: decoder(215), decodeResult: decoder(216), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(216)) }, { operation: "application_memory_status", operationId: "operation.application.memory_status", transport: { kind: "http", route: "/application/retained/memory_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.memory_status.v1", requestSchema: { schemaId: "schema.application.retained.memory-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.memory-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(215), decodeResult: decoder(216), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(216)) }, + decodeRequest: decoder(217), decodeResult: decoder(218), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(218)) }, { operation: "application_message_search", operationId: "operation.application.message_search", transport: { kind: "http", route: "/application/retained/message_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.message_search.v1", requestSchema: { schemaId: "schema.application.retained.message-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.message-search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(217), decodeResult: decoder(218), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(218)) }, + decodeRequest: decoder(219), decodeResult: decoder(220), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(220)) }, { operation: "application_module_api", operationId: "operation.application.module_api", transport: { kind: "http", route: "/application/primitives/module_api", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.module_api.v1", requestSchema: { schemaId: "schema.application.primitive.module-api.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.module-api.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(219), decodeResult: decoder(220), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(220)) }, + decodeRequest: decoder(221), decodeResult: decoder(222), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(222)) }, { operation: "move_symbol", operationId: "operation.application.move_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_move_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.move_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.move-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.move-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(221), decodeResult: decoder(14) }, + decodeRequest: decoder(223), decodeResult: decoder(14) }, { operation: "multi_str_replace", operationId: "operation.application.multi_str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_multi_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.multi_str_replace.v1", requestSchema: { schemaId: "schema.application.source-edit.multi-str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.multi-str-replace.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(222), decodeResult: decoder(14) }, + decodeRequest: decoder(224), decodeResult: decoder(14) }, { operation: "native_integration_status", operationId: "operation.application.native_integration_status", transport: { kind: "mcp_tool", toolName: "tracedecay_native_integration_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.native_integration_status.v1", requestSchema: { schemaId: "schema.application.native-integration.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(223), decodeResult: decoder(11) }, + decodeRequest: decoder(225), decodeResult: decoder(11) }, { operation: "node", operationId: "operation.application.node", transport: { kind: "mcp_tool", toolName: "tracedecay_node" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.node.v1", requestSchema: { schemaId: "schema.application.primitive.node.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.node.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(224), decodeResult: decoder(225) }, + decodeRequest: decoder(226), decodeResult: decoder(227) }, { operation: "observatory_read", operationId: "operation.application.observatory_read", transport: { kind: "mcp_tool", toolName: "tracedecay_observatory_read" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.observatory_read.v1", requestSchema: { schemaId: "schema.application.observatory-read.request", revision: 1 }, resultSchema: { schemaId: "schema.application.observatory-read.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":15000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(226), decodeResult: decoder(227) }, + decodeRequest: decoder(228), decodeResult: decoder(229) }, { operation: "port_order", operationId: "operation.application.port_order", transport: { kind: "mcp_tool", toolName: "tracedecay_port_order" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.port_order.v1", requestSchema: { schemaId: "schema.application.primitive.port-order.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.port-order.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(228), decodeResult: decoder(229) }, + decodeRequest: decoder(230), decodeResult: decoder(231) }, { operation: "port_status", operationId: "operation.application.port_status", transport: { kind: "mcp_tool", toolName: "tracedecay_port_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.port_status.v1", requestSchema: { schemaId: "schema.application.primitive.port-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.port-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(230), decodeResult: decoder(231) }, + decodeRequest: decoder(232), decodeResult: decoder(233) }, { operation: "pr_context", operationId: "operation.application.pr_context", transport: { kind: "mcp_tool", toolName: "tracedecay_pr_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.pr_context.v1", requestSchema: { schemaId: "schema.application.primitive.pr-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.pr-context.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(232), decodeResult: decoder(233) }, + decodeRequest: decoder(234), decodeResult: decoder(235) }, { operation: "preflight_native_integration", operationId: "operation.application.preflight_native_integration", transport: { kind: "mcp_tool", toolName: "tracedecay_preflight_native_integration" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.preflight_native_integration.v1", requestSchema: { schemaId: "schema.application.native-integration.preflight.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.preflight.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(234), decodeResult: decoder(11) }, + decodeRequest: decoder(236), decodeResult: decoder(11) }, { operation: "project_context", operationId: "operation.application.project_context", transport: { kind: "mcp_tool", toolName: "tracedecay_project_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_context.v1", requestSchema: { schemaId: "schema.application.primitive.project-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-context.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(235), decodeResult: decoder(236) }, + decodeRequest: decoder(237), decodeResult: decoder(238) }, { operation: "project_list", operationId: "operation.application.project_list", transport: { kind: "mcp_tool", toolName: "tracedecay_project_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_list.v1", requestSchema: { schemaId: "schema.application.primitive.project-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-list.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(237), decodeResult: decoder(238) }, + decodeRequest: decoder(239), decodeResult: decoder(240) }, { operation: "project_search", operationId: "operation.application.project_search", transport: { kind: "mcp_tool", toolName: "tracedecay_project_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_search.v1", requestSchema: { schemaId: "schema.application.primitive.project-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(239), decodeResult: decoder(238) }, + decodeRequest: decoder(241), decodeResult: decoder(240) }, { operation: "application_qualified_name", operationId: "operation.application.qualified_name", transport: { kind: "http", route: "/application/primitives/qualified_name", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.qualified_name.v1", requestSchema: { schemaId: "schema.application.primitive.qualified-name.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.qualified-name.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(240), decodeResult: decoder(241), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(241)) }, + decodeRequest: decoder(242), decodeResult: decoder(243), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(243)) }, { operation: "rank", operationId: "operation.application.rank", transport: { kind: "mcp_tool", toolName: "tracedecay_rank" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rank.v1", requestSchema: { schemaId: "schema.application.primitive.rank.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.rank.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(242), decodeResult: decoder(243) }, + decodeRequest: decoder(244), decodeResult: decoder(245) }, { operation: "recursion", operationId: "operation.application.recursion", transport: { kind: "mcp_tool", toolName: "tracedecay_recursion" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.recursion.v1", requestSchema: { schemaId: "schema.application.primitive.recursion.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.recursion.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(244), decodeResult: decoder(245) }, + decodeRequest: decoder(246), decodeResult: decoder(247) }, { operation: "redundancy", operationId: "operation.application.redundancy", transport: { kind: "mcp_tool", toolName: "tracedecay_redundancy" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.redundancy.v1", requestSchema: { schemaId: "schema.application.primitive.redundancy.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.redundancy.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(246), decodeResult: decoder(247) }, + decodeRequest: decoder(248), decodeResult: decoder(249) }, { operation: "remote_status", operationId: "operation.application.remote_status", transport: { kind: "mcp_tool", toolName: "tracedecay_remote_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.remote_status.v1", requestSchema: { schemaId: "schema.application.primitive.remote-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.remote-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(248), decodeResult: decoder(249) }, + decodeRequest: decoder(250), decodeResult: decoder(251) }, { operation: "rename_preview", operationId: "operation.application.rename_preview", transport: { kind: "mcp_tool", toolName: "tracedecay_rename_preview" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rename_preview.v1", requestSchema: { schemaId: "schema.application.primitive.rename-preview.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.rename-preview.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(250), decodeResult: decoder(251) }, + decodeRequest: decoder(252), decodeResult: decoder(253) }, { operation: "rename_symbol", operationId: "operation.application.rename_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_rename_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rename_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.rename-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rename-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(252), decodeResult: decoder(14) }, + decodeRequest: decoder(254), decodeResult: decoder(14) }, { operation: "replace_symbol", operationId: "operation.application.replace_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_replace_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.replace_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.replace-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.replace-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(253), decodeResult: decoder(14) }, + decodeRequest: decoder(255), decodeResult: decoder(14) }, { operation: "retrieve", operationId: "operation.application.retrieve", transport: { kind: "mcp_tool", toolName: "tracedecay_retrieve" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.retrieve.v1", requestSchema: { schemaId: "schema.application.primitive.retrieve.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.retrieve.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(254), decodeResult: decoder(255) }, + decodeRequest: decoder(256), decodeResult: decoder(257) }, { operation: "run_affected_tests", operationId: "operation.application.run_affected_tests", transport: { kind: "mcp_tool", toolName: "tracedecay_run_affected_tests" }, effect: "spawns_process", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.run_affected_tests.v1", requestSchema: { schemaId: "schema.application.primitive.run-affected-tests.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.run-affected-tests.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","effect_in_flight"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":600000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(256), decodeResult: decoder(257) }, + decodeRequest: decoder(258), decodeResult: decoder(259) }, { operation: "runtime", operationId: "operation.application.runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_runtime" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.runtime.v1", requestSchema: { schemaId: "schema.application.primitive.runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.runtime.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(258), decodeResult: decoder(259) }, + decodeRequest: decoder(260), decodeResult: decoder(261) }, { operation: "search", operationId: "operation.application.search", transport: { kind: "mcp_tool", toolName: "tracedecay_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.search.v1", requestSchema: { schemaId: "schema.application.primitive.search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(260), decodeResult: decoder(261) }, + decodeRequest: decoder(262), decodeResult: decoder(263) }, { operation: "session_lookup", operationId: "operation.application.session_lookup", transport: { kind: "mcp_tool", toolName: "tracedecay_session_lookup" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.session_lookup.v1", requestSchema: { schemaId: "schema.application.primitive.session-lookup.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.session-lookup.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(262), decodeResult: decoder(263) }, + decodeRequest: decoder(264), decodeResult: decoder(265) }, { operation: "application_session_refresh_begin", operationId: "operation.application.session_refresh_begin", transport: { kind: "http", route: "/application/retained/session_refresh_begin", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_begin.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-begin.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-begin.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(264), decodeResult: decoder(265), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(265)) }, + decodeRequest: decoder(266), decodeResult: decoder(267), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(267)) }, { operation: "application_session_refresh_cancel", operationId: "operation.application.session_refresh_cancel", transport: { kind: "http", route: "/application/retained/session_refresh_cancel", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_cancel.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-cancel.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-cancel.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(264), decodeResult: decoder(266), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(266)) }, + decodeRequest: decoder(266), decodeResult: decoder(268), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(268)) }, { operation: "application_session_refresh_status", operationId: "operation.application.session_refresh_status", transport: { kind: "http", route: "/application/retained/session_refresh_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_status.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(264), decodeResult: decoder(267), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(267)) }, + decodeRequest: decoder(266), decodeResult: decoder(269), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(269)) }, { operation: "application_sessions_for", operationId: "operation.application.sessions_for", transport: { kind: "http", route: "/application/retained/sessions_for", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.sessions_for.v1", requestSchema: { schemaId: "schema.application.retained.sessions-for.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.sessions-for.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(268), decodeResult: decoder(269), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(269)) }, + decodeRequest: decoder(270), decodeResult: decoder(271), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(271)) }, { operation: "signature", operationId: "operation.application.signature", transport: { kind: "mcp_tool", toolName: "tracedecay_signature" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.signature.v1", requestSchema: { schemaId: "schema.application.primitive.signature.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.signature.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(108), decodeResult: decoder(270) }, + decodeRequest: decoder(108), decodeResult: decoder(272) }, { operation: "similar", operationId: "operation.application.similar", transport: { kind: "mcp_tool", toolName: "tracedecay_similar" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.similar.v1", requestSchema: { schemaId: "schema.application.primitive.similar.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.similar.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(271), decodeResult: decoder(272) }, + decodeRequest: decoder(273), decodeResult: decoder(274) }, { operation: "skill_list", operationId: "operation.application.skill_list", transport: { kind: "mcp_tool", toolName: "tracedecay_skill_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.skill_list.v1", requestSchema: { schemaId: "schema.application.primitive.skill-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.skill-list.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(273), decodeResult: decoder(274) }, + decodeRequest: decoder(275), decodeResult: decoder(276) }, { operation: "skill_view", operationId: "operation.application.skill_view", transport: { kind: "mcp_tool", toolName: "tracedecay_skill_view" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.skill_view.v1", requestSchema: { schemaId: "schema.application.primitive.skill-view.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.skill-view.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(275), decodeResult: decoder(276) }, + decodeRequest: decoder(277), decodeResult: decoder(278) }, { operation: "application_source_body", operationId: "operation.application.source_body", transport: { kind: "http", route: "/application/primitives/source_body", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_body.v1", requestSchema: { schemaId: "schema.application.primitive.source-body.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-body.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(277), decodeResult: decoder(278), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(278)) }, + decodeRequest: decoder(279), decodeResult: decoder(280), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(280)) }, { operation: "source_edit_reconcile", operationId: "operation.application.source_edit_reconcile", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_reconcile" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_reconcile.v1", requestSchema: { schemaId: "schema.application.source-edit.reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.reconcile.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(279), decodeResult: decoder(14) }, + decodeRequest: decoder(281), decodeResult: decoder(14) }, { operation: "source_edit_rollback", operationId: "operation.application.source_edit_rollback", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_rollback" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_rollback.v1", requestSchema: { schemaId: "schema.application.source-edit.rollback.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rollback.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(280), decodeResult: decoder(14) }, + decodeRequest: decoder(282), decodeResult: decoder(14) }, { operation: "application_source_lines", operationId: "operation.application.source_lines", transport: { kind: "http", route: "/application/primitives/source_lines", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_lines.v1", requestSchema: { schemaId: "schema.application.primitive.source-lines.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-lines.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(281), decodeResult: decoder(282), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(282)) }, + decodeRequest: decoder(283), decodeResult: decoder(284), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(284)) }, { operation: "application_source_outline", operationId: "operation.application.source_outline", transport: { kind: "http", route: "/application/primitives/source_outline", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_outline.v1", requestSchema: { schemaId: "schema.application.primitive.source-outline.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-outline.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(283), decodeResult: decoder(284), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(284)) }, + decodeRequest: decoder(285), decodeResult: decoder(286), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(286)) }, { operation: "stack_snapshot", operationId: "operation.application.stack_snapshot", transport: { kind: "mcp_tool", toolName: "tracedecay_stack_snapshot" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.stack_snapshot.v1", requestSchema: { schemaId: "schema.application.native-integration.stack-snapshot.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.stack-snapshot.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(285), decodeResult: decoder(11) }, + decodeRequest: decoder(287), decodeResult: decoder(11) }, { operation: "status", operationId: "operation.application.status", transport: { kind: "mcp_tool", toolName: "tracedecay_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.status.v1", requestSchema: { schemaId: "schema.application.primitive.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(286), decodeResult: decoder(287) }, + decodeRequest: decoder(288), decodeResult: decoder(289) }, { operation: "application_storage_status", operationId: "operation.application.storage_status", transport: { kind: "http", route: "/application/primitives/storage_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.storage_status.v1", requestSchema: { schemaId: "schema.application.primitive.storage-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.storage-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(288), decodeResult: decoder(289), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(289)) }, + decodeRequest: decoder(290), decodeResult: decoder(291), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(291)) }, { operation: "str_replace", operationId: "operation.application.str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.str_replace.v1", requestSchema: { schemaId: "schema.application.source-edit.str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.str-replace.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(290), decodeResult: decoder(14) }, + decodeRequest: decoder(292), decodeResult: decoder(14) }, { operation: "test_map", operationId: "operation.application.test_map", transport: { kind: "mcp_tool", toolName: "tracedecay_test_map" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_map.v1", requestSchema: { schemaId: "schema.application.primitive.test-map.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-map.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(291), decodeResult: decoder(292) }, + decodeRequest: decoder(293), decodeResult: decoder(294) }, { operation: "application_test_results", operationId: "operation.application.test_results", transport: { kind: "http", route: "/application/tests/results", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.test_results.v1", requestSchema: { schemaId: "schema.application.feedback.test-results.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.test-results.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":15000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(293), decodeResult: decoder(294), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(294)) }, + decodeRequest: decoder(295), decodeResult: decoder(296), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(296)) }, { operation: "test_risk", operationId: "operation.application.test_risk", transport: { kind: "mcp_tool", toolName: "tracedecay_test_risk" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_risk.v1", requestSchema: { schemaId: "schema.application.primitive.test-risk.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-risk.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(295), decodeResult: decoder(296) }, + decodeRequest: decoder(297), decodeResult: decoder(298) }, { operation: "todos", operationId: "operation.application.todos", transport: { kind: "mcp_tool", toolName: "tracedecay_todos" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.todos.v1", requestSchema: { schemaId: "schema.application.primitive.todos.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.todos.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(297), decodeResult: decoder(298) }, + decodeRequest: decoder(299), decodeResult: decoder(300) }, { operation: "unmounted_files", operationId: "operation.application.unmounted_files", transport: { kind: "mcp_tool", toolName: "tracedecay_unmounted_files" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.unmounted_files.v1", requestSchema: { schemaId: "schema.application.primitive.unmounted-files.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.unmounted-files.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(299), decodeResult: decoder(300) }, + decodeRequest: decoder(301), decodeResult: decoder(302) }, { operation: "unsafe_patterns", operationId: "operation.application.unsafe_patterns", transport: { kind: "mcp_tool", toolName: "tracedecay_unsafe_patterns" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.unsafe_patterns.v1", requestSchema: { schemaId: "schema.application.primitive.unsafe-patterns.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.unsafe-patterns.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(301), decodeResult: decoder(302) }, + decodeRequest: decoder(303), decodeResult: decoder(304) }, { operation: "application_workflows", operationId: "operation.application.workflows", transport: { kind: "http", route: "/application/retained/workflows", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflows.v1", requestSchema: { schemaId: "schema.application.retained.workflows.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.workflows.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(303), decodeResult: decoder(304), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(304)) }, + decodeRequest: decoder(305), decodeResult: decoder(306), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(306)) }, { operation: "application_worktree_cleanup_confirm", operationId: "operation.application.worktree_cleanup_confirm", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_confirm", method: "POST" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_confirm.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-confirm.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-confirm.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(305), decodeResult: decoder(11), + decodeRequest: decoder(307), decodeResult: decoder(11), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_confirm.v1", "schema.application.native-integration.worktree-cleanup-confirm.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(11)) }, { operation: "application_worktree_cleanup_inspect", operationId: "operation.application.worktree_cleanup_inspect", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_inspect", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_inspect.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(306), decodeResult: decoder(11), + decodeRequest: decoder(308), decodeResult: decoder(11), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_inspect.v1", "schema.application.native-integration.worktree-cleanup-inspect.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(11)) }, { operation: "application_worktree_cleanup_reconcile", operationId: "operation.application.worktree_cleanup_reconcile", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_reconcile", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_reconcile.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(307), decodeResult: decoder(11), + decodeRequest: decoder(309), decodeResult: decoder(11), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_reconcile.v1", "schema.application.native-integration.worktree-cleanup-reconcile.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(11)) }, { operation: "application_worktree_cleanup_remove", operationId: "operation.application.worktree_cleanup_remove", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_remove", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_remove.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(308), decodeResult: decoder(11), + decodeRequest: decoder(310), decodeResult: decoder(11), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_remove.v1", "schema.application.native-integration.worktree-cleanup-remove.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(11)) }, { operation: "application_worktree_inventory", operationId: "operation.application.worktree_inventory", transport: { kind: "http", route: "/application/native-integration/worktree_inventory", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_inventory.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-inventory.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-inventory.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(309), decodeResult: decoder(11), + decodeRequest: decoder(311), decodeResult: decoder(11), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_inventory.v1", "schema.application.native-integration.worktree-inventory.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(11)) }, { operation: "handoff_issue_task_handoff", operationId: "operation.handoff.issue_task_handoff", transport: { kind: "http", route: "/application/handoff/issue-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.issue_task_handoff", requestSchema: { schemaId: "schema.handoff.issue_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.issue_task_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(310), decodeResult: decoder(311), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(311)) }, + decodeRequest: decoder(312), decodeResult: decoder(313), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(313)) }, { operation: "handoff_list_task_handoffs", operationId: "operation.handoff.list_task_handoffs", transport: { kind: "http", route: "/application/handoff/list-task", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.list_task_handoffs", requestSchema: { schemaId: "schema.handoff.list_task_handoffs.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.list_task_handoffs.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","partial"], - decodeRequest: decoder(312), decodeResult: decoder(313), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder(313)) }, + decodeRequest: decoder(314), decodeResult: decoder(315), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder(315)) }, { operation: "handoff_open_investigation_handoff", operationId: "operation.handoff.open_investigation_handoff", transport: { kind: "http", route: "/application/handoff/open-investigation", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.open_investigation_handoff", requestSchema: { schemaId: "schema.handoff.open_investigation_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.open_investigation_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(314), decodeResult: decoder(315), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(315)) }, + decodeRequest: decoder(316), decodeResult: decoder(317), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(317)) }, { operation: "handoff_open_task_handoff", operationId: "operation.handoff.open_task_handoff", transport: { kind: "http", route: "/application/handoff/open-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.open_task_handoff", requestSchema: { schemaId: "schema.handoff.open_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.open_task_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(316), decodeResult: decoder(317), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(317)) }, + decodeRequest: decoder(318), decodeResult: decoder(319), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(319)) }, { operation: "multi_root_execute", operationId: "operation.multi_root.execute", transport: { kind: "http", route: "/application/multi-root/execute", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.execute.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.execute-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.execute-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(318), decodeResult: decoder(319), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(319)) }, + decodeRequest: decoder(320), decodeResult: decoder(321), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(321)) }, { operation: "multi_root_scope_set_compare_and_swap", operationId: "operation.multi_root.scope_set_compare_and_swap", transport: { kind: "http", route: "/application/multi-root/scope-set/compare-and-swap", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.scope_set_compare_and_swap.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-compare-and-swap-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(320), decodeResult: decoder(321), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(321)) }, + decodeRequest: decoder(322), decodeResult: decoder(323), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(323)) }, { operation: "multi_root_scope_set_read", operationId: "operation.multi_root.scope_set_read", transport: { kind: "http", route: "/application/multi-root/scope-set/read", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.scope_set_read.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-read-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-read-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(322), decodeResult: decoder(323), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(323)) }, + decodeRequest: decoder(324), decodeResult: decoder(325), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(325)) }, { operation: "work_accept_proposal", operationId: "operation.work.accept_proposal", transport: { kind: "http", route: "/application/work/accept-proposal", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.accept_proposal", requestSchema: { schemaId: "schema.work.accept_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.accept_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(324), decodeResult: decoder(325), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(325)) }, + decodeRequest: decoder(326), decodeResult: decoder(327), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, { operation: "work_adjudicate_duplicate", operationId: "operation.work.adjudicate_duplicate", transport: { kind: "http", route: "/application/work/adjudicate-duplicate", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.adjudicate_duplicate", requestSchema: { schemaId: "schema.work.adjudicate_duplicate.request", revision: 1 }, resultSchema: { schemaId: "schema.work.adjudicate_duplicate.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(326), decodeResult: decoder(327), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, + decodeRequest: decoder(328), decodeResult: decoder(329), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, { operation: "work_adjudicate_leak", operationId: "operation.work.adjudicate_leak", transport: { kind: "http", route: "/application/work/adjudicate-leak", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.adjudicate_leak", requestSchema: { schemaId: "schema.work.adjudicate_leak.request", revision: 1 }, resultSchema: { schemaId: "schema.work.adjudicate_leak.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(328), decodeResult: decoder(329), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, + decodeRequest: decoder(330), decodeResult: decoder(331), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, { operation: "work_admit_execution", operationId: "operation.work.admit_execution", transport: { kind: "http", route: "/application/work/admit-execution", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.admit_execution", requestSchema: { schemaId: "schema.work.admit_execution.request", revision: 1 }, resultSchema: { schemaId: "schema.work.admit_execution.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(330), decodeResult: decoder(331), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, + decodeRequest: decoder(332), decodeResult: decoder(333), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, { operation: "work_admit_placement", operationId: "operation.work.admit_placement", transport: { kind: "http", route: "/application/work/admit-placement", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.admit_placement", requestSchema: { schemaId: "schema.work.admit_placement.request", revision: 1 }, resultSchema: { schemaId: "schema.work.admit_placement.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(332), decodeResult: decoder(333), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, + decodeRequest: decoder(334), decodeResult: decoder(335), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, { operation: "work_attempt_status", operationId: "operation.work.attempt_status", transport: { kind: "http", route: "/application/work/attempt-status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.attempt_status", requestSchema: { schemaId: "schema.work.attempt_status.request", revision: 1 }, resultSchema: { schemaId: "schema.work.attempt_status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(334), decodeResult: decoder(335), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(335)) }, + decodeRequest: decoder(336), decodeResult: decoder(337), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(337)) }, { operation: "work_cancel_attempt", operationId: "operation.work.cancel_attempt", transport: { kind: "http", route: "/application/work/cancel-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.cancel_attempt", requestSchema: { schemaId: "schema.work.cancel_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.cancel_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(336), decodeResult: decoder(335), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, + decodeRequest: decoder(338), decodeResult: decoder(337), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, { operation: "work_compare_proposal", operationId: "operation.work.compare_proposal", transport: { kind: "http", route: "/application/work/compare-proposal", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.compare_proposal", requestSchema: { schemaId: "schema.work.compare_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.compare_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(337), decodeResult: decoder(338), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(338)) }, + decodeRequest: decoder(339), decodeResult: decoder(340), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(340)) }, { operation: "work_create", operationId: "operation.work.create", transport: { kind: "http", route: "/application/work/create", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.create", requestSchema: { schemaId: "schema.work.create.request", revision: 1 }, resultSchema: { schemaId: "schema.work.create.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(339), decodeResult: decoder(325), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(325)) }, + decodeRequest: decoder(341), decodeResult: decoder(327), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, { operation: "work_execution_history", operationId: "operation.work.execution_history", transport: { kind: "http", route: "/application/work/execution-history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.execution_history", requestSchema: { schemaId: "schema.work.execution_history.request", revision: 1 }, resultSchema: { schemaId: "schema.work.execution_history.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(340), decodeResult: decoder(341), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(341)) }, + decodeRequest: decoder(342), decodeResult: decoder(343), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(343)) }, { operation: "work_experience", operationId: "operation.work.experience", transport: { kind: "http", route: "/application/work/experience", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.experience", requestSchema: { schemaId: "schema.work.experience.request", revision: 1 }, resultSchema: { schemaId: "schema.work.experience.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(342), decodeResult: decoder(343), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(343)) }, + decodeRequest: decoder(344), decodeResult: decoder(345), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(345)) }, { operation: "work_generate_proposal", operationId: "operation.work.generate_proposal", transport: { kind: "http", route: "/application/work/generate-proposal", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.generate_proposal", requestSchema: { schemaId: "schema.work.generate_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.generate_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(344), decodeResult: decoder(345), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(345)) }, + decodeRequest: decoder(346), decodeResult: decoder(347), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(347)) }, { operation: "work_hydrate_artifacts", operationId: "operation.work.hydrate_artifacts", transport: { kind: "http", route: "/application/work/hydrate-artifacts", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.hydrate_artifacts", requestSchema: { schemaId: "schema.work.hydrate_artifacts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.hydrate_artifacts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(346), decodeResult: decoder(347), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(347)) }, + decodeRequest: decoder(348), decodeResult: decoder(349), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(349)) }, { operation: "work_list_attempts", operationId: "operation.work.list_attempts", transport: { kind: "http", route: "/application/work/list-attempts", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.list_attempts", requestSchema: { schemaId: "schema.work.list_attempts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.list_attempts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(340), decodeResult: decoder(348), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(348)) }, + decodeRequest: decoder(342), decodeResult: decoder(350), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(350)) }, { operation: "work_mutate_graph", operationId: "operation.work.mutate_graph", transport: { kind: "http", route: "/application/work/mutate-graph", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.mutate_graph", requestSchema: { schemaId: "schema.work.mutate_graph.request", revision: 1 }, resultSchema: { schemaId: "schema.work.mutate_graph.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(349), decodeResult: decoder(325), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(325)) }, + decodeRequest: decoder(351), decodeResult: decoder(327), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, { operation: "work_pause_run", operationId: "operation.work.pause_run", transport: { kind: "http", route: "/application/work/pause-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.pause_run", requestSchema: { schemaId: "schema.work.pause_run.request", revision: 1 }, resultSchema: { schemaId: "schema.work.pause_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(350), decodeResult: decoder(351), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(351)) }, + decodeRequest: decoder(352), decodeResult: decoder(353), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(353)) }, { operation: "work_placement_preflight", operationId: "operation.work.placement_preflight", transport: { kind: "http", route: "/application/work/placement-preflight", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.placement_preflight", requestSchema: { schemaId: "schema.work.placement_preflight.request", revision: 1 }, resultSchema: { schemaId: "schema.work.placement_preflight.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(352), decodeResult: decoder(353), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(353)) }, + decodeRequest: decoder(354), decodeResult: decoder(355), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(355)) }, { operation: "work_placement_status", operationId: "operation.work.placement_status", transport: { kind: "http", route: "/application/work/placement-status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.placement_status", requestSchema: { schemaId: "schema.work.placement_status.request", revision: 1 }, resultSchema: { schemaId: "schema.work.placement_status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(354), decodeResult: decoder(355), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(355)) }, + decodeRequest: decoder(356), decodeResult: decoder(357), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(357)) }, { operation: "work_prepare_duplicate_adjudication", operationId: "operation.work.prepare_duplicate_adjudication", transport: { kind: "http", route: "/application/work/prepare-duplicate-adjudication", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.prepare_duplicate_adjudication", requestSchema: { schemaId: "schema.work.prepare_duplicate_adjudication.request", revision: 1 }, resultSchema: { schemaId: "schema.work.prepare_duplicate_adjudication.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(356), decodeResult: decoder(326), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(326)) }, + decodeRequest: decoder(358), decodeResult: decoder(328), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(328)) }, { operation: "work_prepare_graph_mutation", operationId: "operation.work.prepare_graph_mutation", transport: { kind: "http", route: "/application/work/prepare-graph-mutation", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.prepare_graph_mutation", requestSchema: { schemaId: "schema.work.prepare_graph_mutation.request", revision: 1 }, resultSchema: { schemaId: "schema.work.prepare_graph_mutation.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(357), decodeResult: decoder(349), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(349)) }, + decodeRequest: decoder(359), decodeResult: decoder(351), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(351)) }, { operation: "work_release_placement", operationId: "operation.work.release_placement", transport: { kind: "http", route: "/application/work/release-placement", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.release_placement", requestSchema: { schemaId: "schema.work.release_placement.request", revision: 1 }, resultSchema: { schemaId: "schema.work.release_placement.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(358), decodeResult: decoder(333), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, + decodeRequest: decoder(360), decodeResult: decoder(335), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, { operation: "work_resume_attempts", operationId: "operation.work.resume_attempts", transport: { kind: "http", route: "/application/work/resume-attempts", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.resume_attempts", requestSchema: { schemaId: "schema.work.resume_attempts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.resume_attempts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(359), decodeResult: decoder(360), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(360)) }, + decodeRequest: decoder(361), decodeResult: decoder(362), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(362)) }, { operation: "work_resume_run", operationId: "operation.work.resume_run", transport: { kind: "http", route: "/application/work/resume-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.resume_run", requestSchema: { schemaId: "schema.work.resume_run.request", revision: 1 }, resultSchema: { schemaId: "schema.work.resume_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(361), decodeResult: decoder(351), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(351)) }, + decodeRequest: decoder(363), decodeResult: decoder(353), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(353)) }, { operation: "work_retrieve_evidence", operationId: "operation.work.retrieve_evidence", transport: { kind: "http", route: "/application/work/retrieve-evidence", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.retrieve_evidence", requestSchema: { schemaId: "schema.work.retrieve_evidence.request", revision: 1 }, resultSchema: { schemaId: "schema.work.retrieve_evidence.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(362), decodeResult: decoder(363), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(363)) }, + decodeRequest: decoder(364), decodeResult: decoder(365), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(365)) }, { operation: "work_retry_attempt", operationId: "operation.work.retry_attempt", transport: { kind: "http", route: "/application/work/retry-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.retry_attempt", requestSchema: { schemaId: "schema.work.retry_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.retry_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(364), decodeResult: decoder(365), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(365)) }, + decodeRequest: decoder(366), decodeResult: decoder(367), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(367)) }, { operation: "work_review_proposal", operationId: "operation.work.review_proposal", transport: { kind: "http", route: "/application/work/review-proposal", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.review_proposal", requestSchema: { schemaId: "schema.work.review_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.review_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(366), decodeResult: decoder(325), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(325)) }, + decodeRequest: decoder(368), decodeResult: decoder(327), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, { operation: "work_run_control", operationId: "operation.work.run_control", transport: { kind: "http", route: "/application/work/run-control", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.run_control", requestSchema: { schemaId: "schema.work.run_control.request", revision: 1 }, resultSchema: { schemaId: "schema.work.run_control.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(367), decodeResult: decoder(368), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(368)) }, + decodeRequest: decoder(369), decodeResult: decoder(370), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(370)) }, { operation: "work_start_attempt", operationId: "operation.work.start_attempt", transport: { kind: "http", route: "/application/work/start-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.start_attempt", requestSchema: { schemaId: "schema.work.start_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.start_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(369), decodeResult: decoder(335), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, + decodeRequest: decoder(371), decodeResult: decoder(337), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, { operation: "work_synthesize", operationId: "operation.work.synthesize", transport: { kind: "http", route: "/application/work/synthesize", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.synthesize", requestSchema: { schemaId: "schema.work.synthesize.request", revision: 1 }, resultSchema: { schemaId: "schema.work.synthesize.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(370), decodeResult: decoder(371), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(371)) }, + decodeRequest: decoder(372), decodeResult: decoder(373), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(373)) }, { operation: "work_topology", operationId: "operation.work.topology", transport: { kind: "http", route: "/application/work/topology", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.topology", requestSchema: { schemaId: "schema.work.topology.request", revision: 1 }, resultSchema: { schemaId: "schema.work.topology.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(372), decodeResult: decoder(373), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(373)) }, + decodeRequest: decoder(374), decodeResult: decoder(375), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(375)) }, { operation: "work_topology_metrics", operationId: "operation.work.topology_metrics", transport: { kind: "http", route: "/application/work/topology-metrics", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.topology_metrics", requestSchema: { schemaId: "schema.work.topology_metrics.request", revision: 1 }, resultSchema: { schemaId: "schema.work.topology_metrics.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(374), decodeResult: decoder(375), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(375)) }, + decodeRequest: decoder(376), decodeResult: decoder(377), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(377)) }, { operation: "work_views", operationId: "operation.work.views", transport: { kind: "http", route: "/application/work/views", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.views", requestSchema: { schemaId: "schema.work.views.request", revision: 1 }, resultSchema: { schemaId: "schema.work.views.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(376), decodeResult: decoder(377), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(377)) }, + decodeRequest: decoder(378), decodeResult: decoder(379), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(379)) }, { operation: "workflow_activate_definition", operationId: "operation.workflow.activate_definition", transport: { kind: "http", route: "/application/workflow/activate-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.activate_definition", requestSchema: { schemaId: "schema.workflow.activate_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.activate_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(378), decodeResult: decoder(379), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(379)) }, + decodeRequest: decoder(380), decodeResult: decoder(381), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, { operation: "workflow_cancel_run", operationId: "operation.workflow.cancel_run", transport: { kind: "http", route: "/application/workflow/cancel-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.cancel_run", requestSchema: { schemaId: "schema.workflow.cancel_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.cancel_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(380), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(382), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_definition_history", operationId: "operation.workflow.definition_history", transport: { kind: "http", route: "/application/workflow/definition-history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.definition_history", requestSchema: { schemaId: "schema.workflow.definition_history.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.definition_history.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(382), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(383)) }, + decodeRequest: decoder(384), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, { operation: "workflow_diff_definition", operationId: "operation.workflow.diff_definition", transport: { kind: "http", route: "/application/workflow/diff-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.diff_definition", requestSchema: { schemaId: "schema.workflow.diff_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.diff_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(384), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, + decodeRequest: decoder(386), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, { operation: "workflow_get_definition", operationId: "operation.workflow.get_definition", transport: { kind: "http", route: "/application/workflow/get-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.get_definition", requestSchema: { schemaId: "schema.workflow.get_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.get_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(386), decodeResult: decoder(387), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, + decodeRequest: decoder(388), decodeResult: decoder(389), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(389)) }, { operation: "workflow_get_run", operationId: "operation.workflow.get_run", transport: { kind: "http", route: "/application/workflow/get-run", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.get_run", requestSchema: { schemaId: "schema.workflow.get_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.get_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(388), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(381)) }, + decodeRequest: decoder(390), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(383)) }, { operation: "workflow_handoff_issue", operationId: "operation.workflow.handoff_issue", transport: { kind: "http", route: "/application/workflow/handoff-issue", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.handoff_issue", requestSchema: { schemaId: "schema.workflow.handoff_issue.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.handoff_issue.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(389), decodeResult: decoder(390), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(390)) }, + decodeRequest: decoder(391), decodeResult: decoder(392), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(392)) }, { operation: "workflow_handoff_redeem", operationId: "operation.workflow.handoff_redeem", transport: { kind: "http", route: "/application/workflow/handoff-redeem", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.handoff_redeem", requestSchema: { schemaId: "schema.workflow.handoff_redeem.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.handoff_redeem.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(391), decodeResult: decoder(392), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(392)) }, + decodeRequest: decoder(393), decodeResult: decoder(394), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(394)) }, { operation: "workflow_list_definitions", operationId: "operation.workflow.list_definitions", transport: { kind: "http", route: "/application/workflow/list-definitions", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.list_definitions", requestSchema: { schemaId: "schema.workflow.list_definitions.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.list_definitions.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(393), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(383)) }, + decodeRequest: decoder(395), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, { operation: "workflow_pause_run", operationId: "operation.workflow.pause_run", transport: { kind: "http", route: "/application/workflow/pause-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.pause_run", requestSchema: { schemaId: "schema.workflow.pause_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.pause_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(394), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(396), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_register_definition", operationId: "operation.workflow.register_definition", transport: { kind: "http", route: "/application/workflow/register-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.register_definition", requestSchema: { schemaId: "schema.workflow.register_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.register_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(395), decodeResult: decoder(387), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(387)) }, + decodeRequest: decoder(397), decodeResult: decoder(389), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(389)) }, { operation: "workflow_reject_definition", operationId: "operation.workflow.reject_definition", transport: { kind: "http", route: "/application/workflow/reject-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.reject_definition", requestSchema: { schemaId: "schema.workflow.reject_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.reject_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(396), decodeResult: decoder(379), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(379)) }, + decodeRequest: decoder(398), decodeResult: decoder(381), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, { operation: "workflow_resume_run", operationId: "operation.workflow.resume_run", transport: { kind: "http", route: "/application/workflow/resume-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.resume_run", requestSchema: { schemaId: "schema.workflow.resume_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.resume_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(397), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(399), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_retire_definition", operationId: "operation.workflow.retire_definition", transport: { kind: "http", route: "/application/workflow/retire-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.retire_definition", requestSchema: { schemaId: "schema.workflow.retire_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.retire_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(398), decodeResult: decoder(379), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(379)) }, + decodeRequest: decoder(400), decodeResult: decoder(381), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, { operation: "workflow_start_run", operationId: "operation.workflow.start_run", transport: { kind: "http", route: "/application/workflow/start-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.start_run", requestSchema: { schemaId: "schema.workflow.start_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.start_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(399), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(401), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_validate_definition", operationId: "operation.workflow.validate_definition", transport: { kind: "http", route: "/application/workflow/validate-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.validate_definition", requestSchema: { schemaId: "schema.workflow.validate_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.validate_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(400), decodeResult: decoder(401), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(401)) }, + decodeRequest: decoder(402), decodeResult: decoder(403), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(403)) }, ] as const; export type Operation = (typeof OPERATIONS)[number]; From 9a6957265845ba3a32637288156ecaacfd5cd506 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 19:25:18 +0000 Subject: [PATCH 03/10] refactor(mcp): answer profile hook actions through the profile owner --- .../schemas/dashboard-contracts.schema.json | 5 + dashboard/src/contracts/generated.ts | 2 +- sdks/typescript/src/operations.ts | 428 +++++++++--------- 3 files changed, 231 insertions(+), 204 deletions(-) diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json index 5cb381ceb2..df2b582a1d 100644 --- a/dashboard/codegen/schemas/dashboard-contracts.schema.json +++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json @@ -11236,6 +11236,11 @@ "const": "maintains_owner_state", "description": "Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.", "type": "string" + }, + { + "const": "records_host_evidence", + "description": "Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.", + "type": "string" } ] }, diff --git a/dashboard/src/contracts/generated.ts b/dashboard/src/contracts/generated.ts index 7f166e1430..42ee9a976d 100644 --- a/dashboard/src/contracts/generated.ts +++ b/dashboard/src/contracts/generated.ts @@ -2390,7 +2390,7 @@ export type DuplicateEffortKindV1 = z.infer; Git index writes remain separate classes so policy cannot accidentally substitute one index mutation for another. */ -export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work"), z.literal("maintains_owner_state")]); +export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work"), z.literal("maintains_owner_state"), z.literal("records_host_evidence")]); export type EffectClass = z.infer; /** Durable effect proof. It records identities and receipts, never credentials diff --git a/sdks/typescript/src/operations.ts b/sdks/typescript/src/operations.ts index 68755a1822..6bdbdceee8 100644 --- a/sdks/typescript/src/operations.ts +++ b/sdks/typescript/src/operations.ts @@ -268,6 +268,7 @@ export type ContextScoutServiceStateV1 = "active" | "paused" | "disabled"; export type ContextScoutSettingsV1 = { readonly limits: ContextScoutConfigurationLimitsV1; readonly mode: ContextScoutConfigurationModeV1; readonly model_id?: string | null; readonly model_path?: ContextScoutConfiguredModelPathV1 | null; readonly model_timeout_secs?: number | null; readonly schema_version: number; readonly state: ContextScoutConfigurationStateV1 }; export type ContextScoutStatusResultV1 = { readonly active_suggestions: number; readonly configuration_revision: readonly number[]; readonly last_delivery_outcome?: ContextScoutDeliveryOutcomeV1 | null; readonly last_feedback?: ContextScoutFeedbackKindV1 | null; readonly last_model_outcome?: ContextScoutModelOutcomeV1 | null; readonly last_model_receipt?: ContextScoutModelReceiptV1 | null; readonly last_route?: ContextScoutRouteV1 | null; readonly last_suppression?: ContextScoutSuppressionV1 | null; readonly limits: ContextScoutLimitsV1; readonly mode: ContextScoutRuntimeModeV1; readonly model_path?: ContextScoutModelBackendV1 | null; readonly state: ContextScoutServiceStateV1 }; export type ContextScoutStoreOutcomeV1 = "stored" | "duplicate" | "superseded"; +export type ContextScoutStoreStatusV1 = "stored" | "duplicate" | "superseded" | "unavailable"; export type ContextScoutSuggestionProjectionV1 = { readonly category: ContextScoutCategoryV1; readonly configuration_revision: readonly number[]; readonly dedupe_key: readonly number[]; readonly delivery_window: ContextScoutDeliveryWindowV1; readonly envelope_id: readonly number[]; readonly evidence: ContextScoutEvidenceProjectionV1; readonly expires_at: UtcMicros; readonly model_outcome: ContextScoutModelOutcomeV1; readonly model_receipt?: ContextScoutModelReceiptV1 | null; readonly relevance_score: number; readonly route: ContextScoutRouteV1; readonly suggestion_text: string; readonly work: ContextScoutWorkV1 }; export type ContextScoutSuppressionV1 = "disabled" | "paused" | "dirty_overlay" | "quiet_or_unreceptive" | "no_eligible_candidate" | "expired" | "duplicate" | "cancelled" | "model_output_invalid" | "evidence_partial" | "evidence_stale" | "evidence_unavailable"; export type ContextScoutWorkV1 = { readonly address: ContextScoutAddressV1; readonly generation: number; readonly input_watermark: readonly number[] }; @@ -336,7 +337,7 @@ export type DsmStatsV1 = { readonly clusters: number; readonly density: number; export type DuplicateEffectOutcomeV1 = "prevented" | "committed" | "unknown" | "not_applicable"; export type DuplicateEffortKindV1 = "exact_duplicate" | "superseded_overlap" | "repeated_investigation" | "duplicate_effect" | "not_duplicate" | "censored" | "unknown"; export type EditResult = { readonly diff?: string | null; readonly dry_run?: boolean; readonly file_path: string; readonly matched_str: string; readonly message: string; readonly new_str: string; readonly replaced_span?: string | null; readonly success: boolean; readonly [key: string]: unknown }; -export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work" | "maintains_owner_state"; +export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work" | "maintains_owner_state" | "records_host_evidence"; export type EffectReceipt_2 = { readonly actor: ActorId; readonly catalog_digest: ManifestDigest; readonly committed_state?: ManifestDigest | null; readonly configuration_digest: ManifestDigest; readonly effect_class: EffectClass; readonly expected_state: ManifestDigest; readonly external_proof?: RetrievalAnchorId | null; readonly idempotency_key: string; readonly input_digest: ManifestDigest; readonly operation: UseCaseId; readonly outcome: EffectTermination_2; readonly policy_digest: ManifestDigest; readonly privacy_digest: ManifestDigest; readonly request_id: string; readonly scope: ResolvedScope }; export type EffectResult_2 = { readonly authority: AuthorityReceipt; readonly effect_class: EffectClass; readonly effect_id: string; readonly execution: OperationReceipt_2; readonly expected_state: ManifestDigest; readonly idempotency_key: string; readonly payload?: SourceEditDurableEffectPayloadV1 | null; readonly receipt: EffectReceipt_2; readonly reconciliation: ReconciliationState }; export type EffectTermination_2 = "completed" | "cancelled" | "timed_out" | "failed" | "partial" | "effect_unknown"; @@ -527,10 +528,16 @@ export type HealthModularityV1 = { readonly components_after_hub_removal: number export type HealthRedundancyV1 = { readonly dead_count: number; readonly score: number; readonly source: string; readonly total_fns: number }; export type HealthWeightsV1 = { readonly note: string }; export type HermesPendingSkillWrite = { readonly action?: string | null; readonly created_at?: unknown; readonly id: string; readonly name?: string | null; readonly origin?: string | null; readonly payload?: unknown; readonly source_path: string; readonly summary?: string | null; readonly [key: string]: unknown }; +export type HermesReceiptStatusV1 = "recorded" | "ingested" | "awaiting_transcript"; export type HermesSkillBridgeContracts = { readonly discovery_policy: string; readonly lifecycle_owner: string; readonly mutation_policy: string; readonly [key: string]: unknown }; export type HermesSkillBridgeSnapshot = { readonly agent_home: string; readonly archive_count: number; readonly contracts: HermesSkillBridgeContracts; readonly pending_skill_corrupt_count: number; readonly pending_skill_count: number; readonly pending_skills: readonly HermesPendingSkillWrite[]; readonly skill_count: number; readonly skills: readonly HermesSkillSummary[]; readonly skills_dir: string; readonly usage_record_count: number; readonly usage_records: { readonly [key: string]: unknown }; readonly [key: string]: unknown }; export type HermesSkillSummary = { readonly body_markdown?: string | null; readonly category?: string | null; readonly description?: string | null; readonly name: string; readonly path: string; readonly pending_write_ids: readonly string[]; readonly usage?: unknown; readonly [key: string]: unknown }; export type HistoryRewritePolicyV1 = "forbid_force_and_rebase"; +export type HookIngestAdmissionV1 = { readonly reason_code?: string | null; readonly retryable: boolean; readonly status: string }; +export type HookOrchestrationAdmissionV1 = "enqueued" | "backpressured" | "unsupported_trigger" | "unavailable"; +export type HookRuntimeAcceptedV1 = "accepted"; +export type HookRuntimeDispositionV1 = "accepted" | "catchup_required"; +export type HookV2RejectionReasonV1 = "admission_identity_conflict"; export type HostInstanceId = string; export type HotspotV1 = { readonly file: string; readonly id: string; readonly incoming: number; readonly kind: string; readonly line: number; readonly name: string; readonly outgoing: number; readonly total: number }; export type HunkDirectionV1 = "working_tree_to_index" | "index_to_head"; @@ -1461,6 +1468,8 @@ export type OperationApplicationHealthReadRequest = { }; export type OperationApplicationHealthReadResult = { readonly status: string }; export type OperationApplicationHermesSkillBridgeRequest = { readonly include_pending_payloads?: boolean; readonly include_skill_bodies?: boolean }; export type OperationApplicationHermesSkillBridgeResult = { readonly bridge: HermesSkillBridgeSnapshot; readonly status: AutomationReadStatusV1 }; +export type OperationApplicationHookRuntimeRequest = { readonly action: "reset_counter" } | { readonly action: "hook_v2_admit"; readonly envelope: unknown; readonly native_lifecycle?: unknown; readonly native_session_id?: string | null } | { readonly action: "hook_v2_delivery_receipt"; readonly receipt: unknown } | { readonly action: "hook_v2_feedback_notice_delivery"; readonly envelope: unknown; readonly feedback_notice: unknown } | { readonly action: "opencode_lsp_updated"; readonly event: unknown } | { readonly action: "ingest_transcript"; readonly event_json?: string | null; readonly max_new_bytes?: number | null; readonly messages?: readonly unknown[] | null; readonly provider: string; readonly session_id?: string | null; readonly user_scope: boolean } | { readonly action: "codex_compact"; readonly event_json: string } | { readonly action: "claude_compact"; readonly event_json: string; readonly user_scope: boolean } | { readonly action: "cursor_compact"; readonly event_json: string } | { readonly action: "user_review"; readonly provider: string; readonly session_id?: string | null } | { readonly action: "hermes_receipt"; readonly event: unknown } | { readonly action: "hook_v2_profile_admit"; readonly admission: unknown }; +export type OperationApplicationHookRuntimeResult = { readonly action: "reset_counter"; readonly reset: boolean } | { readonly context_scout_address?: ContextScoutAddressV1 | null; readonly disposition: HookRuntimeDispositionV1; readonly feedback_notice?: unknown; readonly github_stack_signal_available: boolean; readonly orchestration: HookOrchestrationAdmissionV1; readonly ready_guidance?: unknown; readonly status: "accepted"; readonly [key: string]: unknown } | { readonly context_scout_address?: ContextScoutAddressV1 | null; readonly disposition: HookRuntimeDispositionV1; readonly ready_guidance?: unknown; readonly status: "exact_duplicate"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly reason?: HookV2RejectionReasonV1 | null; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly status: "backpressured"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown } | { readonly action: "hook_v2_delivery_receipt"; readonly status: ContextScoutStoreStatusV1 } | { readonly status: "stored"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly action: "opencode_lsp_updated"; readonly status: HookRuntimeAcceptedV1 } | { readonly action: "ingest_transcript"; readonly admission: HookIngestAdmissionV1; readonly bytes_consumed?: number | null; readonly completed: boolean; readonly cursor_advances?: number | null; readonly cursor_duplicates?: number | null; readonly deferred_by_byte_cap?: boolean | null; readonly deferred_sources?: number | null; readonly hint_outcomes?: unknown; readonly messages_upserted: number; readonly observation_duplicates?: number | null; readonly observations_committed?: number | null; readonly projection_duplicates?: number | null; readonly projections_completed?: number | null; readonly projections_skipped?: number | null; readonly provider: string; readonly records_quarantined?: number | null; readonly records_rejected?: number | null; readonly source_bytes_scanned?: number | null; readonly status: string; readonly user_scope: boolean } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly action: "hermes_receipt"; readonly status: HermesReceiptStatusV1 } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "accepted"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "exact_duplicate"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown }; export type OperationApplicationHotspotsRequest = { readonly limit?: number | null }; export type OperationApplicationHotspotsResult = { readonly hotspot_count: number; readonly hotspots: readonly HotspotV1[] }; export type OperationApplicationImpactRequest = { readonly max_depth?: number | null; readonly node_id: string }; @@ -1955,6 +1964,7 @@ const DEFINITIONS = { ContextScoutSettingsV1: {"additionalProperties":false,"description":"Canonical Context Scout control-plane value. Disabled is the only stock\nstate; deterministic or configured-model execution requires an explicit\nconfiguration revision.","properties":{"limits":{"$ref":"#/$defs/ContextScoutConfigurationLimitsV1"},"mode":{"$ref":"#/$defs/ContextScoutConfigurationModeV1"},"model_id":{"type":["string","null"]},"model_path":{"anyOf":[{"$ref":"#/$defs/ContextScoutConfiguredModelPathV1"},{"type":"null"}]},"model_timeout_secs":{"format":"uint64","minimum":0,"type":["integer","null"]},"schema_version":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"state":{"$ref":"#/$defs/ContextScoutConfigurationStateV1"}},"required":["schema_version","state","mode","limits"],"type":"object"}, ContextScoutStatusResultV1: {"additionalProperties":false,"properties":{"active_suggestions":{"format":"uint","minimum":0,"type":"integer"},"configuration_revision":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"last_delivery_outcome":{"anyOf":[{"$ref":"#/$defs/ContextScoutDeliveryOutcomeV1"},{"type":"null"}]},"last_feedback":{"anyOf":[{"$ref":"#/$defs/ContextScoutFeedbackKindV1"},{"type":"null"}]},"last_model_outcome":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelOutcomeV1"},{"type":"null"}]},"last_model_receipt":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelReceiptV1"},{"type":"null"}]},"last_route":{"anyOf":[{"$ref":"#/$defs/ContextScoutRouteV1"},{"type":"null"}]},"last_suppression":{"anyOf":[{"$ref":"#/$defs/ContextScoutSuppressionV1"},{"type":"null"}]},"limits":{"$ref":"#/$defs/ContextScoutLimitsV1"},"mode":{"$ref":"#/$defs/ContextScoutRuntimeModeV1"},"model_path":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelBackendV1"},{"type":"null"}]},"state":{"$ref":"#/$defs/ContextScoutServiceStateV1"}},"required":["configuration_revision","state","mode","limits","active_suggestions"],"type":"object"}, ContextScoutStoreOutcomeV1: {"enum":["stored","duplicate","superseded"],"type":"string"}, + ContextScoutStoreStatusV1: {"enum":["stored","duplicate","superseded","unavailable"],"type":"string"}, ContextScoutSuggestionProjectionV1: {"additionalProperties":false,"properties":{"category":{"$ref":"#/$defs/ContextScoutCategoryV1"},"configuration_revision":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"dedupe_key":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"delivery_window":{"$ref":"#/$defs/ContextScoutDeliveryWindowV1"},"envelope_id":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":16,"minItems":16,"type":"array"},"evidence":{"$ref":"#/$defs/ContextScoutEvidenceProjectionV1"},"expires_at":{"$ref":"#/$defs/UtcMicros"},"model_outcome":{"$ref":"#/$defs/ContextScoutModelOutcomeV1"},"model_receipt":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelReceiptV1"},{"type":"null"}]},"relevance_score":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"route":{"$ref":"#/$defs/ContextScoutRouteV1"},"suggestion_text":{"type":"string"},"work":{"$ref":"#/$defs/ContextScoutWorkV1"}},"required":["work","envelope_id","configuration_revision","delivery_window","route","model_outcome","dedupe_key","category","relevance_score","suggestion_text","evidence","expires_at"],"type":"object"}, ContextScoutSuppressionV1: {"enum":["disabled","paused","dirty_overlay","quiet_or_unreceptive","no_eligible_candidate","expired","duplicate","cancelled","model_output_invalid","evidence_partial","evidence_stale","evidence_unavailable"],"type":"string"}, ContextScoutWorkV1: {"additionalProperties":false,"properties":{"address":{"$ref":"#/$defs/ContextScoutAddressV1"},"generation":{"format":"uint64","minimum":0,"type":"integer"},"input_watermark":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"}},"required":["address","generation","input_watermark"],"type":"object"}, @@ -2023,7 +2033,7 @@ const DEFINITIONS = { DuplicateEffectOutcomeV1: {"enum":["prevented","committed","unknown","not_applicable"],"type":"string"}, DuplicateEffortKindV1: {"enum":["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],"type":"string"}, EditResult: {"description":"Result of a single string replacement edit.","properties":{"diff":{"description":"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.","type":["string","null"]},"dry_run":{"description":"True when this was a dry run: validation, spans, and the resulting\ncontent were all computed, but nothing was written to disk.","type":"boolean"},"file_path":{"type":"string"},"matched_str":{"type":"string"},"message":{"type":"string"},"new_str":{"type":"string"},"replaced_span":{"description":"The exact source text that was replaced. For `replace_symbol` this is\nthe item's full span, including any leading doc-comment / attribute\nblock, so callers can recover its docs/attrs if the replacement\ndropped them; for `str_replace` it is the matched `old_str` text.\n`None` only on a failed edit, where nothing was resolved to replace.","type":["string","null"]},"success":{"type":"boolean"}},"required":["success","file_path","matched_str","new_str","message"],"type":"object"}, - EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"},{"const":"maintains_owner_state","description":"Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.","type":"string"}]}, + EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"},{"const":"maintains_owner_state","description":"Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.","type":"string"},{"const":"records_host_evidence","description":"Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.","type":"string"}]}, EffectReceipt_2: {"additionalProperties":false,"description":"Durable effect proof. It records identities and receipts, never credentials\nor arbitrary command text.","properties":{"actor":{"$ref":"#/$defs/ActorId"},"catalog_digest":{"$ref":"#/$defs/ManifestDigest"},"committed_state":{"anyOf":[{"$ref":"#/$defs/ManifestDigest"},{"type":"null"}]},"configuration_digest":{"$ref":"#/$defs/ManifestDigest"},"effect_class":{"$ref":"#/$defs/EffectClass"},"expected_state":{"$ref":"#/$defs/ManifestDigest"},"external_proof":{"anyOf":[{"$ref":"#/$defs/RetrievalAnchorId"},{"type":"null"}]},"idempotency_key":{"type":"string"},"input_digest":{"$ref":"#/$defs/ManifestDigest"},"operation":{"$ref":"#/$defs/UseCaseId"},"outcome":{"$ref":"#/$defs/EffectTermination"},"policy_digest":{"$ref":"#/$defs/ManifestDigest"},"privacy_digest":{"$ref":"#/$defs/ManifestDigest"},"request_id":{"type":"string"},"scope":{"$ref":"#/$defs/ResolvedScope"}},"required":["operation","request_id","actor","scope","effect_class","idempotency_key","input_digest","expected_state","policy_digest","configuration_digest","catalog_digest","privacy_digest","outcome"],"type":"object"}, EffectResult_2: {"additionalProperties":false,"description":"Result of an admitted effect. `EffectUnknown` remains a receipt state and\ncannot be remapped into a pre-admission problem.","properties":{"authority":{"$ref":"#/$defs/AuthorityReceipt"},"effect_class":{"$ref":"#/$defs/EffectClass"},"effect_id":{"type":"string"},"execution":{"$ref":"#/$defs/OperationReceipt"},"expected_state":{"$ref":"#/$defs/ManifestDigest"},"idempotency_key":{"type":"string"},"payload":{"anyOf":[{"$ref":"#/$defs/SourceEditDurableEffectPayloadV1"},{"type":"null"}]},"receipt":{"$ref":"#/$defs/EffectReceipt"},"reconciliation":{"$ref":"#/$defs/ReconciliationState"}},"required":["effect_id","effect_class","idempotency_key","authority","expected_state","execution","reconciliation","receipt"],"type":"object"}, EffectTermination_2: {"description":"Durable effect receipt terminal state.","enum":["completed","cancelled","timed_out","failed","partial","effect_unknown"],"type":"string"}, @@ -2214,10 +2224,16 @@ const DEFINITIONS = { HealthRedundancyV1: {"additionalProperties":false,"properties":{"dead_count":{"format":"uint64","minimum":0,"type":"integer"},"score":{"format":"double","type":"number"},"source":{"type":"string"},"total_fns":{"format":"uint64","minimum":0,"type":"integer"}},"required":["score","dead_count","total_fns","source"],"type":"object"}, HealthWeightsV1: {"additionalProperties":false,"properties":{"note":{"type":"string"}},"required":["note"],"type":"object"}, HermesPendingSkillWrite: {"properties":{"action":{"type":["string","null"]},"created_at":true,"id":{"type":"string"},"name":{"type":["string","null"]},"origin":{"type":["string","null"]},"payload":true,"source_path":{"type":"string"},"summary":{"type":["string","null"]}},"required":["id","source_path"],"type":"object"}, + HermesReceiptStatusV1: {"oneOf":[{"const":"recorded","description":"A terminal receipt was recorded.","type":"string"},{"const":"ingested","description":"The turn was marked ingested and no receipt awaits review.","type":"string"},{"const":"awaiting_transcript","description":"A receipt awaits a transcript that has not landed yet.","type":"string"}]}, HermesSkillBridgeContracts: {"properties":{"discovery_policy":{"type":"string"},"lifecycle_owner":{"type":"string"},"mutation_policy":{"type":"string"}},"required":["lifecycle_owner","mutation_policy","discovery_policy"],"type":"object"}, HermesSkillBridgeSnapshot: {"properties":{"agent_home":{"type":"string"},"archive_count":{"format":"uint","minimum":0,"type":"integer"},"contracts":{"$ref":"#/$defs/HermesSkillBridgeContracts"},"pending_skill_corrupt_count":{"format":"uint","minimum":0,"type":"integer"},"pending_skill_count":{"format":"uint","minimum":0,"type":"integer"},"pending_skills":{"items":{"$ref":"#/$defs/HermesPendingSkillWrite"},"type":"array"},"skill_count":{"format":"uint","minimum":0,"type":"integer"},"skills":{"items":{"$ref":"#/$defs/HermesSkillSummary"},"type":"array"},"skills_dir":{"type":"string"},"usage_record_count":{"format":"uint","minimum":0,"type":"integer"},"usage_records":{"additionalProperties":true,"description":"Hermes-owned usage telemetry keyed by skill name, as Hermes wrote it.","type":"object"}},"required":["agent_home","skills_dir","skill_count","pending_skill_count","pending_skill_corrupt_count","usage_record_count","archive_count","skills","pending_skills","usage_records","contracts"],"type":"object"}, HermesSkillSummary: {"properties":{"body_markdown":{"type":["string","null"]},"category":{"type":["string","null"]},"description":{"type":["string","null"]},"name":{"type":"string"},"path":{"type":"string"},"pending_write_ids":{"items":{"type":"string"},"type":"array"},"usage":true},"required":["name","path","pending_write_ids"],"type":"object"}, HistoryRewritePolicyV1: {"enum":["forbid_force_and_rebase"],"type":"string"}, + HookIngestAdmissionV1: {"additionalProperties":false,"description":"The admission authority's verdict on one transcript ingest.","properties":{"reason_code":{"type":["string","null"]},"retryable":{"type":"boolean"},"status":{"description":"The session host-admission status, in its wire spelling.","type":"string"}},"required":["status","retryable"],"type":"object"}, + HookOrchestrationAdmissionV1: {"description":"Outcome of admitting one hook envelope into the registered orchestrator.","enum":["enqueued","backpressured","unsupported_trigger","unavailable"],"type":"string"}, + HookRuntimeAcceptedV1: {"enum":["accepted"],"type":"string"}, + HookRuntimeDispositionV1: {"description":"How the hook transport should treat a Hook V2 envelope.","oneOf":[{"enum":["accepted"],"type":"string"},{"const":"catchup_required","description":"The published binding no longer authorizes the envelope; the host\nmust catch up before sending again.","type":"string"}]}, + HookV2RejectionReasonV1: {"oneOf":[{"const":"admission_identity_conflict","description":"The same event identity previously carried different bytes.","type":"string"}]}, HostInstanceId: {"description":"Strongly typed canonical identity: `HostInstanceId`.","type":"string"}, HotspotV1: {"additionalProperties":false,"properties":{"file":{"type":"string"},"id":{"type":"string"},"incoming":{"format":"uint64","minimum":0,"type":"integer"},"kind":{"type":"string"},"line":{"format":"uint32","minimum":0,"type":"integer"},"name":{"type":"string"},"outgoing":{"format":"uint64","minimum":0,"type":"integer"},"total":{"format":"uint64","minimum":0,"type":"integer"}},"required":["id","name","kind","file","line","incoming","outgoing","total"],"type":"object"}, HunkDirectionV1: {"description":"`HunkRef` operation direction: working tree to index, or index to\nHEAD/base. No other direction is encodable.","enum":["working_tree_to_index","index_to_head"],"type":"string"}, @@ -3120,6 +3136,8 @@ const SCHEMAS: readonly CanonicalJsonSchema[] = [ {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"status":{"type":"string"}},"required":["status"],"title":"HealthReadResult","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"include_pending_payloads":{"default":false,"description":"Include staged Hermes skill-write payloads (default: false).","type":"boolean"},"include_skill_bodies":{"default":false,"description":"Include bounded SKILL.md contents (default: false).","type":"boolean"}},"title":"HermesSkillBridgeSurfaceRequestV1","type":"object"}, {"$defs":{"AutomationReadStatusV1":DEFINITIONS.AutomationReadStatusV1,"HermesPendingSkillWrite":DEFINITIONS.HermesPendingSkillWrite,"HermesSkillBridgeContracts":DEFINITIONS.HermesSkillBridgeContracts,"HermesSkillBridgeSnapshot":DEFINITIONS.HermesSkillBridgeSnapshot,"HermesSkillSummary":DEFINITIONS.HermesSkillSummary},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"bridge":{"$ref":"#/$defs/HermesSkillBridgeSnapshot"},"status":{"$ref":"#/$defs/AutomationReadStatusV1"}},"required":["status","bridge"],"title":"HermesSkillBridgeResultV1","type":"object"}, + {"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"description":"Reset the project's local token counter.","properties":{"action":{"const":"reset_counter","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"description":"Admit one Hook V2 envelope for the bound project.","properties":{"action":{"const":"hook_v2_admit","type":"string"},"envelope":true,"native_lifecycle":true,"native_session_id":{"description":"The host's native session id; it binds only when it hashes to the\nenvelope's protected session.","type":["string","null"]}},"required":["action","envelope"],"type":"object"},{"additionalProperties":false,"description":"Commit a Context Scout delivery receipt for guidance the last\nadmission handed out.","properties":{"action":{"const":"hook_v2_delivery_receipt","type":"string"},"receipt":true},"required":["action","receipt"],"type":"object"},{"additionalProperties":false,"description":"Acknowledge delivery of an advisory feedback notice.","properties":{"action":{"const":"hook_v2_feedback_notice_delivery","type":"string"},"envelope":true,"feedback_notice":true},"required":["action","envelope","feedback_notice"],"type":"object"},{"additionalProperties":false,"description":"Record an `OpenCode` `lsp.updated` event.","properties":{"action":{"const":"opencode_lsp_updated","type":"string"},"event":true},"required":["action","event"],"type":"object"},{"additionalProperties":false,"description":"Land a host transcript in the owning session store.","properties":{"action":{"const":"ingest_transcript","type":"string"},"event_json":{"description":"The host's raw hook event, for providers that locate the transcript\nfrom it.","type":["string","null"]},"max_new_bytes":{"description":"Byte budget for this pass across every scanned source.","format":"uint64","minimum":0,"type":["integer","null"]},"messages":{"description":"One turn the host inlined instead of a source to scan.","items":true,"type":["array","null"]},"provider":{"type":"string"},"session_id":{"type":["string","null"]},"user_scope":{"description":"Land the transcript in the profile's user store instead of the\nproject's.","type":"boolean"}},"required":["action","provider","user_scope"],"type":"object"},{"additionalProperties":false,"description":"Codex `PostCompact` pressure evidence.","properties":{"action":{"const":"codex_compact","type":"string"},"event_json":{"type":"string"}},"required":["action","event_json"],"type":"object"},{"additionalProperties":false,"description":"Claude `PostCompact` pressure evidence; `user_scope` routes it to the\nprofile.","properties":{"action":{"const":"claude_compact","type":"string"},"event_json":{"type":"string"},"user_scope":{"type":"boolean"}},"required":["action","event_json","user_scope"],"type":"object"},{"additionalProperties":false,"description":"Cursor `preCompact` pressure evidence.","properties":{"action":{"const":"cursor_compact","type":"string"},"event_json":{"type":"string"}},"required":["action","event_json"],"type":"object"},{"additionalProperties":false,"description":"Review a finished user session.","properties":{"action":{"const":"user_review","type":"string"},"provider":{"type":"string"},"session_id":{"type":["string","null"]}},"required":["action","provider"],"type":"object"},{"additionalProperties":false,"description":"Record a Hermes terminal receipt without a project route.","properties":{"action":{"const":"hermes_receipt","type":"string"},"event":true},"required":["action","event"],"type":"object"},{"additionalProperties":false,"description":"Admit a native event without a project route into the profile's\nHook V2 ledger.","properties":{"action":{"const":"hook_v2_profile_admit","type":"string"},"admission":true},"required":["action","admission"],"type":"object"}],"title":"HookRuntimeSurfaceRequestV1"}, + {"$defs":{"ContextScoutAddressV1":DEFINITIONS.ContextScoutAddressV1,"ContextScoutStoreStatusV1":DEFINITIONS.ContextScoutStoreStatusV1,"HermesReceiptStatusV1":DEFINITIONS.HermesReceiptStatusV1,"HookIngestAdmissionV1":DEFINITIONS.HookIngestAdmissionV1,"HookOrchestrationAdmissionV1":DEFINITIONS.HookOrchestrationAdmissionV1,"HookRuntimeAcceptedV1":DEFINITIONS.HookRuntimeAcceptedV1,"HookRuntimeDispositionV1":DEFINITIONS.HookRuntimeDispositionV1,"HookV2RejectionReasonV1":DEFINITIONS.HookV2RejectionReasonV1},"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"properties":{"action":{"const":"reset_counter","type":"string"},"reset":{"type":"boolean"}},"required":["action","reset"],"type":"object"},{"oneOf":[{"properties":{"context_scout_address":{"anyOf":[{"$ref":"#/$defs/ContextScoutAddressV1"},{"type":"null"}]},"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"feedback_notice":{"description":"The advisory `AdvisoryHookLookupNoticeV1` waiting for this\nworktree."},"github_stack_signal_available":{"type":"boolean"},"orchestration":{"$ref":"#/$defs/HookOrchestrationAdmissionV1"},"ready_guidance":{"description":"The hook's `HookReadyGuidanceV1`, when admission claimed one."},"status":{"const":"accepted","type":"string"}},"required":["status","disposition","orchestration","github_stack_signal_available"],"type":"object"},{"description":"This exact envelope was already admitted; a retry may still receive\nguidance retained before a lost host response.","properties":{"context_scout_address":{"anyOf":[{"$ref":"#/$defs/ContextScoutAddressV1"},{"type":"null"}]},"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"ready_guidance":true,"status":{"const":"exact_duplicate","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"reason":{"anyOf":[{"$ref":"#/$defs/HookV2RejectionReasonV1"},{"type":"null"}]},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"},{"description":"Idempotency could not be recorded, so nothing was admitted.","properties":{"status":{"const":"backpressured","type":"string"}},"required":["status"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"}],"properties":{"action":{"const":"hook_v2_admit","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"hook_v2_delivery_receipt","type":"string"},"status":{"$ref":"#/$defs/ContextScoutStoreStatusV1"}},"required":["action","status"],"type":"object"},{"oneOf":[{"properties":{"status":{"const":"stored","type":"string"}},"required":["status"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"}],"properties":{"action":{"const":"hook_v2_feedback_notice_delivery","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"opencode_lsp_updated","type":"string"},"status":{"$ref":"#/$defs/HookRuntimeAcceptedV1"}},"required":["action","status"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"ingest_transcript","type":"string"},"admission":{"$ref":"#/$defs/HookIngestAdmissionV1"},"bytes_consumed":{"format":"uint64","minimum":0,"type":["integer","null"]},"completed":{"description":"False when the byte budget left work for a later pass.","type":"boolean"},"cursor_advances":{"format":"uint64","minimum":0,"type":["integer","null"]},"cursor_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"deferred_by_byte_cap":{"type":["boolean","null"]},"deferred_sources":{"format":"uint64","minimum":0,"type":["integer","null"]},"hint_outcomes":{"description":"How emitted hook hints settled against the new project activity."},"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"observation_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"observations_committed":{"format":"uint64","minimum":0,"type":["integer","null"]},"projection_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"projections_completed":{"format":"uint64","minimum":0,"type":["integer","null"]},"projections_skipped":{"format":"uint64","minimum":0,"type":["integer","null"]},"provider":{"type":"string"},"records_quarantined":{"format":"uint64","minimum":0,"type":["integer","null"]},"records_rejected":{"format":"uint64","minimum":0,"type":["integer","null"]},"source_bytes_scanned":{"format":"uint64","minimum":0,"type":["integer","null"]},"status":{"type":"string"},"user_scope":{"type":"boolean"}},"required":["action","provider","user_scope","completed","status","admission","messages_upserted"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"codex_compact","type":"string"}},"required":["action"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"claude_compact","type":"string"}},"required":["action"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"cursor_compact","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"hermes_receipt","type":"string"},"status":{"$ref":"#/$defs/HermesReceiptStatusV1"}},"required":["action","status"],"type":"object"},{"oneOf":[{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"accepted","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"exact_duplicate","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"}],"properties":{"action":{"const":"hook_v2_profile_admit","type":"string"}},"required":["action"],"type":"object"}],"title":"HookRuntimeResultV1"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"limit":{"description":"Maximum number of hotspots to return (default: 10, at most 100).","format":"uint32","minimum":0,"type":["integer","null"]}},"title":"HotspotsSurfaceRequestV1","type":"object"}, {"$defs":{"HotspotV1":DEFINITIONS.HotspotV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"hotspot_count":{"format":"uint64","minimum":0,"type":"integer"},"hotspots":{"items":{"$ref":"#/$defs/HotspotV1"},"type":"array"}},"required":["hotspot_count","hotspots"],"title":"HotspotsResultV1","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"max_depth":{"format":"uint32","minimum":0,"type":["integer","null"]},"node_id":{"type":"string"}},"required":["node_id"],"title":"NodeDepthSurfaceRequestV1","type":"object"}, @@ -3847,587 +3865,591 @@ export const OPERATIONS = [ requestSchema: { schemaId: "schema.application.primitive.hermes-skill-bridge.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hermes-skill-bridge.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], decodeRequest: decoder(191), decodeResult: decoder(192) }, + { operation: "hook_runtime", operationId: "operation.application.hook_runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_hook_runtime" }, effect: "records_host_evidence", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hook_runtime.v1", + requestSchema: { schemaId: "schema.application.primitive.hook-runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hook-runtime.result", revision: 1 }, + cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","unavailable","partial"], + decodeRequest: decoder(193), decodeResult: decoder(194) }, { operation: "hotspots", operationId: "operation.application.hotspots", transport: { kind: "mcp_tool", toolName: "tracedecay_hotspots" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hotspots.v1", requestSchema: { schemaId: "schema.application.primitive.hotspots.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hotspots.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(193), decodeResult: decoder(194) }, + decodeRequest: decoder(195), decodeResult: decoder(196) }, { operation: "impact", operationId: "operation.application.impact", transport: { kind: "mcp_tool", toolName: "tracedecay_impact" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.impact.v1", requestSchema: { schemaId: "schema.application.primitive.impact.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.impact.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(195), decodeResult: decoder(196) }, + decodeRequest: decoder(197), decodeResult: decoder(198) }, { operation: "inheritance_depth", operationId: "operation.application.inheritance_depth", transport: { kind: "mcp_tool", toolName: "tracedecay_inheritance_depth" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.inheritance_depth.v1", requestSchema: { schemaId: "schema.application.primitive.inheritance-depth.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.inheritance-depth.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(197), decodeResult: decoder(198) }, + decodeRequest: decoder(199), decodeResult: decoder(200) }, { operation: "insert_at", operationId: "operation.application.insert_at", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at.v1", requestSchema: { schemaId: "schema.application.source-edit.insert-at.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(199), decodeResult: decoder(16) }, + decodeRequest: decoder(201), decodeResult: decoder(16) }, { operation: "insert_at_symbol", operationId: "operation.application.insert_at_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(200), decodeResult: decoder(16) }, + decodeRequest: decoder(202), decodeResult: decoder(16) }, { operation: "largest", operationId: "operation.application.largest", transport: { kind: "mcp_tool", toolName: "tracedecay_largest" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.largest.v1", requestSchema: { schemaId: "schema.application.primitive.largest.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.largest.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(201), decodeResult: decoder(202) }, + decodeRequest: decoder(203), decodeResult: decoder(204) }, { operation: "application_lcm_describe", operationId: "operation.application.lcm_describe", transport: { kind: "http", route: "/application/retained/lcm_describe", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_describe.v1", requestSchema: { schemaId: "schema.application.retained.lcm-describe.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-describe.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(203), decodeResult: decoder(204), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(204)) }, + decodeRequest: decoder(205), decodeResult: decoder(206), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(206)) }, { operation: "application_lcm_doctor", operationId: "operation.application.lcm_doctor", transport: { kind: "http", route: "/application/retained/lcm_doctor", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_doctor.v1", requestSchema: { schemaId: "schema.application.retained.lcm-doctor.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-doctor.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(205), decodeResult: decoder(206), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(206)) }, + decodeRequest: decoder(207), decodeResult: decoder(208), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(208)) }, { operation: "application_lcm_expand", operationId: "operation.application.lcm_expand", transport: { kind: "http", route: "/application/retained/lcm_expand", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_expand.v1", requestSchema: { schemaId: "schema.application.retained.lcm-expand.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-expand.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(207), decodeResult: decoder(208), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(208)) }, + decodeRequest: decoder(209), decodeResult: decoder(210), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(210)) }, { operation: "application_lcm_expand_query", operationId: "operation.application.lcm_expand_query", transport: { kind: "http", route: "/application/retained/lcm_expand_query", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_expand_query.v1", requestSchema: { schemaId: "schema.application.retained.lcm-expand-query.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-expand-query.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(209), decodeResult: decoder(210), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(210)) }, + decodeRequest: decoder(211), decodeResult: decoder(212), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(212)) }, { operation: "application_lcm_grep", operationId: "operation.application.lcm_grep", transport: { kind: "http", route: "/application/retained/lcm_grep", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_grep.v1", requestSchema: { schemaId: "schema.application.retained.lcm-grep.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-grep.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(211), decodeResult: decoder(212), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(212)) }, + decodeRequest: decoder(213), decodeResult: decoder(214), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(214)) }, { operation: "application_lcm_load_session", operationId: "operation.application.lcm_load_session", transport: { kind: "http", route: "/application/retained/lcm_load_session", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_load_session.v1", requestSchema: { schemaId: "schema.application.retained.lcm-load-session.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-load-session.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(213), decodeResult: decoder(214), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(214)) }, + decodeRequest: decoder(215), decodeResult: decoder(216), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(216)) }, { operation: "application_lcm_status", operationId: "operation.application.lcm_status", transport: { kind: "http", route: "/application/retained/lcm_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_status.v1", requestSchema: { schemaId: "schema.application.retained.lcm-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(215), decodeResult: decoder(216), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(216)) }, + decodeRequest: decoder(217), decodeResult: decoder(218), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(218)) }, { operation: "application_memory_status", operationId: "operation.application.memory_status", transport: { kind: "http", route: "/application/retained/memory_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.memory_status.v1", requestSchema: { schemaId: "schema.application.retained.memory-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.memory-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(217), decodeResult: decoder(218), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(218)) }, + decodeRequest: decoder(219), decodeResult: decoder(220), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(220)) }, { operation: "application_message_search", operationId: "operation.application.message_search", transport: { kind: "http", route: "/application/retained/message_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.message_search.v1", requestSchema: { schemaId: "schema.application.retained.message-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.message-search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(219), decodeResult: decoder(220), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(220)) }, + decodeRequest: decoder(221), decodeResult: decoder(222), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(222)) }, { operation: "application_module_api", operationId: "operation.application.module_api", transport: { kind: "http", route: "/application/primitives/module_api", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.module_api.v1", requestSchema: { schemaId: "schema.application.primitive.module-api.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.module-api.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(221), decodeResult: decoder(222), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(222)) }, + decodeRequest: decoder(223), decodeResult: decoder(224), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(224)) }, { operation: "move_symbol", operationId: "operation.application.move_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_move_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.move_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.move-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.move-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(223), decodeResult: decoder(16) }, + decodeRequest: decoder(225), decodeResult: decoder(16) }, { operation: "multi_str_replace", operationId: "operation.application.multi_str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_multi_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.multi_str_replace.v1", requestSchema: { schemaId: "schema.application.source-edit.multi-str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.multi-str-replace.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(224), decodeResult: decoder(16) }, + decodeRequest: decoder(226), decodeResult: decoder(16) }, { operation: "native_integration_status", operationId: "operation.application.native_integration_status", transport: { kind: "mcp_tool", toolName: "tracedecay_native_integration_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.native_integration_status.v1", requestSchema: { schemaId: "schema.application.native-integration.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(225), decodeResult: decoder(13) }, + decodeRequest: decoder(227), decodeResult: decoder(13) }, { operation: "node", operationId: "operation.application.node", transport: { kind: "mcp_tool", toolName: "tracedecay_node" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.node.v1", requestSchema: { schemaId: "schema.application.primitive.node.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.node.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(226), decodeResult: decoder(227) }, + decodeRequest: decoder(228), decodeResult: decoder(229) }, { operation: "observatory_read", operationId: "operation.application.observatory_read", transport: { kind: "mcp_tool", toolName: "tracedecay_observatory_read" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.observatory_read.v1", requestSchema: { schemaId: "schema.application.observatory-read.request", revision: 1 }, resultSchema: { schemaId: "schema.application.observatory-read.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":15000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(228), decodeResult: decoder(229) }, + decodeRequest: decoder(230), decodeResult: decoder(231) }, { operation: "port_order", operationId: "operation.application.port_order", transport: { kind: "mcp_tool", toolName: "tracedecay_port_order" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.port_order.v1", requestSchema: { schemaId: "schema.application.primitive.port-order.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.port-order.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(230), decodeResult: decoder(231) }, + decodeRequest: decoder(232), decodeResult: decoder(233) }, { operation: "port_status", operationId: "operation.application.port_status", transport: { kind: "mcp_tool", toolName: "tracedecay_port_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.port_status.v1", requestSchema: { schemaId: "schema.application.primitive.port-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.port-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(232), decodeResult: decoder(233) }, + decodeRequest: decoder(234), decodeResult: decoder(235) }, { operation: "pr_context", operationId: "operation.application.pr_context", transport: { kind: "mcp_tool", toolName: "tracedecay_pr_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.pr_context.v1", requestSchema: { schemaId: "schema.application.primitive.pr-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.pr-context.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(234), decodeResult: decoder(235) }, + decodeRequest: decoder(236), decodeResult: decoder(237) }, { operation: "preflight_native_integration", operationId: "operation.application.preflight_native_integration", transport: { kind: "mcp_tool", toolName: "tracedecay_preflight_native_integration" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.preflight_native_integration.v1", requestSchema: { schemaId: "schema.application.native-integration.preflight.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.preflight.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(236), decodeResult: decoder(13) }, + decodeRequest: decoder(238), decodeResult: decoder(13) }, { operation: "project_context", operationId: "operation.application.project_context", transport: { kind: "mcp_tool", toolName: "tracedecay_project_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_context.v1", requestSchema: { schemaId: "schema.application.primitive.project-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-context.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(237), decodeResult: decoder(238) }, + decodeRequest: decoder(239), decodeResult: decoder(240) }, { operation: "project_list", operationId: "operation.application.project_list", transport: { kind: "mcp_tool", toolName: "tracedecay_project_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_list.v1", requestSchema: { schemaId: "schema.application.primitive.project-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-list.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(239), decodeResult: decoder(240) }, + decodeRequest: decoder(241), decodeResult: decoder(242) }, { operation: "project_search", operationId: "operation.application.project_search", transport: { kind: "mcp_tool", toolName: "tracedecay_project_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_search.v1", requestSchema: { schemaId: "schema.application.primitive.project-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(241), decodeResult: decoder(240) }, + decodeRequest: decoder(243), decodeResult: decoder(242) }, { operation: "application_qualified_name", operationId: "operation.application.qualified_name", transport: { kind: "http", route: "/application/primitives/qualified_name", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.qualified_name.v1", requestSchema: { schemaId: "schema.application.primitive.qualified-name.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.qualified-name.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(242), decodeResult: decoder(243), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(243)) }, + decodeRequest: decoder(244), decodeResult: decoder(245), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(245)) }, { operation: "rank", operationId: "operation.application.rank", transport: { kind: "mcp_tool", toolName: "tracedecay_rank" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rank.v1", requestSchema: { schemaId: "schema.application.primitive.rank.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.rank.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(244), decodeResult: decoder(245) }, + decodeRequest: decoder(246), decodeResult: decoder(247) }, { operation: "recursion", operationId: "operation.application.recursion", transport: { kind: "mcp_tool", toolName: "tracedecay_recursion" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.recursion.v1", requestSchema: { schemaId: "schema.application.primitive.recursion.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.recursion.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(246), decodeResult: decoder(247) }, + decodeRequest: decoder(248), decodeResult: decoder(249) }, { operation: "redundancy", operationId: "operation.application.redundancy", transport: { kind: "mcp_tool", toolName: "tracedecay_redundancy" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.redundancy.v1", requestSchema: { schemaId: "schema.application.primitive.redundancy.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.redundancy.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(248), decodeResult: decoder(249) }, + decodeRequest: decoder(250), decodeResult: decoder(251) }, { operation: "remote_status", operationId: "operation.application.remote_status", transport: { kind: "mcp_tool", toolName: "tracedecay_remote_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.remote_status.v1", requestSchema: { schemaId: "schema.application.primitive.remote-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.remote-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(250), decodeResult: decoder(251) }, + decodeRequest: decoder(252), decodeResult: decoder(253) }, { operation: "rename_preview", operationId: "operation.application.rename_preview", transport: { kind: "mcp_tool", toolName: "tracedecay_rename_preview" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rename_preview.v1", requestSchema: { schemaId: "schema.application.primitive.rename-preview.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.rename-preview.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(252), decodeResult: decoder(253) }, + decodeRequest: decoder(254), decodeResult: decoder(255) }, { operation: "rename_symbol", operationId: "operation.application.rename_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_rename_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rename_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.rename-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rename-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(254), decodeResult: decoder(16) }, + decodeRequest: decoder(256), decodeResult: decoder(16) }, { operation: "replace_symbol", operationId: "operation.application.replace_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_replace_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.replace_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.replace-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.replace-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(255), decodeResult: decoder(16) }, + decodeRequest: decoder(257), decodeResult: decoder(16) }, { operation: "retrieve", operationId: "operation.application.retrieve", transport: { kind: "mcp_tool", toolName: "tracedecay_retrieve" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.retrieve.v1", requestSchema: { schemaId: "schema.application.primitive.retrieve.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.retrieve.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(256), decodeResult: decoder(257) }, + decodeRequest: decoder(258), decodeResult: decoder(259) }, { operation: "run_affected_tests", operationId: "operation.application.run_affected_tests", transport: { kind: "mcp_tool", toolName: "tracedecay_run_affected_tests" }, effect: "spawns_process", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.run_affected_tests.v1", requestSchema: { schemaId: "schema.application.primitive.run-affected-tests.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.run-affected-tests.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","effect_in_flight"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":600000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(258), decodeResult: decoder(259) }, + decodeRequest: decoder(260), decodeResult: decoder(261) }, { operation: "runtime", operationId: "operation.application.runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_runtime" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.runtime.v1", requestSchema: { schemaId: "schema.application.primitive.runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.runtime.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(260), decodeResult: decoder(261) }, + decodeRequest: decoder(262), decodeResult: decoder(263) }, { operation: "search", operationId: "operation.application.search", transport: { kind: "mcp_tool", toolName: "tracedecay_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.search.v1", requestSchema: { schemaId: "schema.application.primitive.search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(262), decodeResult: decoder(263) }, + decodeRequest: decoder(264), decodeResult: decoder(265) }, { operation: "session_lookup", operationId: "operation.application.session_lookup", transport: { kind: "mcp_tool", toolName: "tracedecay_session_lookup" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.session_lookup.v1", requestSchema: { schemaId: "schema.application.primitive.session-lookup.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.session-lookup.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(264), decodeResult: decoder(265) }, + decodeRequest: decoder(266), decodeResult: decoder(267) }, { operation: "application_session_refresh_begin", operationId: "operation.application.session_refresh_begin", transport: { kind: "http", route: "/application/retained/session_refresh_begin", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_begin.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-begin.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-begin.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(266), decodeResult: decoder(267), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(267)) }, + decodeRequest: decoder(268), decodeResult: decoder(269), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(269)) }, { operation: "application_session_refresh_cancel", operationId: "operation.application.session_refresh_cancel", transport: { kind: "http", route: "/application/retained/session_refresh_cancel", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_cancel.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-cancel.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-cancel.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(266), decodeResult: decoder(268), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(268)) }, + decodeRequest: decoder(268), decodeResult: decoder(270), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(270)) }, { operation: "application_session_refresh_status", operationId: "operation.application.session_refresh_status", transport: { kind: "http", route: "/application/retained/session_refresh_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_status.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(266), decodeResult: decoder(269), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(269)) }, + decodeRequest: decoder(268), decodeResult: decoder(271), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(271)) }, { operation: "application_sessions_for", operationId: "operation.application.sessions_for", transport: { kind: "http", route: "/application/retained/sessions_for", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.sessions_for.v1", requestSchema: { schemaId: "schema.application.retained.sessions-for.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.sessions-for.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(270), decodeResult: decoder(271), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(271)) }, + decodeRequest: decoder(272), decodeResult: decoder(273), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(273)) }, { operation: "signature", operationId: "operation.application.signature", transport: { kind: "mcp_tool", toolName: "tracedecay_signature" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.signature.v1", requestSchema: { schemaId: "schema.application.primitive.signature.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.signature.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(110), decodeResult: decoder(272) }, + decodeRequest: decoder(110), decodeResult: decoder(274) }, { operation: "similar", operationId: "operation.application.similar", transport: { kind: "mcp_tool", toolName: "tracedecay_similar" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.similar.v1", requestSchema: { schemaId: "schema.application.primitive.similar.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.similar.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(273), decodeResult: decoder(274) }, + decodeRequest: decoder(275), decodeResult: decoder(276) }, { operation: "skill_list", operationId: "operation.application.skill_list", transport: { kind: "mcp_tool", toolName: "tracedecay_skill_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.skill_list.v1", requestSchema: { schemaId: "schema.application.primitive.skill-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.skill-list.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(275), decodeResult: decoder(276) }, + decodeRequest: decoder(277), decodeResult: decoder(278) }, { operation: "skill_view", operationId: "operation.application.skill_view", transport: { kind: "mcp_tool", toolName: "tracedecay_skill_view" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.skill_view.v1", requestSchema: { schemaId: "schema.application.primitive.skill-view.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.skill-view.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(277), decodeResult: decoder(278) }, + decodeRequest: decoder(279), decodeResult: decoder(280) }, { operation: "application_source_body", operationId: "operation.application.source_body", transport: { kind: "http", route: "/application/primitives/source_body", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_body.v1", requestSchema: { schemaId: "schema.application.primitive.source-body.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-body.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(279), decodeResult: decoder(280), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(280)) }, + decodeRequest: decoder(281), decodeResult: decoder(282), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(282)) }, { operation: "source_edit_reconcile", operationId: "operation.application.source_edit_reconcile", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_reconcile" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_reconcile.v1", requestSchema: { schemaId: "schema.application.source-edit.reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.reconcile.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(281), decodeResult: decoder(16) }, + decodeRequest: decoder(283), decodeResult: decoder(16) }, { operation: "source_edit_rollback", operationId: "operation.application.source_edit_rollback", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_rollback" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_rollback.v1", requestSchema: { schemaId: "schema.application.source-edit.rollback.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rollback.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(282), decodeResult: decoder(16) }, + decodeRequest: decoder(284), decodeResult: decoder(16) }, { operation: "application_source_lines", operationId: "operation.application.source_lines", transport: { kind: "http", route: "/application/primitives/source_lines", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_lines.v1", requestSchema: { schemaId: "schema.application.primitive.source-lines.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-lines.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(283), decodeResult: decoder(284), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(284)) }, + decodeRequest: decoder(285), decodeResult: decoder(286), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(286)) }, { operation: "application_source_outline", operationId: "operation.application.source_outline", transport: { kind: "http", route: "/application/primitives/source_outline", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_outline.v1", requestSchema: { schemaId: "schema.application.primitive.source-outline.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-outline.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(285), decodeResult: decoder(286), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(286)) }, + decodeRequest: decoder(287), decodeResult: decoder(288), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(288)) }, { operation: "stack_snapshot", operationId: "operation.application.stack_snapshot", transport: { kind: "mcp_tool", toolName: "tracedecay_stack_snapshot" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.stack_snapshot.v1", requestSchema: { schemaId: "schema.application.native-integration.stack-snapshot.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.stack-snapshot.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(287), decodeResult: decoder(13) }, + decodeRequest: decoder(289), decodeResult: decoder(13) }, { operation: "status", operationId: "operation.application.status", transport: { kind: "mcp_tool", toolName: "tracedecay_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.status.v1", requestSchema: { schemaId: "schema.application.primitive.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(288), decodeResult: decoder(289) }, + decodeRequest: decoder(290), decodeResult: decoder(291) }, { operation: "application_storage_status", operationId: "operation.application.storage_status", transport: { kind: "http", route: "/application/primitives/storage_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.storage_status.v1", requestSchema: { schemaId: "schema.application.primitive.storage-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.storage-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(290), decodeResult: decoder(291), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(291)) }, + decodeRequest: decoder(292), decodeResult: decoder(293), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(293)) }, { operation: "str_replace", operationId: "operation.application.str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.str_replace.v1", requestSchema: { schemaId: "schema.application.source-edit.str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.str-replace.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(292), decodeResult: decoder(16) }, + decodeRequest: decoder(294), decodeResult: decoder(16) }, { operation: "test_map", operationId: "operation.application.test_map", transport: { kind: "mcp_tool", toolName: "tracedecay_test_map" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_map.v1", requestSchema: { schemaId: "schema.application.primitive.test-map.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-map.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(293), decodeResult: decoder(294) }, + decodeRequest: decoder(295), decodeResult: decoder(296) }, { operation: "application_test_results", operationId: "operation.application.test_results", transport: { kind: "http", route: "/application/tests/results", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.test_results.v1", requestSchema: { schemaId: "schema.application.feedback.test-results.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.test-results.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":15000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(295), decodeResult: decoder(296), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(296)) }, + decodeRequest: decoder(297), decodeResult: decoder(298), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(298)) }, { operation: "test_risk", operationId: "operation.application.test_risk", transport: { kind: "mcp_tool", toolName: "tracedecay_test_risk" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_risk.v1", requestSchema: { schemaId: "schema.application.primitive.test-risk.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-risk.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(297), decodeResult: decoder(298) }, + decodeRequest: decoder(299), decodeResult: decoder(300) }, { operation: "todos", operationId: "operation.application.todos", transport: { kind: "mcp_tool", toolName: "tracedecay_todos" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.todos.v1", requestSchema: { schemaId: "schema.application.primitive.todos.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.todos.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(299), decodeResult: decoder(300) }, + decodeRequest: decoder(301), decodeResult: decoder(302) }, { operation: "unmounted_files", operationId: "operation.application.unmounted_files", transport: { kind: "mcp_tool", toolName: "tracedecay_unmounted_files" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.unmounted_files.v1", requestSchema: { schemaId: "schema.application.primitive.unmounted-files.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.unmounted-files.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(301), decodeResult: decoder(302) }, + decodeRequest: decoder(303), decodeResult: decoder(304) }, { operation: "unsafe_patterns", operationId: "operation.application.unsafe_patterns", transport: { kind: "mcp_tool", toolName: "tracedecay_unsafe_patterns" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.unsafe_patterns.v1", requestSchema: { schemaId: "schema.application.primitive.unsafe-patterns.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.unsafe-patterns.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(303), decodeResult: decoder(304) }, + decodeRequest: decoder(305), decodeResult: decoder(306) }, { operation: "application_workflows", operationId: "operation.application.workflows", transport: { kind: "http", route: "/application/retained/workflows", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflows.v1", requestSchema: { schemaId: "schema.application.retained.workflows.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.workflows.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(305), decodeResult: decoder(306), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(306)) }, + decodeRequest: decoder(307), decodeResult: decoder(308), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(308)) }, { operation: "application_worktree_cleanup_confirm", operationId: "operation.application.worktree_cleanup_confirm", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_confirm", method: "POST" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_confirm.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-confirm.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-confirm.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(307), decodeResult: decoder(13), + decodeRequest: decoder(309), decodeResult: decoder(13), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_confirm.v1", "schema.application.native-integration.worktree-cleanup-confirm.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(13)) }, { operation: "application_worktree_cleanup_inspect", operationId: "operation.application.worktree_cleanup_inspect", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_inspect", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_inspect.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(308), decodeResult: decoder(13), + decodeRequest: decoder(310), decodeResult: decoder(13), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_inspect.v1", "schema.application.native-integration.worktree-cleanup-inspect.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(13)) }, { operation: "application_worktree_cleanup_reconcile", operationId: "operation.application.worktree_cleanup_reconcile", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_reconcile", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_reconcile.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(309), decodeResult: decoder(13), + decodeRequest: decoder(311), decodeResult: decoder(13), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_reconcile.v1", "schema.application.native-integration.worktree-cleanup-reconcile.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(13)) }, { operation: "application_worktree_cleanup_remove", operationId: "operation.application.worktree_cleanup_remove", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_remove", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_remove.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(310), decodeResult: decoder(13), + decodeRequest: decoder(312), decodeResult: decoder(13), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_remove.v1", "schema.application.native-integration.worktree-cleanup-remove.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(13)) }, { operation: "application_worktree_inventory", operationId: "operation.application.worktree_inventory", transport: { kind: "http", route: "/application/native-integration/worktree_inventory", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_inventory.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-inventory.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-inventory.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(311), decodeResult: decoder(13), + decodeRequest: decoder(313), decodeResult: decoder(13), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_inventory.v1", "schema.application.native-integration.worktree-inventory.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(13)) }, { operation: "handoff_issue_task_handoff", operationId: "operation.handoff.issue_task_handoff", transport: { kind: "http", route: "/application/handoff/issue-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.issue_task_handoff", requestSchema: { schemaId: "schema.handoff.issue_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.issue_task_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(312), decodeResult: decoder(313), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(313)) }, + decodeRequest: decoder(314), decodeResult: decoder(315), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(315)) }, { operation: "handoff_list_task_handoffs", operationId: "operation.handoff.list_task_handoffs", transport: { kind: "http", route: "/application/handoff/list-task", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.list_task_handoffs", requestSchema: { schemaId: "schema.handoff.list_task_handoffs.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.list_task_handoffs.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","partial"], - decodeRequest: decoder(314), decodeResult: decoder(315), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder(315)) }, + decodeRequest: decoder(316), decodeResult: decoder(317), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder(317)) }, { operation: "handoff_open_investigation_handoff", operationId: "operation.handoff.open_investigation_handoff", transport: { kind: "http", route: "/application/handoff/open-investigation", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.open_investigation_handoff", requestSchema: { schemaId: "schema.handoff.open_investigation_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.open_investigation_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(316), decodeResult: decoder(317), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(317)) }, + decodeRequest: decoder(318), decodeResult: decoder(319), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(319)) }, { operation: "handoff_open_task_handoff", operationId: "operation.handoff.open_task_handoff", transport: { kind: "http", route: "/application/handoff/open-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.open_task_handoff", requestSchema: { schemaId: "schema.handoff.open_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.open_task_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(318), decodeResult: decoder(319), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(319)) }, + decodeRequest: decoder(320), decodeResult: decoder(321), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(321)) }, { operation: "multi_root_execute", operationId: "operation.multi_root.execute", transport: { kind: "http", route: "/application/multi-root/execute", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.execute.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.execute-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.execute-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(320), decodeResult: decoder(321), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(321)) }, + decodeRequest: decoder(322), decodeResult: decoder(323), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(323)) }, { operation: "multi_root_scope_set_compare_and_swap", operationId: "operation.multi_root.scope_set_compare_and_swap", transport: { kind: "http", route: "/application/multi-root/scope-set/compare-and-swap", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.scope_set_compare_and_swap.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-compare-and-swap-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(322), decodeResult: decoder(323), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(323)) }, + decodeRequest: decoder(324), decodeResult: decoder(325), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(325)) }, { operation: "multi_root_scope_set_read", operationId: "operation.multi_root.scope_set_read", transport: { kind: "http", route: "/application/multi-root/scope-set/read", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.scope_set_read.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-read-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-read-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(324), decodeResult: decoder(325), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(325)) }, + decodeRequest: decoder(326), decodeResult: decoder(327), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(327)) }, { operation: "work_accept_proposal", operationId: "operation.work.accept_proposal", transport: { kind: "http", route: "/application/work/accept-proposal", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.accept_proposal", requestSchema: { schemaId: "schema.work.accept_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.accept_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(326), decodeResult: decoder(327), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, + decodeRequest: decoder(328), decodeResult: decoder(329), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, { operation: "work_adjudicate_duplicate", operationId: "operation.work.adjudicate_duplicate", transport: { kind: "http", route: "/application/work/adjudicate-duplicate", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.adjudicate_duplicate", requestSchema: { schemaId: "schema.work.adjudicate_duplicate.request", revision: 1 }, resultSchema: { schemaId: "schema.work.adjudicate_duplicate.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(328), decodeResult: decoder(329), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, + decodeRequest: decoder(330), decodeResult: decoder(331), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, { operation: "work_adjudicate_leak", operationId: "operation.work.adjudicate_leak", transport: { kind: "http", route: "/application/work/adjudicate-leak", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.adjudicate_leak", requestSchema: { schemaId: "schema.work.adjudicate_leak.request", revision: 1 }, resultSchema: { schemaId: "schema.work.adjudicate_leak.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(330), decodeResult: decoder(331), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, + decodeRequest: decoder(332), decodeResult: decoder(333), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, { operation: "work_admit_execution", operationId: "operation.work.admit_execution", transport: { kind: "http", route: "/application/work/admit-execution", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.admit_execution", requestSchema: { schemaId: "schema.work.admit_execution.request", revision: 1 }, resultSchema: { schemaId: "schema.work.admit_execution.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(332), decodeResult: decoder(333), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, + decodeRequest: decoder(334), decodeResult: decoder(335), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, { operation: "work_admit_placement", operationId: "operation.work.admit_placement", transport: { kind: "http", route: "/application/work/admit-placement", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.admit_placement", requestSchema: { schemaId: "schema.work.admit_placement.request", revision: 1 }, resultSchema: { schemaId: "schema.work.admit_placement.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(334), decodeResult: decoder(335), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, + decodeRequest: decoder(336), decodeResult: decoder(337), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, { operation: "work_attempt_status", operationId: "operation.work.attempt_status", transport: { kind: "http", route: "/application/work/attempt-status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.attempt_status", requestSchema: { schemaId: "schema.work.attempt_status.request", revision: 1 }, resultSchema: { schemaId: "schema.work.attempt_status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(336), decodeResult: decoder(337), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(337)) }, + decodeRequest: decoder(338), decodeResult: decoder(339), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(339)) }, { operation: "work_cancel_attempt", operationId: "operation.work.cancel_attempt", transport: { kind: "http", route: "/application/work/cancel-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.cancel_attempt", requestSchema: { schemaId: "schema.work.cancel_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.cancel_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(338), decodeResult: decoder(337), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, + decodeRequest: decoder(340), decodeResult: decoder(339), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(339)) }, { operation: "work_compare_proposal", operationId: "operation.work.compare_proposal", transport: { kind: "http", route: "/application/work/compare-proposal", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.compare_proposal", requestSchema: { schemaId: "schema.work.compare_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.compare_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(339), decodeResult: decoder(340), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(340)) }, + decodeRequest: decoder(341), decodeResult: decoder(342), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(342)) }, { operation: "work_create", operationId: "operation.work.create", transport: { kind: "http", route: "/application/work/create", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.create", requestSchema: { schemaId: "schema.work.create.request", revision: 1 }, resultSchema: { schemaId: "schema.work.create.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(341), decodeResult: decoder(327), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, + decodeRequest: decoder(343), decodeResult: decoder(329), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, { operation: "work_execution_history", operationId: "operation.work.execution_history", transport: { kind: "http", route: "/application/work/execution-history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.execution_history", requestSchema: { schemaId: "schema.work.execution_history.request", revision: 1 }, resultSchema: { schemaId: "schema.work.execution_history.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(342), decodeResult: decoder(343), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(343)) }, + decodeRequest: decoder(344), decodeResult: decoder(345), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(345)) }, { operation: "work_experience", operationId: "operation.work.experience", transport: { kind: "http", route: "/application/work/experience", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.experience", requestSchema: { schemaId: "schema.work.experience.request", revision: 1 }, resultSchema: { schemaId: "schema.work.experience.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(344), decodeResult: decoder(345), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(345)) }, + decodeRequest: decoder(346), decodeResult: decoder(347), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(347)) }, { operation: "work_generate_proposal", operationId: "operation.work.generate_proposal", transport: { kind: "http", route: "/application/work/generate-proposal", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.generate_proposal", requestSchema: { schemaId: "schema.work.generate_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.generate_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(346), decodeResult: decoder(347), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(347)) }, + decodeRequest: decoder(348), decodeResult: decoder(349), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(349)) }, { operation: "work_hydrate_artifacts", operationId: "operation.work.hydrate_artifacts", transport: { kind: "http", route: "/application/work/hydrate-artifacts", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.hydrate_artifacts", requestSchema: { schemaId: "schema.work.hydrate_artifacts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.hydrate_artifacts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(348), decodeResult: decoder(349), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(349)) }, + decodeRequest: decoder(350), decodeResult: decoder(351), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(351)) }, { operation: "work_list_attempts", operationId: "operation.work.list_attempts", transport: { kind: "http", route: "/application/work/list-attempts", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.list_attempts", requestSchema: { schemaId: "schema.work.list_attempts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.list_attempts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(342), decodeResult: decoder(350), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(350)) }, + decodeRequest: decoder(344), decodeResult: decoder(352), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(352)) }, { operation: "work_mutate_graph", operationId: "operation.work.mutate_graph", transport: { kind: "http", route: "/application/work/mutate-graph", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.mutate_graph", requestSchema: { schemaId: "schema.work.mutate_graph.request", revision: 1 }, resultSchema: { schemaId: "schema.work.mutate_graph.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(351), decodeResult: decoder(327), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, + decodeRequest: decoder(353), decodeResult: decoder(329), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, { operation: "work_pause_run", operationId: "operation.work.pause_run", transport: { kind: "http", route: "/application/work/pause-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.pause_run", requestSchema: { schemaId: "schema.work.pause_run.request", revision: 1 }, resultSchema: { schemaId: "schema.work.pause_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(352), decodeResult: decoder(353), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(353)) }, + decodeRequest: decoder(354), decodeResult: decoder(355), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(355)) }, { operation: "work_placement_preflight", operationId: "operation.work.placement_preflight", transport: { kind: "http", route: "/application/work/placement-preflight", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.placement_preflight", requestSchema: { schemaId: "schema.work.placement_preflight.request", revision: 1 }, resultSchema: { schemaId: "schema.work.placement_preflight.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(354), decodeResult: decoder(355), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(355)) }, + decodeRequest: decoder(356), decodeResult: decoder(357), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(357)) }, { operation: "work_placement_status", operationId: "operation.work.placement_status", transport: { kind: "http", route: "/application/work/placement-status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.placement_status", requestSchema: { schemaId: "schema.work.placement_status.request", revision: 1 }, resultSchema: { schemaId: "schema.work.placement_status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(356), decodeResult: decoder(357), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(357)) }, + decodeRequest: decoder(358), decodeResult: decoder(359), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(359)) }, { operation: "work_prepare_duplicate_adjudication", operationId: "operation.work.prepare_duplicate_adjudication", transport: { kind: "http", route: "/application/work/prepare-duplicate-adjudication", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.prepare_duplicate_adjudication", requestSchema: { schemaId: "schema.work.prepare_duplicate_adjudication.request", revision: 1 }, resultSchema: { schemaId: "schema.work.prepare_duplicate_adjudication.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(358), decodeResult: decoder(328), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(328)) }, + decodeRequest: decoder(360), decodeResult: decoder(330), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(330)) }, { operation: "work_prepare_graph_mutation", operationId: "operation.work.prepare_graph_mutation", transport: { kind: "http", route: "/application/work/prepare-graph-mutation", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.prepare_graph_mutation", requestSchema: { schemaId: "schema.work.prepare_graph_mutation.request", revision: 1 }, resultSchema: { schemaId: "schema.work.prepare_graph_mutation.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(359), decodeResult: decoder(351), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(351)) }, + decodeRequest: decoder(361), decodeResult: decoder(353), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(353)) }, { operation: "work_release_placement", operationId: "operation.work.release_placement", transport: { kind: "http", route: "/application/work/release-placement", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.release_placement", requestSchema: { schemaId: "schema.work.release_placement.request", revision: 1 }, resultSchema: { schemaId: "schema.work.release_placement.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(360), decodeResult: decoder(335), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, + decodeRequest: decoder(362), decodeResult: decoder(337), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, { operation: "work_resume_attempts", operationId: "operation.work.resume_attempts", transport: { kind: "http", route: "/application/work/resume-attempts", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.resume_attempts", requestSchema: { schemaId: "schema.work.resume_attempts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.resume_attempts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(361), decodeResult: decoder(362), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(362)) }, + decodeRequest: decoder(363), decodeResult: decoder(364), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(364)) }, { operation: "work_resume_run", operationId: "operation.work.resume_run", transport: { kind: "http", route: "/application/work/resume-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.resume_run", requestSchema: { schemaId: "schema.work.resume_run.request", revision: 1 }, resultSchema: { schemaId: "schema.work.resume_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(363), decodeResult: decoder(353), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(353)) }, + decodeRequest: decoder(365), decodeResult: decoder(355), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(355)) }, { operation: "work_retrieve_evidence", operationId: "operation.work.retrieve_evidence", transport: { kind: "http", route: "/application/work/retrieve-evidence", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.retrieve_evidence", requestSchema: { schemaId: "schema.work.retrieve_evidence.request", revision: 1 }, resultSchema: { schemaId: "schema.work.retrieve_evidence.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(364), decodeResult: decoder(365), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(365)) }, + decodeRequest: decoder(366), decodeResult: decoder(367), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(367)) }, { operation: "work_retry_attempt", operationId: "operation.work.retry_attempt", transport: { kind: "http", route: "/application/work/retry-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.retry_attempt", requestSchema: { schemaId: "schema.work.retry_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.retry_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(366), decodeResult: decoder(367), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(367)) }, + decodeRequest: decoder(368), decodeResult: decoder(369), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(369)) }, { operation: "work_review_proposal", operationId: "operation.work.review_proposal", transport: { kind: "http", route: "/application/work/review-proposal", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.review_proposal", requestSchema: { schemaId: "schema.work.review_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.review_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(368), decodeResult: decoder(327), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, + decodeRequest: decoder(370), decodeResult: decoder(329), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, { operation: "work_run_control", operationId: "operation.work.run_control", transport: { kind: "http", route: "/application/work/run-control", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.run_control", requestSchema: { schemaId: "schema.work.run_control.request", revision: 1 }, resultSchema: { schemaId: "schema.work.run_control.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(369), decodeResult: decoder(370), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(370)) }, + decodeRequest: decoder(371), decodeResult: decoder(372), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(372)) }, { operation: "work_start_attempt", operationId: "operation.work.start_attempt", transport: { kind: "http", route: "/application/work/start-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.start_attempt", requestSchema: { schemaId: "schema.work.start_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.start_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(371), decodeResult: decoder(337), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, + decodeRequest: decoder(373), decodeResult: decoder(339), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(339)) }, { operation: "work_synthesize", operationId: "operation.work.synthesize", transport: { kind: "http", route: "/application/work/synthesize", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.synthesize", requestSchema: { schemaId: "schema.work.synthesize.request", revision: 1 }, resultSchema: { schemaId: "schema.work.synthesize.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(372), decodeResult: decoder(373), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(373)) }, + decodeRequest: decoder(374), decodeResult: decoder(375), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(375)) }, { operation: "work_topology", operationId: "operation.work.topology", transport: { kind: "http", route: "/application/work/topology", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.topology", requestSchema: { schemaId: "schema.work.topology.request", revision: 1 }, resultSchema: { schemaId: "schema.work.topology.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(374), decodeResult: decoder(375), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(375)) }, + decodeRequest: decoder(376), decodeResult: decoder(377), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(377)) }, { operation: "work_topology_metrics", operationId: "operation.work.topology_metrics", transport: { kind: "http", route: "/application/work/topology-metrics", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.topology_metrics", requestSchema: { schemaId: "schema.work.topology_metrics.request", revision: 1 }, resultSchema: { schemaId: "schema.work.topology_metrics.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(376), decodeResult: decoder(377), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(377)) }, + decodeRequest: decoder(378), decodeResult: decoder(379), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(379)) }, { operation: "work_views", operationId: "operation.work.views", transport: { kind: "http", route: "/application/work/views", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.views", requestSchema: { schemaId: "schema.work.views.request", revision: 1 }, resultSchema: { schemaId: "schema.work.views.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(378), decodeResult: decoder(379), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(379)) }, + decodeRequest: decoder(380), decodeResult: decoder(381), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(381)) }, { operation: "workflow_activate_definition", operationId: "operation.workflow.activate_definition", transport: { kind: "http", route: "/application/workflow/activate-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.activate_definition", requestSchema: { schemaId: "schema.workflow.activate_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.activate_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(380), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(382), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_cancel_run", operationId: "operation.workflow.cancel_run", transport: { kind: "http", route: "/application/workflow/cancel-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.cancel_run", requestSchema: { schemaId: "schema.workflow.cancel_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.cancel_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(382), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(384), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_definition_history", operationId: "operation.workflow.definition_history", transport: { kind: "http", route: "/application/workflow/definition-history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.definition_history", requestSchema: { schemaId: "schema.workflow.definition_history.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.definition_history.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(384), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, + decodeRequest: decoder(386), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, { operation: "workflow_diff_definition", operationId: "operation.workflow.diff_definition", transport: { kind: "http", route: "/application/workflow/diff-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.diff_definition", requestSchema: { schemaId: "schema.workflow.diff_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.diff_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(386), decodeResult: decoder(387), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, + decodeRequest: decoder(388), decodeResult: decoder(389), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(389)) }, { operation: "workflow_get_definition", operationId: "operation.workflow.get_definition", transport: { kind: "http", route: "/application/workflow/get-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.get_definition", requestSchema: { schemaId: "schema.workflow.get_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.get_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(388), decodeResult: decoder(389), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(389)) }, + decodeRequest: decoder(390), decodeResult: decoder(391), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(391)) }, { operation: "workflow_get_run", operationId: "operation.workflow.get_run", transport: { kind: "http", route: "/application/workflow/get-run", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.get_run", requestSchema: { schemaId: "schema.workflow.get_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.get_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(390), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(383)) }, + decodeRequest: decoder(392), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, { operation: "workflow_handoff_issue", operationId: "operation.workflow.handoff_issue", transport: { kind: "http", route: "/application/workflow/handoff-issue", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.handoff_issue", requestSchema: { schemaId: "schema.workflow.handoff_issue.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.handoff_issue.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(391), decodeResult: decoder(392), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(392)) }, + decodeRequest: decoder(393), decodeResult: decoder(394), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(394)) }, { operation: "workflow_handoff_redeem", operationId: "operation.workflow.handoff_redeem", transport: { kind: "http", route: "/application/workflow/handoff-redeem", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.handoff_redeem", requestSchema: { schemaId: "schema.workflow.handoff_redeem.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.handoff_redeem.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(393), decodeResult: decoder(394), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(394)) }, + decodeRequest: decoder(395), decodeResult: decoder(396), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(396)) }, { operation: "workflow_list_definitions", operationId: "operation.workflow.list_definitions", transport: { kind: "http", route: "/application/workflow/list-definitions", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.list_definitions", requestSchema: { schemaId: "schema.workflow.list_definitions.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.list_definitions.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(395), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, + decodeRequest: decoder(397), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, { operation: "workflow_pause_run", operationId: "operation.workflow.pause_run", transport: { kind: "http", route: "/application/workflow/pause-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.pause_run", requestSchema: { schemaId: "schema.workflow.pause_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.pause_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(396), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(398), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_register_definition", operationId: "operation.workflow.register_definition", transport: { kind: "http", route: "/application/workflow/register-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.register_definition", requestSchema: { schemaId: "schema.workflow.register_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.register_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(397), decodeResult: decoder(389), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(389)) }, + decodeRequest: decoder(399), decodeResult: decoder(391), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(391)) }, { operation: "workflow_reject_definition", operationId: "operation.workflow.reject_definition", transport: { kind: "http", route: "/application/workflow/reject-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.reject_definition", requestSchema: { schemaId: "schema.workflow.reject_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.reject_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(398), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(400), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_resume_run", operationId: "operation.workflow.resume_run", transport: { kind: "http", route: "/application/workflow/resume-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.resume_run", requestSchema: { schemaId: "schema.workflow.resume_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.resume_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(399), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(401), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_retire_definition", operationId: "operation.workflow.retire_definition", transport: { kind: "http", route: "/application/workflow/retire-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.retire_definition", requestSchema: { schemaId: "schema.workflow.retire_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.retire_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(400), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(381)) }, + decodeRequest: decoder(402), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, { operation: "workflow_start_run", operationId: "operation.workflow.start_run", transport: { kind: "http", route: "/application/workflow/start-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.start_run", requestSchema: { schemaId: "schema.workflow.start_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.start_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(401), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(403), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_validate_definition", operationId: "operation.workflow.validate_definition", transport: { kind: "http", route: "/application/workflow/validate-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.validate_definition", requestSchema: { schemaId: "schema.workflow.validate_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.validate_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(402), decodeResult: decoder(403), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(403)) }, + decodeRequest: decoder(404), decodeResult: decoder(405), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(405)) }, ] as const; export type Operation = (typeof OPERATIONS)[number]; From c939aa5b894b77b461b9666663399f183cfb0eef Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 19:33:51 +0000 Subject: [PATCH 04/10] test(cli): assert user-scope hook ingest reaches the profile owner --- .../tests/core_cli_suite/tool_daemon_test.rs | 151 ++++++------------ 1 file changed, 49 insertions(+), 102 deletions(-) diff --git a/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs b/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs index 351734c457..eae73e7a1e 100644 --- a/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs +++ b/crates/tracedecay-cli/tests/core_cli_suite/tool_daemon_test.rs @@ -2338,87 +2338,19 @@ fn tool_returns_a_completed_authority_result_without_resending() { ); } -fn spawn_handshake_capturing_daemon(socket_path: PathBuf) -> mpsc::Receiver { - let (ready_tx, ready_rx) = mpsc::channel(); - let (handshake_tx, handshake_rx) = mpsc::channel(); - - std::thread::spawn(move || { - let _ = std::fs::remove_file(&socket_path); - let authority = seed_fake_daemon_authority(&socket_path); - let listener = UnixListener::bind(&socket_path).expect("bind fake daemon socket"); - listener - .set_nonblocking(true) - .expect("set listener nonblocking"); - ready_tx.send(()).expect("notify fake daemon readiness"); - - let deadline = Instant::now() + CLI_ROUNDTRIP_TIMEOUT; - let (stream, _) = common::poll_until( - deadline, - Duration::from_millis(10), - || match listener.accept() { - Ok(accepted) => Some(accepted), - Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => None, - Err(e) => panic!("accept fake daemon client: {e}"), - }, - || "timed out waiting for tool CLI to connect to fake daemon".to_string(), - ); - stream - .set_nonblocking(false) - .expect("set accepted stream blocking"); - let _ = stream.set_read_timeout(Some(CLI_ROUNDTRIP_TIMEOUT)); - let _ = stream.set_write_timeout(Some(CLI_ROUNDTRIP_TIMEOUT)); - - let mut reader = BufReader::new(stream.try_clone().expect("clone fake daemon stream")); - let mut preface = String::new(); - reader.read_line(&mut preface).expect("read auth preface"); - assert!( - DaemonAuthPreface::from_line(preface.trim()) - .expect("fake daemon auth preface") - .authenticate(authority.auth_token()), - "the CLI must present the daemon token" - ); - let mut handshake = String::new(); - reader - .read_line(&mut handshake) - .expect("read daemon handshake"); - let handshake: Value = serde_json::from_str(handshake.trim()).expect("handshake JSON"); - handshake_tx - .send(handshake) - .expect("send observed handshake"); - - let mut request = String::new(); - reader - .read_line(&mut request) - .expect("read JSON-RPC request"); - let request: Value = serde_json::from_str(request.trim()).expect("request JSON"); - let response = json!({ - "jsonrpc": "2.0", - "id": request["id"].clone(), - "result": { - "content": [{ - "type": "text", - "text": "{\"status\":\"ok\"}" - }] - } - }); - let mut writer = stream; - writeln!(writer, "{}", serde_json::to_string(&response).unwrap()) - .expect("write fake daemon response"); - }); - - ready_rx - .recv_timeout(LOCAL_READY_TIMEOUT) - .expect("fake daemon should become ready"); - handshake_rx -} - +/// Hermes sends a user-scope transcript with cwd=/ so its home is never +/// mistaken for a project: the CLI handshakes projectless and asks the +/// daemon's profile owner, not a project, for the ingest. #[test] fn user_scoped_transcript_ingest_handshakes_projectless_from_filesystem_root_cwd() { let home = TempDir::new().unwrap(); - let socket_dir = TempDir::new().unwrap(); let home_path = canonical_existing_path(home.path()); - let socket_path = socket_dir.path().join("tracedecay.sock"); - let observed_handshake = spawn_handshake_capturing_daemon(socket_path.clone()); + let daemon = spawn_scripted_retained_daemon( + &home_path, + vec![completed_authority_problem( + "profile session store is unavailable", + )], + ); let args = json!({ "action": "ingest_transcript", "provider": "hermes", @@ -2428,36 +2360,51 @@ fn user_scoped_transcript_ingest_handshakes_projectless_from_filesystem_root_cwd {"role": "user", "content": "hello", "id": "m1"}, {"role": "assistant", "content": "hi there", "id": "m2"} ], - }) - .to_string(); - - let output = tracedecay_command_with_home(&home_path) - .current_dir(std::path::Path::new("/")) - .env("TRACEDECAY_DAEMON_SOCKET", &socket_path) - .args([ - "tool", - "tracedecay_hook_runtime", - "--json", - "--args", - args.as_str(), - ]) - .output() - .expect("tracedecay tool should run"); + }); - assert!( - output.status.success(), - "user-scoped LCM from cwd=/ must reach the daemon projectless\nstdout:\n{}\nstderr:\n{}", - String::from_utf8_lossy(&output.stdout), - String::from_utf8_lossy(&output.stderr) + let output = run_command_with_timeout( + { + let mut command = tracedecay_command_with_home(&home_path); + command.current_dir(std::path::Path::new("/")).args([ + "tool", + "tracedecay_hook_runtime", + "--json", + "--args", + args.to_string().as_str(), + ]); + command + }, + CLI_ROUNDTRIP_TIMEOUT, ); - let handshake = observed_handshake + + let (handshake, request) = daemon + .requests .recv_timeout(CLI_ROUNDTRIP_TIMEOUT) - .expect("fake daemon should observe handshake"); - assert!( - handshake.get("project_path").is_none() - || handshake.get("project_path") == Some(&Value::Null), + .unwrap_or_else(|_| { + panic!( + "the daemon must receive the ingest\nstdout:\n{}\nstderr:\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ) + }); + assert_eq!( + handshake.get("project_path").unwrap_or(&Value::Null), + &Value::Null, "Hermes user scope must not invent project=/; handshake was {handshake}" ); + let DaemonInvocationPayload::ProfileGraphTool { + surface_operation, + arguments, + .. + } = request.payload + else { + panic!("user-scope ingest must reach the profile owner: {request:?}"); + }; + assert_eq!( + surface_operation, + tracedecay_tool_catalog::ApplicationSurfaceOperation::HookRuntime + ); + assert_eq!(Value::Object(arguments), args); } #[test] From fffb88d3d423d250c8b17e14b5a5db8a8bd0501d Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 19:53:01 +0000 Subject: [PATCH 05/10] test(daemon): read a blocked Hermes receipt as the owner's refusal --- crates/tracedecay/src/daemon/tests/replay.rs | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/crates/tracedecay/src/daemon/tests/replay.rs b/crates/tracedecay/src/daemon/tests/replay.rs index 94e80e87a3..a4a7895f12 100644 --- a/crates/tracedecay/src/daemon/tests/replay.rs +++ b/crates/tracedecay/src/daemon/tests/replay.rs @@ -101,10 +101,18 @@ async fn client_identity_startup_replays_retained_profile_receipts() { &first_admin, ) .await; - assert!( - response.error.is_some(), - "blocked canonical apply must retain the daemon-admitted receipt" + // The profile owner refuses the receipt it could not apply, and keeps it + // retained for replay. + let result = response.result.clone().unwrap_or_else(|| { + panic!("blocked canonical apply must be the owner's typed refusal: {response:?}") + }); + assert_eq!(result["isError"], true, "{result}"); + assert_eq!(result["problem"]["kind"], "unavailable", "{result}"); + assert_eq!( + result["problem"]["code"], "canonical_admission_failed", + "{result}" ); + assert_eq!(result["problem"]["retryable"], true, "{result}"); assert_eq!(broker.pending_count().await, 1); assert!(!profile_root.join("host_receipts.json").exists()); first_admin.shutdown_host_admission_replay().await; From 2609d9234db35a2d66850640532c237ab4b4a6c7 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 20:06:40 +0000 Subject: [PATCH 06/10] test(hermes): assert turn sync scopes by user_scope --- crates/tracedecay/tests/hermes_suite/lcm_bridge.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs b/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs index f43ca63098..0084e8d053 100644 --- a/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs +++ b/crates/tracedecay/tests/hermes_suite/lcm_bridge.rs @@ -1206,7 +1206,8 @@ fallback.initialize(session_id="session-2", hermes_home="/tmp/hermes") fallback.sync_turn("user", "assistant", session_id="session-2") assert fallback.project_root is None assert "project_root" not in calls[-1][1] -assert calls[-1][1]["storage_scope"] == "user" +assert calls[-1][1]["user_scope"] is True +assert "storage_scope" not in calls[-1][1] assert "project_root" not in calls[-1][2] "#, "sync_turn fallback messages should not collapse repeated identical turns", @@ -1261,8 +1262,11 @@ provider.sync_turn( assert len(calls) == 3, calls user_call, alpha_call, beta_call = calls -assert user_call[1]["storage_scope"] == "user" +assert user_call[1]["user_scope"] is True +assert "storage_scope" not in user_call[1] assert user_call[2] == {} +assert alpha_call[1]["user_scope"] is False +assert beta_call[1]["user_scope"] is False assert alpha_call[2] == {"project_root": "/repos/alpha"} assert beta_call[2] == {"project_root": "/repos/beta"} assert "storage_scope" not in alpha_call[1] From d7e6e3ef0abef6e9dbaee876db640a22645906b7 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 20:11:08 +0000 Subject: [PATCH 07/10] fix(hermes): request the hook runtime's JSON result on turn sync --- .../src/agents/hermes/templates/plugin_init.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py b/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py index 7199b9928e..3a97d132de 100644 --- a/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py +++ b/crates/tracedecay-agent-hosts/src/agents/hermes/templates/plugin_init.py @@ -2420,12 +2420,15 @@ def sync_turn(self, user_content, assistant_content, *, session_id="", messages= # so one turn can be searched from every repository it actually touched # without binding the long-lived host session to any one project. for project_root in [None, *project_roots]: + # The internal hook tool is not format-capable, so the JSON + # result this reads back is requested explicitly. args = { "action": "ingest_transcript", "provider": STANDARD_HERMES_LCM_PROVIDER, "session_id": sid, "messages": turn_messages, "user_scope": project_root is None, + "format": "json", } try: result = call_tracedecay_json( From c9e217f9707233c12ad1bedb090522a971456ae4 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 20:40:36 +0000 Subject: [PATCH 08/10] refactor(mcp): regenerate contracts after the admin cli owner --- .../schemas/dashboard-contracts.schema.json | 5 + dashboard/src/contracts/generated.ts | 2 +- sdks/typescript/src/operations.ts | 428 +++++++++--------- 3 files changed, 231 insertions(+), 204 deletions(-) diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json index abb7056766..603c78c38f 100644 --- a/dashboard/codegen/schemas/dashboard-contracts.schema.json +++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json @@ -11241,6 +11241,11 @@ "const": "maintains_profile_state", "description": "Reads and rewrites the daemon profile's own state: its project\nregistry, accounting ledgers, and session stores. Unlike bookkeeping,\nit includes long work, a registry collection or a transcript import,\nthat a cancelled call stops.", "type": "string" + }, + { + "const": "records_host_evidence", + "description": "Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.", + "type": "string" } ] }, diff --git a/dashboard/src/contracts/generated.ts b/dashboard/src/contracts/generated.ts index 58d91adf89..b57a8f0d82 100644 --- a/dashboard/src/contracts/generated.ts +++ b/dashboard/src/contracts/generated.ts @@ -2390,7 +2390,7 @@ export type DuplicateEffortKindV1 = z.infer; Git index writes remain separate classes so policy cannot accidentally substitute one index mutation for another. */ -export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work"), z.literal("maintains_owner_state"), z.literal("maintains_profile_state")]); +export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work"), z.literal("maintains_owner_state"), z.literal("maintains_profile_state"), z.literal("records_host_evidence")]); export type EffectClass = z.infer; /** Durable effect proof. It records identities and receipts, never credentials diff --git a/sdks/typescript/src/operations.ts b/sdks/typescript/src/operations.ts index 1a38533b55..c188d96b09 100644 --- a/sdks/typescript/src/operations.ts +++ b/sdks/typescript/src/operations.ts @@ -286,6 +286,7 @@ export type ContextScoutServiceStateV1 = "active" | "paused" | "disabled"; export type ContextScoutSettingsV1 = { readonly limits: ContextScoutConfigurationLimitsV1; readonly mode: ContextScoutConfigurationModeV1; readonly model_id?: string | null; readonly model_path?: ContextScoutConfiguredModelPathV1 | null; readonly model_timeout_secs?: number | null; readonly schema_version: number; readonly state: ContextScoutConfigurationStateV1 }; export type ContextScoutStatusResultV1 = { readonly active_suggestions: number; readonly configuration_revision: readonly number[]; readonly last_delivery_outcome?: ContextScoutDeliveryOutcomeV1 | null; readonly last_feedback?: ContextScoutFeedbackKindV1 | null; readonly last_model_outcome?: ContextScoutModelOutcomeV1 | null; readonly last_model_receipt?: ContextScoutModelReceiptV1 | null; readonly last_route?: ContextScoutRouteV1 | null; readonly last_suppression?: ContextScoutSuppressionV1 | null; readonly limits: ContextScoutLimitsV1; readonly mode: ContextScoutRuntimeModeV1; readonly model_path?: ContextScoutModelBackendV1 | null; readonly state: ContextScoutServiceStateV1 }; export type ContextScoutStoreOutcomeV1 = "stored" | "duplicate" | "superseded"; +export type ContextScoutStoreStatusV1 = "stored" | "duplicate" | "superseded" | "unavailable"; export type ContextScoutSuggestionProjectionV1 = { readonly category: ContextScoutCategoryV1; readonly configuration_revision: readonly number[]; readonly dedupe_key: readonly number[]; readonly delivery_window: ContextScoutDeliveryWindowV1; readonly envelope_id: readonly number[]; readonly evidence: ContextScoutEvidenceProjectionV1; readonly expires_at: UtcMicros; readonly model_outcome: ContextScoutModelOutcomeV1; readonly model_receipt?: ContextScoutModelReceiptV1 | null; readonly relevance_score: number; readonly route: ContextScoutRouteV1; readonly suggestion_text: string; readonly work: ContextScoutWorkV1 }; export type ContextScoutSuppressionV1 = "disabled" | "paused" | "dirty_overlay" | "quiet_or_unreceptive" | "no_eligible_candidate" | "expired" | "duplicate" | "cancelled" | "model_output_invalid" | "evidence_partial" | "evidence_stale" | "evidence_unavailable"; export type ContextScoutWorkV1 = { readonly address: ContextScoutAddressV1; readonly generation: number; readonly input_watermark: readonly number[] }; @@ -354,7 +355,7 @@ export type DsmStatsV1 = { readonly clusters: number; readonly density: number; export type DuplicateEffectOutcomeV1 = "prevented" | "committed" | "unknown" | "not_applicable"; export type DuplicateEffortKindV1 = "exact_duplicate" | "superseded_overlap" | "repeated_investigation" | "duplicate_effect" | "not_duplicate" | "censored" | "unknown"; export type EditResult = { readonly diff?: string | null; readonly dry_run?: boolean; readonly file_path: string; readonly matched_str: string; readonly message: string; readonly new_str: string; readonly replaced_span?: string | null; readonly success: boolean; readonly [key: string]: unknown }; -export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work" | "maintains_owner_state" | "maintains_profile_state"; +export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work" | "maintains_owner_state" | "maintains_profile_state" | "records_host_evidence"; export type EffectReceipt_2 = { readonly actor: ActorId; readonly catalog_digest: ManifestDigest; readonly committed_state?: ManifestDigest | null; readonly configuration_digest: ManifestDigest; readonly effect_class: EffectClass; readonly expected_state: ManifestDigest; readonly external_proof?: RetrievalAnchorId | null; readonly idempotency_key: string; readonly input_digest: ManifestDigest; readonly operation: UseCaseId; readonly outcome: EffectTermination_2; readonly policy_digest: ManifestDigest; readonly privacy_digest: ManifestDigest; readonly request_id: string; readonly scope: ResolvedScope }; export type EffectResult_2 = { readonly authority: AuthorityReceipt; readonly effect_class: EffectClass; readonly effect_id: string; readonly execution: OperationReceipt_2; readonly expected_state: ManifestDigest; readonly idempotency_key: string; readonly payload?: SourceEditDurableEffectPayloadV1 | null; readonly receipt: EffectReceipt_2; readonly reconciliation: ReconciliationState }; export type EffectTermination_2 = "completed" | "cancelled" | "timed_out" | "failed" | "partial" | "effect_unknown"; @@ -545,10 +546,16 @@ export type HealthModularityV1 = { readonly components_after_hub_removal: number export type HealthRedundancyV1 = { readonly dead_count: number; readonly score: number; readonly source: string; readonly total_fns: number }; export type HealthWeightsV1 = { readonly note: string }; export type HermesPendingSkillWrite = { readonly action?: string | null; readonly created_at?: unknown; readonly id: string; readonly name?: string | null; readonly origin?: string | null; readonly payload?: unknown; readonly source_path: string; readonly summary?: string | null; readonly [key: string]: unknown }; +export type HermesReceiptStatusV1 = "recorded" | "ingested" | "awaiting_transcript"; export type HermesSkillBridgeContracts = { readonly discovery_policy: string; readonly lifecycle_owner: string; readonly mutation_policy: string; readonly [key: string]: unknown }; export type HermesSkillBridgeSnapshot = { readonly agent_home: string; readonly archive_count: number; readonly contracts: HermesSkillBridgeContracts; readonly pending_skill_corrupt_count: number; readonly pending_skill_count: number; readonly pending_skills: readonly HermesPendingSkillWrite[]; readonly skill_count: number; readonly skills: readonly HermesSkillSummary[]; readonly skills_dir: string; readonly usage_record_count: number; readonly usage_records: { readonly [key: string]: unknown }; readonly [key: string]: unknown }; export type HermesSkillSummary = { readonly body_markdown?: string | null; readonly category?: string | null; readonly description?: string | null; readonly name: string; readonly path: string; readonly pending_write_ids: readonly string[]; readonly usage?: unknown; readonly [key: string]: unknown }; export type HistoryRewritePolicyV1 = "forbid_force_and_rebase"; +export type HookIngestAdmissionV1 = { readonly reason_code?: string | null; readonly retryable: boolean; readonly status: string }; +export type HookOrchestrationAdmissionV1 = "enqueued" | "backpressured" | "unsupported_trigger" | "unavailable"; +export type HookRuntimeAcceptedV1 = "accepted"; +export type HookRuntimeDispositionV1 = "accepted" | "catchup_required"; +export type HookV2RejectionReasonV1 = "admission_identity_conflict"; export type HostInstanceId = string; export type HotspotV1 = { readonly file: string; readonly id: string; readonly incoming: number; readonly kind: string; readonly line: number; readonly name: string; readonly outgoing: number; readonly total: number }; export type HunkDirectionV1 = "working_tree_to_index" | "index_to_head"; @@ -1485,6 +1492,8 @@ export type OperationApplicationHealthReadRequest = { }; export type OperationApplicationHealthReadResult = { readonly status: string }; export type OperationApplicationHermesSkillBridgeRequest = { readonly include_pending_payloads?: boolean; readonly include_skill_bodies?: boolean }; export type OperationApplicationHermesSkillBridgeResult = { readonly bridge: HermesSkillBridgeSnapshot; readonly status: AutomationReadStatusV1 }; +export type OperationApplicationHookRuntimeRequest = { readonly action: "reset_counter" } | { readonly action: "hook_v2_admit"; readonly envelope: unknown; readonly native_lifecycle?: unknown; readonly native_session_id?: string | null } | { readonly action: "hook_v2_delivery_receipt"; readonly receipt: unknown } | { readonly action: "hook_v2_feedback_notice_delivery"; readonly envelope: unknown; readonly feedback_notice: unknown } | { readonly action: "opencode_lsp_updated"; readonly event: unknown } | { readonly action: "ingest_transcript"; readonly event_json?: string | null; readonly max_new_bytes?: number | null; readonly messages?: readonly unknown[] | null; readonly provider: string; readonly session_id?: string | null; readonly user_scope: boolean } | { readonly action: "codex_compact"; readonly event_json: string } | { readonly action: "claude_compact"; readonly event_json: string; readonly user_scope: boolean } | { readonly action: "cursor_compact"; readonly event_json: string } | { readonly action: "user_review"; readonly provider: string; readonly session_id?: string | null } | { readonly action: "hermes_receipt"; readonly event: unknown } | { readonly action: "hook_v2_profile_admit"; readonly admission: unknown }; +export type OperationApplicationHookRuntimeResult = { readonly action: "reset_counter"; readonly reset: boolean } | { readonly context_scout_address?: ContextScoutAddressV1 | null; readonly disposition: HookRuntimeDispositionV1; readonly feedback_notice?: unknown; readonly github_stack_signal_available: boolean; readonly orchestration: HookOrchestrationAdmissionV1; readonly ready_guidance?: unknown; readonly status: "accepted"; readonly [key: string]: unknown } | { readonly context_scout_address?: ContextScoutAddressV1 | null; readonly disposition: HookRuntimeDispositionV1; readonly ready_guidance?: unknown; readonly status: "exact_duplicate"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly reason?: HookV2RejectionReasonV1 | null; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly status: "backpressured"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown } | { readonly action: "hook_v2_delivery_receipt"; readonly status: ContextScoutStoreStatusV1 } | { readonly status: "stored"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly action: "opencode_lsp_updated"; readonly status: HookRuntimeAcceptedV1 } | { readonly action: "ingest_transcript"; readonly admission: HookIngestAdmissionV1; readonly bytes_consumed?: number | null; readonly completed: boolean; readonly cursor_advances?: number | null; readonly cursor_duplicates?: number | null; readonly deferred_by_byte_cap?: boolean | null; readonly deferred_sources?: number | null; readonly hint_outcomes?: unknown; readonly messages_upserted: number; readonly observation_duplicates?: number | null; readonly observations_committed?: number | null; readonly projection_duplicates?: number | null; readonly projections_completed?: number | null; readonly projections_skipped?: number | null; readonly provider: string; readonly records_quarantined?: number | null; readonly records_rejected?: number | null; readonly source_bytes_scanned?: number | null; readonly status: string; readonly user_scope: boolean } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly relation_projection_status: unknown; readonly retry_status?: string | null; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly authority_outcome: unknown; readonly committed_state: unknown; readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly reason: string; readonly relation_projection_status?: unknown; readonly status: string; readonly summary_node_ids: readonly string[]; readonly summary_nodes_created: number; readonly [key: string]: unknown } | { readonly messages_upserted: number; readonly reason: string; readonly status: string; readonly [key: string]: unknown } | { readonly action: "hermes_receipt"; readonly status: HermesReceiptStatusV1 } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "accepted"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "exact_duplicate"; readonly [key: string]: unknown } | { readonly disposition: HookRuntimeDispositionV1; readonly status: "rejected"; readonly [key: string]: unknown } | { readonly status: "unavailable"; readonly [key: string]: unknown }; export type OperationApplicationHotspotsRequest = { readonly limit?: number | null }; export type OperationApplicationHotspotsResult = { readonly hotspot_count: number; readonly hotspots: readonly HotspotV1[] }; export type OperationApplicationImpactRequest = { readonly max_depth?: number | null; readonly node_id: string }; @@ -1997,6 +2006,7 @@ const DEFINITIONS = { ContextScoutSettingsV1: {"additionalProperties":false,"description":"Canonical Context Scout control-plane value. Disabled is the only stock\nstate; deterministic or configured-model execution requires an explicit\nconfiguration revision.","properties":{"limits":{"$ref":"#/$defs/ContextScoutConfigurationLimitsV1"},"mode":{"$ref":"#/$defs/ContextScoutConfigurationModeV1"},"model_id":{"type":["string","null"]},"model_path":{"anyOf":[{"$ref":"#/$defs/ContextScoutConfiguredModelPathV1"},{"type":"null"}]},"model_timeout_secs":{"format":"uint64","minimum":0,"type":["integer","null"]},"schema_version":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"state":{"$ref":"#/$defs/ContextScoutConfigurationStateV1"}},"required":["schema_version","state","mode","limits"],"type":"object"}, ContextScoutStatusResultV1: {"additionalProperties":false,"properties":{"active_suggestions":{"format":"uint","minimum":0,"type":"integer"},"configuration_revision":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"last_delivery_outcome":{"anyOf":[{"$ref":"#/$defs/ContextScoutDeliveryOutcomeV1"},{"type":"null"}]},"last_feedback":{"anyOf":[{"$ref":"#/$defs/ContextScoutFeedbackKindV1"},{"type":"null"}]},"last_model_outcome":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelOutcomeV1"},{"type":"null"}]},"last_model_receipt":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelReceiptV1"},{"type":"null"}]},"last_route":{"anyOf":[{"$ref":"#/$defs/ContextScoutRouteV1"},{"type":"null"}]},"last_suppression":{"anyOf":[{"$ref":"#/$defs/ContextScoutSuppressionV1"},{"type":"null"}]},"limits":{"$ref":"#/$defs/ContextScoutLimitsV1"},"mode":{"$ref":"#/$defs/ContextScoutRuntimeModeV1"},"model_path":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelBackendV1"},{"type":"null"}]},"state":{"$ref":"#/$defs/ContextScoutServiceStateV1"}},"required":["configuration_revision","state","mode","limits","active_suggestions"],"type":"object"}, ContextScoutStoreOutcomeV1: {"enum":["stored","duplicate","superseded"],"type":"string"}, + ContextScoutStoreStatusV1: {"enum":["stored","duplicate","superseded","unavailable"],"type":"string"}, ContextScoutSuggestionProjectionV1: {"additionalProperties":false,"properties":{"category":{"$ref":"#/$defs/ContextScoutCategoryV1"},"configuration_revision":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"dedupe_key":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"},"delivery_window":{"$ref":"#/$defs/ContextScoutDeliveryWindowV1"},"envelope_id":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":16,"minItems":16,"type":"array"},"evidence":{"$ref":"#/$defs/ContextScoutEvidenceProjectionV1"},"expires_at":{"$ref":"#/$defs/UtcMicros"},"model_outcome":{"$ref":"#/$defs/ContextScoutModelOutcomeV1"},"model_receipt":{"anyOf":[{"$ref":"#/$defs/ContextScoutModelReceiptV1"},{"type":"null"}]},"relevance_score":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"route":{"$ref":"#/$defs/ContextScoutRouteV1"},"suggestion_text":{"type":"string"},"work":{"$ref":"#/$defs/ContextScoutWorkV1"}},"required":["work","envelope_id","configuration_revision","delivery_window","route","model_outcome","dedupe_key","category","relevance_score","suggestion_text","evidence","expires_at"],"type":"object"}, ContextScoutSuppressionV1: {"enum":["disabled","paused","dirty_overlay","quiet_or_unreceptive","no_eligible_candidate","expired","duplicate","cancelled","model_output_invalid","evidence_partial","evidence_stale","evidence_unavailable"],"type":"string"}, ContextScoutWorkV1: {"additionalProperties":false,"properties":{"address":{"$ref":"#/$defs/ContextScoutAddressV1"},"generation":{"format":"uint64","minimum":0,"type":"integer"},"input_watermark":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"maxItems":32,"minItems":32,"type":"array"}},"required":["address","generation","input_watermark"],"type":"object"}, @@ -2065,7 +2075,7 @@ const DEFINITIONS = { DuplicateEffectOutcomeV1: {"enum":["prevented","committed","unknown","not_applicable"],"type":"string"}, DuplicateEffortKindV1: {"enum":["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],"type":"string"}, EditResult: {"description":"Result of a single string replacement edit.","properties":{"diff":{"description":"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.","type":["string","null"]},"dry_run":{"description":"True when this was a dry run: validation, spans, and the resulting\ncontent were all computed, but nothing was written to disk.","type":"boolean"},"file_path":{"type":"string"},"matched_str":{"type":"string"},"message":{"type":"string"},"new_str":{"type":"string"},"replaced_span":{"description":"The exact source text that was replaced. For `replace_symbol` this is\nthe item's full span, including any leading doc-comment / attribute\nblock, so callers can recover its docs/attrs if the replacement\ndropped them; for `str_replace` it is the matched `old_str` text.\n`None` only on a failed edit, where nothing was resolved to replace.","type":["string","null"]},"success":{"type":"boolean"}},"required":["success","file_path","matched_str","new_str","message"],"type":"object"}, - EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"},{"const":"maintains_owner_state","description":"Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.","type":"string"},{"const":"maintains_profile_state","description":"Reads and rewrites the daemon profile's own state: its project\nregistry, accounting ledgers, and session stores. Unlike bookkeeping,\nit includes long work, a registry collection or a transcript import,\nthat a cancelled call stops.","type":"string"}]}, + EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"},{"const":"maintains_owner_state","description":"Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.","type":"string"},{"const":"maintains_profile_state","description":"Reads and rewrites the daemon profile's own state: its project\nregistry, accounting ledgers, and session stores. Unlike bookkeeping,\nit includes long work, a registry collection or a transcript import,\nthat a cancelled call stops.","type":"string"},{"const":"records_host_evidence","description":"Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.","type":"string"}]}, EffectReceipt_2: {"additionalProperties":false,"description":"Durable effect proof. It records identities and receipts, never credentials\nor arbitrary command text.","properties":{"actor":{"$ref":"#/$defs/ActorId"},"catalog_digest":{"$ref":"#/$defs/ManifestDigest"},"committed_state":{"anyOf":[{"$ref":"#/$defs/ManifestDigest"},{"type":"null"}]},"configuration_digest":{"$ref":"#/$defs/ManifestDigest"},"effect_class":{"$ref":"#/$defs/EffectClass"},"expected_state":{"$ref":"#/$defs/ManifestDigest"},"external_proof":{"anyOf":[{"$ref":"#/$defs/RetrievalAnchorId"},{"type":"null"}]},"idempotency_key":{"type":"string"},"input_digest":{"$ref":"#/$defs/ManifestDigest"},"operation":{"$ref":"#/$defs/UseCaseId"},"outcome":{"$ref":"#/$defs/EffectTermination"},"policy_digest":{"$ref":"#/$defs/ManifestDigest"},"privacy_digest":{"$ref":"#/$defs/ManifestDigest"},"request_id":{"type":"string"},"scope":{"$ref":"#/$defs/ResolvedScope"}},"required":["operation","request_id","actor","scope","effect_class","idempotency_key","input_digest","expected_state","policy_digest","configuration_digest","catalog_digest","privacy_digest","outcome"],"type":"object"}, EffectResult_2: {"additionalProperties":false,"description":"Result of an admitted effect. `EffectUnknown` remains a receipt state and\ncannot be remapped into a pre-admission problem.","properties":{"authority":{"$ref":"#/$defs/AuthorityReceipt"},"effect_class":{"$ref":"#/$defs/EffectClass"},"effect_id":{"type":"string"},"execution":{"$ref":"#/$defs/OperationReceipt"},"expected_state":{"$ref":"#/$defs/ManifestDigest"},"idempotency_key":{"type":"string"},"payload":{"anyOf":[{"$ref":"#/$defs/SourceEditDurableEffectPayloadV1"},{"type":"null"}]},"receipt":{"$ref":"#/$defs/EffectReceipt"},"reconciliation":{"$ref":"#/$defs/ReconciliationState"}},"required":["effect_id","effect_class","idempotency_key","authority","expected_state","execution","reconciliation","receipt"],"type":"object"}, EffectTermination_2: {"description":"Durable effect receipt terminal state.","enum":["completed","cancelled","timed_out","failed","partial","effect_unknown"],"type":"string"}, @@ -2256,10 +2266,16 @@ const DEFINITIONS = { HealthRedundancyV1: {"additionalProperties":false,"properties":{"dead_count":{"format":"uint64","minimum":0,"type":"integer"},"score":{"format":"double","type":"number"},"source":{"type":"string"},"total_fns":{"format":"uint64","minimum":0,"type":"integer"}},"required":["score","dead_count","total_fns","source"],"type":"object"}, HealthWeightsV1: {"additionalProperties":false,"properties":{"note":{"type":"string"}},"required":["note"],"type":"object"}, HermesPendingSkillWrite: {"properties":{"action":{"type":["string","null"]},"created_at":true,"id":{"type":"string"},"name":{"type":["string","null"]},"origin":{"type":["string","null"]},"payload":true,"source_path":{"type":"string"},"summary":{"type":["string","null"]}},"required":["id","source_path"],"type":"object"}, + HermesReceiptStatusV1: {"oneOf":[{"const":"recorded","description":"A terminal receipt was recorded.","type":"string"},{"const":"ingested","description":"The turn was marked ingested and no receipt awaits review.","type":"string"},{"const":"awaiting_transcript","description":"A receipt awaits a transcript that has not landed yet.","type":"string"}]}, HermesSkillBridgeContracts: {"properties":{"discovery_policy":{"type":"string"},"lifecycle_owner":{"type":"string"},"mutation_policy":{"type":"string"}},"required":["lifecycle_owner","mutation_policy","discovery_policy"],"type":"object"}, HermesSkillBridgeSnapshot: {"properties":{"agent_home":{"type":"string"},"archive_count":{"format":"uint","minimum":0,"type":"integer"},"contracts":{"$ref":"#/$defs/HermesSkillBridgeContracts"},"pending_skill_corrupt_count":{"format":"uint","minimum":0,"type":"integer"},"pending_skill_count":{"format":"uint","minimum":0,"type":"integer"},"pending_skills":{"items":{"$ref":"#/$defs/HermesPendingSkillWrite"},"type":"array"},"skill_count":{"format":"uint","minimum":0,"type":"integer"},"skills":{"items":{"$ref":"#/$defs/HermesSkillSummary"},"type":"array"},"skills_dir":{"type":"string"},"usage_record_count":{"format":"uint","minimum":0,"type":"integer"},"usage_records":{"additionalProperties":true,"description":"Hermes-owned usage telemetry keyed by skill name, as Hermes wrote it.","type":"object"}},"required":["agent_home","skills_dir","skill_count","pending_skill_count","pending_skill_corrupt_count","usage_record_count","archive_count","skills","pending_skills","usage_records","contracts"],"type":"object"}, HermesSkillSummary: {"properties":{"body_markdown":{"type":["string","null"]},"category":{"type":["string","null"]},"description":{"type":["string","null"]},"name":{"type":"string"},"path":{"type":"string"},"pending_write_ids":{"items":{"type":"string"},"type":"array"},"usage":true},"required":["name","path","pending_write_ids"],"type":"object"}, HistoryRewritePolicyV1: {"enum":["forbid_force_and_rebase"],"type":"string"}, + HookIngestAdmissionV1: {"additionalProperties":false,"description":"The admission authority's verdict on one transcript ingest.","properties":{"reason_code":{"type":["string","null"]},"retryable":{"type":"boolean"},"status":{"description":"The session host-admission status, in its wire spelling.","type":"string"}},"required":["status","retryable"],"type":"object"}, + HookOrchestrationAdmissionV1: {"description":"Outcome of admitting one hook envelope into the registered orchestrator.","enum":["enqueued","backpressured","unsupported_trigger","unavailable"],"type":"string"}, + HookRuntimeAcceptedV1: {"enum":["accepted"],"type":"string"}, + HookRuntimeDispositionV1: {"description":"How the hook transport should treat a Hook V2 envelope.","oneOf":[{"enum":["accepted"],"type":"string"},{"const":"catchup_required","description":"The published binding no longer authorizes the envelope; the host\nmust catch up before sending again.","type":"string"}]}, + HookV2RejectionReasonV1: {"oneOf":[{"const":"admission_identity_conflict","description":"The same event identity previously carried different bytes.","type":"string"}]}, HostInstanceId: {"description":"Strongly typed canonical identity: `HostInstanceId`.","type":"string"}, HotspotV1: {"additionalProperties":false,"properties":{"file":{"type":"string"},"id":{"type":"string"},"incoming":{"format":"uint64","minimum":0,"type":"integer"},"kind":{"type":"string"},"line":{"format":"uint32","minimum":0,"type":"integer"},"name":{"type":"string"},"outgoing":{"format":"uint64","minimum":0,"type":"integer"},"total":{"format":"uint64","minimum":0,"type":"integer"}},"required":["id","name","kind","file","line","incoming","outgoing","total"],"type":"object"}, HunkDirectionV1: {"description":"`HunkRef` operation direction: working tree to index, or index to\nHEAD/base. No other direction is encodable.","enum":["working_tree_to_index","index_to_head"],"type":"string"}, @@ -3168,6 +3184,8 @@ const SCHEMAS: readonly CanonicalJsonSchema[] = [ {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"status":{"type":"string"}},"required":["status"],"title":"HealthReadResult","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"include_pending_payloads":{"default":false,"description":"Include staged Hermes skill-write payloads (default: false).","type":"boolean"},"include_skill_bodies":{"default":false,"description":"Include bounded SKILL.md contents (default: false).","type":"boolean"}},"title":"HermesSkillBridgeSurfaceRequestV1","type":"object"}, {"$defs":{"AutomationReadStatusV1":DEFINITIONS.AutomationReadStatusV1,"HermesPendingSkillWrite":DEFINITIONS.HermesPendingSkillWrite,"HermesSkillBridgeContracts":DEFINITIONS.HermesSkillBridgeContracts,"HermesSkillBridgeSnapshot":DEFINITIONS.HermesSkillBridgeSnapshot,"HermesSkillSummary":DEFINITIONS.HermesSkillSummary},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"bridge":{"$ref":"#/$defs/HermesSkillBridgeSnapshot"},"status":{"$ref":"#/$defs/AutomationReadStatusV1"}},"required":["status","bridge"],"title":"HermesSkillBridgeResultV1","type":"object"}, + {"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"description":"Reset the project's local token counter.","properties":{"action":{"const":"reset_counter","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"description":"Admit one Hook V2 envelope for the bound project.","properties":{"action":{"const":"hook_v2_admit","type":"string"},"envelope":true,"native_lifecycle":true,"native_session_id":{"description":"The host's native session id; it binds only when it hashes to the\nenvelope's protected session.","type":["string","null"]}},"required":["action","envelope"],"type":"object"},{"additionalProperties":false,"description":"Commit a Context Scout delivery receipt for guidance the last\nadmission handed out.","properties":{"action":{"const":"hook_v2_delivery_receipt","type":"string"},"receipt":true},"required":["action","receipt"],"type":"object"},{"additionalProperties":false,"description":"Acknowledge delivery of an advisory feedback notice.","properties":{"action":{"const":"hook_v2_feedback_notice_delivery","type":"string"},"envelope":true,"feedback_notice":true},"required":["action","envelope","feedback_notice"],"type":"object"},{"additionalProperties":false,"description":"Record an `OpenCode` `lsp.updated` event.","properties":{"action":{"const":"opencode_lsp_updated","type":"string"},"event":true},"required":["action","event"],"type":"object"},{"additionalProperties":false,"description":"Land a host transcript in the owning session store.","properties":{"action":{"const":"ingest_transcript","type":"string"},"event_json":{"description":"The host's raw hook event, for providers that locate the transcript\nfrom it.","type":["string","null"]},"max_new_bytes":{"description":"Byte budget for this pass across every scanned source.","format":"uint64","minimum":0,"type":["integer","null"]},"messages":{"description":"One turn the host inlined instead of a source to scan.","items":true,"type":["array","null"]},"provider":{"type":"string"},"session_id":{"type":["string","null"]},"user_scope":{"description":"Land the transcript in the profile's user store instead of the\nproject's.","type":"boolean"}},"required":["action","provider","user_scope"],"type":"object"},{"additionalProperties":false,"description":"Codex `PostCompact` pressure evidence.","properties":{"action":{"const":"codex_compact","type":"string"},"event_json":{"type":"string"}},"required":["action","event_json"],"type":"object"},{"additionalProperties":false,"description":"Claude `PostCompact` pressure evidence; `user_scope` routes it to the\nprofile.","properties":{"action":{"const":"claude_compact","type":"string"},"event_json":{"type":"string"},"user_scope":{"type":"boolean"}},"required":["action","event_json","user_scope"],"type":"object"},{"additionalProperties":false,"description":"Cursor `preCompact` pressure evidence.","properties":{"action":{"const":"cursor_compact","type":"string"},"event_json":{"type":"string"}},"required":["action","event_json"],"type":"object"},{"additionalProperties":false,"description":"Review a finished user session.","properties":{"action":{"const":"user_review","type":"string"},"provider":{"type":"string"},"session_id":{"type":["string","null"]}},"required":["action","provider"],"type":"object"},{"additionalProperties":false,"description":"Record a Hermes terminal receipt without a project route.","properties":{"action":{"const":"hermes_receipt","type":"string"},"event":true},"required":["action","event"],"type":"object"},{"additionalProperties":false,"description":"Admit a native event without a project route into the profile's\nHook V2 ledger.","properties":{"action":{"const":"hook_v2_profile_admit","type":"string"},"admission":true},"required":["action","admission"],"type":"object"}],"title":"HookRuntimeSurfaceRequestV1"}, + {"$defs":{"ContextScoutAddressV1":DEFINITIONS.ContextScoutAddressV1,"ContextScoutStoreStatusV1":DEFINITIONS.ContextScoutStoreStatusV1,"HermesReceiptStatusV1":DEFINITIONS.HermesReceiptStatusV1,"HookIngestAdmissionV1":DEFINITIONS.HookIngestAdmissionV1,"HookOrchestrationAdmissionV1":DEFINITIONS.HookOrchestrationAdmissionV1,"HookRuntimeAcceptedV1":DEFINITIONS.HookRuntimeAcceptedV1,"HookRuntimeDispositionV1":DEFINITIONS.HookRuntimeDispositionV1,"HookV2RejectionReasonV1":DEFINITIONS.HookV2RejectionReasonV1},"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"properties":{"action":{"const":"reset_counter","type":"string"},"reset":{"type":"boolean"}},"required":["action","reset"],"type":"object"},{"oneOf":[{"properties":{"context_scout_address":{"anyOf":[{"$ref":"#/$defs/ContextScoutAddressV1"},{"type":"null"}]},"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"feedback_notice":{"description":"The advisory `AdvisoryHookLookupNoticeV1` waiting for this\nworktree."},"github_stack_signal_available":{"type":"boolean"},"orchestration":{"$ref":"#/$defs/HookOrchestrationAdmissionV1"},"ready_guidance":{"description":"The hook's `HookReadyGuidanceV1`, when admission claimed one."},"status":{"const":"accepted","type":"string"}},"required":["status","disposition","orchestration","github_stack_signal_available"],"type":"object"},{"description":"This exact envelope was already admitted; a retry may still receive\nguidance retained before a lost host response.","properties":{"context_scout_address":{"anyOf":[{"$ref":"#/$defs/ContextScoutAddressV1"},{"type":"null"}]},"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"ready_guidance":true,"status":{"const":"exact_duplicate","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"reason":{"anyOf":[{"$ref":"#/$defs/HookV2RejectionReasonV1"},{"type":"null"}]},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"},{"description":"Idempotency could not be recorded, so nothing was admitted.","properties":{"status":{"const":"backpressured","type":"string"}},"required":["status"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"}],"properties":{"action":{"const":"hook_v2_admit","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"hook_v2_delivery_receipt","type":"string"},"status":{"$ref":"#/$defs/ContextScoutStoreStatusV1"}},"required":["action","status"],"type":"object"},{"oneOf":[{"properties":{"status":{"const":"stored","type":"string"}},"required":["status"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"}],"properties":{"action":{"const":"hook_v2_feedback_notice_delivery","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"opencode_lsp_updated","type":"string"},"status":{"$ref":"#/$defs/HookRuntimeAcceptedV1"}},"required":["action","status"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"ingest_transcript","type":"string"},"admission":{"$ref":"#/$defs/HookIngestAdmissionV1"},"bytes_consumed":{"format":"uint64","minimum":0,"type":["integer","null"]},"completed":{"description":"False when the byte budget left work for a later pass.","type":"boolean"},"cursor_advances":{"format":"uint64","minimum":0,"type":["integer","null"]},"cursor_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"deferred_by_byte_cap":{"type":["boolean","null"]},"deferred_sources":{"format":"uint64","minimum":0,"type":["integer","null"]},"hint_outcomes":{"description":"How emitted hook hints settled against the new project activity."},"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"observation_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"observations_committed":{"format":"uint64","minimum":0,"type":["integer","null"]},"projection_duplicates":{"format":"uint64","minimum":0,"type":["integer","null"]},"projections_completed":{"format":"uint64","minimum":0,"type":["integer","null"]},"projections_skipped":{"format":"uint64","minimum":0,"type":["integer","null"]},"provider":{"type":"string"},"records_quarantined":{"format":"uint64","minimum":0,"type":["integer","null"]},"records_rejected":{"format":"uint64","minimum":0,"type":["integer","null"]},"source_bytes_scanned":{"format":"uint64","minimum":0,"type":["integer","null"]},"status":{"type":"string"},"user_scope":{"type":"boolean"}},"required":["action","provider","user_scope","completed","status","admission","messages_upserted"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"codex_compact","type":"string"}},"required":["action"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"claude_compact","type":"string"}},"required":["action"],"type":"object"},{"anyOf":[{"description":"The LCM authority settled the compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"relation_projection_status":true,"retry_status":{"type":["string","null"]},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],"type":"object"},{"description":"The LCM authority answered without a compaction.","properties":{"authority_outcome":true,"committed_state":true,"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],"type":"object"},{"description":"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.","properties":{"reason":{"type":"string"},"relation_projection_status":true,"status":{"type":"string"},"summary_node_ids":{"items":{"type":"string"},"type":"array"},"summary_nodes_created":{"format":"uint64","minimum":0,"type":"integer"}},"required":["status","reason","summary_nodes_created","summary_node_ids"],"type":"object"},{"description":"The host event named no session to compact.","properties":{"messages_upserted":{"format":"uint64","minimum":0,"type":"integer"},"reason":{"type":"string"},"status":{"type":"string"}},"required":["status","reason","messages_upserted"],"type":"object"}],"description":"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.","properties":{"action":{"const":"cursor_compact","type":"string"}},"required":["action"],"type":"object"},{"additionalProperties":false,"properties":{"action":{"const":"hermes_receipt","type":"string"},"status":{"$ref":"#/$defs/HermesReceiptStatusV1"}},"required":["action","status"],"type":"object"},{"oneOf":[{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"accepted","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"exact_duplicate","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"disposition":{"$ref":"#/$defs/HookRuntimeDispositionV1"},"status":{"const":"rejected","type":"string"}},"required":["status","disposition"],"type":"object"},{"properties":{"status":{"const":"unavailable","type":"string"}},"required":["status"],"type":"object"}],"properties":{"action":{"const":"hook_v2_profile_admit","type":"string"}},"required":["action"],"type":"object"}],"title":"HookRuntimeResultV1"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"limit":{"description":"Maximum number of hotspots to return (default: 10, at most 100).","format":"uint32","minimum":0,"type":["integer","null"]}},"title":"HotspotsSurfaceRequestV1","type":"object"}, {"$defs":{"HotspotV1":DEFINITIONS.HotspotV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"hotspot_count":{"format":"uint64","minimum":0,"type":"integer"},"hotspots":{"items":{"$ref":"#/$defs/HotspotV1"},"type":"array"}},"required":["hotspot_count","hotspots"],"title":"HotspotsResultV1","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"max_depth":{"format":"uint32","minimum":0,"type":["integer","null"]},"node_id":{"type":"string"}},"required":["node_id"],"title":"NodeDepthSurfaceRequestV1","type":"object"}, @@ -3899,587 +3917,591 @@ export const OPERATIONS = [ requestSchema: { schemaId: "schema.application.primitive.hermes-skill-bridge.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hermes-skill-bridge.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], decodeRequest: decoder(193), decodeResult: decoder(194) }, + { operation: "hook_runtime", operationId: "operation.application.hook_runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_hook_runtime" }, effect: "records_host_evidence", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hook_runtime.v1", + requestSchema: { schemaId: "schema.application.primitive.hook-runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hook-runtime.result", revision: 1 }, + cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","unavailable","partial"], + decodeRequest: decoder(195), decodeResult: decoder(196) }, { operation: "hotspots", operationId: "operation.application.hotspots", transport: { kind: "mcp_tool", toolName: "tracedecay_hotspots" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hotspots.v1", requestSchema: { schemaId: "schema.application.primitive.hotspots.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.hotspots.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(195), decodeResult: decoder(196) }, + decodeRequest: decoder(197), decodeResult: decoder(198) }, { operation: "impact", operationId: "operation.application.impact", transport: { kind: "mcp_tool", toolName: "tracedecay_impact" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.impact.v1", requestSchema: { schemaId: "schema.application.primitive.impact.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.impact.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(197), decodeResult: decoder(198) }, + decodeRequest: decoder(199), decodeResult: decoder(200) }, { operation: "inheritance_depth", operationId: "operation.application.inheritance_depth", transport: { kind: "mcp_tool", toolName: "tracedecay_inheritance_depth" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.inheritance_depth.v1", requestSchema: { schemaId: "schema.application.primitive.inheritance-depth.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.inheritance-depth.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(199), decodeResult: decoder(200) }, + decodeRequest: decoder(201), decodeResult: decoder(202) }, { operation: "insert_at", operationId: "operation.application.insert_at", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at.v1", requestSchema: { schemaId: "schema.application.source-edit.insert-at.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(201), decodeResult: decoder(18) }, + decodeRequest: decoder(203), decodeResult: decoder(18) }, { operation: "insert_at_symbol", operationId: "operation.application.insert_at_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(202), decodeResult: decoder(18) }, + decodeRequest: decoder(204), decodeResult: decoder(18) }, { operation: "largest", operationId: "operation.application.largest", transport: { kind: "mcp_tool", toolName: "tracedecay_largest" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.largest.v1", requestSchema: { schemaId: "schema.application.primitive.largest.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.largest.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(203), decodeResult: decoder(204) }, + decodeRequest: decoder(205), decodeResult: decoder(206) }, { operation: "application_lcm_describe", operationId: "operation.application.lcm_describe", transport: { kind: "http", route: "/application/retained/lcm_describe", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_describe.v1", requestSchema: { schemaId: "schema.application.retained.lcm-describe.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-describe.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(205), decodeResult: decoder(206), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(206)) }, + decodeRequest: decoder(207), decodeResult: decoder(208), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(208)) }, { operation: "application_lcm_doctor", operationId: "operation.application.lcm_doctor", transport: { kind: "http", route: "/application/retained/lcm_doctor", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_doctor.v1", requestSchema: { schemaId: "schema.application.retained.lcm-doctor.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-doctor.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(207), decodeResult: decoder(208), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(208)) }, + decodeRequest: decoder(209), decodeResult: decoder(210), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(210)) }, { operation: "application_lcm_expand", operationId: "operation.application.lcm_expand", transport: { kind: "http", route: "/application/retained/lcm_expand", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_expand.v1", requestSchema: { schemaId: "schema.application.retained.lcm-expand.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-expand.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(209), decodeResult: decoder(210), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(210)) }, + decodeRequest: decoder(211), decodeResult: decoder(212), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(212)) }, { operation: "application_lcm_expand_query", operationId: "operation.application.lcm_expand_query", transport: { kind: "http", route: "/application/retained/lcm_expand_query", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_expand_query.v1", requestSchema: { schemaId: "schema.application.retained.lcm-expand-query.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-expand-query.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(211), decodeResult: decoder(212), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(212)) }, + decodeRequest: decoder(213), decodeResult: decoder(214), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(214)) }, { operation: "application_lcm_grep", operationId: "operation.application.lcm_grep", transport: { kind: "http", route: "/application/retained/lcm_grep", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_grep.v1", requestSchema: { schemaId: "schema.application.retained.lcm-grep.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-grep.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(213), decodeResult: decoder(214), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(214)) }, + decodeRequest: decoder(215), decodeResult: decoder(216), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(216)) }, { operation: "application_lcm_load_session", operationId: "operation.application.lcm_load_session", transport: { kind: "http", route: "/application/retained/lcm_load_session", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_load_session.v1", requestSchema: { schemaId: "schema.application.retained.lcm-load-session.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-load-session.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(215), decodeResult: decoder(216), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(216)) }, + decodeRequest: decoder(217), decodeResult: decoder(218), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(218)) }, { operation: "application_lcm_status", operationId: "operation.application.lcm_status", transport: { kind: "http", route: "/application/retained/lcm_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.lcm_status.v1", requestSchema: { schemaId: "schema.application.retained.lcm-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.lcm-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(217), decodeResult: decoder(218), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(218)) }, + decodeRequest: decoder(219), decodeResult: decoder(220), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(220)) }, { operation: "application_memory_status", operationId: "operation.application.memory_status", transport: { kind: "http", route: "/application/retained/memory_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.memory_status.v1", requestSchema: { schemaId: "schema.application.retained.memory-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.memory-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(219), decodeResult: decoder(220), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(220)) }, + decodeRequest: decoder(221), decodeResult: decoder(222), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(222)) }, { operation: "application_message_search", operationId: "operation.application.message_search", transport: { kind: "http", route: "/application/retained/message_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.message_search.v1", requestSchema: { schemaId: "schema.application.retained.message-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.message-search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(221), decodeResult: decoder(222), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(222)) }, + decodeRequest: decoder(223), decodeResult: decoder(224), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(224)) }, { operation: "application_module_api", operationId: "operation.application.module_api", transport: { kind: "http", route: "/application/primitives/module_api", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.module_api.v1", requestSchema: { schemaId: "schema.application.primitive.module-api.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.module-api.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(223), decodeResult: decoder(224), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(224)) }, + decodeRequest: decoder(225), decodeResult: decoder(226), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(226)) }, { operation: "move_symbol", operationId: "operation.application.move_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_move_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.move_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.move-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.move-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(225), decodeResult: decoder(18) }, + decodeRequest: decoder(227), decodeResult: decoder(18) }, { operation: "multi_str_replace", operationId: "operation.application.multi_str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_multi_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.multi_str_replace.v1", requestSchema: { schemaId: "schema.application.source-edit.multi-str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.multi-str-replace.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(226), decodeResult: decoder(18) }, + decodeRequest: decoder(228), decodeResult: decoder(18) }, { operation: "native_integration_status", operationId: "operation.application.native_integration_status", transport: { kind: "mcp_tool", toolName: "tracedecay_native_integration_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.native_integration_status.v1", requestSchema: { schemaId: "schema.application.native-integration.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(227), decodeResult: decoder(15) }, + decodeRequest: decoder(229), decodeResult: decoder(15) }, { operation: "node", operationId: "operation.application.node", transport: { kind: "mcp_tool", toolName: "tracedecay_node" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.node.v1", requestSchema: { schemaId: "schema.application.primitive.node.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.node.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(228), decodeResult: decoder(229) }, + decodeRequest: decoder(230), decodeResult: decoder(231) }, { operation: "observatory_read", operationId: "operation.application.observatory_read", transport: { kind: "mcp_tool", toolName: "tracedecay_observatory_read" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.observatory_read.v1", requestSchema: { schemaId: "schema.application.observatory-read.request", revision: 1 }, resultSchema: { schemaId: "schema.application.observatory-read.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":15000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(230), decodeResult: decoder(231) }, + decodeRequest: decoder(232), decodeResult: decoder(233) }, { operation: "port_order", operationId: "operation.application.port_order", transport: { kind: "mcp_tool", toolName: "tracedecay_port_order" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.port_order.v1", requestSchema: { schemaId: "schema.application.primitive.port-order.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.port-order.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(232), decodeResult: decoder(233) }, + decodeRequest: decoder(234), decodeResult: decoder(235) }, { operation: "port_status", operationId: "operation.application.port_status", transport: { kind: "mcp_tool", toolName: "tracedecay_port_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.port_status.v1", requestSchema: { schemaId: "schema.application.primitive.port-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.port-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(234), decodeResult: decoder(235) }, + decodeRequest: decoder(236), decodeResult: decoder(237) }, { operation: "pr_context", operationId: "operation.application.pr_context", transport: { kind: "mcp_tool", toolName: "tracedecay_pr_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.pr_context.v1", requestSchema: { schemaId: "schema.application.primitive.pr-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.pr-context.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(236), decodeResult: decoder(237) }, + decodeRequest: decoder(238), decodeResult: decoder(239) }, { operation: "preflight_native_integration", operationId: "operation.application.preflight_native_integration", transport: { kind: "mcp_tool", toolName: "tracedecay_preflight_native_integration" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.preflight_native_integration.v1", requestSchema: { schemaId: "schema.application.native-integration.preflight.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.preflight.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(238), decodeResult: decoder(15) }, + decodeRequest: decoder(240), decodeResult: decoder(15) }, { operation: "project_context", operationId: "operation.application.project_context", transport: { kind: "mcp_tool", toolName: "tracedecay_project_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_context.v1", requestSchema: { schemaId: "schema.application.primitive.project-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-context.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(239), decodeResult: decoder(240) }, + decodeRequest: decoder(241), decodeResult: decoder(242) }, { operation: "project_list", operationId: "operation.application.project_list", transport: { kind: "mcp_tool", toolName: "tracedecay_project_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_list.v1", requestSchema: { schemaId: "schema.application.primitive.project-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-list.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(241), decodeResult: decoder(242) }, + decodeRequest: decoder(243), decodeResult: decoder(244) }, { operation: "project_search", operationId: "operation.application.project_search", transport: { kind: "mcp_tool", toolName: "tracedecay_project_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_search.v1", requestSchema: { schemaId: "schema.application.primitive.project-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(243), decodeResult: decoder(242) }, + decodeRequest: decoder(245), decodeResult: decoder(244) }, { operation: "application_qualified_name", operationId: "operation.application.qualified_name", transport: { kind: "http", route: "/application/primitives/qualified_name", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.qualified_name.v1", requestSchema: { schemaId: "schema.application.primitive.qualified-name.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.qualified-name.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(244), decodeResult: decoder(245), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(245)) }, + decodeRequest: decoder(246), decodeResult: decoder(247), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(247)) }, { operation: "rank", operationId: "operation.application.rank", transport: { kind: "mcp_tool", toolName: "tracedecay_rank" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rank.v1", requestSchema: { schemaId: "schema.application.primitive.rank.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.rank.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(246), decodeResult: decoder(247) }, + decodeRequest: decoder(248), decodeResult: decoder(249) }, { operation: "recursion", operationId: "operation.application.recursion", transport: { kind: "mcp_tool", toolName: "tracedecay_recursion" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.recursion.v1", requestSchema: { schemaId: "schema.application.primitive.recursion.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.recursion.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(248), decodeResult: decoder(249) }, + decodeRequest: decoder(250), decodeResult: decoder(251) }, { operation: "redundancy", operationId: "operation.application.redundancy", transport: { kind: "mcp_tool", toolName: "tracedecay_redundancy" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.redundancy.v1", requestSchema: { schemaId: "schema.application.primitive.redundancy.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.redundancy.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(250), decodeResult: decoder(251) }, + decodeRequest: decoder(252), decodeResult: decoder(253) }, { operation: "remote_status", operationId: "operation.application.remote_status", transport: { kind: "mcp_tool", toolName: "tracedecay_remote_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.remote_status.v1", requestSchema: { schemaId: "schema.application.primitive.remote-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.remote-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(252), decodeResult: decoder(253) }, + decodeRequest: decoder(254), decodeResult: decoder(255) }, { operation: "rename_preview", operationId: "operation.application.rename_preview", transport: { kind: "mcp_tool", toolName: "tracedecay_rename_preview" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rename_preview.v1", requestSchema: { schemaId: "schema.application.primitive.rename-preview.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.rename-preview.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(254), decodeResult: decoder(255) }, + decodeRequest: decoder(256), decodeResult: decoder(257) }, { operation: "rename_symbol", operationId: "operation.application.rename_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_rename_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.rename_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.rename-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rename-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(256), decodeResult: decoder(18) }, + decodeRequest: decoder(258), decodeResult: decoder(18) }, { operation: "replace_symbol", operationId: "operation.application.replace_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_replace_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.replace_symbol.v1", requestSchema: { schemaId: "schema.application.source-edit.replace-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.replace-symbol.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(257), decodeResult: decoder(18) }, + decodeRequest: decoder(259), decodeResult: decoder(18) }, { operation: "retrieve", operationId: "operation.application.retrieve", transport: { kind: "mcp_tool", toolName: "tracedecay_retrieve" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.retrieve.v1", requestSchema: { schemaId: "schema.application.primitive.retrieve.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.retrieve.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(258), decodeResult: decoder(259) }, + decodeRequest: decoder(260), decodeResult: decoder(261) }, { operation: "run_affected_tests", operationId: "operation.application.run_affected_tests", transport: { kind: "mcp_tool", toolName: "tracedecay_run_affected_tests" }, effect: "spawns_process", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.run_affected_tests.v1", requestSchema: { schemaId: "schema.application.primitive.run-affected-tests.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.run-affected-tests.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","effect_in_flight"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":600000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(260), decodeResult: decoder(261) }, + decodeRequest: decoder(262), decodeResult: decoder(263) }, { operation: "runtime", operationId: "operation.application.runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_runtime" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.runtime.v1", requestSchema: { schemaId: "schema.application.primitive.runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.runtime.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(262), decodeResult: decoder(263) }, + decodeRequest: decoder(264), decodeResult: decoder(265) }, { operation: "search", operationId: "operation.application.search", transport: { kind: "mcp_tool", toolName: "tracedecay_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.search.v1", requestSchema: { schemaId: "schema.application.primitive.search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.search.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(264), decodeResult: decoder(265) }, + decodeRequest: decoder(266), decodeResult: decoder(267) }, { operation: "session_lookup", operationId: "operation.application.session_lookup", transport: { kind: "mcp_tool", toolName: "tracedecay_session_lookup" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.session_lookup.v1", requestSchema: { schemaId: "schema.application.primitive.session-lookup.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.session-lookup.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(266), decodeResult: decoder(267) }, + decodeRequest: decoder(268), decodeResult: decoder(269) }, { operation: "application_session_refresh_begin", operationId: "operation.application.session_refresh_begin", transport: { kind: "http", route: "/application/retained/session_refresh_begin", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_begin.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-begin.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-begin.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(268), decodeResult: decoder(269), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(269)) }, + decodeRequest: decoder(270), decodeResult: decoder(271), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(271)) }, { operation: "application_session_refresh_cancel", operationId: "operation.application.session_refresh_cancel", transport: { kind: "http", route: "/application/retained/session_refresh_cancel", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_cancel.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-cancel.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-cancel.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(268), decodeResult: decoder(270), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(270)) }, + decodeRequest: decoder(270), decodeResult: decoder(272), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder(272)) }, { operation: "application_session_refresh_status", operationId: "operation.application.session_refresh_status", transport: { kind: "http", route: "/application/retained/session_refresh_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.session_refresh_status.v1", requestSchema: { schemaId: "schema.application.retained.session-refresh-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.session-refresh-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(268), decodeResult: decoder(271), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(271)) }, + decodeRequest: decoder(270), decodeResult: decoder(273), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(273)) }, { operation: "application_sessions_for", operationId: "operation.application.sessions_for", transport: { kind: "http", route: "/application/retained/sessions_for", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.sessions_for.v1", requestSchema: { schemaId: "schema.application.retained.sessions-for.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.sessions-for.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(272), decodeResult: decoder(273), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(273)) }, + decodeRequest: decoder(274), decodeResult: decoder(275), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(275)) }, { operation: "signature", operationId: "operation.application.signature", transport: { kind: "mcp_tool", toolName: "tracedecay_signature" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.signature.v1", requestSchema: { schemaId: "schema.application.primitive.signature.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.signature.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(112), decodeResult: decoder(274) }, + decodeRequest: decoder(112), decodeResult: decoder(276) }, { operation: "similar", operationId: "operation.application.similar", transport: { kind: "mcp_tool", toolName: "tracedecay_similar" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.similar.v1", requestSchema: { schemaId: "schema.application.primitive.similar.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.similar.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(275), decodeResult: decoder(276) }, + decodeRequest: decoder(277), decodeResult: decoder(278) }, { operation: "skill_list", operationId: "operation.application.skill_list", transport: { kind: "mcp_tool", toolName: "tracedecay_skill_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.skill_list.v1", requestSchema: { schemaId: "schema.application.primitive.skill-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.skill-list.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(277), decodeResult: decoder(278) }, + decodeRequest: decoder(279), decodeResult: decoder(280) }, { operation: "skill_view", operationId: "operation.application.skill_view", transport: { kind: "mcp_tool", toolName: "tracedecay_skill_view" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.skill_view.v1", requestSchema: { schemaId: "schema.application.primitive.skill-view.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.skill-view.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(279), decodeResult: decoder(280) }, + decodeRequest: decoder(281), decodeResult: decoder(282) }, { operation: "application_source_body", operationId: "operation.application.source_body", transport: { kind: "http", route: "/application/primitives/source_body", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_body.v1", requestSchema: { schemaId: "schema.application.primitive.source-body.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-body.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(281), decodeResult: decoder(282), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(282)) }, + decodeRequest: decoder(283), decodeResult: decoder(284), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(284)) }, { operation: "source_edit_reconcile", operationId: "operation.application.source_edit_reconcile", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_reconcile" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_reconcile.v1", requestSchema: { schemaId: "schema.application.source-edit.reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.reconcile.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(283), decodeResult: decoder(18) }, + decodeRequest: decoder(285), decodeResult: decoder(18) }, { operation: "source_edit_rollback", operationId: "operation.application.source_edit_rollback", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_rollback" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_rollback.v1", requestSchema: { schemaId: "schema.application.source-edit.rollback.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rollback.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(284), decodeResult: decoder(18) }, + decodeRequest: decoder(286), decodeResult: decoder(18) }, { operation: "application_source_lines", operationId: "operation.application.source_lines", transport: { kind: "http", route: "/application/primitives/source_lines", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_lines.v1", requestSchema: { schemaId: "schema.application.primitive.source-lines.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-lines.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(285), decodeResult: decoder(286), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(286)) }, + decodeRequest: decoder(287), decodeResult: decoder(288), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(288)) }, { operation: "application_source_outline", operationId: "operation.application.source_outline", transport: { kind: "http", route: "/application/primitives/source_outline", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_outline.v1", requestSchema: { schemaId: "schema.application.primitive.source-outline.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-outline.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(287), decodeResult: decoder(288), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(288)) }, + decodeRequest: decoder(289), decodeResult: decoder(290), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(290)) }, { operation: "stack_snapshot", operationId: "operation.application.stack_snapshot", transport: { kind: "mcp_tool", toolName: "tracedecay_stack_snapshot" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.stack_snapshot.v1", requestSchema: { schemaId: "schema.application.native-integration.stack-snapshot.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.stack-snapshot.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(289), decodeResult: decoder(15) }, + decodeRequest: decoder(291), decodeResult: decoder(15) }, { operation: "status", operationId: "operation.application.status", transport: { kind: "mcp_tool", toolName: "tracedecay_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.status.v1", requestSchema: { schemaId: "schema.application.primitive.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(290), decodeResult: decoder(291) }, + decodeRequest: decoder(292), decodeResult: decoder(293) }, { operation: "application_storage_status", operationId: "operation.application.storage_status", transport: { kind: "http", route: "/application/primitives/storage_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.storage_status.v1", requestSchema: { schemaId: "schema.application.primitive.storage-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.storage-status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(292), decodeResult: decoder(293), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(293)) }, + decodeRequest: decoder(294), decodeResult: decoder(295), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(295)) }, { operation: "str_replace", operationId: "operation.application.str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.str_replace.v1", requestSchema: { schemaId: "schema.application.source-edit.str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.str-replace.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(294), decodeResult: decoder(18) }, + decodeRequest: decoder(296), decodeResult: decoder(18) }, { operation: "test_map", operationId: "operation.application.test_map", transport: { kind: "mcp_tool", toolName: "tracedecay_test_map" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_map.v1", requestSchema: { schemaId: "schema.application.primitive.test-map.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-map.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(295), decodeResult: decoder(296) }, + decodeRequest: decoder(297), decodeResult: decoder(298) }, { operation: "application_test_results", operationId: "operation.application.test_results", transport: { kind: "http", route: "/application/tests/results", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.test_results.v1", requestSchema: { schemaId: "schema.application.feedback.test-results.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.test-results.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":15000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(297), decodeResult: decoder(298), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(298)) }, + decodeRequest: decoder(299), decodeResult: decoder(300), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(300)) }, { operation: "test_risk", operationId: "operation.application.test_risk", transport: { kind: "mcp_tool", toolName: "tracedecay_test_risk" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_risk.v1", requestSchema: { schemaId: "schema.application.primitive.test-risk.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-risk.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(299), decodeResult: decoder(300) }, + decodeRequest: decoder(301), decodeResult: decoder(302) }, { operation: "todos", operationId: "operation.application.todos", transport: { kind: "mcp_tool", toolName: "tracedecay_todos" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.todos.v1", requestSchema: { schemaId: "schema.application.primitive.todos.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.todos.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(301), decodeResult: decoder(302) }, + decodeRequest: decoder(303), decodeResult: decoder(304) }, { operation: "unmounted_files", operationId: "operation.application.unmounted_files", transport: { kind: "mcp_tool", toolName: "tracedecay_unmounted_files" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.unmounted_files.v1", requestSchema: { schemaId: "schema.application.primitive.unmounted-files.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.unmounted-files.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(303), decodeResult: decoder(304) }, + decodeRequest: decoder(305), decodeResult: decoder(306) }, { operation: "unsafe_patterns", operationId: "operation.application.unsafe_patterns", transport: { kind: "mcp_tool", toolName: "tracedecay_unsafe_patterns" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.unsafe_patterns.v1", requestSchema: { schemaId: "schema.application.primitive.unsafe-patterns.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.unsafe-patterns.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(305), decodeResult: decoder(306) }, + decodeRequest: decoder(307), decodeResult: decoder(308) }, { operation: "application_workflows", operationId: "operation.application.workflows", transport: { kind: "http", route: "/application/retained/workflows", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflows.v1", requestSchema: { schemaId: "schema.application.retained.workflows.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.workflows.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"], - decodeRequest: decoder(307), decodeResult: decoder(308), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(308)) }, + decodeRequest: decoder(309), decodeResult: decoder(310), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(310)) }, { operation: "application_worktree_cleanup_confirm", operationId: "operation.application.worktree_cleanup_confirm", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_confirm", method: "POST" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_confirm.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-confirm.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-confirm.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(309), decodeResult: decoder(15), + decodeRequest: decoder(311), decodeResult: decoder(15), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_confirm.v1", "schema.application.native-integration.worktree-cleanup-confirm.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(15)) }, { operation: "application_worktree_cleanup_inspect", operationId: "operation.application.worktree_cleanup_inspect", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_inspect", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_inspect.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(310), decodeResult: decoder(15), + decodeRequest: decoder(312), decodeResult: decoder(15), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_inspect.v1", "schema.application.native-integration.worktree-cleanup-inspect.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(15)) }, { operation: "application_worktree_cleanup_reconcile", operationId: "operation.application.worktree_cleanup_reconcile", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_reconcile", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_reconcile.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(311), decodeResult: decoder(15), + decodeRequest: decoder(313), decodeResult: decoder(15), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_reconcile.v1", "schema.application.native-integration.worktree-cleanup-reconcile.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(15)) }, { operation: "application_worktree_cleanup_remove", operationId: "operation.application.worktree_cleanup_remove", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_remove", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_remove.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(312), decodeResult: decoder(15), + decodeRequest: decoder(314), decodeResult: decoder(15), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_remove.v1", "schema.application.native-integration.worktree-cleanup-remove.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(15)) }, { operation: "application_worktree_inventory", operationId: "operation.application.worktree_inventory", transport: { kind: "http", route: "/application/native-integration/worktree_inventory", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_inventory.v1", requestSchema: { schemaId: "schema.application.native-integration.worktree-inventory.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-inventory.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(313), decodeResult: decoder(15), + decodeRequest: decoder(315), decodeResult: decoder(15), decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_inventory.v1", "schema.application.native-integration.worktree-inventory.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(15)) }, { operation: "handoff_issue_task_handoff", operationId: "operation.handoff.issue_task_handoff", transport: { kind: "http", route: "/application/handoff/issue-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.issue_task_handoff", requestSchema: { schemaId: "schema.handoff.issue_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.issue_task_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(314), decodeResult: decoder(315), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(315)) }, + decodeRequest: decoder(316), decodeResult: decoder(317), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(317)) }, { operation: "handoff_list_task_handoffs", operationId: "operation.handoff.list_task_handoffs", transport: { kind: "http", route: "/application/handoff/list-task", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.list_task_handoffs", requestSchema: { schemaId: "schema.handoff.list_task_handoffs.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.list_task_handoffs.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","partial"], - decodeRequest: decoder(316), decodeResult: decoder(317), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder(317)) }, + decodeRequest: decoder(318), decodeResult: decoder(319), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder(319)) }, { operation: "handoff_open_investigation_handoff", operationId: "operation.handoff.open_investigation_handoff", transport: { kind: "http", route: "/application/handoff/open-investigation", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.open_investigation_handoff", requestSchema: { schemaId: "schema.handoff.open_investigation_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.open_investigation_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(318), decodeResult: decoder(319), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(319)) }, + decodeRequest: decoder(320), decodeResult: decoder(321), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(321)) }, { operation: "handoff_open_task_handoff", operationId: "operation.handoff.open_task_handoff", transport: { kind: "http", route: "/application/handoff/open-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.open_task_handoff", requestSchema: { schemaId: "schema.handoff.open_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.open_task_handoff.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(320), decodeResult: decoder(321), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(321)) }, + decodeRequest: decoder(322), decodeResult: decoder(323), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(323)) }, { operation: "multi_root_execute", operationId: "operation.multi_root.execute", transport: { kind: "http", route: "/application/multi-root/execute", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.execute.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.execute-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.execute-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(322), decodeResult: decoder(323), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(323)) }, + decodeRequest: decoder(324), decodeResult: decoder(325), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(325)) }, { operation: "multi_root_scope_set_compare_and_swap", operationId: "operation.multi_root.scope_set_compare_and_swap", transport: { kind: "http", route: "/application/multi-root/scope-set/compare-and-swap", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.scope_set_compare_and_swap.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-compare-and-swap-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(324), decodeResult: decoder(325), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(325)) }, + decodeRequest: decoder(326), decodeResult: decoder(327), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(327)) }, { operation: "multi_root_scope_set_read", operationId: "operation.multi_root.scope_set_read", transport: { kind: "http", route: "/application/multi-root/scope-set/read", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.multi_root.scope_set_read.v1", requestSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-read-request.v1", revision: 1 }, resultSchema: { schemaId: "schema.tracedecay.multi-root.scope-set-read-result.v1", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(326), decodeResult: decoder(327), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(327)) }, + decodeRequest: decoder(328), decodeResult: decoder(329), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(329)) }, { operation: "work_accept_proposal", operationId: "operation.work.accept_proposal", transport: { kind: "http", route: "/application/work/accept-proposal", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.accept_proposal", requestSchema: { schemaId: "schema.work.accept_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.accept_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(328), decodeResult: decoder(329), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, + decodeRequest: decoder(330), decodeResult: decoder(331), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, { operation: "work_adjudicate_duplicate", operationId: "operation.work.adjudicate_duplicate", transport: { kind: "http", route: "/application/work/adjudicate-duplicate", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.adjudicate_duplicate", requestSchema: { schemaId: "schema.work.adjudicate_duplicate.request", revision: 1 }, resultSchema: { schemaId: "schema.work.adjudicate_duplicate.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(330), decodeResult: decoder(331), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, + decodeRequest: decoder(332), decodeResult: decoder(333), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, { operation: "work_adjudicate_leak", operationId: "operation.work.adjudicate_leak", transport: { kind: "http", route: "/application/work/adjudicate-leak", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.adjudicate_leak", requestSchema: { schemaId: "schema.work.adjudicate_leak.request", revision: 1 }, resultSchema: { schemaId: "schema.work.adjudicate_leak.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(332), decodeResult: decoder(333), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(333)) }, + decodeRequest: decoder(334), decodeResult: decoder(335), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, { operation: "work_admit_execution", operationId: "operation.work.admit_execution", transport: { kind: "http", route: "/application/work/admit-execution", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.admit_execution", requestSchema: { schemaId: "schema.work.admit_execution.request", revision: 1 }, resultSchema: { schemaId: "schema.work.admit_execution.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(334), decodeResult: decoder(335), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(335)) }, + decodeRequest: decoder(336), decodeResult: decoder(337), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, { operation: "work_admit_placement", operationId: "operation.work.admit_placement", transport: { kind: "http", route: "/application/work/admit-placement", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.admit_placement", requestSchema: { schemaId: "schema.work.admit_placement.request", revision: 1 }, resultSchema: { schemaId: "schema.work.admit_placement.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(336), decodeResult: decoder(337), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, + decodeRequest: decoder(338), decodeResult: decoder(339), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(339)) }, { operation: "work_attempt_status", operationId: "operation.work.attempt_status", transport: { kind: "http", route: "/application/work/attempt-status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.attempt_status", requestSchema: { schemaId: "schema.work.attempt_status.request", revision: 1 }, resultSchema: { schemaId: "schema.work.attempt_status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(338), decodeResult: decoder(339), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(339)) }, + decodeRequest: decoder(340), decodeResult: decoder(341), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(341)) }, { operation: "work_cancel_attempt", operationId: "operation.work.cancel_attempt", transport: { kind: "http", route: "/application/work/cancel-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.cancel_attempt", requestSchema: { schemaId: "schema.work.cancel_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.cancel_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(340), decodeResult: decoder(339), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(339)) }, + decodeRequest: decoder(342), decodeResult: decoder(341), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(341)) }, { operation: "work_compare_proposal", operationId: "operation.work.compare_proposal", transport: { kind: "http", route: "/application/work/compare-proposal", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.compare_proposal", requestSchema: { schemaId: "schema.work.compare_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.compare_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(341), decodeResult: decoder(342), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(342)) }, + decodeRequest: decoder(343), decodeResult: decoder(344), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(344)) }, { operation: "work_create", operationId: "operation.work.create", transport: { kind: "http", route: "/application/work/create", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.create", requestSchema: { schemaId: "schema.work.create.request", revision: 1 }, resultSchema: { schemaId: "schema.work.create.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(343), decodeResult: decoder(329), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, + decodeRequest: decoder(345), decodeResult: decoder(331), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, { operation: "work_execution_history", operationId: "operation.work.execution_history", transport: { kind: "http", route: "/application/work/execution-history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.execution_history", requestSchema: { schemaId: "schema.work.execution_history.request", revision: 1 }, resultSchema: { schemaId: "schema.work.execution_history.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(344), decodeResult: decoder(345), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(345)) }, + decodeRequest: decoder(346), decodeResult: decoder(347), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(347)) }, { operation: "work_experience", operationId: "operation.work.experience", transport: { kind: "http", route: "/application/work/experience", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.experience", requestSchema: { schemaId: "schema.work.experience.request", revision: 1 }, resultSchema: { schemaId: "schema.work.experience.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(346), decodeResult: decoder(347), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(347)) }, + decodeRequest: decoder(348), decodeResult: decoder(349), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(349)) }, { operation: "work_generate_proposal", operationId: "operation.work.generate_proposal", transport: { kind: "http", route: "/application/work/generate-proposal", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.generate_proposal", requestSchema: { schemaId: "schema.work.generate_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.generate_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(348), decodeResult: decoder(349), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(349)) }, + decodeRequest: decoder(350), decodeResult: decoder(351), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(351)) }, { operation: "work_hydrate_artifacts", operationId: "operation.work.hydrate_artifacts", transport: { kind: "http", route: "/application/work/hydrate-artifacts", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.hydrate_artifacts", requestSchema: { schemaId: "schema.work.hydrate_artifacts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.hydrate_artifacts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(350), decodeResult: decoder(351), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(351)) }, + decodeRequest: decoder(352), decodeResult: decoder(353), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(353)) }, { operation: "work_list_attempts", operationId: "operation.work.list_attempts", transport: { kind: "http", route: "/application/work/list-attempts", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.list_attempts", requestSchema: { schemaId: "schema.work.list_attempts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.list_attempts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(344), decodeResult: decoder(352), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(352)) }, + decodeRequest: decoder(346), decodeResult: decoder(354), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(354)) }, { operation: "work_mutate_graph", operationId: "operation.work.mutate_graph", transport: { kind: "http", route: "/application/work/mutate-graph", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.mutate_graph", requestSchema: { schemaId: "schema.work.mutate_graph.request", revision: 1 }, resultSchema: { schemaId: "schema.work.mutate_graph.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(353), decodeResult: decoder(329), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, + decodeRequest: decoder(355), decodeResult: decoder(331), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, { operation: "work_pause_run", operationId: "operation.work.pause_run", transport: { kind: "http", route: "/application/work/pause-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.pause_run", requestSchema: { schemaId: "schema.work.pause_run.request", revision: 1 }, resultSchema: { schemaId: "schema.work.pause_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(354), decodeResult: decoder(355), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(355)) }, + decodeRequest: decoder(356), decodeResult: decoder(357), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(357)) }, { operation: "work_placement_preflight", operationId: "operation.work.placement_preflight", transport: { kind: "http", route: "/application/work/placement-preflight", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.placement_preflight", requestSchema: { schemaId: "schema.work.placement_preflight.request", revision: 1 }, resultSchema: { schemaId: "schema.work.placement_preflight.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(356), decodeResult: decoder(357), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(357)) }, + decodeRequest: decoder(358), decodeResult: decoder(359), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(359)) }, { operation: "work_placement_status", operationId: "operation.work.placement_status", transport: { kind: "http", route: "/application/work/placement-status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.placement_status", requestSchema: { schemaId: "schema.work.placement_status.request", revision: 1 }, resultSchema: { schemaId: "schema.work.placement_status.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(358), decodeResult: decoder(359), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(359)) }, + decodeRequest: decoder(360), decodeResult: decoder(361), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(361)) }, { operation: "work_prepare_duplicate_adjudication", operationId: "operation.work.prepare_duplicate_adjudication", transport: { kind: "http", route: "/application/work/prepare-duplicate-adjudication", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.prepare_duplicate_adjudication", requestSchema: { schemaId: "schema.work.prepare_duplicate_adjudication.request", revision: 1 }, resultSchema: { schemaId: "schema.work.prepare_duplicate_adjudication.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(360), decodeResult: decoder(330), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(330)) }, + decodeRequest: decoder(362), decodeResult: decoder(332), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(332)) }, { operation: "work_prepare_graph_mutation", operationId: "operation.work.prepare_graph_mutation", transport: { kind: "http", route: "/application/work/prepare-graph-mutation", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.prepare_graph_mutation", requestSchema: { schemaId: "schema.work.prepare_graph_mutation.request", revision: 1 }, resultSchema: { schemaId: "schema.work.prepare_graph_mutation.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(361), decodeResult: decoder(353), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(353)) }, + decodeRequest: decoder(363), decodeResult: decoder(355), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(355)) }, { operation: "work_release_placement", operationId: "operation.work.release_placement", transport: { kind: "http", route: "/application/work/release-placement", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.release_placement", requestSchema: { schemaId: "schema.work.release_placement.request", revision: 1 }, resultSchema: { schemaId: "schema.work.release_placement.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(362), decodeResult: decoder(337), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(337)) }, + decodeRequest: decoder(364), decodeResult: decoder(339), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(339)) }, { operation: "work_resume_attempts", operationId: "operation.work.resume_attempts", transport: { kind: "http", route: "/application/work/resume-attempts", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.resume_attempts", requestSchema: { schemaId: "schema.work.resume_attempts.request", revision: 1 }, resultSchema: { schemaId: "schema.work.resume_attempts.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(363), decodeResult: decoder(364), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(364)) }, + decodeRequest: decoder(365), decodeResult: decoder(366), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(366)) }, { operation: "work_resume_run", operationId: "operation.work.resume_run", transport: { kind: "http", route: "/application/work/resume-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.resume_run", requestSchema: { schemaId: "schema.work.resume_run.request", revision: 1 }, resultSchema: { schemaId: "schema.work.resume_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(365), decodeResult: decoder(355), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(355)) }, + decodeRequest: decoder(367), decodeResult: decoder(357), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(357)) }, { operation: "work_retrieve_evidence", operationId: "operation.work.retrieve_evidence", transport: { kind: "http", route: "/application/work/retrieve-evidence", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.retrieve_evidence", requestSchema: { schemaId: "schema.work.retrieve_evidence.request", revision: 1 }, resultSchema: { schemaId: "schema.work.retrieve_evidence.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(366), decodeResult: decoder(367), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(367)) }, + decodeRequest: decoder(368), decodeResult: decoder(369), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(369)) }, { operation: "work_retry_attempt", operationId: "operation.work.retry_attempt", transport: { kind: "http", route: "/application/work/retry-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.retry_attempt", requestSchema: { schemaId: "schema.work.retry_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.retry_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(368), decodeResult: decoder(369), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(369)) }, + decodeRequest: decoder(370), decodeResult: decoder(371), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(371)) }, { operation: "work_review_proposal", operationId: "operation.work.review_proposal", transport: { kind: "http", route: "/application/work/review-proposal", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.review_proposal", requestSchema: { schemaId: "schema.work.review_proposal.request", revision: 1 }, resultSchema: { schemaId: "schema.work.review_proposal.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(370), decodeResult: decoder(329), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(329)) }, + decodeRequest: decoder(372), decodeResult: decoder(331), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(331)) }, { operation: "work_run_control", operationId: "operation.work.run_control", transport: { kind: "http", route: "/application/work/run-control", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.run_control", requestSchema: { schemaId: "schema.work.run_control.request", revision: 1 }, resultSchema: { schemaId: "schema.work.run_control.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(371), decodeResult: decoder(372), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(372)) }, + decodeRequest: decoder(373), decodeResult: decoder(374), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(374)) }, { operation: "work_start_attempt", operationId: "operation.work.start_attempt", transport: { kind: "http", route: "/application/work/start-attempt", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.start_attempt", requestSchema: { schemaId: "schema.work.start_attempt.request", revision: 1 }, resultSchema: { schemaId: "schema.work.start_attempt.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(373), decodeResult: decoder(339), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(339)) }, + decodeRequest: decoder(375), decodeResult: decoder(341), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(341)) }, { operation: "work_synthesize", operationId: "operation.work.synthesize", transport: { kind: "http", route: "/application/work/synthesize", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.synthesize", requestSchema: { schemaId: "schema.work.synthesize.request", revision: 1 }, resultSchema: { schemaId: "schema.work.synthesize.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(374), decodeResult: decoder(375), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(375)) }, + decodeRequest: decoder(376), decodeResult: decoder(377), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder(377)) }, { operation: "work_topology", operationId: "operation.work.topology", transport: { kind: "http", route: "/application/work/topology", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.topology", requestSchema: { schemaId: "schema.work.topology.request", revision: 1 }, resultSchema: { schemaId: "schema.work.topology.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(376), decodeResult: decoder(377), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(377)) }, + decodeRequest: decoder(378), decodeResult: decoder(379), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(379)) }, { operation: "work_topology_metrics", operationId: "operation.work.topology_metrics", transport: { kind: "http", route: "/application/work/topology-metrics", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.topology_metrics", requestSchema: { schemaId: "schema.work.topology_metrics.request", revision: 1 }, resultSchema: { schemaId: "schema.work.topology_metrics.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(378), decodeResult: decoder(379), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(379)) }, + decodeRequest: decoder(380), decodeResult: decoder(381), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(381)) }, { operation: "work_views", operationId: "operation.work.views", transport: { kind: "http", route: "/application/work/views", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.work.views", requestSchema: { schemaId: "schema.work.views.request", revision: 1 }, resultSchema: { schemaId: "schema.work.views.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(380), decodeResult: decoder(381), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(381)) }, + decodeRequest: decoder(382), decodeResult: decoder(383), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(383)) }, { operation: "workflow_activate_definition", operationId: "operation.workflow.activate_definition", transport: { kind: "http", route: "/application/workflow/activate-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.activate_definition", requestSchema: { schemaId: "schema.workflow.activate_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.activate_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(382), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(384), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_cancel_run", operationId: "operation.workflow.cancel_run", transport: { kind: "http", route: "/application/workflow/cancel-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.cancel_run", requestSchema: { schemaId: "schema.workflow.cancel_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.cancel_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(384), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, + decodeRequest: decoder(386), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(387)) }, { operation: "workflow_definition_history", operationId: "operation.workflow.definition_history", transport: { kind: "http", route: "/application/workflow/definition-history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.definition_history", requestSchema: { schemaId: "schema.workflow.definition_history.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.definition_history.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(386), decodeResult: decoder(387), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, + decodeRequest: decoder(388), decodeResult: decoder(389), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(389)) }, { operation: "workflow_diff_definition", operationId: "operation.workflow.diff_definition", transport: { kind: "http", route: "/application/workflow/diff-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.diff_definition", requestSchema: { schemaId: "schema.workflow.diff_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.diff_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(388), decodeResult: decoder(389), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(389)) }, + decodeRequest: decoder(390), decodeResult: decoder(391), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(391)) }, { operation: "workflow_get_definition", operationId: "operation.workflow.get_definition", transport: { kind: "http", route: "/application/workflow/get-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.get_definition", requestSchema: { schemaId: "schema.workflow.get_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.get_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(390), decodeResult: decoder(391), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(391)) }, + decodeRequest: decoder(392), decodeResult: decoder(393), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(393)) }, { operation: "workflow_get_run", operationId: "operation.workflow.get_run", transport: { kind: "http", route: "/application/workflow/get-run", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.get_run", requestSchema: { schemaId: "schema.workflow.get_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.get_run.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(392), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(385)) }, + decodeRequest: decoder(394), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, { operation: "workflow_handoff_issue", operationId: "operation.workflow.handoff_issue", transport: { kind: "http", route: "/application/workflow/handoff-issue", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.handoff_issue", requestSchema: { schemaId: "schema.workflow.handoff_issue.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.handoff_issue.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(393), decodeResult: decoder(394), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(394)) }, + decodeRequest: decoder(395), decodeResult: decoder(396), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(396)) }, { operation: "workflow_handoff_redeem", operationId: "operation.workflow.handoff_redeem", transport: { kind: "http", route: "/application/workflow/handoff-redeem", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.handoff_redeem", requestSchema: { schemaId: "schema.workflow.handoff_redeem.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.handoff_redeem.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(395), decodeResult: decoder(396), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(396)) }, + decodeRequest: decoder(397), decodeResult: decoder(398), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(398)) }, { operation: "workflow_list_definitions", operationId: "operation.workflow.list_definitions", transport: { kind: "http", route: "/application/workflow/list-definitions", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.list_definitions", requestSchema: { schemaId: "schema.workflow.list_definitions.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.list_definitions.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(397), decodeResult: decoder(387), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(387)) }, + decodeRequest: decoder(399), decodeResult: decoder(389), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(389)) }, { operation: "workflow_pause_run", operationId: "operation.workflow.pause_run", transport: { kind: "http", route: "/application/workflow/pause-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.pause_run", requestSchema: { schemaId: "schema.workflow.pause_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.pause_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(398), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, + decodeRequest: decoder(400), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(387)) }, { operation: "workflow_register_definition", operationId: "operation.workflow.register_definition", transport: { kind: "http", route: "/application/workflow/register-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.register_definition", requestSchema: { schemaId: "schema.workflow.register_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.register_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(399), decodeResult: decoder(391), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(391)) }, + decodeRequest: decoder(401), decodeResult: decoder(393), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(393)) }, { operation: "workflow_reject_definition", operationId: "operation.workflow.reject_definition", transport: { kind: "http", route: "/application/workflow/reject-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.reject_definition", requestSchema: { schemaId: "schema.workflow.reject_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.reject_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(400), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(402), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_resume_run", operationId: "operation.workflow.resume_run", transport: { kind: "http", route: "/application/workflow/resume-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.resume_run", requestSchema: { schemaId: "schema.workflow.resume_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.resume_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(401), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, + decodeRequest: decoder(403), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(387)) }, { operation: "workflow_retire_definition", operationId: "operation.workflow.retire_definition", transport: { kind: "http", route: "/application/workflow/retire-definition", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.retire_definition", requestSchema: { schemaId: "schema.workflow.retire_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.retire_definition.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(402), decodeResult: decoder(383), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(383)) }, + decodeRequest: decoder(404), decodeResult: decoder(385), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, { operation: "workflow_start_run", operationId: "operation.workflow.start_run", transport: { kind: "http", route: "/application/workflow/start-run", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.start_run", requestSchema: { schemaId: "schema.workflow.start_run.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.start_run.result", revision: 1 }, cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"], - decodeRequest: decoder(403), decodeResult: decoder(385), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(385)) }, + decodeRequest: decoder(405), decodeResult: decoder(387), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder(387)) }, { operation: "workflow_validate_definition", operationId: "operation.workflow.validate_definition", transport: { kind: "http", route: "/application/workflow/validate-definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.workflow.validate_definition", requestSchema: { schemaId: "schema.workflow.validate_definition.request", revision: 1 }, resultSchema: { schemaId: "schema.workflow.validate_definition.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"], - decodeRequest: decoder(404), decodeResult: decoder(405), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(405)) }, + decodeRequest: decoder(406), decodeResult: decoder(407), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(407)) }, ] as const; export type Operation = (typeof OPERATIONS)[number]; From 568a06d7d18d96432a3416655e108924bcdb1825 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 21:16:25 +0000 Subject: [PATCH 09/10] fix(daemon): hold hook evidence until the session owner registers --- .../src/retrieval/hook_runtime_surface.rs | 8 ++++++++ .../retrieval/hook_runtime_surface/tests.rs | 14 ++++++++++++++ .../tracedecay-contracts/src/retrieval/mod.rs | 1 + .../src/daemon/invocation_dispatch.rs | 2 +- .../src/daemon/project_open_admission.rs | 19 +++++++++++-------- .../src/mcp/server/graph_tool_owner.rs | 12 +++++++++++- 6 files changed, 46 insertions(+), 10 deletions(-) diff --git a/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs index baa718cbce..1c06907c76 100644 --- a/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs +++ b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface.rs @@ -55,6 +55,14 @@ pub enum HookRuntimeSurfaceRequestV1 { HookV2ProfileAdmit { admission: Value }, } +/// Whether a hook call records session evidence, so it needs the session +/// stores only the project's full server mounts. Resetting the local counter +/// is the one action that does not; anything else, including a request that +/// does not decode, waits for them. +pub fn hook_runtime_needs_session_stores(arguments: &serde_json::Map) -> bool { + arguments.get("action").and_then(Value::as_str) != Some("reset_counter") +} + #[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)] #[serde(deny_unknown_fields)] pub struct HookV2AdmitRequestV1 { diff --git a/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs index 6e0bb161d1..2f141ef922 100644 --- a/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs +++ b/crates/tracedecay-contracts/src/retrieval/hook_runtime_surface/tests.rs @@ -165,3 +165,17 @@ fn requests_accept_what_hosts_send_and_refuse_anything_else() { .contains("unknown variant `hook_v2_status`") ); } + +#[test] +fn only_a_counter_reset_skips_the_session_stores() { + let needs = |arguments: Value| { + super::hook_runtime_needs_session_stores(arguments.as_object().expect("object arguments")) + }; + assert!(!needs(json!({"action": "reset_counter"}))); + assert!(needs( + json!({"action": "ingest_transcript", "user_scope": false}) + )); + assert!(needs(json!({"action": "hook_v2_admit"}))); + assert!(needs(json!({"action": 42}))); + assert!(needs(json!({}))); +} diff --git a/crates/tracedecay-contracts/src/retrieval/mod.rs b/crates/tracedecay-contracts/src/retrieval/mod.rs index ac69c4a055..8bbafd2e6f 100644 --- a/crates/tracedecay-contracts/src/retrieval/mod.rs +++ b/crates/tracedecay-contracts/src/retrieval/mod.rs @@ -204,6 +204,7 @@ pub use hook_runtime_surface::{ HookRuntimeAcceptedV1, HookRuntimeDispositionV1, HookRuntimeResultV1, HookRuntimeSurfaceRequestV1, HookV2AdmissionResultV1, HookV2AdmitRequestV1, HookV2NoticeDeliveryResultV1, HookV2ProfileAdmissionResultV1, HookV2RejectionReasonV1, + hook_runtime_needs_session_stores, }; pub use owner_effect_surface::{ AdminSyncAdmissionV1, AdminSyncReconcileScopeV1, AdminSyncResultV1, AdminSyncSurfaceRequestV1, diff --git a/crates/tracedecay/src/daemon/invocation_dispatch.rs b/crates/tracedecay/src/daemon/invocation_dispatch.rs index 981b510e66..be2669d4e8 100644 --- a/crates/tracedecay/src/daemon/invocation_dispatch.rs +++ b/crates/tracedecay/src/daemon/invocation_dispatch.rs @@ -384,7 +384,7 @@ pub(super) async fn execute_portable_daemon_invocation( surface_operation: tracedecay_tool_catalog::ApplicationSurfaceOperation::HookRuntime, arguments, .. - } => super::project_open_admission::hook_runtime_requirement(arguments.get("action")), + } => super::project_open_admission::hook_runtime_requirement(Some(arguments)), _ => ProjectServerRequirement::Core, }; if request.requires_project() { diff --git a/crates/tracedecay/src/daemon/project_open_admission.rs b/crates/tracedecay/src/daemon/project_open_admission.rs index 111e662042..255c8d9a77 100644 --- a/crates/tracedecay/src/daemon/project_open_admission.rs +++ b/crates/tracedecay/src/daemon/project_open_admission.rs @@ -1078,7 +1078,7 @@ pub(super) fn project_server_requirement( == tracedecay_tool_catalog::ApplicationSurfaceOperation::HookRuntime .mcp_tool_name() => { - hook_runtime_requirement(arguments.get("action")) + hook_runtime_requirement(arguments.as_object()) } _ => ProjectServerRequirement::Core, }, @@ -1086,15 +1086,18 @@ pub(super) fn project_server_requirement( } } -/// A hook action records host evidence through the session stores only the -/// full server mounts; resetting the local counter needs only the core one. +/// The server a hook call needs: the full one whose session stores it +/// records evidence in, or the core one for an action that records none. pub(super) fn hook_runtime_requirement( - action: Option<&serde_json::Value>, + arguments: Option<&serde_json::Map>, ) -> ProjectServerRequirement { - if action.and_then(serde_json::Value::as_str) == Some("reset_counter") { - ProjectServerRequirement::Core - } else { - ProjectServerRequirement::RegisteredHostIngest + match arguments { + Some(arguments) + if !tracedecay_contracts::retrieval::hook_runtime_needs_session_stores(arguments) => + { + ProjectServerRequirement::Core + } + _ => ProjectServerRequirement::RegisteredHostIngest, } } diff --git a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs index 897162108d..c213095327 100644 --- a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs +++ b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs @@ -5,9 +5,10 @@ use std::path::Path; use std::sync::{Arc, Weak}; +use tracedecay_contracts::ApplicationProblem; use tracedecay_contracts::ResolvedScope; use tracedecay_contracts::graph_tool::GraphToolResultV1; -use tracedecay_contracts::retrieval::HookRuntimeResultV1; +use tracedecay_contracts::retrieval::{HookRuntimeResultV1, hook_runtime_needs_session_stores}; use tracedecay_daemon_service::{ DaemonInvocationService, GraphToolFuture, GraphToolInvocationV1, ProjectGraphToolPortV1, RegisteredGraphToolOwnerV1, @@ -35,6 +36,15 @@ impl ProjectGraphToolPortV1 for McpGraphToolPort { "the MCP server was released before the graph read was admitted", ))); }; + // Project open registers the core server as owner before the + // full server, which mounts the session stores, replaces it. A + // hook that records session evidence meanwhile is still mounting. + if invocation.operation == ApplicationSurfaceOperation::HookRuntime + && server.project_session_db.is_none() + && hook_runtime_needs_session_stores(&invocation.arguments) + { + return Err(ApplicationProblem::runtime_mounting()); + } server .compute_graph_tool(invocation) .await From 6db8cc59f2f61ceb82197becc1ec99732a9a5c5f Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 21:51:28 +0000 Subject: [PATCH 10/10] test(mcp): name the git group in the dispatch registry check --- crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs b/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs index f29e6b31ab..be26b4f758 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs @@ -331,7 +331,7 @@ async fn advertised_tools_resolve_one_concrete_dispatch_entry() { "{} has no canonical Workflow operation entry", definition.name ), - group => { + group @ McpToolDispatchGroup::Git => { assert_eq!( dispatch_group_for_tool(&definition.name), Some(group),