From bbbc8aea599c0af1b03c7d0fc6efd90ca78fdeb1 Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Sun, 27 Sep 2026 08:02:25 +0000 Subject: [PATCH] refactor(mcp): run affected tests and the dashboard through the owner The graph-tool owner's catalog gains a typed side-effect entry kind. The tool-catalog operation's OwnerSideEffectEntryV1 names what the call does (EffectClass::SpawnsProcess or BindsServer), its dispatch ceiling (the long-running ten-minute ceiling for a test run, the interactive ceiling for the dashboard), and that identical concurrent calls each run. The capability manifest takes its effect class, cancellation, and deadline from that entry, settles within the call (operation receipt, no idempotency key), and the MCP dispatch contract, the dispatch ceiling, and the identical-read coalescer all read it. The tools migrated earlier stay read entries. tracedecay_run_affected_tests and tracedecay_dashboard are owner-served operations with typed requests and results. An unknown key, a mistyped changed path, an unknown profile, or an out-of-range port is refused instead of being ignored or silently defaulted. The dashboard's daemon-owned readers, writers, and session authorities reach it through the owner's existing tool context. The session-workflow dispatch group, its binding row, and the name-keyed effect, cancellation, and ceiling rules for both tools are deleted. --- .../src/http/application_operation_owner.rs | 4 +- .../src/capability_manifest.rs | 9 +- crates/tracedecay-contracts/src/graph_tool.rs | 25 +- crates/tracedecay-contracts/src/policy.rs | 12 +- .../src/retrieval/catalog.rs | 121 +++- .../tracedecay-contracts/src/retrieval/mod.rs | 7 + .../src/retrieval/owner_effect_surface.rs | 164 +++++ .../tracedecay-contracts/src/sdk_catalog.rs | 4 +- .../src/application_surface.rs | 4 +- .../src/application_surface/invocation.rs | 2 + .../src/contract/mod.rs | 4 +- .../tracedecay-mcp-catalog/src/definitions.rs | 4 +- .../src/definitions/admin.rs | 21 +- .../src/definitions/application.rs | 2 + .../src/definitions/testing.rs | 37 +- .../tracedecay-mcp/src/handlers/workflow.rs | 184 +++--- .../workflow/affected_test_failure.rs | 33 +- .../handlers/workflow/affected_tests_tests.rs | 73 ++- .../src/server/read_coalescing.rs | 7 + crates/tracedecay-mcp/src/tools/binding.rs | 42 +- .../src/tools/catalog_discovery.rs | 13 +- .../src/tools/dispatch_ceiling.rs | 11 +- crates/tracedecay-mcp/src/workflow/mod.rs | 1 + .../src/workflow/test_request.rs | 134 ++-- crates/tracedecay-tool-catalog/src/lib.rs | 5 + .../tracedecay-tool-catalog/src/manifest.rs | 26 +- .../tracedecay-tool-catalog/src/operation.rs | 4 + .../src/owner_side_effect.rs | 87 +++ .../src/mcp/server/graph_tool_owner.rs | 29 + .../src/mcp/tools/handlers/dashboard.rs | 114 ++-- .../src/mcp/tools/handlers/dispatch_groups.rs | 82 +-- .../tools/handlers/dispatch_test_support.rs | 3 - .../tracedecay/src/mcp/tools/handlers/mod.rs | 8 +- .../mcp_suite/mcp_dashboard_tool_test.rs | 131 ++-- .../affected_tests_behavior_test.rs | 141 ++++- .../mcp_handler_test/graph_analysis_test.rs | 22 - .../schemas/dashboard-contracts.schema.json | 36 +- dashboard/src/contracts/generated.ts | 2 +- sdks/typescript/src/operations.ts | 578 +++++++++--------- 39 files changed, 1293 insertions(+), 893 deletions(-) create mode 100644 crates/tracedecay-contracts/src/retrieval/owner_effect_surface.rs create mode 100644 crates/tracedecay-tool-catalog/src/owner_side_effect.rs diff --git a/crates/tracedecay-api/src/http/application_operation_owner.rs b/crates/tracedecay-api/src/http/application_operation_owner.rs index 44bacbed3a..e56d227e30 100644 --- a/crates/tracedecay-api/src/http/application_operation_owner.rs +++ b/crates/tracedecay-api/src/http/application_operation_owner.rs @@ -157,7 +157,9 @@ pub const fn http_application_owner_kind( | ApplicationSurfaceOperation::SkillView | ApplicationSurfaceOperation::HermesSkillBridge | ApplicationSurfaceOperation::Analytics - | ApplicationSurfaceOperation::Search => return None, + | ApplicationSurfaceOperation::Search + | ApplicationSurfaceOperation::RunAffectedTests + | ApplicationSurfaceOperation::Dashboard => return None, ApplicationSurfaceOperation::FactStoreCurate | ApplicationSurfaceOperation::FactStoreAdd | ApplicationSurfaceOperation::FactStoreSearch diff --git a/crates/tracedecay-contracts/src/capability_manifest.rs b/crates/tracedecay-contracts/src/capability_manifest.rs index bf91206225..1655be2f76 100644 --- a/crates/tracedecay-contracts/src/capability_manifest.rs +++ b/crates/tracedecay-contracts/src/capability_manifest.rs @@ -34,7 +34,10 @@ pub(crate) struct ApplicationCapabilityManifestInput { pub(crate) fn application_capability_manifest( input: ApplicationCapabilityManifestInput, ) -> Result { + // Owner side effects settle within the call, so they carry the read + // receipt shape rather than a durable, idempotent effect journey. let is_effect = input.effect.is_effect(); + let durable_effect = is_effect && !input.effect.is_owner_side_effect(); CapabilityManifestV1::new(CapabilityManifestInputV1 { capability_id: input.capability_id, use_case_id: input.use_case_id, @@ -51,7 +54,7 @@ pub(crate) fn application_capability_manifest( cancellation: input.cancellation, deadline: input.deadline, pagination: input.pagination, - idempotency: if is_effect { + idempotency: if durable_effect { IdempotencyContract::Required } else { IdempotencyContract::NotRequired @@ -66,12 +69,12 @@ pub(crate) fn application_capability_manifest( } }), authority_revalidation: input.authority_revalidation, - reconciliation: if is_effect { + reconciliation: if durable_effect { ReconciliationContract::Required } else { ReconciliationContract::NotRequired }, - receipt: if is_effect { + receipt: if durable_effect { ReceiptContract::DurableEffect } else { ReceiptContract::Operation diff --git a/crates/tracedecay-contracts/src/graph_tool.rs b/crates/tracedecay-contracts/src/graph_tool.rs index 720d615e8c..5f5c185591 100644 --- a/crates/tracedecay-contracts/src/graph_tool.rs +++ b/crates/tracedecay-contracts/src/graph_tool.rs @@ -11,15 +11,16 @@ use crate::retrieval::{ AutomationRunListResultV1, AutomationRunViewResultV1, BranchDiffResultV1, BranchListResultV1, BranchSearchResultV1, ByQualifiedNameResultV1, ChangelogResultV1, CircularResultV1, CommitContextResultV1, ComplexityReportV1, ConfigResultV1, ConstructorsResultV1, - ContextResultV1, CouplingResultV1, DeadCodeResultV1, DependencyDepthResultV1, DerivesResultV1, - DiagnoseResultV1, DiffContextResultV1, DistributionResultV1, DocCoverageResultV1, DsmResultV1, - FieldSitesResultV1, FilesResultV1, FindExactSymbolResultV1, GiniResultV1, GodClassResultV1, - GrepSearchResultV1, HealthResultV1, HermesSkillBridgeResultV1, HotspotsResultV1, - ImpactResultV1, InheritanceDepthResultV1, LargestResultV1, NodeResultV1, PortOrderResultV1, - PortStatusResultV1, PrContextResultV1, RankResultV1, RecursionResultV1, RedundancyResultV1, - RenamePreviewPrimitiveOutcomeV1, RetrieveResultV1, SearchResultV1, SignatureResultV1, - SimilarResultV1, SkillListResultV1, SkillViewResultV1, TestMapResultV1, TestRiskResultV1, - TodosResultV1, UnmountedFilesResultV1, UnsafePatternsResultV1, + ContextResultV1, CouplingResultV1, DashboardResultV1, DeadCodeResultV1, + DependencyDepthResultV1, DerivesResultV1, DiagnoseResultV1, DiffContextResultV1, + DistributionResultV1, DocCoverageResultV1, DsmResultV1, FieldSitesResultV1, FilesResultV1, + FindExactSymbolResultV1, GiniResultV1, GodClassResultV1, GrepSearchResultV1, HealthResultV1, + HermesSkillBridgeResultV1, HotspotsResultV1, ImpactResultV1, InheritanceDepthResultV1, + LargestResultV1, NodeResultV1, PortOrderResultV1, PortStatusResultV1, PrContextResultV1, + RankResultV1, RecursionResultV1, RedundancyResultV1, RenamePreviewPrimitiveOutcomeV1, + RetrieveResultV1, RunAffectedTestsResultV1, SearchResultV1, SignatureResultV1, SimilarResultV1, + SkillListResultV1, SkillViewResultV1, TestMapResultV1, TestRiskResultV1, TodosResultV1, + UnmountedFilesResultV1, UnsafePatternsResultV1, }; /// One graph read's typed result, tagged by its operation. @@ -83,6 +84,8 @@ pub enum GraphToolResultV1 { HermesSkillBridge(Box), Analytics(Box), Search(Box), + RunAffectedTests(RunAffectedTestsResultV1), + Dashboard(DashboardResultV1), } impl GraphToolResultV1 { @@ -152,6 +155,8 @@ impl GraphToolResultV1 { Operation::HermesSkillBridge => Self::HermesSkillBridge(serde_json::from_value(value)?), Operation::Analytics => Self::Analytics(serde_json::from_value(value)?), Operation::Search => Self::Search(serde_json::from_value(value)?), + Operation::RunAffectedTests => Self::RunAffectedTests(serde_json::from_value(value)?), + Operation::Dashboard => Self::Dashboard(serde_json::from_value(value)?), operation => { return Err(serde::de::Error::custom(format!( "{} is not a graph-tool operation", @@ -221,6 +226,8 @@ impl GraphToolResultV1 { Self::HermesSkillBridge(result) => serde_json::to_value(result), Self::Analytics(result) => serde_json::to_value(result), Self::Search(result) => serde_json::to_value(result), + Self::RunAffectedTests(result) => serde_json::to_value(result), + Self::Dashboard(result) => serde_json::to_value(result), } } } diff --git a/crates/tracedecay-contracts/src/policy.rs b/crates/tracedecay-contracts/src/policy.rs index df87c8a582..8c348c7187 100644 --- a/crates/tracedecay-contracts/src/policy.rs +++ b/crates/tracedecay-contracts/src/policy.rs @@ -536,10 +536,12 @@ fn route_effect(effect: EffectClass) -> Result Ok(CapabilityEffectClassV1::GitIndexStage), EffectClass::GitIndexUnstage => Ok(CapabilityEffectClassV1::GitIndexUnstage), EffectClass::GitIndexCommit => Ok(CapabilityEffectClassV1::GitIndexCommit), - EffectClass::SourceEdit | EffectClass::ConfigurationWrite | EffectClass::Administrative => { - Err(ApplicationContractError::Inconsistent { - field: "capability routing effect class", - }) - } + EffectClass::SourceEdit + | EffectClass::ConfigurationWrite + | EffectClass::Administrative + | EffectClass::SpawnsProcess + | EffectClass::BindsServer => 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 02f6cd6177..1efac3f49d 100644 --- a/crates/tracedecay-contracts/src/retrieval/catalog.rs +++ b/crates/tracedecay-contracts/src/retrieval/catalog.rs @@ -1,11 +1,15 @@ +use crate::retrieval::owner_effect_surface::{ + DashboardResultV1, DashboardSurfaceRequestV1, RunAffectedTestsResultV1, + RunAffectedTestsSurfaceRequestV1, +}; use schemars::JsonSchema; use tracedecay_tool_catalog::{ ApplicationSurfaceOperation, AvailabilityContract, BindingId, BindingSurface, CancellationContract, CancellationPoint, CapabilityId, CatalogContributionInputV1, CatalogContributionV1, ContributionContractRef, ContributionId, CoverageContractRef, DeadlineBehavior, DeadlineContract, DeniedDisclosurePolicy, EffectClass, - ExecutableSchemaAuthority, LifecycleClass, OmissionContractRef, PaginationContract, - PrivacyClass, ProfileId, ProtocolRevisionRange, RetrievalFamily, + ExecutableSchemaAuthority, LifecycleClass, OmissionContractRef, OwnerSideEffectEntryV1, + PaginationContract, PrivacyClass, ProfileId, ProtocolRevisionRange, RetrievalFamily, RetrievalPrimitiveManifestInputV1, RetrievalPrimitiveManifestV1, RetrieverId, RevalidationContract, RevalidationPoint, RoutingContractV1, SchemaId, SchemaRef, ScopeDimension, ScopeRequirement, ScoringContractRef, SortContract, SortContractId, @@ -154,6 +158,9 @@ struct PrimitiveReadSpec { /// answer in one response and advertise no pagination. paginated: bool, deadline_millis: u64, + /// The tool-catalog entry of an operation that acts beyond reading; its + /// effect class and ceiling replace the read defaults. + side_effect: Option, } fn primitive_profile_ids(operation: &str) -> &'static [&'static str] { @@ -255,6 +262,8 @@ const PRIMITIVE_READ_SPECS: &[PrimitiveReadSpec] = &[ graph_report_spec("hermes_skill_bridge"), graph_report_spec("analytics"), graph_report_spec("search"), + owner_side_effect_spec(ApplicationSurfaceOperation::RunAffectedTests), + owner_side_effect_spec(ApplicationSurfaceOperation::Dashboard), git_context_spec("affected"), git_context_spec("diff_context"), git_context_spec("changelog"), @@ -352,7 +361,9 @@ fn primitive_read_surfaces(spec: &PrimitiveReadSpec) -> &'static [BindingSurface | "skill_view" | "hermes_skill_bridge" | "analytics" - | "search" => &CLI_MCP_PRIMITIVE_SURFACES, + | "search" + | "run_affected_tests" + | "dashboard" => &CLI_MCP_PRIMITIVE_SURFACES, "health_read" | "storage_status" | "diagnostics_read" => &DASHBOARD_PRIMITIVE_SURFACES, _ => &PRE_DASHBOARD_PRIMITIVE_SURFACES, } @@ -574,6 +585,12 @@ fn primitive_read_description(operation: &str) -> &'static str { "search" => { "Rank symbols by name, identifier fragment, signature, path, or phrase through exact and lexical routes." } + "run_affected_tests" => { + "Run the libtest tests that cover a changed-path manifest and report each observed outcome." + } + "dashboard" => { + "Start or stop this project's loopback dashboard server and report its bound address." + } _ => "Read bounded data from the admitted project's current retained state.", } } @@ -593,6 +610,7 @@ const fn primitive_spec_with_default_page_size( default_page_size, paginated: true, deadline_millis: 10_000, + side_effect: None, } } @@ -616,6 +634,63 @@ const fn graph_report_spec(operation: &'static str) -> PrimitiveReadSpec { default_page_size: CALLABLE_CODE_DEFAULT_PAGE_SIZE, paginated: false, deadline_millis: 120_000, + side_effect: None, + } +} + +/// A read observes cancellation until it answers. A spawned process is killed +/// when its call is cancelled; binding a server is not interruptible. +fn primitive_cancellation( + spec: &PrimitiveReadSpec, +) -> Result { + let points = match spec.side_effect.map(|entry| entry.effect) { + None => vec![ + CancellationPoint::BeforeAdmission, + CancellationPoint::BeforeRead, + CancellationPoint::DuringRead, + ], + Some(EffectClass::SpawnsProcess) => vec![ + CancellationPoint::BeforeAdmission, + CancellationPoint::EffectInFlight, + ], + Some(_) => return Ok(CancellationContract::NotCancellable), + }; + Ok(CancellationContract::cooperative(points)?) +} + +fn primitive_terminal_states(spec: &PrimitiveReadSpec) -> Vec { + let mut states = vec![TerminalState::Completed]; + if !matches!( + spec.side_effect.map(|entry| entry.effect), + Some(EffectClass::BindsServer) + ) { + states.push(TerminalState::Cancelled); + } + states.extend([ + TerminalState::TimedOut, + TerminalState::Failed, + TerminalState::Unavailable, + TerminalState::Partial, + ]); + states +} + +/// An owner-served operation that acts beyond reading. Its tool-catalog side +/// effect entry is the authority for its effect class and ceiling; an +/// operation without one yields a zero deadline the catalog refuses. +const fn owner_side_effect_spec(operation: ApplicationSurfaceOperation) -> PrimitiveReadSpec { + let side_effect = operation.owner_side_effect(); + PrimitiveReadSpec { + operation: operation.as_str(), + capability: operation.as_str(), + use_case: operation.as_str(), + default_page_size: CALLABLE_CODE_DEFAULT_PAGE_SIZE, + paginated: false, + deadline_millis: match side_effect { + Some(entry) => entry.ceiling_millis, + None => 0, + }, + side_effect, } } @@ -720,6 +795,11 @@ pub fn primitive_read_contribution() -> Result Result Result, + /// Cargo profile (default: debug). + pub profile: Option, + /// Maximum wall time in seconds before the cargo subprocess is killed, + /// 1 through 300 (default: 300). + #[schemars(range(min = 1, max = 300))] + pub timeout_secs: Option, + /// Cap on tests dispatched in a single invocation, 1 through 500 + /// (default: 100). + #[schemars(range(min = 1, max = 500))] + pub max_tests: Option, +} + +/// Why a run failed or was refused. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AffectedTestErrorV1 { + pub kind: String, + pub operation: String, + pub message: String, +} + +/// One observed libtest outcome. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AffectedTestOutcomeV1 { + pub test: String, + pub passed: bool, + /// Graph symbols this test was selected to cover. + pub covers_source_ids: Vec, +} + +/// The managed test-run operation the run was recorded under. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct ManagedTestTerminalV1 { + pub operation_id: String, + /// The tool that reads the recorded results back. + pub result_tool: String, + pub receipt: OperationReceipt, +} + +/// A dispatched run, completed or failed, with what it observed. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AffectedTestRunV1 { + pub exit_code: Option, + pub passed: u64, + pub failed: u64, + pub total_observed: u64, + pub dispatched_tests: Vec, + /// More affected tests existed than `max_tests` admitted. + pub truncated: bool, + pub results: Vec, + pub stderr_tail: String, + pub stdout_tail: String, + pub terminal: ManagedTestTerminalV1, + /// Present when the run did not complete. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +/// No test was dispatched: nothing covers the change, or the request was +/// refused before a run began. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AffectedTestsNotRunV1 { + /// Always 0. + pub passed: u64, + /// Always 0. + pub failed: u64, + /// Always empty. + pub results: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub note: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(untagged)] +pub enum RunAffectedTestsResultV1 { + Ran(Box), + NotRun(AffectedTestsNotRunV1), +} + +/// What `tracedecay_dashboard` does. +#[derive(Clone, Copy, Debug, Default, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum DashboardActionV1 { + #[default] + Start, + Stop, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct DashboardSurfaceRequestV1 { + /// Action to perform (default: "start"). "stop" shuts down a previously + /// started dashboard if any. + pub action: Option, + /// Loopback host address to bind: 127.0.0.1, localhost, or ::1 + /// (default: "127.0.0.1"). Wildcard, LAN, public IPs, and other + /// hostnames are rejected. + pub host: Option, + /// Port to listen on; 0 picks an ephemeral port (default: 7341). + pub port: Option, +} + +/// A dashboard that was already bound when `start` was asked again. +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct DashboardBoundV1 { + pub url: String, + pub host: String, + pub port: u16, + pub requested_host: String, + pub requested_port: u16, + /// Whether the bound port is the one asked for (always true for 0). + pub requested_port_honored: bool, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)] +#[serde(tag = "status", rename_all = "snake_case", deny_unknown_fields)] +pub enum DashboardResultV1 { + Started { + url: String, + host: String, + port: u16, + }, + AlreadyRunning(DashboardBoundV1), + /// The bound server is shutting down. + Stopping(DashboardBoundV1), + Stopped { + previous_url: String, + }, + NotRunning, +} diff --git a/crates/tracedecay-contracts/src/sdk_catalog.rs b/crates/tracedecay-contracts/src/sdk_catalog.rs index fac24ce959..658c91d4df 100644 --- a/crates/tracedecay-contracts/src/sdk_catalog.rs +++ b/crates/tracedecay-contracts/src/sdk_catalog.rs @@ -165,7 +165,9 @@ pub fn application_http_route_path(operation: ApplicationSurfaceOperation) -> St | ApplicationSurfaceOperation::SkillView | ApplicationSurfaceOperation::HermesSkillBridge | ApplicationSurfaceOperation::Analytics - | ApplicationSurfaceOperation::Search) => { + | ApplicationSurfaceOperation::Search + | ApplicationSurfaceOperation::RunAffectedTests + | ApplicationSurfaceOperation::Dashboard) => { 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 664db7168c..09616bcc1f 100644 --- a/crates/tracedecay-daemon-protocol/src/application_surface.rs +++ b/crates/tracedecay-daemon-protocol/src/application_surface.rs @@ -941,7 +941,9 @@ pub fn parse_application_surface_request( | ApplicationSurfaceOperation::SkillView | ApplicationSurfaceOperation::HermesSkillBridge | ApplicationSurfaceOperation::Analytics - | ApplicationSurfaceOperation::Search => match value { + | ApplicationSurfaceOperation::Search + | ApplicationSurfaceOperation::RunAffectedTests + | ApplicationSurfaceOperation::Dashboard => 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 f36e597ebc..b43f8c0740 100644 --- a/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs +++ b/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs @@ -906,6 +906,8 @@ pub fn application_surface_feedback_operation( | ApplicationSurfaceOperation::HermesSkillBridge | ApplicationSurfaceOperation::Analytics | ApplicationSurfaceOperation::Search + | ApplicationSurfaceOperation::RunAffectedTests + | ApplicationSurfaceOperation::Dashboard | 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 0cdb87bd77..c2235b4718 100644 --- a/crates/tracedecay-daemon-protocol/src/contract/mod.rs +++ b/crates/tracedecay-daemon-protocol/src/contract/mod.rs @@ -1040,7 +1040,9 @@ impl DaemonInvocationRequest { | ApplicationSurfaceOperation::SkillView | ApplicationSurfaceOperation::HermesSkillBridge | ApplicationSurfaceOperation::Analytics - | ApplicationSurfaceOperation::Search => { + | ApplicationSurfaceOperation::Search + | ApplicationSurfaceOperation::RunAffectedTests + | ApplicationSurfaceOperation::Dashboard => { 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 137fea9082..ce3891bb29 100644 --- a/crates/tracedecay-mcp-catalog/src/definitions.rs +++ b/crates/tracedecay-mcp-catalog/src/definitions.rs @@ -380,7 +380,7 @@ fn build_maximal_tool_definitions() -> Result, McpCatalogErr def_signature(request_schema("signature")?), def_diagnose(request_schema("diagnose")?), def_derives(request_schema("derives")?), - def_run_affected_tests(), + def_run_affected_tests(request_schema("run_affected_tests")?), ]; definitions.extend(memory::memory_definitions(&request_schema)?); definitions.extend([ @@ -390,7 +390,7 @@ fn build_maximal_tool_definitions() -> Result, McpCatalogErr def_skill_list(request_schema("skill_list")?), def_skill_view(request_schema("skill_view")?), def_hermes_skill_bridge(request_schema("hermes_skill_bridge")?), - def_dashboard(), + def_dashboard(request_schema("dashboard")?), def_analytics(request_schema("analytics")?), session::def_session_refresh_begin(request_schema("session_refresh_begin")?), session::def_session_refresh_status(request_schema("session_refresh_status")?), diff --git a/crates/tracedecay-mcp-catalog/src/definitions/admin.rs b/crates/tracedecay-mcp-catalog/src/definitions/admin.rs index 373bedb160..125bdb2819 100644 --- a/crates/tracedecay-mcp-catalog/src/definitions/admin.rs +++ b/crates/tracedecay-mcp-catalog/src/definitions/admin.rs @@ -149,29 +149,12 @@ pub(super) fn def_runtime() -> ToolDefinition { ) } -pub(super) fn def_dashboard() -> ToolDefinition { +pub(super) fn def_dashboard(input_schema: Value) -> ToolDefinition { def_rw( "tracedecay_dashboard", "Dashboard", "Start (or manage) the tracedecay dashboard server for the current project as a background task inside the MCP server. Returns the listening URL. Idempotent: if already running, returns the existing URL. Pass action:\"stop\" to shut down a running instance. MCP dashboard binds are loopback-only: optional host must be 127.0.0.1, localhost, or ::1. Port is optional.", - json!({ - "type": "object", - "properties": { - "action": { - "type": "string", - "enum": ["start", "stop"], - "description": "Action to perform (default: \"start\"). \"stop\" shuts down a previously started dashboard if any." - }, - "host": { - "type": "string", - "description": "Loopback host address to bind: 127.0.0.1, localhost, or ::1 (default: \"127.0.0.1\"). Wildcard, LAN, public IPs, and other hostnames are rejected." - }, - "port": { - "type": "number", - "description": "Port to listen on; 0 picks an ephemeral port (default: 7341)" - } - } - }), + input_schema, ) } diff --git a/crates/tracedecay-mcp-catalog/src/definitions/application.rs b/crates/tracedecay-mcp-catalog/src/definitions/application.rs index f01aa1e159..ec34ad8717 100644 --- a/crates/tracedecay-mcp-catalog/src/definitions/application.rs +++ b/crates/tracedecay-mcp-catalog/src/definitions/application.rs @@ -83,6 +83,8 @@ const HANDWRITTEN_DEFINITION_OPERATIONS: &[ApplicationSurfaceOperation] = &[ ApplicationSurfaceOperation::HermesSkillBridge, ApplicationSurfaceOperation::Analytics, ApplicationSurfaceOperation::Search, + ApplicationSurfaceOperation::RunAffectedTests, + ApplicationSurfaceOperation::Dashboard, ApplicationSurfaceOperation::StrReplace, ApplicationSurfaceOperation::MultiStrReplace, ApplicationSurfaceOperation::InsertAt, diff --git a/crates/tracedecay-mcp-catalog/src/definitions/testing.rs b/crates/tracedecay-mcp-catalog/src/definitions/testing.rs index 811218329a..b1478be225 100644 --- a/crates/tracedecay-mcp-catalog/src/definitions/testing.rs +++ b/crates/tracedecay-mcp-catalog/src/definitions/testing.rs @@ -1,6 +1,6 @@ //! Test-coverage and diagnostics workflow tool definitions. -use serde_json::{Value, json}; +use serde_json::Value; use super::{def, def_rw}; use crate::ToolDefinition; @@ -36,7 +36,7 @@ pub(super) fn def_diagnose(input_schema: Value) -> ToolDefinition { ) } -pub(super) fn def_run_affected_tests() -> ToolDefinition { +pub(super) fn def_run_affected_tests(input_schema: Value) -> ToolDefinition { def_rw( "tracedecay_run_affected_tests", "Run Affected Tests", @@ -45,40 +45,19 @@ pub(super) fn def_run_affected_tests() -> ToolDefinition { `tracedecay_test_map` / `tracedecay_test_risk`, emits pass/fail per \ test alongside the source nodes each test covers. Output is the \ libtest summary parsed into JSON.", - json!({ - "type": "object", - "properties": { - "changed_paths": { - "type": "array", - "items": {"type": "string"}, - "description": "Explicit manifest of file paths used to compute affected tests." - }, - "profile": { - "type": "string", - "enum": ["debug", "release"], - "description": "Cargo profile (default: debug)." - }, - "timeout_secs": { - "type": "number", - "description": "Maximum wall time before the cargo subprocess is killed (default: 300)." - }, - "max_tests": { - "type": "number", - "description": "Cap on tests dispatched in a single invocation (default: 100)." - } - }, - "required": ["changed_paths"] - }), + input_schema, ) } #[cfg(test)] mod tests { - use super::def_run_affected_tests; - #[test] fn affected_test_execution_requires_an_explicit_file_manifest() { - let definition = def_run_affected_tests(); + let definition = crate::get_maximal_tool_definitions() + .expect("tool definitions") + .into_iter() + .find(|definition| definition.name == "tracedecay_run_affected_tests") + .expect("tracedecay_run_affected_tests definition"); assert_eq!( definition.input_schema["required"], serde_json::json!(["changed_paths"]) diff --git a/crates/tracedecay-mcp/src/handlers/workflow.rs b/crates/tracedecay-mcp/src/handlers/workflow.rs index 859ce741f5..1733acde73 100644 --- a/crates/tracedecay-mcp/src/handlers/workflow.rs +++ b/crates/tracedecay-mcp/src/handlers/workflow.rs @@ -10,11 +10,15 @@ use std::path::{Component, Path, PathBuf}; use std::time::Duration; use futures_util::stream::{self, StreamExt}; -use serde_json::{Value, json}; +use serde_json::Value; use tracedecay_code_index::graph_projection::CodeGraphSymbolSummaryV1; use tracedecay_code_index::intake::content_digest; use tracedecay_contracts::clock::now_micros; use tracedecay_contracts::graph_tool::{GraphToolCompletionV1, GraphToolResultV1}; +use tracedecay_contracts::retrieval::{ + AffectedTestOutcomeV1, AffectedTestRunV1, AffectedTestsNotRunV1, ManagedTestTerminalV1, + RunAffectedTestsResultV1, RunAffectedTestsSurfaceRequestV1, +}; use tracedecay_contracts::retrieval::{ DiagnoseItemV1, DiagnosePublicationV1, DiagnoseResultV1, DiagnoseSeverityFilterV1, DiagnoseSeverityV1, DiagnoseSurfaceRequestV1, DiagnoseSymbolV1, @@ -38,13 +42,13 @@ use tracedecay_contracts::request_identity::{GlobalRequestSurface, mint_global_r use tracedecay_domain::errors::{Result, TraceDecayError}; use tracedecay_project::project::TraceDecay; -use crate::ToolResult; use crate::handlers::graph::graph_tool_completion; use crate::handlers::support::decode_primitive_request; -use crate::handlers::{generic_tool_result, unique_file_paths}; +use crate::handlers::unique_file_paths; mod affected_test_failure; +use crate::workflow::refused_run; #[cfg(test)] use crate::{MAX_TEST_TIMEOUT_SECS, cargo_test_args}; use crate::{ @@ -436,17 +440,21 @@ fn severity_wire(s: Severity) -> DiagnoseSeverityV1 { } } -/// Handles `tracedecay_run_affected_tests`. -pub async fn handle_run_affected_tests( +/// Computes `tracedecay_run_affected_tests` on the graph-tool owner's side: +/// selects the tests covering the changed-path manifest, runs them once each, +/// and reports every observed outcome. +pub async fn compute_run_affected_tests( cg: &TraceDecay, graph: F, args: Value, cancellation: Option, -) -> Result +) -> Result where F: Future>, { - handle_run_affected_tests_with_runner(cg, graph, args, cancellation, run_cargo_tests).await + let request: RunAffectedTestsSurfaceRequestV1 = + decode_primitive_request(&args, "tracedecay_run_affected_tests")?; + run_affected_tests_with_runner(cg, graph, request, cancellation, run_cargo_tests).await } #[hotpath::measure(future = true, label = "mcp.workflow.affected_tests.total")] @@ -457,34 +465,28 @@ where reason = "Affected-test run is one select-and-execute through the injected runner." ) )] -async fn handle_run_affected_tests_with_runner( +async fn run_affected_tests_with_runner( cg: &TraceDecay, graph: F, - args: Value, + request: RunAffectedTestsSurfaceRequestV1, cancellation: Option, runner: Runner, -) -> Result +) -> Result where F: Future>, Runner: FnOnce(PathBuf, TestProfile, Vec, Duration, TestRunControl) -> RunFuture, RunFuture: Future>, { - let run_args = match RunAffectedArgs::parse(&args) { + // The caller's manifest is the authority for the affected-test scope. + // Graph admission stays unawaited until that scope is validated. + let run_args = match RunAffectedArgs::from_request(request) { Ok(run_args) => run_args, - Err(result) => return Ok(*result), + Err(refused) => return Ok(not_run(*refused)), }; let project_root = cg.project_root().to_path_buf(); - - // The caller's manifest is the authority for the affected-test scope. - // Graph admission stays unawaited until that scope is validated: a request - // without manifest-scoped changed paths is an invalid request regardless - // of whether the graph projection is mounted. - let changed_paths = match resolve_changed_paths(&args, run_args.explicit_paths) { - Ok(paths) => paths, - Err(result) => return Ok(*result), - }; + let changed_paths = run_args.changed_paths; if changed_paths.is_empty() { - return Ok(empty_result(&args, "no changed files detected")); + return Ok(not_run(empty_result("no changed files detected"))); } let graph = @@ -495,25 +497,21 @@ where )?; if test_targets.is_empty() { - return Ok(empty_result( - &args, - &format!( - "no tests cover the changed paths ({} file(s))", - changed_paths.len() - ), - )); + return Ok(not_run(empty_result(&format!( + "no tests cover the changed paths ({} file(s))", + changed_paths.len() + )))); } let (selected_targets, test_names, truncated) = select_test_targets(test_targets, run_args.max_tests); for test_name in &test_names { if let Err(message) = validate_test_identity(test_name) { - return Ok(error_result( - &args, + return Ok(not_run(refused_run( "invalid_test_identity", "test_identity", &message, - )); + ))); } } let started_at = now_micros(); @@ -559,7 +557,6 @@ where Err(failure) => { return affected_test_failure::terminal_failure( &emitter, - &args, started_at, &effective_deadline, run_args.timeout_secs, @@ -595,7 +592,6 @@ where }; return affected_test_failure::terminal_failure( &emitter, - &args, started_at, &effective_deadline, run_args.timeout_secs, @@ -617,7 +613,7 @@ where .await?; let touched_files: Vec = unique_file_paths(changed_paths.iter().map(String::as_str)); - let body = hotpath::measure_block!( + let run = hotpath::measure_block!( "mcp.workflow.affected_tests.assemble", run_affected_tests_body( &output, @@ -625,18 +621,22 @@ where &test_names, truncated, &selected_targets, - &managed_test_terminal(&emitter, &receipt) + managed_test_terminal(&emitter, receipt) ) ); - - Ok(generic_tool_result( - Some(&cg.store_layout().response_handle_root), - &args, - &body, + Ok(graph_tool_completion( + GraphToolResultV1::RunAffectedTests(RunAffectedTestsResultV1::Ran(Box::new(run))), touched_files, )) } +fn not_run(not_run: AffectedTestsNotRunV1) -> GraphToolCompletionV1 { + graph_tool_completion( + GraphToolResultV1::RunAffectedTests(RunAffectedTestsResultV1::NotRun(not_run)), + Vec::new(), + ) +} + async fn wait_for_test_run_cancellation( mut emitter: OperationEmitter, cancellation: Option, @@ -828,21 +828,6 @@ fn test_run_contract_error(error: impl std::fmt::Display) -> TraceDecayError { } } -fn resolve_changed_paths( - args: &Value, - explicit_paths: Option>, -) -> std::result::Result, Box> { - match explicit_paths { - Some(paths) => Ok(paths), - None => Err(Box::new(error_result( - args, - "invalid_request", - "changed_paths", - "`changed_paths` is required and must explicitly scope the affected-test run", - ))), - } -} - fn collect_affected_test_targets( graph: &tracedecay_graph_query::VerifiedGraphQuery, changed_paths: &[String], @@ -1074,40 +1059,40 @@ fn run_affected_tests_body( test_names: &[String], truncated: bool, selected_targets: &[TestTarget], - terminal: &Value, -) -> Value { + terminal: ManagedTestTerminalV1, +) -> AffectedTestRunV1 { let passed = results.iter().filter(|(_, ok)| *ok).count(); - let failed = results.iter().filter(|(_, ok)| !*ok).count(); - - json!({ - "exit_code": output.exit_code, - "passed": passed, - "failed": failed, - "total_observed": results.len(), - "dispatched_tests": test_names, - "truncated": truncated, - "results": results + AffectedTestRunV1 { + exit_code: output.exit_code, + passed: passed as u64, + failed: (results.len() - passed) as u64, + total_observed: results.len() as u64, + dispatched_tests: test_names.to_vec(), + truncated, + results: results .iter() - .map(|(name, ok)| { - json!({ - "test": name, - "passed": ok, - "covers_source_ids": covered_source_ids(name, selected_targets), - }) + .map(|(name, ok)| AffectedTestOutcomeV1 { + test: name.clone(), + passed: *ok, + covers_source_ids: covered_source_ids(name, selected_targets), }) - .collect::>(), - "stderr_tail": tail(&output.stderr, 2000), - "stdout_tail": tail(&output.stdout, 2000), - "terminal": terminal, - }) + .collect(), + stderr_tail: tail(&output.stderr, 2000), + stdout_tail: tail(&output.stdout, 2000), + terminal, + error: None, + } } -fn managed_test_terminal(emitter: &OperationEmitter, receipt: &OperationReceipt) -> Value { - json!({ - "operation_id": emitter.binding().operation_id().to_string(), - "result_tool": "tracedecay_test_results", - "receipt": receipt, - }) +fn managed_test_terminal( + emitter: &OperationEmitter, + receipt: OperationReceipt, +) -> ManagedTestTerminalV1 { + ManagedTestTerminalV1 { + operation_id: emitter.binding().operation_id().to_string(), + result_tool: "tracedecay_test_results".to_owned(), + receipt, + } } fn covered_source_ids(name: &str, selected_targets: &[TestTarget]) -> Vec { @@ -1124,26 +1109,15 @@ fn covered_source_ids(name: &str, selected_targets: &[TestTarget]) -> Vec ToolResult { - let value = json!({ - "passed": 0, "failed": 0, "results": [], "note": message - }); - generic_tool_result(None, args, &value, vec![]) -} - -fn error_result(args: &Value, kind: &str, operation: &str, message: &str) -> ToolResult { - let value = json!({ - "passed": 0, - "failed": 0, - "results": [], - "error": { - "kind": kind, - "operation": operation, - "message": message, - } - }); - generic_tool_result(None, args, &value, vec![]) +/// A run with nothing to dispatch. +fn empty_result(message: &str) -> AffectedTestsNotRunV1 { + AffectedTestsNotRunV1 { + passed: 0, + failed: 0, + results: Vec::new(), + note: Some(message.to_owned()), + error: None, + } } /// Returns the last `n` characters of `s`, trimmed to a char boundary. diff --git a/crates/tracedecay-mcp/src/handlers/workflow/affected_test_failure.rs b/crates/tracedecay-mcp/src/handlers/workflow/affected_test_failure.rs index 247308ea76..d3a137f1e7 100644 --- a/crates/tracedecay-mcp/src/handlers/workflow/affected_test_failure.rs +++ b/crates/tracedecay-mcp/src/handlers/workflow/affected_test_failure.rs @@ -1,6 +1,7 @@ //! Typed terminal results for failed managed affected-test executions. -use serde_json::{Value, json}; +use tracedecay_contracts::graph_tool::{GraphToolCompletionV1, GraphToolResultV1}; +use tracedecay_contracts::retrieval::{AffectedTestErrorV1, RunAffectedTestsResultV1}; use tracedecay_contracts::{Deadline, OperationTermination}; use tracedecay_domain::UtcMicros; @@ -11,7 +12,8 @@ use super::{ TestTarget, emit_observed_test_results, finish_test_run, managed_test_terminal, parse_libtest_output, run_affected_tests_body, }; -use crate::{TestRunFailure, TestRunOutput, ToolResult}; +use crate::handlers::graph::graph_tool_completion; +use crate::{TestRunFailure, TestRunOutput}; #[hotpath::measure(future = true, label = "mcp.workflow.affected_tests.failure")] #[allow( @@ -27,7 +29,6 @@ use crate::{TestRunFailure, TestRunOutput, ToolResult}; )] pub(super) async fn terminal_failure( emitter: &OperationEmitter, - args: &Value, started_at: UtcMicros, effective_deadline: &Deadline, timeout_secs: u64, @@ -35,7 +36,7 @@ pub(super) async fn terminal_failure( test_names: &[String], truncated: bool, selected_targets: &[TestTarget], -) -> Result { +) -> Result { let mut partial = failure.partial_output().cloned(); let failure_exit_code = match &failure { TestRunFailure::Harness { exit_code, .. } => *exit_code, @@ -135,26 +136,24 @@ pub(super) async fn terminal_failure( stderr: String::new(), output_bytes, }); - let body = hotpath::measure_block!("mcp.workflow.affected_tests.assemble", { - let mut body = run_affected_tests_body( + let run = hotpath::measure_block!("mcp.workflow.affected_tests.assemble", { + let mut run = run_affected_tests_body( &partial, &results, test_names, truncated, selected_targets, - &managed_test_terminal(emitter, &receipt), + managed_test_terminal(emitter, receipt), ); - body["error"] = json!({ - "kind": kind, - "operation": operation, - "message": message, + run.error = Some(AffectedTestErrorV1 { + kind: kind.to_owned(), + operation: operation.to_owned(), + message, }); - body + run }); - Ok(crate::handlers::generic_tool_result( - None, - args, - &body, - vec![], + Ok(graph_tool_completion( + GraphToolResultV1::RunAffectedTests(RunAffectedTestsResultV1::Ran(Box::new(run))), + Vec::new(), )) } diff --git a/crates/tracedecay-mcp/src/handlers/workflow/affected_tests_tests.rs b/crates/tracedecay-mcp/src/handlers/workflow/affected_tests_tests.rs index f34ed52e38..fe65d53dca 100644 --- a/crates/tracedecay-mcp/src/handlers/workflow/affected_tests_tests.rs +++ b/crates/tracedecay-mcp/src/handlers/workflow/affected_tests_tests.rs @@ -1,5 +1,9 @@ use super::*; +use serde_json::json; + +use crate::ToolResult; + use std::collections::BTreeSet; use std::fmt::Debug; use std::future::ready; @@ -23,6 +27,33 @@ use tracedecay_domain::{ use tracedecay_graph_db::NeverCancelled; use tracedecay_tool_catalog::{CapabilityId, UseCaseId}; +/// Decodes `args` the way the owner does and renders the typed result the +/// way every surface does. +async fn handle_run_affected_tests_with_runner( + cg: &TraceDecay, + graph: F, + args: Value, + cancellation: Option, + runner: Runner, +) -> Result +where + F: Future>, + Runner: FnOnce(PathBuf, TestProfile, Vec, Duration, TestRunControl) -> RunFuture, + RunFuture: Future>, +{ + let request = decode_primitive_request(&args, "tracedecay_run_affected_tests")?; + let completion = + run_affected_tests_with_runner(cg, graph, request, cancellation, runner).await?; + crate::handlers::graph_tool::render_graph_tool(None, &args, completion) +} + +fn bounds(arguments: Value) -> Value { + let request = serde_json::from_value(arguments).expect("typed affected-test request"); + let refused = RunAffectedArgs::from_request(request) + .expect_err("an out-of-bounds request must be refused before any test runs"); + serde_json::to_value(refused).expect("refusal JSON") +} + #[allow(dead_code)] fn assert_begin_test_run_future_is_send(cg: &TraceDecay, deadline: Deadline) { fn assert_send(_: T) {} @@ -502,7 +533,7 @@ async fn non_string_changed_paths_are_rejected_before_test_selection() { qualified_name: "util", annotated_test: false, }]); - let result = handle_run_affected_tests_with_runner( + let error = handle_run_affected_tests_with_runner( &cg, ready(Ok(graph)), json!({ @@ -515,15 +546,10 @@ async fn non_string_changed_paths_are_rejected_before_test_selection() { }, ) .await - .unwrap(); - - let text = result.value["content"][0]["text"].as_str().unwrap(); - let output: Value = serde_json::from_str(text).unwrap(); - assert_eq!(output["error"]["kind"], "invalid_request"); - assert_eq!(output["error"]["operation"], "changed_paths"); - assert!( - output["note"].is_null(), - "malformed producer input must not be relabelled as an empty change set" + .expect_err("a non-string changed path is refused, not relabelled as an empty change set"); + assert_eq!( + error.to_string(), + "config error: invalid arguments for tracedecay_run_affected_tests: invalid type: integer `7`, expected a string" ); cg.close(); @@ -531,9 +557,7 @@ async fn non_string_changed_paths_are_rejected_before_test_selection() { #[test] fn zero_max_tests_is_rejected_before_any_test_runner_can_start() { - let result = RunAffectedArgs::parse(&json!({"max_tests": 0, "format": "json"})) - .expect_err("zero max tests must not become an unfiltered cargo invocation"); - let output = tool_result_body(&result); + let output = bounds(json!({"changed_paths": ["src/lib.rs"], "max_tests": 0})); assert_eq!(output["error"]["kind"], "invalid_request"); assert_eq!(output["error"]["operation"], "max_tests"); @@ -541,12 +565,10 @@ fn zero_max_tests_is_rejected_before_any_test_runner_can_start() { #[test] fn timeout_above_the_managed_test_limit_is_rejected() { - let result = RunAffectedArgs::parse(&json!({ + let output = bounds(json!({ + "changed_paths": ["src/lib.rs"], "timeout_secs": MAX_TEST_TIMEOUT_SECS + 1, - "format": "json" - })) - .expect_err("a managed test run cannot select an unbounded deadline"); - let output = tool_result_body(&result); + })); assert_eq!(output["error"]["kind"], "invalid_request"); assert_eq!(output["error"]["operation"], "timeout_secs"); @@ -554,12 +576,15 @@ fn timeout_above_the_managed_test_limit_is_rejected() { #[test] fn unsupported_profile_is_rejected_before_test_selection() { - let result = RunAffectedArgs::parse(&json!({"profile": "bench", "format": "json"})) - .expect_err("an unsupported profile must not silently become a debug test run"); - let output = tool_result_body(&result); - - assert_eq!(output["error"]["kind"], "invalid_request"); - assert_eq!(output["error"]["operation"], "profile"); + let error = serde_json::from_value::(json!({ + "changed_paths": ["src/lib.rs"], + "profile": "bench", + })) + .expect_err("an unsupported profile must not silently become a debug test run"); + assert_eq!( + error.to_string(), + "unknown variant `bench`, expected `debug` or `release`" + ); } #[tokio::test] diff --git a/crates/tracedecay-mcp/src/server/read_coalescing.rs b/crates/tracedecay-mcp/src/server/read_coalescing.rs index ba630316ae..c4cd66ce1a 100644 --- a/crates/tracedecay-mcp/src/server/read_coalescing.rs +++ b/crates/tracedecay-mcp/src/server/read_coalescing.rs @@ -9,6 +9,7 @@ use std::sync::{Arc, Mutex, Weak}; use serde_json::Value; use tracedecay_domain::canonical_text::canonical_framed_sha256_bytes; +use tracedecay_tool_catalog::{ApplicationSurfaceOperation, IdenticalCallPolicyV1}; use crate::ToolResult; use tracedecay_runtime_core::weak_registry::WeakRegistry; @@ -196,6 +197,12 @@ pub fn tool_allows_identical_read_coalescing( tool_name: &str, tool_is_read_only: impl FnOnce(&str) -> bool, ) -> bool { + if ApplicationSurfaceOperation::from_tool_name(tool_name) + .and_then(ApplicationSurfaceOperation::owner_side_effect) + .is_some_and(|entry| entry.identical_calls == IdenticalCallPolicyV1::RunEach) + { + return false; + } if matches!( tool_name, "tracedecay_search" diff --git a/crates/tracedecay-mcp/src/tools/binding.rs b/crates/tracedecay-mcp/src/tools/binding.rs index 61ac342752..f370d4b554 100644 --- a/crates/tracedecay-mcp/src/tools/binding.rs +++ b/crates/tracedecay-mcp/src/tools/binding.rs @@ -51,7 +51,6 @@ pub enum McpToolDispatchGroup { Admin, Git, Health, - SessionWorkflow, Work, Workflow, } @@ -86,8 +85,7 @@ pub fn tool_branch_sensitivity(tool_name: &str) -> BranchSensitivity { | McpToolDispatchGroup::Git | McpToolDispatchGroup::Health | McpToolDispatchGroup::MultiRoot - | McpToolDispatchGroup::ApplicationSurface - | McpToolDispatchGroup::SessionWorkflow, + | McpToolDispatchGroup::ApplicationSurface, ) => BranchSensitivity::Sensitive, Some(McpToolDispatchGroup::Work | McpToolDispatchGroup::Workflow) => { BranchSensitivity::Independent @@ -296,6 +294,8 @@ fn application_surface_branch_sensitivity( | ApplicationSurfaceOperation::Config | ApplicationSurfaceOperation::Retrieve | ApplicationSurfaceOperation::Search + | ApplicationSurfaceOperation::RunAffectedTests + | ApplicationSurfaceOperation::Dashboard | HealthRead | HealthDelta | DiagnosticsRead @@ -362,8 +362,6 @@ const BINDING_GROUPS: &[BindingGroup] = binding_groups![ [Some(McpToolDispatchGroup::MultiRoot), RegisteredProjectAccess::ActiveProjectOnly, "tracedecay_multi_root_scope_set_read", "tracedecay_multi_root_scope_set_compare_and_swap", "tracedecay_multi_root_execute"], - [Some(McpToolDispatchGroup::SessionWorkflow), RegisteredProjectAccess::ActiveProjectOnly, - "tracedecay_run_affected_tests", "tracedecay_dashboard"], [None, RegisteredProjectAccess::SelectorOnly, "tracedecay_fact_feedback"], [None, RegisteredProjectAccess::ActiveProjectOnly, "tracedecay_lcm_describe", "tracedecay_lcm_doctor", "tracedecay_lcm_expand", "tracedecay_lcm_expand_query", @@ -506,7 +504,6 @@ pub(super) fn tool_is_selector_bound_effect(tool_name: &str) -> bool { fn direct_effect(tool_name: &str) -> EffectClass { match tool_name { "tracedecay_multi_root_scope_set_compare_and_swap" - | "tracedecay_dashboard" | "tracedecay_fact_store_curate" | "tracedecay_fact_store_add" | "tracedecay_fact_store_update" @@ -514,8 +511,7 @@ fn direct_effect(tool_name: &str) -> EffectClass { | "tracedecay_fact_store_supersede" | "tracedecay_fact_feedback" | "tracedecay_session_refresh_begin" - | "tracedecay_session_refresh_cancel" - | "tracedecay_run_affected_tests" => EffectClass::Administrative, + | "tracedecay_session_refresh_cancel" => EffectClass::Administrative, _ => EffectClass::Read, } } @@ -760,10 +756,7 @@ fn compute_tool_supports_live_cancellation(tool_name: &str) -> bool { }) || multi_root_operation_for_tool(tool_name).is_some() || compute_tool_dispatches_source_edit_effect(tool_name) - || matches!( - tool_name, - "tracedecay_admin_cli" | "tracedecay_search" | "tracedecay_run_affected_tests" - ) + || matches!(tool_name, "tracedecay_admin_cli" | "tracedecay_search") } pub fn tool_requires_canonical_effect_settlement(tool_name: &str) -> bool { @@ -790,8 +783,7 @@ fn compute_tool_requires_canonical_effect_settlement(tool_name: &str) -> bool { fn verified_effect_journey(tool_name: &str) -> bool { matches!( tool_name, - "tracedecay_dashboard" - | "tracedecay_fact_store_curate" + "tracedecay_fact_store_curate" | "tracedecay_fact_store_add" | "tracedecay_fact_store_update" | "tracedecay_fact_store_remove" @@ -799,7 +791,6 @@ fn verified_effect_journey(tool_name: &str) -> bool { | "tracedecay_fact_feedback" | "tracedecay_session_refresh_begin" | "tracedecay_session_refresh_cancel" - | "tracedecay_run_affected_tests" | "tracedecay_configuration_set" | "tracedecay_configuration_unset" | "tracedecay_configuration_batch" @@ -899,9 +890,6 @@ fn cancellation_for_tool( CancellationPoint::EffectInFlight, ], _ if tool_name == "tracedecay_search" => vec![CancellationPoint::DuringRead], - _ if tool_name == "tracedecay_run_affected_tests" => { - vec![CancellationPoint::EffectInFlight] - } _ => return Ok(CancellationContract::NotCancellable), }; CancellationContract::cooperative(points) @@ -1170,24 +1158,6 @@ mod tests { } } - /// The retained-surface predicate used to sit between the health and - /// session-workflow arms of an ordered match, so retained tools won over - /// that group. A flat lookup only preserves that if no session-workflow - /// tool is also a retained operation. - #[test] - fn session_workflow_tools_are_not_retained_operations() { - for entry in MCP_TOOL_BINDINGS - .iter() - .filter(|entry| entry.group == Some(McpToolDispatchGroup::SessionWorkflow)) - { - assert!( - RetainedSurfaceOperation::from_tool_name(entry.name).is_none(), - "{} would change groups under a flat lookup", - entry.name - ); - } - } - /// Every Independent catalog tool, plus one Sensitive representative per /// dispatch family that still reopens on branch drift. An advertised tool /// missing from this table must stay Sensitive (fail-safe). diff --git a/crates/tracedecay-mcp/src/tools/catalog_discovery.rs b/crates/tracedecay-mcp/src/tools/catalog_discovery.rs index dcf201bfe6..6d84503245 100644 --- a/crates/tracedecay-mcp/src/tools/catalog_discovery.rs +++ b/crates/tracedecay-mcp/src/tools/catalog_discovery.rs @@ -408,7 +408,8 @@ mod tests { .find(|definition| definition.name == "tracedecay_dashboard") .unwrap(); let dispatch = &dashboard.meta.as_ref().unwrap()["tracedecay/dispatch"]; - assert_eq!(dispatch["effect"], "administrative"); + assert_eq!(dispatch["effect"], "binds_server"); + assert_eq!(dispatch["read_only"], false); assert_eq!(dispatch["availability"]["state"], "available"); assert_eq!(dispatch["idempotency"], "idempotent"); assert_eq!(dispatch["inverse"]["mode"], "same_tool"); @@ -428,9 +429,11 @@ mod tests { .iter() .find(|definition| definition.name == "tracedecay_run_affected_tests") .unwrap(); + let dispatch = &affected_tests.meta.as_ref().unwrap()["tracedecay/dispatch"]; + assert_eq!(dispatch["effect"], "spawns_process"); + assert_eq!(dispatch["read_only"], false); assert_eq!( - affected_tests.meta.as_ref().unwrap()["tracedecay/dispatch"]["deadline"]["maximum_millis"], - 600_000, + dispatch["deadline"]["maximum_millis"], 600_000, "a long-running tool gets the ten-minute ceiling" ); @@ -464,12 +467,14 @@ mod tests { assert!( definitions .iter() - .any(|definition| definition.name == "tracedecay_dashboard"), + .any(|definition| definition.name == "tracedecay_status"), "legacy production tools remain discoverable until cataloged" ); assert!( definitions.iter().all(|definition| { definition.name != "tracedecay_search" + && definition.name != "tracedecay_run_affected_tests" + && definition.name != "tracedecay_dashboard" && definition.name != "tracedecay_context" && definition.name != "tracedecay_git_preview" }), diff --git a/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs b/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs index 0116bca627..2a1041eb25 100644 --- a/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs +++ b/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs @@ -5,6 +5,7 @@ //! contract without an explicit deadline. use tracedecay_domain::errors::TraceDecayError; +use tracedecay_tool_catalog::ApplicationSurfaceOperation; /// The hard ceiling every MCP tool call is bounded by, regardless of dispatch /// group, when admission carried no client deadline. @@ -25,7 +26,7 @@ pub const TOOL_DISPATCH_CEILING: std::time::Duration = std::time::Duration::from /// 900 seconds that motivated this wrap. They simply cannot share the /// interactive ceiling without failing correct, user-requested work. pub const LONG_RUNNING_TOOL_DISPATCH_CEILING: std::time::Duration = - std::time::Duration::from_mins(10); + std::time::Duration::from_millis(tracedecay_tool_catalog::LONG_RUNNING_CEILING_MILLIS); /// Tools whose ceiling is [`LONG_RUNNING_TOOL_DISPATCH_CEILING`]. /// @@ -35,7 +36,6 @@ pub const LONG_RUNNING_TOOL_DISPATCH_CEILING: std::time::Duration = /// inherits [`TOOL_DISPATCH_CEILING`] automatically, so a tool added tomorrow is /// bounded without touching this file. const LONG_RUNNING_DISPATCH_TOOLS: &[&str] = &[ - "tracedecay_run_affected_tests", "tracedecay_fact_store_curate", "tracedecay_admin_cli", "tracedecay_admin_project", @@ -45,7 +45,14 @@ const LONG_RUNNING_DISPATCH_TOOLS: &[&str] = &[ /// The ceiling that applies to `tool_name` in the absence of a shorter carried /// deadline. +/// +/// An owner-served side effect's tool-catalog entry names its own ceiling. pub fn tool_dispatch_ceiling(tool_name: &str) -> std::time::Duration { + if let Some(entry) = ApplicationSurfaceOperation::from_tool_name(tool_name) + .and_then(ApplicationSurfaceOperation::owner_side_effect) + { + return std::time::Duration::from_millis(entry.ceiling_millis); + } if LONG_RUNNING_DISPATCH_TOOLS.contains(&tool_name) { LONG_RUNNING_TOOL_DISPATCH_CEILING } else { diff --git a/crates/tracedecay-mcp/src/workflow/mod.rs b/crates/tracedecay-mcp/src/workflow/mod.rs index 2f5522cd5a..4158ba0542 100644 --- a/crates/tracedecay-mcp/src/workflow/mod.rs +++ b/crates/tracedecay-mcp/src/workflow/mod.rs @@ -5,6 +5,7 @@ mod test_request; mod test_runner; pub use test_identity::{libtest_identity, libtest_module_prefix}; +pub(crate) use test_request::refused_run; pub use test_request::{MAX_TEST_TIMEOUT_SECS, MAX_TESTS_HARD_CAP, RunAffectedArgs, TestProfile}; pub use test_runner::{ TestRunControl, TestRunFailure, TestRunOutput, TestRunStream, cargo_test_args, diff --git a/crates/tracedecay-mcp/src/workflow/test_request.rs b/crates/tracedecay-mcp/src/workflow/test_request.rs index 7ec267f360..7b30c399b2 100644 --- a/crates/tracedecay-mcp/src/workflow/test_request.rs +++ b/crates/tracedecay-mcp/src/workflow/test_request.rs @@ -1,33 +1,30 @@ //! Validation for the bounded `tracedecay_run_affected_tests` request. -use serde_json::{Value, json}; - -use crate::ToolResult; -use crate::tools::render; +use tracedecay_contracts::retrieval::{ + AffectedTestErrorV1, AffectedTestsNotRunV1, RunAffectedTestsSurfaceRequestV1, TestProfileV1, +}; const DEFAULT_TEST_TIMEOUT_SECS: u64 = 300; +const DEFAULT_MAX_TESTS: u64 = 100; /// Maximum exact test identities admitted to one managed foreground request. pub const MAX_TESTS_HARD_CAP: usize = 500; /// Managed test runs are foreground tool effects. A caller cannot turn one /// into an unbounded daemon job by selecting an arbitrarily distant deadline. pub const MAX_TEST_TIMEOUT_SECS: u64 = DEFAULT_TEST_TIMEOUT_SECS; -fn error_result(args: &Value, kind: &str, operation: &str, message: &str) -> Box { - let value = json!({ - "passed": 0, - "failed": 0, - "results": [], - "error": { - "kind": kind, - "operation": operation, - "message": message, - } - }); - let text = render::finalize(None, args, &value, || render::generic_md(&value)); - Box::new(ToolResult::new( - json!({ "content": [{ "type": "text", "text": text }] }), - Vec::new(), - )) +/// A run refused before any test was selected. +pub(crate) fn refused_run(kind: &str, operation: &str, message: &str) -> AffectedTestsNotRunV1 { + AffectedTestsNotRunV1 { + passed: 0, + failed: 0, + results: Vec::new(), + note: None, + error: Some(AffectedTestErrorV1 { + kind: kind.to_owned(), + operation: operation.to_owned(), + message: message.to_owned(), + }), + } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -36,114 +33,65 @@ pub enum TestProfile { Release, } -impl TestProfile { - fn parse(args: &Value) -> std::result::Result> { - match args.get("profile") { - None => Ok(Self::Debug), - Some(Value::String(profile)) if profile == "debug" => Ok(Self::Debug), - Some(Value::String(profile)) if profile == "release" => Ok(Self::Release), - Some(_) => Err(error_result( - args, - "invalid_request", - "profile", - "`profile` must be `debug` or `release`", - )), - } - } -} - #[derive(Debug)] pub struct RunAffectedArgs { - pub explicit_paths: Option>, + pub changed_paths: Vec, pub profile: TestProfile, pub timeout_secs: u64, pub max_tests: usize, } impl RunAffectedArgs { + /// Applies the managed-run bounds to a decoded request. A bound violation + /// is an in-band refusal, reported before any test is selected. #[hotpath::measure(label = "mcp.workflow.affected_tests.request_build")] - pub fn parse(args: &Value) -> std::result::Result> { - let explicit_paths = match args.get("changed_paths") { - Some(Value::Array(paths)) => { - let mut parsed = Vec::with_capacity(paths.len()); - for path in paths { - let Some(path) = path.as_str() else { - return Err(error_result( - args, - "invalid_request", - "changed_paths", - "`changed_paths` must contain only project-relative string paths", - )); - }; - parsed.push(path.to_owned()); - } - Some(parsed) - } - Some(_) => { - return Err(error_result( - args, - "invalid_request", - "changed_paths", - "`changed_paths` must be an array of project-relative string paths", - )); - } - None => None, - }; - let profile = TestProfile::parse(args)?; - let timeout_secs = bounded_positive_u64( - args, + pub fn from_request( + request: RunAffectedTestsSurfaceRequestV1, + ) -> std::result::Result> { + let timeout_secs = bounded_positive( + request.timeout_secs, "timeout_secs", DEFAULT_TEST_TIMEOUT_SECS, MAX_TEST_TIMEOUT_SECS, )?; - let max_tests = usize::try_from(bounded_positive_u64( - args, + let max_tests = usize::try_from(bounded_positive( + request.max_tests, "max_tests", - 100, + DEFAULT_MAX_TESTS, MAX_TESTS_HARD_CAP as u64, )?) .map_err(|_| { - error_result( - args, + Box::new(refused_run( "invalid_request", "max_tests", "`max_tests` cannot be represented on this platform", - ) + )) })?; - Ok(Self { - explicit_paths, - profile, + changed_paths: request.changed_paths, + profile: match request.profile.unwrap_or_default() { + TestProfileV1::Debug => TestProfile::Debug, + TestProfileV1::Release => TestProfile::Release, + }, timeout_secs, max_tests, }) } } -fn bounded_positive_u64( - args: &Value, +fn bounded_positive( + value: Option, field: &str, default: u64, maximum: u64, -) -> std::result::Result> { - let Some(value) = args.get(field) else { - return Ok(default); - }; - let Some(value) = value.as_u64() else { - return Err(error_result( - args, - "invalid_request", - field, - &format!("`{field}` must be an integer from 1 through {maximum}"), - )); - }; +) -> std::result::Result> { + let value = value.unwrap_or(default); if !(1..=maximum).contains(&value) { - return Err(error_result( - args, + return Err(Box::new(refused_run( "invalid_request", field, &format!("`{field}` must be an integer from 1 through {maximum}"), - )); + ))); } Ok(value) } diff --git a/crates/tracedecay-tool-catalog/src/lib.rs b/crates/tracedecay-tool-catalog/src/lib.rs index 20efe06ea0..e69614fc14 100644 --- a/crates/tracedecay-tool-catalog/src/lib.rs +++ b/crates/tracedecay-tool-catalog/src/lib.rs @@ -13,6 +13,7 @@ mod id; mod manifest; mod mcp; mod operation; +mod owner_side_effect; mod profile; mod retrieval; mod snapshot; @@ -50,6 +51,10 @@ pub use mcp::{ McpInverseContract, McpInverseUnavailableReason, McpTerminalState, }; pub use operation::ApplicationSurfaceOperation; +pub use owner_side_effect::{ + INTERACTIVE_CEILING_MILLIS, IdenticalCallPolicyV1, LONG_RUNNING_CEILING_MILLIS, + OwnerSideEffectEntryV1, +}; pub use profile::{ProfileBudget, ProfileDefinition, ProfileDefinitionInputV1, ProfileKind}; pub use retrieval::{ ContributionContractRef, CoverageContractRef, OmissionContractRef, RetrievalFamily, diff --git a/crates/tracedecay-tool-catalog/src/manifest.rs b/crates/tracedecay-tool-catalog/src/manifest.rs index 95d2c3c9b2..c851ffd7ea 100644 --- a/crates/tracedecay-tool-catalog/src/manifest.rs +++ b/crates/tracedecay-tool-catalog/src/manifest.rs @@ -135,6 +135,10 @@ pub enum EffectClass { GitIndexCommit, ConfigurationWrite, Administrative, + /// Runs a child process in the project (e.g. the project's test runner). + SpawnsProcess, + /// Binds a listening server in the daemon process. + BindsServer, } impl EffectClass { @@ -142,6 +146,12 @@ impl EffectClass { !matches!(self, Self::Read | Self::Preview) } + /// An effect of an owner-served operation that settles within the call: + /// it answers with an operation receipt and takes no idempotency key. + pub const fn is_owner_side_effect(self) -> bool { + matches!(self, Self::SpawnsProcess | Self::BindsServer) + } + pub const fn is_read_only(self) -> bool { matches!(self, Self::Read | Self::Preview) } @@ -795,7 +805,21 @@ impl CapabilityManifestV1 { ); } - if self.effect.is_effect() { + if self.effect.is_owner_side_effect() { + if self.receipt != ReceiptContract::Operation + || self.idempotency != IdempotencyContract::NotRequired + || self.reconciliation != ReconciliationContract::NotRequired + || !matches!( + self.authority_revalidation, + RevalidationContract::Required { .. } + ) + || self.terminal_states.contains(TerminalState::EffectUnknown) + { + return Err(self.invalid( + "owner side effects settle within the call: operation receipt, no idempotency key or reconciliation, revalidated authority, and no unknown-effect terminal", + )); + } + } else if self.effect.is_effect() { if self.receipt != ReceiptContract::DurableEffect || self.idempotency != IdempotencyContract::Required || self.reconciliation != ReconciliationContract::Required diff --git a/crates/tracedecay-tool-catalog/src/operation.rs b/crates/tracedecay-tool-catalog/src/operation.rs index c586c31df6..7682d3d550 100644 --- a/crates/tracedecay-tool-catalog/src/operation.rs +++ b/crates/tracedecay-tool-catalog/src/operation.rs @@ -217,6 +217,8 @@ application_surface_operations! { HermesSkillBridge => "hermes_skill_bridge"; Analytics => "analytics"; Search => "search"; + RunAffectedTests => "run_affected_tests"; + Dashboard => "dashboard"; HealthRead => "health_read"; HealthDelta => "health_delta"; StorageStatus => "storage_status"; @@ -344,6 +346,8 @@ impl ApplicationSurfaceOperation { Self::HermesSkillBridge, Self::Analytics, Self::Search, + Self::RunAffectedTests, + Self::Dashboard, ]; pub fn is_graph_tool(self) -> bool { diff --git a/crates/tracedecay-tool-catalog/src/owner_side_effect.rs b/crates/tracedecay-tool-catalog/src/owner_side_effect.rs new file mode 100644 index 0000000000..39515d6bdd --- /dev/null +++ b/crates/tracedecay-tool-catalog/src/owner_side_effect.rs @@ -0,0 +1,87 @@ +//! Side-effecting operations the project's graph-tool owner serves beside its +//! reads. + +use crate::{ApplicationSurfaceOperation, EffectClass}; + +/// The ceiling for an owner call whose requested work is itself a long job, +/// such as running a test suite. +pub const LONG_RUNNING_CEILING_MILLIS: u64 = 600_000; + +/// The ceiling for an interactive owner call. +pub const INTERACTIVE_CEILING_MILLIS: u64 = 120_000; + +/// How the server treats identical calls that are in flight together. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum IdenticalCallPolicyV1 { + /// Every call runs its own effect; a second identical call is never + /// answered from the first one's result. + RunEach, +} + +/// One side-effecting owner entry: what the call does, how long it may run, +/// and how identical concurrent calls are treated. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct OwnerSideEffectEntryV1 { + pub effect: EffectClass, + pub ceiling_millis: u64, + pub identical_calls: IdenticalCallPolicyV1, +} + +impl ApplicationSurfaceOperation { + /// The side-effect entry of an owner-served operation that acts beyond + /// reading; `None` for every read. + pub const fn owner_side_effect(self) -> Option { + match self { + Self::RunAffectedTests => Some(OwnerSideEffectEntryV1 { + effect: EffectClass::SpawnsProcess, + ceiling_millis: LONG_RUNNING_CEILING_MILLIS, + identical_calls: IdenticalCallPolicyV1::RunEach, + }), + Self::Dashboard => Some(OwnerSideEffectEntryV1 { + effect: EffectClass::BindsServer, + ceiling_millis: INTERACTIVE_CEILING_MILLIS, + identical_calls: IdenticalCallPolicyV1::RunEach, + }), + _ => None, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn only_owner_side_effects_carry_an_entry_and_none_merges_identical_calls() { + let entries = ApplicationSurfaceOperation::ALL + .into_iter() + .filter_map(|operation| { + operation + .owner_side_effect() + .map(|entry| (operation.as_str(), entry)) + }) + .collect::>(); + assert_eq!( + entries, + [ + ( + "run_affected_tests", + OwnerSideEffectEntryV1 { + effect: EffectClass::SpawnsProcess, + ceiling_millis: 600_000, + identical_calls: IdenticalCallPolicyV1::RunEach, + } + ), + ( + "dashboard", + OwnerSideEffectEntryV1 { + effect: EffectClass::BindsServer, + ceiling_millis: 120_000, + identical_calls: IdenticalCallPolicyV1::RunEach, + } + ), + ] + ); + assert_eq!(ApplicationSurfaceOperation::Files.owner_side_effect(), None); + } +} diff --git a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs index ac0db7b1f6..7d4b686914 100644 --- a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs +++ b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs @@ -69,6 +69,35 @@ impl McpServer { code_index_ignored_dependency_admission: self .code_index_ignored_dependency_admission .clone(), + // The dashboard the owner binds composes these daemon-owned + // readers, writers, and session authorities. + registered_profile_session_db: self.profile_session_db.clone(), + registered_savings_db: self.accounting_db.clone(), + dashboard_session_retrieval_service: self + .project_application_retrieval + .as_ref() + .map(|mounted| Arc::clone(&mounted.service)), + dashboard_session_retrieval_identity: self + .project_application_retrieval + .as_ref() + .map(|mounted| mounted.identity.clone()), + daemon_user_profile_id: self + .profile_identity + .as_ref() + .map(|identity| identity.profile_id().clone()), + automation_scheduler_reconciler: self.automation_scheduler_reconciler.clone(), + automation_writer: self.dashboard_automation_writer.clone(), + doctor_report_reader: self.dashboard_doctor_report_reader.clone(), + remote_operational_status: self.remote_operational_status.clone(), + feedback_status_reader: self.dashboard_feedback_status_reader.clone(), + pr_autotrack_reader: self.dashboard_pr_autotrack_reader.clone(), + diagnostics_lsp: Some(Arc::clone(&self.diagnostics_lsp)), + dashboard_application_invocation_executor: self.application_invocation_executor.clone(), + daemon_invocation_service: self.daemon_invocation_service.as_ref(), + dashboard_delivery_settlement_authority: self.delivery_settlement_authority.clone(), + code_graph_projection_read_port: self.code_graph_projection_read_port.clone(), + code_graph_read_admission_port: self.code_graph_read_admission_port.clone(), + retained_project_server_resolver: self.retained_project_server_resolver.clone(), ..ToolCallRegistryOptions::default() }; compute_graph_tool_for_owner( diff --git a/crates/tracedecay/src/mcp/tools/handlers/dashboard.rs b/crates/tracedecay/src/mcp/tools/handlers/dashboard.rs index ef78860952..36cb2d0d30 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/dashboard.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/dashboard.rs @@ -15,7 +15,9 @@ use std::collections::HashMap; use std::path::{Path, PathBuf}; use std::sync::Arc; -use serde_json::{Value, json}; +use tracedecay_contracts::retrieval::{ + DashboardActionV1, DashboardBoundV1, DashboardResultV1, DashboardSurfaceRequestV1, +}; use tracedecay_contracts::{ ApplicationProblem, ApplicationProblemEnvelope, RequestId, SafeDiagnostic, }; @@ -30,9 +32,7 @@ use tracedecay_domain::errors::{Result, TraceDecayError}; use tracedecay_global_db::RegisteredGlobalDbLeaseV1; use tracedecay_project::project::TraceDecay; -use tracedecay_mcp::ToolResult; use tracedecay_mcp::handlers::dashboard_lcm::DashboardLcmReadAdapter; -use tracedecay_mcp::handlers::generic_tool_result; use code_reads::DashboardCodeReadAdapter; use tracedecay_dashboard_api::{ @@ -663,15 +663,6 @@ pub(crate) async fn shutdown_dashboard() -> Result<()> { .await } -fn dashboard_tool_result(cg: &TraceDecay, args: &Value, payload: &Value) -> ToolResult { - generic_tool_result( - Some(&cg.store_layout().response_handle_root), - args, - payload, - vec![], - ) -} - /// The session authorities a project server admits; `None` for the core /// server of a project whose session store is not admitted yet. fn dashboard_session_authorities( @@ -739,9 +730,9 @@ fn opening_project_sessions( reason = "Dashboard handling is one action match onto the composed dashboard readers." ) )] -pub(super) async fn handle_dashboard( +pub(super) async fn compute_dashboard( cg: &TraceDecay, - args: Value, + request: DashboardSurfaceRequestV1, retained_project_server_resolver: Option, code_graph_read_admission: Option, code_graph_projection_read_port: Option, @@ -773,14 +764,9 @@ pub(super) async fn handle_dashboard( Arc, >, daemon_invocation_service: Option, -) -> Result { - let action = args - .get("action") - .and_then(|v| v.as_str()) - .unwrap_or("start"); - - match action { - "stop" => { +) -> Result { + match request.action.unwrap_or_default() { + DashboardActionV1::Stop => { let project_root = cg.project_root() .canonicalize() @@ -796,19 +782,17 @@ pub(super) async fn handle_dashboard( .get(&project_root) .map(|dashboard| dashboard.url.clone()) }; - let payload = if let Some(previous_url) = previous_url { - hotpath::future!( - shutdown_dashboard_for(&project_root), - label = "mcp.dashboard.open.stop" - ) - .await?; - json!({ "status": "stopped", "previous_url": previous_url }) - } else { - json!({ "status": "not_running" }) + let Some(previous_url) = previous_url else { + return Ok(DashboardResultV1::NotRunning); }; - Ok(dashboard_tool_result(cg, &args, &payload)) + hotpath::future!( + shutdown_dashboard_for(&project_root), + label = "mcp.dashboard.open.stop" + ) + .await?; + Ok(DashboardResultV1::Stopped { previous_url }) } - "start" | "" => { + DashboardActionV1::Start => { // Canonicalized once up front: it is both the manager key (each // enrolled project gets its own dashboard slot) and, later, the // invariant check against the retained project server's root. @@ -824,47 +808,37 @@ pub(super) async fn handle_dashboard( if let Some(finished) = take_finished_dashboard_for(&requested_root).await { join_dashboard(finished, false).await?; } - let host = args - .get("host") - .and_then(|v| v.as_str()) + let host = request + .host + .as_deref() .map(validate_dashboard_host) .transpose()? .unwrap_or("127.0.0.1") .to_string(); - let port = args - .get("port") - .and_then(serde_json::Value::as_u64) - .and_then(|p| u16::try_from(p).ok()) - .unwrap_or(DEFAULT_PORT); + let port = request.port.unwrap_or(DEFAULT_PORT); let manager = get_manager(); let mut guard = manager.lock().await; if let Some(handle) = guard.get(&requested_root) { - let status = if handle.shutdown.is_some() { - "already_running" - } else { - "stopping" - }; // The lookup is keyed by this project's own canonicalized // root, so the reused server always serves *this* project, // only the host/port the caller asked for may differ from // what is actually bound. `port == 0` means "any port is // fine", so it can never be dishonored. - let requested_port_honored = port == 0 || port == handle.addr.port(); - return Ok(dashboard_tool_result( - cg, - &args, - &json!({ - "status": status, - "url": handle.url, - "host": handle.addr.ip().to_string(), - "port": handle.addr.port(), - "requested_host": host, - "requested_port": port, - "requested_port_honored": requested_port_honored, - }), - )); + let bound = DashboardBoundV1 { + url: handle.url.clone(), + host: handle.addr.ip().to_string(), + port: handle.addr.port(), + requested_host: host, + requested_port: port, + requested_port_honored: port == 0 || port == handle.addr.port(), + }; + return Ok(if handle.shutdown.is_some() { + DashboardResultV1::AlreadyRunning(bound) + } else { + DashboardResultV1::Stopping(bound) + }); } // Shared construction with the CLI path: resolved LCM/session store @@ -1090,22 +1064,12 @@ pub(super) async fn handle_dashboard( }, ); - Ok(dashboard_tool_result( - cg, - &args, - &json!({ - "status": "started", - "url": url, - "host": host, - "port": addr.port() - }), - )) + Ok(DashboardResultV1::Started { + url, + host, + port: addr.port(), + }) } - other => Err(TraceDecayError::Config { - message: format!( - "unknown action for tracedecay_dashboard: {other} (use 'start' or 'stop')" - ), - }), } } diff --git a/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs b/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs index fa178a874d..b643adf592 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs @@ -1,4 +1,5 @@ use serde_json::Value; +use tracedecay_contracts::graph_tool::GraphToolResultV1; use tracedecay_contracts::{ApplicationOperation, RetainedSurfaceOperation}; use tracedecay_graph_query::VerifiedGraphQueryRequest; use tracedecay_runtime_core::config::ProfileRoot; @@ -412,6 +413,17 @@ pub(crate) fn compute_graph_tool_for_owner<'a>( std::time::Duration::ZERO, )); }; + if operation.owner_side_effect().is_some() { + return match tokio::time::timeout( + budget, + compute_owner_side_effect(cg, operation, args, &options), + ) + .await + { + Ok(result) => result, + Err(_elapsed) => Err(tool_dispatch_deadline_error(tool_name, budget)), + }; + } if dispatch_controls::is_automation_read(operation) { return match tokio::time::timeout( budget, @@ -700,41 +712,34 @@ fn admitted_tool_context<'a>( Ok(McpToolContext::bind(McpToolBinding { project, request })?) } -/// Dispatch dashboard and workflow tools that have not moved to a dedicated -/// application family. -#[hotpath::measure(future = true, label = "mcp.dispatch.session_workflow")] -pub(super) async fn dispatch_session_workflow_tools( - tool_name: &str, +/// Runs one side-effecting owner operation under the owner's admitted +/// authorities. The dashboard composes the daemon-owned readers and writers +/// this owner carries; the test run admits the verified graph to select tests. +async fn compute_owner_side_effect( cg: &TraceDecay, + operation: ApplicationSurfaceOperation, args: Value, - options: ToolCallRegistryOptions<'_>, -) -> Result { - dispatch_session_workflow_tools_inner(tool_name, cg, args, options).await -} - -fn dispatch_session_workflow_tools_inner<'a>( - tool_name: &'a str, - cg: &'a TraceDecay, - args: Value, - options: ToolCallRegistryOptions<'a>, -) -> std::pin::Pin> + Send + 'a>> { - // Erase the deeply nested match-arm futures before they reach the - // measured wrapper so every profiling feature can compute its layout. - Box::pin(async move { - match tool_name { - "tracedecay_run_affected_tests" => { - workflow::handle_run_affected_tests( - cg, - admitted_graph_query(&options, "file_dependents"), - args, - options.application_cancellation.clone(), - ) - .await - } - "tracedecay_dashboard" => { - dashboard::handle_dashboard( + options: &ToolCallRegistryOptions<'_>, +) -> Result { + let result = match operation { + ApplicationSurfaceOperation::RunAffectedTests => { + return workflow::compute_run_affected_tests( + cg, + admitted_graph_query(options, "file_dependents"), + args, + options.application_cancellation.clone(), + ) + .await; + } + ApplicationSurfaceOperation::Dashboard => { + let request = tracedecay_mcp::handlers::decode_primitive_request( + &args, + operation.mcp_tool_name(), + )?; + GraphToolResultV1::Dashboard( + dashboard::compute_dashboard( cg, - args, + request, options.retained_project_server_resolver.clone(), options.code_graph_read_admission_port.clone(), options.code_graph_projection_read_port.clone(), @@ -757,9 +762,16 @@ fn dispatch_session_workflow_tools_inner<'a>( options.dashboard_delivery_settlement_authority.clone(), options.daemon_invocation_service.cloned(), ) - .await - } - _ => Err(unknown_tool_error(tool_name)), + .await?, + ) } + operation => return Err(unknown_tool_error(operation.mcp_tool_name())), + }; + Ok(tracedecay_contracts::graph_tool::GraphToolCompletionV1 { + result, + touched_files: Vec::new(), + code_graph: None, + analytics: None, + cost: None, }) } diff --git a/crates/tracedecay/src/mcp/tools/handlers/dispatch_test_support.rs b/crates/tracedecay/src/mcp/tools/handlers/dispatch_test_support.rs index 29eb3af956..978c172b41 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_test_support.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_test_support.rs @@ -397,8 +397,5 @@ pub(super) async fn concrete_dispatch_group_accepts( McpToolDispatchGroup::Health => { owned(dispatch_health_tools(tool_name, cg, invalid_args, options).await) } - McpToolDispatchGroup::SessionWorkflow => { - owned(dispatch_session_workflow_tools(tool_name, cg, invalid_args, options).await) - } } } diff --git a/crates/tracedecay/src/mcp/tools/handlers/mod.rs b/crates/tracedecay/src/mcp/tools/handlers/mod.rs index 1aebb07833..3266c3f7d9 100644 --- a/crates/tracedecay/src/mcp/tools/handlers/mod.rs +++ b/crates/tracedecay/src/mcp/tools/handlers/mod.rs @@ -166,7 +166,7 @@ use tracedecay_tool_catalog::{ApplicationSurfaceOperation, BindingSurface}; use super::LegacyToolCompatibilityOwner; use dispatch_groups::{ dispatch_admin_tools, dispatch_application_surface_tools, dispatch_health_tools, - dispatch_info_tools, dispatch_session_workflow_tools, + dispatch_info_tools, }; use tool_call_support::{boxed_send, rejected_tool_project_selector_present}; use tracedecay_api::{WorkHttpRequest, WorkflowHttpRequest}; @@ -625,12 +625,6 @@ pub fn handle_tool_call_with_registry_options<'a>( Some(McpToolDispatchGroup::Health) => { boxed_send(dispatch_health_tools(tool_name, cg, args, options)).await } - Some(McpToolDispatchGroup::SessionWorkflow) => { - boxed_send(dispatch_session_workflow_tools( - tool_name, cg, args, options, - )) - .await - } // Typed daemon surface tools already returned above, and the daemon // serves the internal branch-add tool before MCP dispatch; reaching // here means the name resolves to no reachable dispatch entry. diff --git a/crates/tracedecay/tests/mcp_suite/mcp_dashboard_tool_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_dashboard_tool_test.rs index 2195dea42b..59a87f096c 100644 --- a/crates/tracedecay/tests/mcp_suite/mcp_dashboard_tool_test.rs +++ b/crates/tracedecay/tests/mcp_suite/mcp_dashboard_tool_test.rs @@ -1,90 +1,73 @@ -//! Tests for the new `tracedecay_dashboard` MCP tool (via direct handler dispatch). -//! Follows conventions from mcp_handler_test.rs: real TraceDecay + handle_tool_call, -//! plus live HTTP probe of /api/capabilities on the returned URL. +//! `tracedecay_dashboard` through the production MCP server and the project's +//! graph-tool owner, plus a live HTTP probe of /api/capabilities on the +//! returned URL. + +#![cfg(feature = "test-transport")] -use std::fs; -#[cfg(feature = "test-transport")] use std::time::Duration; -#[cfg(feature = "test-transport")] +use serde_json::{Value, json}; + use crate::common::http_agent; -#[cfg(feature = "test-transport")] -use serde_json::Value; -use serde_json::json; -use tempfile::TempDir; -use tracedecay::mcp::handle_tool_call; -use tracedecay_project::project::{TraceDecay, TraceDecayOpenOptions}; - -use crate::common::canonical_existing_path; -use crate::support::extract_text; -#[cfg(feature = "test-transport")] -use crate::support::{handle_real_server_tool_call, production_composition_fixture}; +use crate::support::{extract_text, handle_real_server_tool_call, production_composition_fixture}; /// The dashboard manager is process-global (one dashboard per MCP server /// process), so these tests must not run concurrently: serialize them. static TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(()); -async fn setup_minimal_project() -> (TraceDecay, TempDir, TempDir) { - let home = TempDir::new().unwrap(); - let dir = TempDir::new().unwrap(); - let project = dir.path(); - let profile_root = canonical_existing_path(home.path()).join(".tracedecay"); - let open_options = TraceDecayOpenOptions { - profile_root: Some(profile_root.clone()), - global_db_path: Some(profile_root.join("global.db")), - }; - fs::create_dir_all(project.join("src")).unwrap(); - fs::write( - project.join("src/main.rs"), - r#" -fn main() { println!("hi"); } -#[test] fn t() {} -"#, - ) - .unwrap(); - let cg = crate::fixture::init_project_from_template_with_options(project, open_options) +async fn dashboard_refusal( + fixture: &crate::support::ProductionCompositionFixture, + mut arguments: Value, +) -> String { + arguments["format"] = json!("json"); + let response = fixture + .harness + .call_tool(&fixture.project_root, "tracedecay_dashboard", arguments) .await - .unwrap(); - (cg, dir, home) + .expect("production dashboard invocation"); + let result = serde_json::to_value(response.result.expect("refusal result")).unwrap(); + assert_eq!(result["isError"], json!(true), "{result}"); + let envelope: Value = + serde_json::from_str(result["content"][0]["text"].as_str().expect("refusal text")) + .expect("problem envelope JSON"); + envelope["problem"]["message"] + .as_str() + .expect("problem message") + .to_owned() } // Multi-thread runtime: the blocking ureq probe must not starve the spawned // axum server task (same reason dashboard_api_test.rs builds a 2-worker runtime). #[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn tracedecay_dashboard_tool_rejects_wildcard_host_without_starting() { +async fn tracedecay_dashboard_tool_refuses_without_starting() { let _guard = TEST_LOCK.lock().await; - let (cg, _tmp, _home) = setup_minimal_project().await; + let fixture = production_composition_fixture().await; + let server = fixture + .harness + .server(&fixture.project_root) + .expect("production project server"); - let err = match handle_tool_call( - &cg, - "tracedecay_dashboard", - json!({ "host": "0.0.0.0", "port": 0 }), - None, - None, - ) - .await - { - Ok(_) => panic!("wildcard host should be rejected"), - Err(err) => err, - }; + let wildcard = dashboard_refusal(&fixture, json!({ "host": "0.0.0.0", "port": 0 })).await; assert!( - err.to_string().contains("loopback-only"), - "unexpected error: {err}" + wildcard.contains("loopback-only"), + "unexpected error: {wildcard}" + ); + assert_eq!( + dashboard_refusal(&fixture, json!({ "bind": "127.0.0.1", "port": 0 })).await, + "invalid arguments for tracedecay_dashboard: unknown field `bind`, expected one of `action`, `host`, `port`" + ); + assert_eq!( + dashboard_refusal(&fixture, json!({ "port": 70000 })).await, + "invalid arguments for tracedecay_dashboard: invalid value: integer `70000`, expected u16" ); - let stop_res = handle_tool_call( - &cg, - "tracedecay_dashboard", - json!({ "action": "stop" }), - None, - None, - ) - .await - .unwrap(); - assert!(extract_text(&stop_res.value).contains("not_running")); + let stop_res = + handle_real_server_tool_call(&server, "tracedecay_dashboard", json!({ "action": "stop" })) + .await; + assert_eq!(extract_text(&stop_res), r#"{"status":"not_running"}"#); + fixture.harness.shutdown().await; } -#[cfg(feature = "test-transport")] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn tracedecay_dashboard_tool_starts_and_returns_url_and_serves_capabilities() { let _guard = TEST_LOCK.lock().await; @@ -111,12 +94,16 @@ async fn tracedecay_dashboard_tool_starts_and_returns_url_and_serves_capabilitie .expect("text result"); let payload: Value = serde_json::from_str(content_text).expect("dashboard payload"); - assert!( - matches!( - payload["status"].as_str(), - Some("started" | "already_running") - ), - "expected started or already: {payload}", + let port = payload["port"].as_u64().expect("bound port"); + assert_ne!(port, 0, "an ephemeral request reports the port it bound"); + assert_eq!( + payload, + json!({ + "status": "started", + "url": format!("http://127.0.0.1:{port}/"), + "host": "127.0.0.1", + "port": port, + }) ); let url = payload["url"].as_str().expect("dashboard url"); let url = if url.ends_with('/') { @@ -155,7 +142,6 @@ async fn tracedecay_dashboard_tool_starts_and_returns_url_and_serves_capabilitie ); } -#[cfg(feature = "test-transport")] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn tracedecay_dashboard_tool_is_idempotent_and_supports_stop() { let _guard = TEST_LOCK.lock().await; @@ -201,7 +187,6 @@ async fn tracedecay_dashboard_tool_is_idempotent_and_supports_stop() { fixture.harness.shutdown().await; } -#[cfg(feature = "test-transport")] fn extract_url(text: &str) -> String { if let Some(start) = text.find("http://") { let rest = &text[start..]; diff --git a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/affected_tests_behavior_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/affected_tests_behavior_test.rs index 6251b687f4..9fdc83dfaf 100644 --- a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/affected_tests_behavior_test.rs +++ b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/affected_tests_behavior_test.rs @@ -111,6 +111,39 @@ async fn run_affected(fixture: &ProductionCompositionFixture, arguments: Value) ) } +/// The problem message a typed request refusal carries. The owner refuses +/// with an error result whose body is the problem envelope. +async fn refusal(fixture: &ProductionCompositionFixture, mut arguments: Value) -> String { + arguments["format"] = json!("json"); + let response = fixture + .harness + .call_tool( + &fixture.project_root, + "tracedecay_run_affected_tests", + arguments, + ) + .await + .expect("production run_affected_tests invocation"); + let result = serde_json::to_value(response.result.expect("refusal result")).unwrap(); + assert_eq!(result["isError"], json!(true), "{result}"); + let envelope: Value = + serde_json::from_str(result["content"][0]["text"].as_str().expect("refusal text")) + .expect("problem envelope JSON"); + assert_eq!( + envelope["problem"]["kind"], + json!("invalid_request"), + "{result}" + ); + envelope["problem"]["message"] + .as_str() + .expect("problem message") + .to_owned() +} + +fn refused(detail: &str) -> String { + format!("invalid arguments for tracedecay_run_affected_tests: {detail}") +} + async fn symbol_id(fixture: &ProductionCompositionFixture, name: &str, file: &str) -> String { let result = call_tool( fixture, @@ -181,37 +214,44 @@ async fn run_affected_tests_reports_the_cargo_result_for_the_changed_manifest() .expect("production affected-tests server"); wait_for_current_graph(&server).await; - assert_rejection( - &run_affected(&fixture, json!({"timeout_secs": 1})).await, - "changed_paths", - "`changed_paths` is required and must explicitly scope the affected-test run", + assert_eq!( + refusal(&fixture, json!({"timeout_secs": 1})).await, + refused("missing field `changed_paths`") ); - assert_rejection( - &run_affected( + assert_eq!( + refusal( &fixture, - json!({"changed_paths": "src/lib.rs", "timeout_secs": 1}), + json!({"changed_paths": "src/lib.rs", "timeout_secs": 1}) ) .await, - "changed_paths", - "`changed_paths` must be an array of project-relative string paths", + refused("invalid type: string \"src/lib.rs\", expected a sequence") ); - assert_rejection( - &run_affected( + assert_eq!( + refusal( &fixture, - json!({"changed_paths": ["src/lib.rs", 7], "timeout_secs": 1}), + json!({"changed_paths": ["src/lib.rs", 7], "timeout_secs": 1}) ) .await, - "changed_paths", - "`changed_paths` must contain only project-relative string paths", + refused("invalid type: integer `7`, expected a string") ); - assert_rejection( - &run_affected( + assert_eq!( + refusal( &fixture, - json!({"changed_paths": ["src/lib.rs"], "profile": "bench", "timeout_secs": 1}), + json!({"changed_paths": ["src/lib.rs"], "profile": "bench", "timeout_secs": 1}) ) .await, - "profile", - "`profile` must be `debug` or `release`", + refused("unknown variant `bench`, expected `debug` or `release`") + ); + // An argument outside the typed request is refused, not silently ignored. + assert_eq!( + refusal( + &fixture, + json!({"changed_paths": ["src/lib.rs"], "filter": "greeting", "timeout_secs": 1}) + ) + .await, + refused( + "unknown field `filter`, expected one of `changed_paths`, `profile`, `timeout_secs`, `max_tests`" + ) ); assert_rejection( &run_affected( @@ -388,6 +428,69 @@ async fn run_affected_tests_reports_the_cargo_result_for_the_changed_manifest() fixture.harness.shutdown().await; } +fn coalescing_counts(stats: &Value) -> (u64, u64) { + let counts = &stats["identical_read_coalescing"]; + ( + counts["leaders"].as_u64().expect("coalescing leaders"), + counts["followers"].as_u64().expect("coalescing followers"), + ) +} + +/// A side-effecting owner call is never answered from an identical call in +/// flight beside it: two identical concurrent runs are two managed test runs. +/// Two identical concurrent reads still enter the identical-read coalescer. +#[tokio::test] +async fn identical_concurrent_test_runs_each_run_while_identical_reads_still_ride() { + let fixture = production_composition_fixture_with_sources(write_affected_fixture).await; + let server = fixture + .harness + .server(&fixture.project_root) + .expect("production affected-tests server"); + wait_for_current_graph(&server).await; + let run = json!({ + "changed_paths": ["tests/ordered.rs"], + "timeout_secs": 120, + "max_tests": 1, + "format": "json", + }); + + let before = coalescing_counts(&server.server_stats_json().await); + let (first, second) = tokio::join!( + run_affected(&fixture, run.clone()), + run_affected(&fixture, run.clone()) + ); + let after_runs = coalescing_counts(&server.server_stats_json().await); + for output in [&first, &second] { + assert_eq!(output["dispatched_tests"], json!([KEPT_TEST]), "{output}"); + assert_eq!(output["passed"], json!(1), "{output}"); + } + assert_ne!( + first["terminal"]["operation_id"], second["terminal"]["operation_id"], + "each identical run records its own managed test run" + ); + assert_eq!( + after_runs, before, + "test runs never enter the identical-read coalescer" + ); + + let read = json!({"path": "src", "format": "json"}); + let (first_read, second_read) = tokio::join!( + call_tool(&fixture, "tracedecay_files", read.clone()), + call_tool(&fixture, "tracedecay_files", read.clone()) + ); + assert_eq!( + extract_text(&first_read.value), + extract_text(&second_read.value) + ); + let after_reads = coalescing_counts(&server.server_stats_json().await); + assert_eq!( + (after_reads.0 - after_runs.0) + (after_reads.1 - after_runs.1), + 2, + "both identical reads enter the identical-read coalescer" + ); + fixture.harness.shutdown().await; +} + /// The operation-event authority is process-global, so every daemon /// composition in this test process shares it. A peer composition shutting /// down (the production `DaemonInvocationState::shutdown` path) between a diff --git a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/graph_analysis_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/graph_analysis_test.rs index ffa1d6fe42..31e899a73d 100644 --- a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/graph_analysis_test.rs +++ b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/graph_analysis_test.rs @@ -753,28 +753,6 @@ async fn test_changelog_no_git() { close_test_graph(cg).await; } -#[tokio::test] -async fn run_affected_tests_requires_manifest_scoped_changed_paths() { - let (cg, _env, _dir) = setup_empty_project().await; - let result = handle_tool_call( - &cg, - "tracedecay_run_affected_tests", - json!({"timeout_secs": 1}), - None, - None, - ) - .await - .unwrap(); - let text = extract_text(&result.value); - let output: Value = serde_json::from_str(text).unwrap(); - assert_eq!(output["error"]["kind"].as_str(), Some("invalid_request")); - assert_eq!(output["error"]["operation"].as_str(), Some("changed_paths")); - assert!( - output["note"].is_null(), - "missing scope input must not be reported as a no-change note: {output}" - ); -} - #[tokio::test] async fn pr_context_no_git_returns_structured_git_error() { let cg = setup_empty_analysis_project().await; diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json index 90b5daa9e1..8a63a3f82f 100644 --- a/dashboard/codegen/schemas/dashboard-contracts.schema.json +++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json @@ -11203,17 +11203,31 @@ }, "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.", - "enum": [ - "read", - "preview", - "source_edit", - "git_index_stage", - "git_index_unstage", - "git_index_commit", - "configuration_write", - "administrative" - ], - "type": "string" + "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" + } + ] }, "EffectReceipt": { "additionalProperties": false, diff --git a/dashboard/src/contracts/generated.ts b/dashboard/src/contracts/generated.ts index 0e3f028474..1bf9419244 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.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]); +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")]); 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 cd24cd84c5..83d8a7a7a4 100644 --- a/sdks/typescript/src/operations.ts +++ b/sdks/typescript/src/operations.ts @@ -36,6 +36,10 @@ export type AddWorkTaskRequestV1 = { readonly item: WorkItemV1; readonly mutatio export type AdjudicateWorkLeakCommandV1 = { readonly adjudication_id: string; readonly attempt: WorkAttemptIdentityV1; readonly command_id: WorkCommandId; readonly detection_horizon_micros: number; readonly expected_revision?: number | null }; export type AdmitWorkExecutionRequestV1 = { readonly based_on_version: number; readonly mutation: WorkProductMutationIdentityV1; readonly selection: WorkProductSelectionScopeV1; readonly task_id: TaskId }; export type AffectedRankingMetadataV1 = { readonly compatibility_field: string; readonly distance: string; readonly recommended_proximity: readonly string[]; readonly strategy: string }; +export type AffectedTestErrorV1 = { readonly kind: string; readonly message: string; readonly operation: string }; +export type AffectedTestOutcomeV1 = { readonly covers_source_ids: readonly string[]; readonly passed: boolean; readonly test: string }; +export type AffectedTestRunV1 = { readonly dispatched_tests: readonly string[]; readonly error?: AffectedTestErrorV1 | null; readonly exit_code?: number | null; readonly failed: number; readonly passed: number; readonly results: readonly AffectedTestOutcomeV1[]; readonly stderr_tail: string; readonly stdout_tail: string; readonly terminal: ManagedTestTerminalV1; readonly total_observed: number; readonly truncated: boolean }; +export type AffectedTestsNotRunV1 = { readonly error?: AffectedTestErrorV1 | null; readonly failed: number; readonly note?: string | null; readonly passed: number; readonly results: readonly AffectedTestOutcomeV1[] }; export type AgentInstanceId = string; export type AgentTaskFailureClass = "retryable" | "permanent" | "timeout" | "unavailable" | "denied" | "disconnected" | "malformed_output"; export type AgentTaskKind = "memory_curator" | "session_reflector" | "skill_writer" | "combined_review" | "user_job"; @@ -249,6 +253,7 @@ export type CreateWorkTaskRequestV1 = { readonly initiative: WorkInitiativeV1; r export type CredentialReferenceId = string; export type CrossMergeModeV1 = "disabled" | "manual_receipt_only" | "fast_forward_only" | "merge_commit" | "cherry_pick_exact_commits"; export type CrossMergePolicyV1 = { readonly allow_cross_repository: boolean; readonly allowed_modes: readonly CrossMergeModeV1[]; readonly default_mode: CrossMergeModeV1 }; +export type DashboardActionV1 = "start" | "stop"; export type DeadCodeSymbolV1 = { readonly file: string; readonly id: string; readonly kind: string; readonly line: number; readonly name: string; readonly signature?: string | null }; export type Deadline = { readonly expires_at: UtcMicros }; export type DecideWorkProposalRequestV1 = { readonly disposition: WorkProposalDispositionV1; readonly mutation: WorkProductMutationIdentityV1; readonly proposal: WorkProposalV1; readonly selection: WorkProductSelectionScopeV1 }; @@ -282,7 +287,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"; +export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server"; 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"; @@ -560,6 +565,7 @@ export type ManagedSkillProvenance = { readonly actor: string; readonly run_id?: export type ManagedSkillSource = "automation_run" | "user" | "import"; export type ManagedSkillState = "active" | "disabled" | "archived"; export type ManagedSupportFile = { readonly bytes: readonly number[]; readonly path: string; readonly [key: string]: unknown }; +export type ManagedTestTerminalV1 = { readonly operation_id: string; readonly receipt: OperationReceipt_2; readonly result_tool: string }; export type ManifestDigest = string; export type MechanicalIntegrationModeV1 = "fast_forward" | "two_parent_merge" | "cherry_pick_exact_commits"; export type MemoryAlgebraV1 = { readonly estimated_capacity: number; readonly hrr_dim: number; readonly name: string }; @@ -906,6 +912,7 @@ export type TestAttributionMethodV1 = "none" | "direct_unit" | "closure"; export type TestMapSourceCoverageV1 = { readonly source_file: string; readonly source_id: string; readonly source_line: number; readonly source_name: string; readonly tests: readonly TestMapTestV1[] }; export type TestMapTestV1 = { readonly attribution_depth: number; readonly test_file: string; readonly test_line: number; readonly test_name: string }; export type TestMapUncoveredV1 = { readonly file: string; readonly id: string; readonly line: number; readonly name: string }; +export type TestProfileV1 = "debug" | "release"; export type TestResultProjectionV1 = { readonly passed: boolean; readonly test: string }; export type TestRiskAttributionSummaryV1 = { readonly cli_entry_attributed: number; readonly closure_attributed: number; readonly depth: number; readonly direct_unit_attributed: number; readonly public_api_attributed: number; readonly total_attributed: number; readonly trait_resolved_attributed: number }; export type TestRiskBucketSummaryV1 = { readonly attributed: number; readonly excluded: number; readonly orphan_entry: number; readonly reachable_unattributed: number }; @@ -1292,6 +1299,8 @@ export type OperationApplicationContextScoutStatusRequest = { readonly address: export type OperationApplicationContextScoutStatusResult = { 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 OperationApplicationCouplingRequest = { readonly direction?: CouplingDirectionV1 | null; readonly limit?: number | null; readonly path?: string | null }; export type OperationApplicationCouplingResult = { readonly direction: CouplingDirectionV1; readonly ranking: readonly CouplingEntryV1[]; readonly result_count: number }; +export type OperationApplicationDashboardRequest = { readonly action?: DashboardActionV1 | null; readonly host?: string | null; readonly port?: number | null }; +export type OperationApplicationDashboardResult = { readonly host: string; readonly port: number; readonly status: "started"; readonly url: string } | { readonly host: string; readonly port: number; readonly requested_host: string; readonly requested_port: number; readonly requested_port_honored: boolean; readonly status: "already_running"; readonly url: string } | { readonly host: string; readonly port: number; readonly requested_host: string; readonly requested_port: number; readonly requested_port_honored: boolean; readonly status: "stopping"; readonly url: string } | { readonly previous_url: string; readonly status: "stopped" } | { readonly status: "not_running" }; export type OperationApplicationDeadCodeRequest = { readonly include_public?: boolean | null; readonly kinds?: readonly string[] | null; readonly limit?: number | null; readonly path?: string | null }; export type OperationApplicationDeadCodeResult = { readonly dead_code_count: number; readonly symbols: readonly DeadCodeSymbolV1[] }; export type OperationApplicationDependencyDepthRequest = { readonly limit?: number | null; readonly path?: string | null }; @@ -1454,6 +1463,8 @@ export type OperationApplicationReplaceSymbolRequest = { readonly dry_run?: bool export type OperationApplicationReplaceSymbolResult = EditResult | MultiEditResult | InsertResult | AstGrepResult | MoveResult | RenameResult | SourceEditFailedResultV1 | SourceEditCancelledResultV1 | SourceEditTimedOutResultV1 | SourceEditEffectUnknownResultV1 | SourceEditReconciledResultV1 | SourceEditDurableEffectPayloadV1; export type OperationApplicationRetrieveRequest = { readonly handle: string; readonly max_chars?: number | null; readonly offset?: number | null }; export type OperationApplicationRetrieveResult = RetrievedPageV1 | RetrieveHandleMissingV1 | RetrieveHandleExpiredV1; +export type OperationApplicationRunAffectedTestsRequest = { readonly changed_paths: readonly string[]; readonly max_tests?: number | null; readonly profile?: TestProfileV1 | null; readonly timeout_secs?: number | null }; +export type OperationApplicationRunAffectedTestsResult = AffectedTestRunV1 | AffectedTestsNotRunV1; export type OperationApplicationSearchRequest = { readonly cursor?: string | null; readonly lazy_index_ignored_dependencies?: boolean | null; readonly lexical_aliases?: readonly SearchLexicalAliasV1[] | null; readonly lexical_anchors?: readonly string[] | null; readonly lexical_field_filters?: readonly SearchLexicalFieldFilterV1[] | null; readonly lexical_phrases?: readonly string[] | null; readonly lexical_proximities?: readonly SearchLexicalProximityV1[] | null; readonly limit?: number | null; readonly prefer_symbol?: boolean | null; readonly query: string }; export type OperationApplicationSearchResult = SearchCompleteV1 | SearchUnavailableV1; export type OperationApplicationSessionLookupRequest = { readonly meta: RetrievalRequestMeta; readonly session_id: SessionId }; @@ -1636,6 +1647,10 @@ const DEFINITIONS = { AdjudicateWorkLeakCommandV1: {"additionalProperties":false,"properties":{"adjudication_id":{"type":"string"},"attempt":{"$ref":"#/$defs/WorkAttemptIdentityV1"},"command_id":{"$ref":"#/$defs/WorkCommandId"},"detection_horizon_micros":{"format":"uint64","minimum":0,"type":"integer"},"expected_revision":{"format":"uint64","minimum":0,"type":["integer","null"]}},"required":["adjudication_id","attempt","detection_horizon_micros","command_id"],"title":"AdjudicateWorkLeakCommandV1","type":"object"}, AdmitWorkExecutionRequestV1: {"additionalProperties":false,"properties":{"based_on_version":{"format":"uint64","minimum":0,"type":"integer"},"mutation":{"$ref":"#/$defs/WorkProductMutationIdentityV1"},"selection":{"$ref":"#/$defs/WorkProductSelectionScopeV1"},"task_id":{"$ref":"#/$defs/TaskId"}},"required":["selection","task_id","based_on_version","mutation"],"type":"object"}, AffectedRankingMetadataV1: {"additionalProperties":false,"properties":{"compatibility_field":{"type":"string"},"distance":{"type":"string"},"recommended_proximity":{"items":{"type":"string"},"type":"array"},"strategy":{"type":"string"}},"required":["strategy","distance","recommended_proximity","compatibility_field"],"type":"object"}, + AffectedTestErrorV1: {"additionalProperties":false,"description":"Why a run failed or was refused.","properties":{"kind":{"type":"string"},"message":{"type":"string"},"operation":{"type":"string"}},"required":["kind","operation","message"],"type":"object"}, + AffectedTestOutcomeV1: {"additionalProperties":false,"description":"One observed libtest outcome.","properties":{"covers_source_ids":{"description":"Graph symbols this test was selected to cover.","items":{"type":"string"},"type":"array"},"passed":{"type":"boolean"},"test":{"type":"string"}},"required":["test","passed","covers_source_ids"],"type":"object"}, + AffectedTestRunV1: {"additionalProperties":false,"description":"A dispatched run, completed or failed, with what it observed.","properties":{"dispatched_tests":{"items":{"type":"string"},"type":"array"},"error":{"anyOf":[{"$ref":"#/$defs/AffectedTestErrorV1"},{"type":"null"}],"description":"Present when the run did not complete."},"exit_code":{"format":"int32","type":["integer","null"]},"failed":{"format":"uint64","minimum":0,"type":"integer"},"passed":{"format":"uint64","minimum":0,"type":"integer"},"results":{"items":{"$ref":"#/$defs/AffectedTestOutcomeV1"},"type":"array"},"stderr_tail":{"type":"string"},"stdout_tail":{"type":"string"},"terminal":{"$ref":"#/$defs/ManagedTestTerminalV1"},"total_observed":{"format":"uint64","minimum":0,"type":"integer"},"truncated":{"description":"More affected tests existed than `max_tests` admitted.","type":"boolean"}},"required":["passed","failed","total_observed","dispatched_tests","truncated","results","stderr_tail","stdout_tail","terminal"],"type":"object"}, + AffectedTestsNotRunV1: {"additionalProperties":false,"description":"No test was dispatched: nothing covers the change, or the request was\nrefused before a run began.","properties":{"error":{"anyOf":[{"$ref":"#/$defs/AffectedTestErrorV1"},{"type":"null"}]},"failed":{"description":"Always 0.","format":"uint64","minimum":0,"type":"integer"},"note":{"type":["string","null"]},"passed":{"description":"Always 0.","format":"uint64","minimum":0,"type":"integer"},"results":{"description":"Always empty.","items":{"$ref":"#/$defs/AffectedTestOutcomeV1"},"type":"array"}},"required":["passed","failed","results"],"type":"object"}, AgentInstanceId: {"description":"Strongly typed canonical identity: `AgentInstanceId`.","type":"string"}, AgentTaskFailureClass: {"enum":["retryable","permanent","timeout","unavailable","denied","disconnected","malformed_output"],"type":"string"}, AgentTaskKind: {"enum":["memory_curator","session_reflector","skill_writer","combined_review","user_job"],"type":"string"}, @@ -1849,6 +1864,7 @@ const DEFINITIONS = { CredentialReferenceId: {"description":"Strongly typed canonical identity: `CredentialReferenceId`.","type":"string"}, CrossMergeModeV1: {"enum":["disabled","manual_receipt_only","fast_forward_only","merge_commit","cherry_pick_exact_commits"],"type":"string"}, CrossMergePolicyV1: {"additionalProperties":false,"properties":{"allow_cross_repository":{"type":"boolean"},"allowed_modes":{"items":{"$ref":"#/$defs/CrossMergeModeV1"},"type":"array","uniqueItems":true},"default_mode":{"$ref":"#/$defs/CrossMergeModeV1"}},"required":["allowed_modes","default_mode","allow_cross_repository"],"type":"object"}, + DashboardActionV1: {"description":"What `tracedecay_dashboard` does.","enum":["start","stop"],"type":"string"}, DeadCodeSymbolV1: {"additionalProperties":false,"properties":{"file":{"type":"string"},"id":{"type":"string"},"kind":{"type":"string"},"line":{"format":"uint32","minimum":0,"type":"integer"},"name":{"type":"string"},"signature":{"type":["string","null"]}},"required":["id","name","kind","file","line"],"type":"object"}, Deadline: {"additionalProperties":false,"description":"One immutable deadline supplied by the caller or upstream admission layer.","properties":{"expires_at":{"$ref":"#/$defs/UtcMicros"}},"required":["expires_at"],"type":"object"}, DecideWorkProposalRequestV1: {"additionalProperties":false,"properties":{"disposition":{"$ref":"#/$defs/WorkProposalDispositionV1"},"mutation":{"$ref":"#/$defs/WorkProductMutationIdentityV1"},"proposal":{"$ref":"#/$defs/WorkProposalV1"},"selection":{"$ref":"#/$defs/WorkProductSelectionScopeV1"}},"required":["selection","proposal","disposition","mutation"],"type":"object"}, @@ -1882,7 +1898,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.","enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"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"}]}, 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"}, @@ -2160,6 +2176,7 @@ const DEFINITIONS = { ManagedSkillSource: {"enum":["automation_run","user","import"],"type":"string"}, ManagedSkillState: {"enum":["active","disabled","archived"],"type":"string"}, ManagedSupportFile: {"properties":{"bytes":{"items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"type":"array"},"path":{"type":"string"}},"required":["path","bytes"],"type":"object"}, + ManagedTestTerminalV1: {"additionalProperties":false,"description":"The managed test-run operation the run was recorded under.","properties":{"operation_id":{"type":"string"},"receipt":{"$ref":"#/$defs/OperationReceipt"},"result_tool":{"description":"The tool that reads the recorded results back.","type":"string"}},"required":["operation_id","result_tool","receipt"],"type":"object"}, ManifestDigest: {"description":"Strongly typed algorithm-tagged integrity digest: `ManifestDigest`.","type":"string"}, MechanicalIntegrationModeV1: {"description":"The only Git histories this product operation can create.","enum":["fast_forward","two_parent_merge","cherry_pick_exact_commits"],"type":"string"}, MemoryAlgebraV1: {"additionalProperties":false,"properties":{"estimated_capacity":{"format":"uint64","minimum":0,"type":"integer"},"hrr_dim":{"format":"uint64","minimum":0,"type":"integer"},"name":{"type":"string"}},"required":["name","hrr_dim","estimated_capacity"],"type":"object"}, @@ -2506,6 +2523,7 @@ const DEFINITIONS = { TestMapSourceCoverageV1: {"additionalProperties":false,"properties":{"source_file":{"type":"string"},"source_id":{"type":"string"},"source_line":{"format":"uint32","minimum":0,"type":"integer"},"source_name":{"type":"string"},"tests":{"items":{"$ref":"#/$defs/TestMapTestV1"},"type":"array"}},"required":["source_name","source_id","source_file","source_line","tests"],"type":"object"}, TestMapTestV1: {"additionalProperties":false,"properties":{"attribution_depth":{"format":"uint32","minimum":0,"type":"integer"},"test_file":{"type":"string"},"test_line":{"format":"uint32","minimum":0,"type":"integer"},"test_name":{"type":"string"}},"required":["test_name","test_file","test_line","attribution_depth"],"type":"object"}, TestMapUncoveredV1: {"additionalProperties":false,"properties":{"file":{"type":"string"},"id":{"type":"string"},"line":{"format":"uint32","minimum":0,"type":"integer"},"name":{"type":"string"}},"required":["id","name","file","line"],"type":"object"}, + TestProfileV1: {"description":"The cargo profile an affected-test run builds with.","enum":["debug","release"],"type":"string"}, TestResultProjectionV1: {"additionalProperties":false,"description":"One result emitted by the daemon-managed test-run authority.","properties":{"passed":{"type":"boolean"},"test":{"type":"string"}},"required":["test","passed"],"type":"object"}, TestRiskAttributionSummaryV1: {"additionalProperties":false,"properties":{"cli_entry_attributed":{"format":"uint64","minimum":0,"type":"integer"},"closure_attributed":{"format":"uint64","minimum":0,"type":"integer"},"depth":{"format":"uint64","minimum":0,"type":"integer"},"direct_unit_attributed":{"format":"uint64","minimum":0,"type":"integer"},"public_api_attributed":{"format":"uint64","minimum":0,"type":"integer"},"total_attributed":{"format":"uint64","minimum":0,"type":"integer"},"trait_resolved_attributed":{"format":"uint64","minimum":0,"type":"integer"}},"required":["depth","direct_unit_attributed","closure_attributed","trait_resolved_attributed","public_api_attributed","cli_entry_attributed","total_attributed"],"type":"object"}, TestRiskBucketSummaryV1: {"additionalProperties":false,"properties":{"attributed":{"format":"uint64","minimum":0,"type":"integer"},"excluded":{"format":"uint64","minimum":0,"type":"integer"},"orphan_entry":{"format":"uint64","minimum":0,"type":"integer"},"reachable_unattributed":{"format":"uint64","minimum":0,"type":"integer"}},"required":["attributed","reachable_unattributed","orphan_entry","excluded"],"type":"object"}, @@ -2873,6 +2891,8 @@ const SCHEMAS: readonly CanonicalJsonSchema[] = [ {"$defs":{"ContextScoutDeliveryOutcomeV1":DEFINITIONS.ContextScoutDeliveryOutcomeV1,"ContextScoutFeedbackKindV1":DEFINITIONS.ContextScoutFeedbackKindV1,"ContextScoutLimitsV1":DEFINITIONS.ContextScoutLimitsV1,"ContextScoutModelBackendV1":DEFINITIONS.ContextScoutModelBackendV1,"ContextScoutModelOutcomeV1":DEFINITIONS.ContextScoutModelOutcomeV1,"ContextScoutModelReceiptV1":DEFINITIONS.ContextScoutModelReceiptV1,"ContextScoutRouteV1":DEFINITIONS.ContextScoutRouteV1,"ContextScoutRuntimeModeV1":DEFINITIONS.ContextScoutRuntimeModeV1,"ContextScoutServiceStateV1":DEFINITIONS.ContextScoutServiceStateV1,"ContextScoutSuppressionV1":DEFINITIONS.ContextScoutSuppressionV1},"$schema":"https://json-schema.org/draft/2020-12/schema","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"],"title":"ContextScoutStatusResultV1","type":"object"}, {"$defs":{"CouplingDirectionV1":DEFINITIONS.CouplingDirectionV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"direction":{"anyOf":[{"$ref":"#/$defs/CouplingDirectionV1"},{"type":"null"}],"description":"fan_in: files depended on by the most others. fan_out: files that\ndepend on the most others (default: fan_in)."},"limit":{"description":"Maximum number of results to return (default: 10, at most 100).","format":"uint32","minimum":0,"type":["integer","null"]},"path":{"description":"Filter to files under this directory path (e.g. 'src/main/java').","type":["string","null"]}},"title":"CouplingSurfaceRequestV1","type":"object"}, {"$defs":{"CouplingDirectionV1":DEFINITIONS.CouplingDirectionV1,"CouplingEntryV1":DEFINITIONS.CouplingEntryV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"direction":{"$ref":"#/$defs/CouplingDirectionV1"},"ranking":{"items":{"$ref":"#/$defs/CouplingEntryV1"},"type":"array"},"result_count":{"format":"uint64","minimum":0,"type":"integer"}},"required":["direction","result_count","ranking"],"title":"CouplingResultV1","type":"object"}, + {"$defs":{"DashboardActionV1":DEFINITIONS.DashboardActionV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"action":{"anyOf":[{"$ref":"#/$defs/DashboardActionV1"},{"type":"null"}],"description":"Action to perform (default: \"start\"). \"stop\" shuts down a previously\nstarted dashboard if any."},"host":{"description":"Loopback host address to bind: 127.0.0.1, localhost, or ::1\n(default: \"127.0.0.1\"). Wildcard, LAN, public IPs, and other\nhostnames are rejected.","type":["string","null"]},"port":{"description":"Port to listen on; 0 picks an ephemeral port (default: 7341).","format":"uint16","maximum":65535,"minimum":0,"type":["integer","null"]}},"title":"DashboardSurfaceRequestV1","type":"object"}, + {"$schema":"https://json-schema.org/draft/2020-12/schema","oneOf":[{"additionalProperties":false,"properties":{"host":{"type":"string"},"port":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"status":{"const":"started","type":"string"},"url":{"type":"string"}},"required":["status","url","host","port"],"type":"object"},{"additionalProperties":false,"description":"A dashboard that was already bound when `start` was asked again.","properties":{"host":{"type":"string"},"port":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"requested_host":{"type":"string"},"requested_port":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"requested_port_honored":{"description":"Whether the bound port is the one asked for (always true for 0).","type":"boolean"},"status":{"const":"already_running","type":"string"},"url":{"type":"string"}},"required":["status","url","host","port","requested_host","requested_port","requested_port_honored"],"type":"object"},{"additionalProperties":false,"description":"The bound server is shutting down.","properties":{"host":{"type":"string"},"port":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"requested_host":{"type":"string"},"requested_port":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"},"requested_port_honored":{"description":"Whether the bound port is the one asked for (always true for 0).","type":"boolean"},"status":{"const":"stopping","type":"string"},"url":{"type":"string"}},"required":["status","url","host","port","requested_host","requested_port","requested_port_honored"],"type":"object"},{"additionalProperties":false,"properties":{"previous_url":{"type":"string"},"status":{"const":"stopped","type":"string"}},"required":["status","previous_url"],"type":"object"},{"additionalProperties":false,"properties":{"status":{"const":"not_running","type":"string"}},"required":["status"],"type":"object"}],"title":"DashboardResultV1"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"include_public":{"description":"When true, do NOT exclude pub items. Default false.","type":["boolean","null"]},"kinds":{"description":"Node kinds to check (default: [\"function\", \"method\"]).","items":{"type":"string"},"type":["array","null"]},"limit":{"description":"Maximum symbols to return (default: 100, max: 1000).","format":"uint32","minimum":0,"type":["integer","null"]},"path":{"description":"Filter reported symbols to files under this directory path (e.g.\n'crates/tracedecay-mcp'). Omit for the entire codebase.","type":["string","null"]}},"title":"DeadCodeSurfaceRequestV1","type":"object"}, {"$defs":{"DeadCodeSymbolV1":DEFINITIONS.DeadCodeSymbolV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"dead_code_count":{"format":"uint64","minimum":0,"type":"integer"},"symbols":{"items":{"$ref":"#/$defs/DeadCodeSymbolV1"},"type":"array"}},"required":["dead_code_count","symbols"],"title":"DeadCodeResultV1","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"limit":{"description":"Maximum number of chains to return (default: 10, at most 100).","format":"uint32","minimum":0,"type":["integer","null"]},"path":{"description":"Filter to files under this directory path.","type":["string","null"]}},"title":"DependencyDepthSurfaceRequestV1","type":"object"}, @@ -3018,6 +3038,8 @@ const SCHEMAS: readonly CanonicalJsonSchema[] = [ {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"description":"Exact public input accepted by `tracedecay_replace_symbol`.","properties":{"dry_run":{"default":false,"type":"boolean"},"expected_state":{"description":"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.","type":["string","null"]},"idempotency_key":{"type":["string","null"]},"new_source":{"type":"string"},"symbol":{"type":"string"},"verify":{"default":false,"type":"boolean"}},"required":["symbol","new_source"],"title":"ReplaceSymbolSurfaceRequestV1","type":"object"}, {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"handle":{"description":"The required `handle` argument copied exactly from a truncated MCP\nresponse envelope.","type":"string"},"max_chars":{"description":"Maximum characters requested for this page. Values above the safe\nresponse-frame budget are clamped.","format":"uint64","minimum":1,"type":["integer","null"]},"offset":{"default":0,"description":"Character offset into the immutable stored response (default: 0). Use\nthe prior page's next_offset.","format":"uint64","minimum":0,"type":["integer","null"]}},"required":["handle"],"title":"RetrieveSurfaceRequestV1","type":"object"}, {"$defs":{"RetrieveHandleExpiredV1":DEFINITIONS.RetrieveHandleExpiredV1,"RetrieveHandleMissingV1":DEFINITIONS.RetrieveHandleMissingV1,"RetrievedPageV1":DEFINITIONS.RetrievedPageV1},"$schema":"https://json-schema.org/draft/2020-12/schema","anyOf":[{"$ref":"#/$defs/RetrievedPageV1"},{"$ref":"#/$defs/RetrieveHandleMissingV1"},{"$ref":"#/$defs/RetrieveHandleExpiredV1"}],"description":"What a retrieve found under the handle.","title":"RetrieveResultV1"}, + {"$defs":{"TestProfileV1":DEFINITIONS.TestProfileV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"changed_paths":{"description":"Explicit manifest of project-relative file paths used to compute\naffected tests.","items":{"type":"string"},"type":"array"},"max_tests":{"description":"Cap on tests dispatched in a single invocation, 1 through 500\n(default: 100).","format":"uint64","maximum":500,"minimum":1,"type":["integer","null"]},"profile":{"anyOf":[{"$ref":"#/$defs/TestProfileV1"},{"type":"null"}],"description":"Cargo profile (default: debug)."},"timeout_secs":{"description":"Maximum wall time in seconds before the cargo subprocess is killed,\n1 through 300 (default: 300).","format":"uint64","maximum":300,"minimum":1,"type":["integer","null"]}},"required":["changed_paths"],"title":"RunAffectedTestsSurfaceRequestV1","type":"object"}, + {"$defs":{"AffectedTestErrorV1":DEFINITIONS.AffectedTestErrorV1,"AffectedTestOutcomeV1":DEFINITIONS.AffectedTestOutcomeV1,"AffectedTestRunV1":DEFINITIONS.AffectedTestRunV1,"AffectedTestsNotRunV1":DEFINITIONS.AffectedTestsNotRunV1,"CancellationObservation":DEFINITIONS.CancellationObservation,"CancellationStage":DEFINITIONS.CancellationStage,"Deadline":DEFINITIONS.Deadline,"ManagedTestTerminalV1":DEFINITIONS.ManagedTestTerminalV1,"OperationBudgetUsage":DEFINITIONS.OperationBudgetUsage,"OperationReceipt":DEFINITIONS.OperationReceipt_2,"OperationTermination":DEFINITIONS.OperationTermination_2,"UtcMicros":DEFINITIONS.UtcMicros},"$schema":"https://json-schema.org/draft/2020-12/schema","anyOf":[{"$ref":"#/$defs/AffectedTestRunV1"},{"$ref":"#/$defs/AffectedTestsNotRunV1"}],"title":"RunAffectedTestsResultV1"}, {"$defs":{"SearchLexicalAliasV1":DEFINITIONS.SearchLexicalAliasV1,"SearchLexicalFieldFilterV1":DEFINITIONS.SearchLexicalFieldFilterV1,"SearchLexicalFieldV1":DEFINITIONS.SearchLexicalFieldV1,"SearchLexicalProximityV1":DEFINITIONS.SearchLexicalProximityV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"cursor":{"description":"Authenticated opaque continuation returned as next_cursor. Repeat the same query and lexical options with it.","type":["string","null"]},"lazy_index_ignored_dependencies":{"description":"Opt in to bounded indexing of ignored dependency entry files when an import hint matches (default: false).","type":["boolean","null"]},"lexical_aliases":{"description":"Named query-time vocabulary aliases. The strict query always ranks first. Alias-only hits follow it with the strict query, alternative, and configured-vocabulary reason disclosed.","items":{"$ref":"#/$defs/SearchLexicalAliasV1"},"maxItems":8,"type":["array","null"]},"lexical_anchors":{"description":"Exact identifiers or technical terms (e.g. 'reserve_stock', 'Foo::bar', 'E0308') that the answer must be about. Each is ranked through the lexical lane as its own route: a hit carrying an anchor outranks every hit that carries none, exact hits included, every anchor with matches keeps at least its best sites through the lane cap, and `lexical_anchors` in the response reports each anchor's outcome (`matched` rows, `admitted` sites this response returns, `dropped` admitted sites it could not carry with the reason, `unmatched`, or `not_served`). Ranked retrieval, not exhaustive grep (use tracedecay_grep for that). Each result names the routes that ranked it. At most 8 anchors, each one whitespace-free term of at most 128 bytes, no repeats.","items":{"type":"string"},"maxItems":8,"type":["array","null"]},"lexical_field_filters":{"description":"Include or exclude lexical symbol_name, qualified_name, path, signature, documentation, body_text, preamble_text, exact_term, or subtoken fields.","items":{"$ref":"#/$defs/SearchLexicalFieldFilterV1"},"maxItems":9,"type":["array","null"]},"lexical_phrases":{"description":"Exact lexical phrases to rank through n-gram candidate pruning.","items":{"type":"string"},"maxItems":4,"type":["array","null"]},"lexical_proximities":{"description":"Ordered lexical terms that must occur within the bounded intervening-token gap.","items":{"$ref":"#/$defs/SearchLexicalProximityV1"},"maxItems":4,"type":["array","null"]},"limit":{"description":"Maximum number of results to return (default: 10)","format":"uint64","minimum":0,"type":["integer","null"]},"prefer_symbol":{"description":"Add a lexical route restricted to symbol-name matches for the identifier-shaped words of the query (default: false). Query words such as class/struct/function/find/explain are ignored; 'Foo::bar' and 'Foo.bar' contribute 'bar'.","type":["boolean","null"]},"query":{"description":"Search query string to match against symbol names","type":"string"}},"required":["query"],"title":"SearchSurfaceRequestV1","type":"object"}, {"$defs":{"ApplicationProblemDetailV1":DEFINITIONS.ApplicationProblemDetailV1_2,"CalibrationProfileId":DEFINITIONS.CalibrationProfileId,"CandidateContribution":DEFINITIONS.CandidateContribution,"CodeIndexBuildBlockedReasonV1":DEFINITIONS.CodeIndexBuildBlockedReasonV1,"CodeIndexConvergenceParkedV1":DEFINITIONS.CodeIndexConvergenceParkedV1,"CodeIndexStalenessStateV1":DEFINITIONS.CodeIndexStalenessStateV1,"ComponentRevision":DEFINITIONS.ComponentRevision,"ContextLexicalAnchorV1":DEFINITIONS.ContextLexicalAnchorV1,"DiagnosticsSearchedTsconfigV1":DEFINITIONS.DiagnosticsSearchedTsconfigV1,"EvidenceRole":DEFINITIONS.EvidenceRole,"ExactClass":DEFINITIONS.ExactClass,"FileOccurrenceId":DEFINITIONS.FileOccurrenceId,"FixedPointScore":DEFINITIONS.FixedPointScore,"FreshnessCompatibilityV1":DEFINITIONS.FreshnessCompatibilityV1,"FusedCandidate":DEFINITIONS.FusedCandidate,"LexicalAnchorDropReasonV1":DEFINITIONS.LexicalAnchorDropReasonV1,"LexicalAnchorDropV1":DEFINITIONS.LexicalAnchorDropV1,"LogicalCopyClusterId":DEFINITIONS.LogicalCopyClusterId,"LogicalEvidenceId":DEFINITIONS.LogicalEvidenceId,"OccurrenceProvenance":DEFINITIONS.OccurrenceProvenance,"PrimitiveFreshnessStateV1":DEFINITIONS.PrimitiveFreshnessStateV1,"PrimitiveIndexingStateV1":DEFINITIONS.PrimitiveIndexingStateV1,"PrimitiveLaneCompleteV1":DEFINITIONS.PrimitiveLaneCompleteV1,"PrimitiveRecallV1":DEFINITIONS.PrimitiveRecallV1,"PrimitiveSearchFreshnessV1":DEFINITIONS.PrimitiveSearchFreshnessV1,"PrimitiveUnavailableEvidenceV1":DEFINITIONS.PrimitiveUnavailableEvidenceV1,"PrimitiveUnavailableStatusV1":DEFINITIONS.PrimitiveUnavailableStatusV1,"RankingDecision":DEFINITIONS.RankingDecision,"RankingDecisionKind":DEFINITIONS.RankingDecisionKind,"RepositoryId":DEFINITIONS.RepositoryId,"RetrievalAnchorId":DEFINITIONS.RetrievalAnchorId,"RetrieverKind":DEFINITIONS.RetrieverKind,"ScoreDomainId":DEFINITIONS.ScoreDomainId,"SearchCompleteV1":DEFINITIONS.SearchCompleteV1,"SearchCoverageV1":DEFINITIONS.SearchCoverageV1,"SearchExternalImportCandidatesV1":DEFINITIONS.SearchExternalImportCandidatesV1,"SearchExternalImportHintV1":DEFINITIONS.SearchExternalImportHintV1,"SearchExternalImportV1":DEFINITIONS.SearchExternalImportV1,"SearchLaneStateV1":DEFINITIONS.SearchLaneStateV1,"SearchLaneStatusV1":DEFINITIONS.SearchLaneStatusV1,"SearchLexicalAlternativeReasonV1":DEFINITIONS.SearchLexicalAlternativeReasonV1,"SearchLexicalRouteV1":DEFINITIONS.SearchLexicalRouteV1,"SearchResultDisplayV1":DEFINITIONS.SearchResultDisplayV1,"SearchResultRowV1":DEFINITIONS.SearchResultRowV1,"SearchRouteMatchV1":DEFINITIONS.SearchRouteMatchV1,"SearchSpellingVariantV1":DEFINITIONS.SearchSpellingVariantV1,"SearchUnavailableV1":DEFINITIONS.SearchUnavailableV1,"SessionOrThreadId":DEFINITIONS.SessionOrThreadId,"SourceFreshness":DEFINITIONS.SourceFreshness,"SourceInstanceKey":DEFINITIONS.SourceInstanceKey,"SourceNamespace":DEFINITIONS.SourceNamespace,"SourceOccurrenceId":DEFINITIONS.SourceOccurrenceId,"UtcMicros":DEFINITIONS.UtcMicros},"$schema":"https://json-schema.org/draft/2020-12/schema","anyOf":[{"$ref":"#/$defs/SearchCompleteV1"},{"$ref":"#/$defs/SearchUnavailableV1"}],"description":"What a search served: a ranked page, or the typed reason no generation\ncould answer.","title":"SearchResultV1"}, {"$defs":{"PageRequest":DEFINITIONS.PageRequest,"ResultProjection":DEFINITIONS.ResultProjection,"RetrievalOrder":DEFINITIONS.RetrievalOrder,"RetrievalRequestMeta":DEFINITIONS.RetrievalRequestMeta,"SessionId":DEFINITIONS.SessionId,"TemporalModeV1":DEFINITIONS.TemporalModeV1,"UtcMicros":DEFINITIONS.UtcMicros},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"meta":{"$ref":"#/$defs/RetrievalRequestMeta"},"session_id":{"$ref":"#/$defs/SessionId"}},"required":["session_id","meta"],"title":"SessionLookupRequest","type":"object"}, @@ -3436,781 +3458,789 @@ export const OPERATIONS = [ requestSchema: { schemaId: "schema.application.primitive.coupling.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.coupling.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(96), decodeResult: decoder(97) }, + { operation: "dashboard", operationId: "operation.application.dashboard", transport: { kind: "mcp_tool", toolName: "tracedecay_dashboard" }, effect: "binds_server", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.dashboard.v1", + requestSchema: { schemaId: "schema.application.primitive.dashboard.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.dashboard.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(98), decodeResult: decoder(99) }, { operation: "dead_code", operationId: "operation.application.dead_code", transport: { kind: "mcp_tool", toolName: "tracedecay_dead_code" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.dead_code.v1", requestSchema: { schemaId: "schema.application.primitive.dead-code.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.dead-code.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(98), decodeResult: decoder(99) }, + decodeRequest: decoder(100), decodeResult: decoder(101) }, { operation: "dependency_depth", operationId: "operation.application.dependency_depth", transport: { kind: "mcp_tool", toolName: "tracedecay_dependency_depth" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.dependency_depth.v1", requestSchema: { schemaId: "schema.application.primitive.dependency-depth.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.dependency-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(100), decodeResult: decoder(101) }, + decodeRequest: decoder(102), decodeResult: decoder(103) }, { operation: "derives", operationId: "operation.application.derives", transport: { kind: "mcp_tool", toolName: "tracedecay_derives" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.derives.v1", requestSchema: { schemaId: "schema.application.primitive.derives.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.derives.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(102), decodeResult: decoder(103) }, + decodeRequest: decoder(104), decodeResult: decoder(105) }, { operation: "diagnose", operationId: "operation.application.diagnose", transport: { kind: "mcp_tool", toolName: "tracedecay_diagnose" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.diagnose.v1", requestSchema: { schemaId: "schema.application.primitive.diagnose.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.diagnose.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(104), decodeResult: decoder(105) }, + decodeRequest: decoder(106), decodeResult: decoder(107) }, { operation: "application_diagnostics_read", operationId: "operation.application.diagnostics_read", transport: { kind: "http", route: "/application/primitives/diagnostics_read", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.diagnostics_read.v1", requestSchema: { schemaId: "schema.application.primitive.diagnostics-read.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.diagnostics-read.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(106), decodeResult: decoder(107), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.diagnostics_read.v1", "schema.application.primitive.diagnostics-read.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(107)) }, + decodeRequest: decoder(108), decodeResult: decoder(109), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.diagnostics_read.v1", "schema.application.primitive.diagnostics-read.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(109)) }, { operation: "diff_context", operationId: "operation.application.diff_context", transport: { kind: "mcp_tool", toolName: "tracedecay_diff_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.diff_context.v1", requestSchema: { schemaId: "schema.application.primitive.diff-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.diff-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(108), decodeResult: decoder(109) }, + decodeRequest: decoder(110), decodeResult: decoder(111) }, { operation: "distribution", operationId: "operation.application.distribution", transport: { kind: "mcp_tool", toolName: "tracedecay_distribution" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.distribution.v1", requestSchema: { schemaId: "schema.application.primitive.distribution.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.distribution.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(111) }, + decodeRequest: decoder(112), decodeResult: decoder(113) }, { operation: "doc_coverage", operationId: "operation.application.doc_coverage", transport: { kind: "mcp_tool", toolName: "tracedecay_doc_coverage" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.doc_coverage.v1", requestSchema: { schemaId: "schema.application.primitive.doc-coverage.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.doc-coverage.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(113) }, + decodeRequest: decoder(114), decodeResult: decoder(115) }, { operation: "dsm", operationId: "operation.application.dsm", transport: { kind: "mcp_tool", toolName: "tracedecay_dsm" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.dsm.v1", requestSchema: { schemaId: "schema.application.primitive.dsm.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.dsm.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(114), decodeResult: decoder(115) }, + decodeRequest: decoder(116), decodeResult: decoder(117) }, { operation: "application_fact_feedback", operationId: "operation.application.fact_feedback", transport: { kind: "http", route: "/application/retained/fact_feedback", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_feedback.v1", requestSchema: { schemaId: "schema.application.retained.fact-feedback.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-feedback.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(116), decodeResult: decoder(117), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_feedback.v1", "schema.application.retained.fact-feedback.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(117)) }, + decodeRequest: decoder(118), decodeResult: decoder(119), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_feedback.v1", "schema.application.retained.fact-feedback.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(119)) }, { operation: "application_fact_store_add", operationId: "operation.application.fact_store_add", transport: { kind: "http", route: "/application/retained/fact_store_add", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_add.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-add.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-add.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(118), decodeResult: decoder(119), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_add.v1", "schema.application.retained.fact-store-add.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(119)) }, + decodeRequest: decoder(120), decodeResult: decoder(121), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_add.v1", "schema.application.retained.fact-store-add.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(121)) }, { operation: "application_fact_store_contradict", operationId: "operation.application.fact_store_contradict", transport: { kind: "http", route: "/application/retained/fact_store_contradict", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_contradict.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-contradict.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-contradict.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(120), decodeResult: decoder(121), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_contradict.v1", "schema.application.retained.fact-store-contradict.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(121)) }, + decodeRequest: decoder(122), decodeResult: decoder(123), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_contradict.v1", "schema.application.retained.fact-store-contradict.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(123)) }, { operation: "application_fact_store_curate", operationId: "operation.application.fact_store_curate", transport: { kind: "http", route: "/application/retained/fact_store_curate", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "required", resultSemantics: "fact_store_curate_terminal", bindingId: "binding.http.fact_store_curate.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-curate.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-curate.result", revision: 1 }, cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":90000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], - decodeRequest: decoder(122), decodeResult: decoder(123), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_curate.v1", "schema.application.retained.fact-store-curate.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(123)) }, + decodeRequest: decoder(124), decodeResult: decoder(125), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_curate.v1", "schema.application.retained.fact-store-curate.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(125)) }, { operation: "application_fact_store_get", operationId: "operation.application.fact_store_get", transport: { kind: "http", route: "/application/retained/fact_store_get", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_get.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-get.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-get.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(124), decodeResult: decoder(125), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_get.v1", "schema.application.retained.fact-store-get.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(125)) }, + decodeRequest: decoder(126), decodeResult: decoder(127), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_get.v1", "schema.application.retained.fact-store-get.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(127)) }, { operation: "application_fact_store_list", operationId: "operation.application.fact_store_list", transport: { kind: "http", route: "/application/retained/fact_store_list", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_list.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-list.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(126), decodeResult: decoder(127), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_list.v1", "schema.application.retained.fact-store-list.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(127)) }, + decodeRequest: decoder(128), decodeResult: decoder(129), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_list.v1", "schema.application.retained.fact-store-list.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(129)) }, { operation: "application_fact_store_probe", operationId: "operation.application.fact_store_probe", transport: { kind: "http", route: "/application/retained/fact_store_probe", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_probe.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-probe.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-probe.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(128), decodeResult: decoder(129), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_probe.v1", "schema.application.retained.fact-store-probe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(129)) }, + decodeRequest: decoder(130), decodeResult: decoder(131), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_probe.v1", "schema.application.retained.fact-store-probe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(131)) }, { operation: "application_fact_store_reason", operationId: "operation.application.fact_store_reason", transport: { kind: "http", route: "/application/retained/fact_store_reason", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_reason.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-reason.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-reason.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(130), decodeResult: decoder(131), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_reason.v1", "schema.application.retained.fact-store-reason.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(131)) }, + decodeRequest: decoder(132), decodeResult: decoder(133), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_reason.v1", "schema.application.retained.fact-store-reason.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(133)) }, { operation: "application_fact_store_related", operationId: "operation.application.fact_store_related", transport: { kind: "http", route: "/application/retained/fact_store_related", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_related.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-related.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-related.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(132), decodeResult: decoder(133), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_related.v1", "schema.application.retained.fact-store-related.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(133)) }, + decodeRequest: decoder(134), decodeResult: decoder(135), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_related.v1", "schema.application.retained.fact-store-related.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(135)) }, { operation: "application_fact_store_remove", operationId: "operation.application.fact_store_remove", transport: { kind: "http", route: "/application/retained/fact_store_remove", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_remove.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-remove.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-remove.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(134), decodeResult: decoder(135), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_remove.v1", "schema.application.retained.fact-store-remove.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(135)) }, + decodeRequest: decoder(136), decodeResult: decoder(137), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_remove.v1", "schema.application.retained.fact-store-remove.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(137)) }, { operation: "application_fact_store_search", operationId: "operation.application.fact_store_search", transport: { kind: "http", route: "/application/retained/fact_store_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_search.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-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(136), decodeResult: decoder(137), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_search.v1", "schema.application.retained.fact-store-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(137)) }, + decodeRequest: decoder(138), decodeResult: decoder(139), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_search.v1", "schema.application.retained.fact-store-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(139)) }, { operation: "application_fact_store_supersede", operationId: "operation.application.fact_store_supersede", transport: { kind: "http", route: "/application/retained/fact_store_supersede", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_supersede.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-supersede.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-supersede.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(138), decodeResult: decoder(139), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_supersede.v1", "schema.application.retained.fact-store-supersede.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(139)) }, + decodeRequest: decoder(140), decodeResult: decoder(141), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_supersede.v1", "schema.application.retained.fact-store-supersede.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(141)) }, { operation: "application_fact_store_update", operationId: "operation.application.fact_store_update", transport: { kind: "http", route: "/application/retained/fact_store_update", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.fact_store_update.v1", requestSchema: { schemaId: "schema.application.retained.fact-store-update.request", revision: 1 }, resultSchema: { schemaId: "schema.application.retained.fact-store-update.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(140), decodeResult: decoder(141), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_update.v1", "schema.application.retained.fact-store-update.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(141)) }, + decodeRequest: decoder(142), decodeResult: decoder(143), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.fact_store_update.v1", "schema.application.retained.fact-store-update.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(143)) }, { operation: "application_feedback_advisory_cycle", operationId: "operation.application.feedback_advisory_cycle", transport: { kind: "http", route: "/application/feedback/advisory_cycle", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_advisory_cycle.v1", requestSchema: { schemaId: "schema.application.feedback.advisory-cycle.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.advisory-cycle.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(142), decodeResult: decoder(143), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_advisory_cycle.v1", "schema.application.feedback.advisory-cycle.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(143)) }, + decodeRequest: decoder(144), decodeResult: decoder(145), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_advisory_cycle.v1", "schema.application.feedback.advisory-cycle.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(145)) }, { operation: "application_feedback_diagnostics", operationId: "operation.application.feedback_diagnostics", transport: { kind: "http", route: "/application/feedback/diagnostics", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_diagnostics.v1", requestSchema: { schemaId: "schema.application.feedback.diagnostics.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.diagnostics.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(2), decodeResult: decoder(144), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_diagnostics.v1", "schema.application.feedback.diagnostics.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(144)) }, + decodeRequest: decoder(2), decodeResult: decoder(146), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_diagnostics.v1", "schema.application.feedback.diagnostics.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(146)) }, { operation: "application_feedback_expand", operationId: "operation.application.feedback_expand", transport: { kind: "http", route: "/application/feedback/expand", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_expand.v1", requestSchema: { schemaId: "schema.application.feedback.expand.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.expand.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(2), decodeResult: decoder(145), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_expand.v1", "schema.application.feedback.expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(145)) }, + decodeRequest: decoder(2), decodeResult: decoder(147), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_expand.v1", "schema.application.feedback.expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(147)) }, { operation: "application_feedback_get", operationId: "operation.application.feedback_get", transport: { kind: "http", route: "/application/feedback/get", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_get.v1", requestSchema: { schemaId: "schema.application.feedback.get.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.get.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(2), decodeResult: decoder(146), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_get.v1", "schema.application.feedback.get.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(146)) }, + decodeRequest: decoder(2), decodeResult: decoder(148), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_get.v1", "schema.application.feedback.get.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(148)) }, { operation: "application_feedback_impact", operationId: "operation.application.feedback_impact", transport: { kind: "http", route: "/application/feedback/impact", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_impact.v1", requestSchema: { schemaId: "schema.application.feedback.impact.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.impact.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(2), decodeResult: decoder(147), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_impact.v1", "schema.application.feedback.impact.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(147)) }, + decodeRequest: decoder(2), decodeResult: decoder(149), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_impact.v1", "schema.application.feedback.impact.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(149)) }, { operation: "application_feedback_list", operationId: "operation.application.feedback_list", transport: { kind: "http", route: "/application/feedback/list", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_list.v1", requestSchema: { schemaId: "schema.application.feedback.list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.list.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(2), decodeResult: decoder(148), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_list.v1", "schema.application.feedback.list.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(148)) }, + decodeRequest: decoder(2), decodeResult: decoder(150), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_list.v1", "schema.application.feedback.list.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(150)) }, { operation: "application_feedback_proximity", operationId: "operation.application.feedback_proximity", transport: { kind: "http", route: "/application/feedback/proximity", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.feedback_proximity.v1", requestSchema: { schemaId: "schema.application.feedback.proximity.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.proximity.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(149), decodeResult: decoder(150), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_proximity.v1", "schema.application.feedback.proximity.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(150)) }, + decodeRequest: decoder(151), decodeResult: decoder(152), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.feedback_proximity.v1", "schema.application.feedback.proximity.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(152)) }, { operation: "field_sites", operationId: "operation.application.field_sites", transport: { kind: "mcp_tool", toolName: "tracedecay_field_sites" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.field_sites.v1", requestSchema: { schemaId: "schema.application.primitive.field-sites.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.field-sites.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(151), decodeResult: decoder(152) }, + decodeRequest: decoder(153), decodeResult: decoder(154) }, { operation: "application_file_dependents", operationId: "operation.application.file_dependents", transport: { kind: "http", route: "/application/primitives/file_dependents", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.file_dependents.v1", requestSchema: { schemaId: "schema.application.primitive.file-dependents.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.file-dependents.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(153), decodeResult: decoder(154), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.file_dependents.v1", "schema.application.primitive.file-dependents.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(154)) }, + decodeRequest: decoder(155), decodeResult: decoder(156), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.file_dependents.v1", "schema.application.primitive.file-dependents.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(156)) }, { operation: "files", operationId: "operation.application.files", transport: { kind: "mcp_tool", toolName: "tracedecay_files" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.files.v1", requestSchema: { schemaId: "schema.application.primitive.files.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.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(155), decodeResult: decoder(156) }, + decodeRequest: decoder(157), decodeResult: decoder(158) }, { operation: "find_exact_symbol", operationId: "operation.application.find_exact_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_find_exact_symbol" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.find_exact_symbol.v1", requestSchema: { schemaId: "schema.application.primitive.find-exact-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.find-exact-symbol.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(157), decodeResult: decoder(158) }, + decodeRequest: decoder(159), decodeResult: decoder(160) }, { operation: "gini", operationId: "operation.application.gini", transport: { kind: "mcp_tool", toolName: "tracedecay_gini" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.gini.v1", requestSchema: { schemaId: "schema.application.primitive.gini.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.gini.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(159), decodeResult: decoder(160) }, + decodeRequest: decoder(161), decodeResult: decoder(162) }, { operation: "git_apply", operationId: "operation.application.git_apply", transport: { kind: "mcp_tool", toolName: "tracedecay_git_apply" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.git_apply.v1", requestSchema: { schemaId: "schema.application.git.apply.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.apply.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(161), decodeResult: decoder(162) }, + decodeRequest: decoder(163), decodeResult: decoder(164) }, { operation: "application_git_blame", operationId: "operation.application.git_blame", transport: { kind: "http", route: "/application/git/blame", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.git_blame.v1", requestSchema: { schemaId: "schema.application.git.blame.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.blame.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(163), decodeResult: decoder(164), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_blame.v1", "schema.application.git.blame.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(164)) }, + decodeRequest: decoder(165), decodeResult: decoder(166), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_blame.v1", "schema.application.git.blame.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(166)) }, { operation: "application_git_diff", operationId: "operation.application.git_diff", transport: { kind: "http", route: "/application/git/diff", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.git_diff.v1", requestSchema: { schemaId: "schema.application.git.diff.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.diff.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(165), decodeResult: decoder(164), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_diff.v1", "schema.application.git.diff.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(164)) }, + decodeRequest: decoder(167), decodeResult: decoder(166), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_diff.v1", "schema.application.git.diff.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(166)) }, { operation: "application_git_history", operationId: "operation.application.git_history", transport: { kind: "http", route: "/application/git/history", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.git_history.v1", requestSchema: { schemaId: "schema.application.git.history.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.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(166), decodeResult: decoder(164), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_history.v1", "schema.application.git.history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(164)) }, + decodeRequest: decoder(168), decodeResult: decoder(166), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_history.v1", "schema.application.git.history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(166)) }, { operation: "application_git_hunks", operationId: "operation.application.git_hunks", transport: { kind: "http", route: "/application/git/hunks", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.git_hunks.v1", requestSchema: { schemaId: "schema.application.git.hunks.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.hunks.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(167), decodeResult: decoder(164), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_hunks.v1", "schema.application.git.hunks.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(164)) }, + decodeRequest: decoder(169), decodeResult: decoder(166), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_hunks.v1", "schema.application.git.hunks.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(166)) }, { operation: "git_preview", operationId: "operation.application.git_preview", transport: { kind: "mcp_tool", toolName: "tracedecay_git_preview" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.git_preview.v1", requestSchema: { schemaId: "schema.application.git.preview.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.preview.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(168), decodeResult: decoder(169) }, + decodeRequest: decoder(170), decodeResult: decoder(171) }, { operation: "application_git_status", operationId: "operation.application.git_status", transport: { kind: "http", route: "/application/git/status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.git_status.v1", requestSchema: { schemaId: "schema.application.git.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.git.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(170), decodeResult: decoder(164), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_status.v1", "schema.application.git.status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(164)) }, + decodeRequest: decoder(172), decodeResult: decoder(166), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.git_status.v1", "schema.application.git.status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(166)) }, { operation: "application_github_stack_signal_expand", operationId: "operation.application.github_stack_signal_expand", transport: { kind: "http", route: "/application/github-stack/signal-expand", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.github_stack_signal_expand.v1", requestSchema: { schemaId: "schema.application.github-stack.signal-expand.request", revision: 1 }, resultSchema: { schemaId: "schema.application.github-stack.signal-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","partial"], - decodeRequest: decoder(171), decodeResult: decoder(172), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.github_stack_signal_expand.v1", "schema.application.github-stack.signal-expand.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(172)) }, + decodeRequest: decoder(173), decodeResult: decoder(174), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.github_stack_signal_expand.v1", "schema.application.github-stack.signal-expand.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(174)) }, { operation: "god_class", operationId: "operation.application.god_class", transport: { kind: "mcp_tool", toolName: "tracedecay_god_class" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.god_class.v1", requestSchema: { schemaId: "schema.application.primitive.god-class.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.god-class.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(173), decodeResult: decoder(174) }, + decodeRequest: decoder(175), decodeResult: decoder(176) }, { operation: "grep", operationId: "operation.application.grep", transport: { kind: "mcp_tool", toolName: "tracedecay_grep" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.grep.v1", requestSchema: { schemaId: "schema.application.primitive.grep.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.grep.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(175), decodeResult: decoder(176) }, + decodeRequest: decoder(177), decodeResult: decoder(178) }, { operation: "health", operationId: "operation.application.health", transport: { kind: "mcp_tool", toolName: "tracedecay_health" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.health.v1", requestSchema: { schemaId: "schema.application.primitive.health.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.health.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(177), decodeResult: decoder(178) }, + decodeRequest: decoder(179), decodeResult: decoder(180) }, { operation: "application_health_delta", operationId: "operation.application.health_delta", transport: { kind: "http", route: "/application/primitives/health_delta", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.health_delta.v1", requestSchema: { schemaId: "schema.application.primitive.health-delta.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.health-delta.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(179), decodeResult: decoder(180), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.health_delta.v1", "schema.application.primitive.health-delta.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(180)) }, + decodeRequest: decoder(181), decodeResult: decoder(182), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.health_delta.v1", "schema.application.primitive.health-delta.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(182)) }, { operation: "application_health_read", operationId: "operation.application.health_read", transport: { kind: "http", route: "/application/primitives/health_read", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.health_read.v1", requestSchema: { schemaId: "schema.application.primitive.health-read.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.health-read.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(181), decodeResult: decoder(182), - decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.health_read.v1", "schema.application.primitive.health-read.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(182)) }, + decodeRequest: decoder(183), decodeResult: decoder(184), + decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.health_read.v1", "schema.application.primitive.health-read.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder(184)) }, { operation: "hermes_skill_bridge", operationId: "operation.application.hermes_skill_bridge", transport: { kind: "mcp_tool", toolName: "tracedecay_hermes_skill_bridge" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.hermes_skill_bridge.v1", 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(183), decodeResult: decoder(184) }, + decodeRequest: decoder(185), decodeResult: decoder(186) }, { 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(185), decodeResult: decoder(186) }, + decodeRequest: decoder(187), decodeResult: decoder(188) }, { 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(187), decodeResult: decoder(188) }, + decodeRequest: decoder(189), decodeResult: decoder(190) }, { 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(189), decodeResult: decoder(190) }, + decodeRequest: decoder(191), decodeResult: decoder(192) }, { 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(191), decodeResult: decoder(10) }, + decodeRequest: decoder(193), decodeResult: decoder(10) }, { 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(192), decodeResult: decoder(10) }, + decodeRequest: decoder(194), decodeResult: decoder(10) }, { 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(193), decodeResult: decoder(194) }, + decodeRequest: decoder(195), decodeResult: decoder(196) }, { 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(195), decodeResult: decoder(196), - 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(196)) }, + decodeRequest: decoder(197), decodeResult: decoder(198), + 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(198)) }, { 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(197), decodeResult: decoder(198), - 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(198)) }, + decodeRequest: decoder(199), decodeResult: decoder(200), + 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(200)) }, { 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(199), decodeResult: decoder(200), - 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(200)) }, + decodeRequest: decoder(201), decodeResult: decoder(202), + 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(202)) }, { 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(201), decodeResult: decoder(202), - 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(202)) }, + decodeRequest: decoder(203), decodeResult: decoder(204), + 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(204)) }, { 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(203), decodeResult: decoder(204), - 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(204)) }, + decodeRequest: decoder(205), decodeResult: decoder(206), + 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(206)) }, { 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(205), decodeResult: decoder(206), - 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(206)) }, + decodeRequest: decoder(207), decodeResult: decoder(208), + 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(208)) }, { 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(207), decodeResult: decoder(208), - 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(208)) }, + decodeRequest: decoder(209), decodeResult: decoder(210), + 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(210)) }, { 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(209), decodeResult: decoder(210), - 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(210)) }, + decodeRequest: decoder(211), decodeResult: decoder(212), + 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(212)) }, { 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(211), decodeResult: decoder(212), - 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(212)) }, + decodeRequest: decoder(213), decodeResult: decoder(214), + 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(214)) }, { 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(213), decodeResult: decoder(214), - 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(214)) }, + decodeRequest: decoder(215), decodeResult: decoder(216), + 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(216)) }, { 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(215), decodeResult: decoder(10) }, + decodeRequest: decoder(217), decodeResult: decoder(10) }, { 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(216), decodeResult: decoder(10) }, + decodeRequest: decoder(218), decodeResult: decoder(10) }, { 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(217), decodeResult: decoder(7) }, + decodeRequest: decoder(219), decodeResult: decoder(7) }, { 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(218), decodeResult: decoder(219) }, + decodeRequest: decoder(220), decodeResult: decoder(221) }, { 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(220), decodeResult: decoder(221) }, + decodeRequest: decoder(222), decodeResult: decoder(223) }, { 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(222), decodeResult: decoder(223) }, + decodeRequest: decoder(224), decodeResult: decoder(225) }, { 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(224), decodeResult: decoder(225) }, + decodeRequest: decoder(226), decodeResult: decoder(227) }, { 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(226), decodeResult: decoder(227) }, + decodeRequest: decoder(228), decodeResult: decoder(229) }, { 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(228), decodeResult: decoder(7) }, + decodeRequest: decoder(230), decodeResult: decoder(7) }, { 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(229), decodeResult: decoder(230), - 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(230)) }, + decodeRequest: decoder(231), decodeResult: decoder(232), + 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(232)) }, { 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(231), decodeResult: decoder(232) }, + decodeRequest: decoder(233), decodeResult: decoder(234) }, { 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(233), decodeResult: decoder(234) }, + decodeRequest: decoder(235), decodeResult: decoder(236) }, { 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(235), decodeResult: decoder(236) }, + decodeRequest: decoder(237), decodeResult: decoder(238) }, { 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(237), decodeResult: decoder(238) }, + decodeRequest: decoder(239), decodeResult: decoder(240) }, { 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(239), decodeResult: decoder(10) }, + decodeRequest: decoder(241), decodeResult: decoder(10) }, { 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(240), decodeResult: decoder(10) }, + decodeRequest: decoder(242), decodeResult: decoder(10) }, { 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(241), decodeResult: decoder(242) }, + decodeRequest: decoder(243), decodeResult: decoder(244) }, + { 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(245), decodeResult: decoder(246) }, { 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(243), decodeResult: decoder(244) }, + decodeRequest: decoder(247), decodeResult: decoder(248) }, { 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(245), decodeResult: decoder(246) }, + decodeRequest: decoder(249), decodeResult: decoder(250) }, { 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(247), decodeResult: decoder(248), - 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(248)) }, + decodeRequest: decoder(251), decodeResult: decoder(252), + 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(252)) }, { 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(247), decodeResult: decoder(249), - 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(249)) }, + decodeRequest: decoder(251), decodeResult: decoder(253), + 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(253)) }, { 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(247), decodeResult: decoder(250), - 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(250)) }, + decodeRequest: decoder(251), decodeResult: decoder(254), + 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(254)) }, { 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(251), decodeResult: decoder(252), - 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(252)) }, + decodeRequest: decoder(255), decodeResult: decoder(256), + 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(256)) }, { 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(102), decodeResult: decoder(253) }, + decodeRequest: decoder(104), decodeResult: decoder(257) }, { 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(254), decodeResult: decoder(255) }, + decodeRequest: decoder(258), decodeResult: decoder(259) }, { 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(256), decodeResult: decoder(257) }, + decodeRequest: decoder(260), decodeResult: decoder(261) }, { 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(258), decodeResult: decoder(259) }, + decodeRequest: decoder(262), decodeResult: decoder(263) }, { 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(260), decodeResult: decoder(261), - 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(261)) }, + decodeRequest: decoder(264), decodeResult: decoder(265), + 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(265)) }, { 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(262), decodeResult: decoder(10) }, + decodeRequest: decoder(266), decodeResult: decoder(10) }, { 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(263), decodeResult: decoder(10) }, + decodeRequest: decoder(267), decodeResult: decoder(10) }, { 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(264), decodeResult: decoder(265), - 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(265)) }, + decodeRequest: decoder(268), decodeResult: decoder(269), + 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(269)) }, { 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(266), decodeResult: decoder(267), - 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(267)) }, + decodeRequest: decoder(270), decodeResult: decoder(271), + 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(271)) }, { 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(268), decodeResult: decoder(7) }, + decodeRequest: decoder(272), decodeResult: decoder(7) }, { 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(269), decodeResult: decoder(270), - 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(270)) }, + decodeRequest: decoder(273), decodeResult: decoder(274), + 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(274)) }, { 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(271), decodeResult: decoder(10) }, + decodeRequest: decoder(275), decodeResult: decoder(10) }, { 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(272), decodeResult: decoder(273) }, + decodeRequest: decoder(276), decodeResult: decoder(277) }, { 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(274), decodeResult: decoder(275), - 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(275)) }, + decodeRequest: decoder(278), decodeResult: decoder(279), + 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(279)) }, { 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(276), decodeResult: decoder(277) }, + decodeRequest: decoder(280), decodeResult: decoder(281) }, { 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(278), decodeResult: decoder(279) }, + decodeRequest: decoder(282), decodeResult: decoder(283) }, { 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(280), decodeResult: decoder(281) }, + decodeRequest: decoder(284), decodeResult: decoder(285) }, { 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(282), decodeResult: decoder(283) }, + decodeRequest: decoder(286), decodeResult: decoder(287) }, { 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(284), decodeResult: decoder(285), - 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(285)) }, + decodeRequest: decoder(288), decodeResult: decoder(289), + 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(289)) }, { 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(286), decodeResult: decoder(7), + decodeRequest: decoder(290), decodeResult: decoder(7), 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(7)) }, { 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(287), decodeResult: decoder(7), + decodeRequest: decoder(291), decodeResult: decoder(7), 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(7)) }, { 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(288), decodeResult: decoder(7), + decodeRequest: decoder(292), decodeResult: decoder(7), 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(7)) }, { 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(289), decodeResult: decoder(7), + decodeRequest: decoder(293), decodeResult: decoder(7), 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(7)) }, { 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(290), decodeResult: decoder(7), + decodeRequest: decoder(294), decodeResult: decoder(7), 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(7)) }, { 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(291), decodeResult: decoder(292), - 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(292)) }, + decodeRequest: decoder(295), decodeResult: decoder(296), + 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(296)) }, { 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(293), decodeResult: decoder(294), - 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(294)) }, + decodeRequest: decoder(297), decodeResult: decoder(298), + 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(298)) }, { 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(295), decodeResult: decoder(296), - 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(296)) }, + decodeRequest: decoder(299), decodeResult: decoder(300), + 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(300)) }, { 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(297), decodeResult: decoder(298), - 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(298)) }, + decodeRequest: decoder(301), decodeResult: decoder(302), + 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(302)) }, { 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(299), decodeResult: decoder(300), - 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(300)) }, + decodeRequest: decoder(303), decodeResult: decoder(304), + 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(304)) }, { 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(301), decodeResult: decoder(302), - 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(302)) }, + decodeRequest: decoder(305), decodeResult: decoder(306), + 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(306)) }, { 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(303), decodeResult: decoder(304), - 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(304)) }, + decodeRequest: decoder(307), decodeResult: decoder(308), + 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(308)) }, { 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(305), decodeResult: decoder(306), - 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(306)) }, + decodeRequest: decoder(309), decodeResult: decoder(310), + 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(310)) }, { 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(307), decodeResult: decoder(308), - 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(308)) }, + decodeRequest: decoder(311), decodeResult: decoder(312), + 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(312)) }, { 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(309), decodeResult: decoder(310), - 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(310)) }, + decodeRequest: decoder(313), decodeResult: decoder(314), + 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(314)) }, { 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(311), decodeResult: decoder(312), - 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(312)) }, + decodeRequest: decoder(315), decodeResult: decoder(316), + 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(316)) }, { 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(313), decodeResult: decoder(314), - 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(314)) }, + decodeRequest: decoder(317), decodeResult: decoder(318), + 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(318)) }, { 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(315), decodeResult: decoder(316), - 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(316)) }, + decodeRequest: decoder(319), decodeResult: decoder(320), + 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(320)) }, { 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(317), decodeResult: decoder(316), - 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(316)) }, + decodeRequest: decoder(321), decodeResult: decoder(320), + 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(320)) }, { 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(318), decodeResult: decoder(319), - 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(319)) }, + decodeRequest: decoder(322), decodeResult: decoder(323), + 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(323)) }, { 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(320), decodeResult: decoder(306), - 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(306)) }, + decodeRequest: decoder(324), decodeResult: decoder(310), + 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(310)) }, { 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(321), decodeResult: decoder(322), - 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(322)) }, + decodeRequest: decoder(325), decodeResult: decoder(326), + 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(326)) }, { 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(323), decodeResult: decoder(324), - 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(324)) }, + decodeRequest: decoder(327), decodeResult: decoder(328), + 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(328)) }, { 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(325), decodeResult: decoder(326), - 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(326)) }, + decodeRequest: decoder(329), decodeResult: decoder(330), + 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(330)) }, { 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(327), decodeResult: decoder(328), - 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(328)) }, + decodeRequest: decoder(331), decodeResult: decoder(332), + 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(332)) }, { 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(321), decodeResult: decoder(329), - 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(329)) }, + decodeRequest: decoder(325), decodeResult: decoder(333), + 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(333)) }, { 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(330), decodeResult: decoder(306), - 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(306)) }, + decodeRequest: decoder(334), decodeResult: decoder(310), + 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(310)) }, { 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(331), decodeResult: decoder(332), - 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(332)) }, + decodeRequest: decoder(335), decodeResult: decoder(336), + 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(336)) }, { 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(333), decodeResult: decoder(334), - 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(334)) }, + decodeRequest: decoder(337), decodeResult: decoder(338), + 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(338)) }, { 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(335), decodeResult: decoder(336), - 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(336)) }, + decodeRequest: decoder(339), decodeResult: decoder(340), + 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(340)) }, { 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(337), decodeResult: decoder(307), - 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(307)) }, + decodeRequest: decoder(341), decodeResult: decoder(311), + 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(311)) }, { 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(338), decodeResult: decoder(330), - 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(330)) }, + decodeRequest: decoder(342), decodeResult: decoder(334), + 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(334)) }, { 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(339), decodeResult: decoder(314), - 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(314)) }, + decodeRequest: decoder(343), decodeResult: decoder(318), + 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(318)) }, { 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(340), decodeResult: decoder(341), - 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(341)) }, + decodeRequest: decoder(344), decodeResult: decoder(345), + 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(345)) }, { 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(342), decodeResult: decoder(332), - 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(332)) }, + decodeRequest: decoder(346), decodeResult: decoder(336), + 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(336)) }, { 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(343), decodeResult: decoder(344), - 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(344)) }, + decodeRequest: decoder(347), decodeResult: decoder(348), + 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(348)) }, { 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(345), decodeResult: decoder(346), - 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(346)) }, + decodeRequest: decoder(349), decodeResult: decoder(350), + 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(350)) }, { 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(347), decodeResult: decoder(306), - 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(306)) }, + decodeRequest: decoder(351), decodeResult: decoder(310), + 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(310)) }, { 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(348), decodeResult: decoder(349), - 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(349)) }, + decodeRequest: decoder(352), decodeResult: decoder(353), + 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(353)) }, { 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(350), decodeResult: decoder(316), - 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(316)) }, + decodeRequest: decoder(354), decodeResult: decoder(320), + 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(320)) }, { 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(351), decodeResult: decoder(352), - 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(352)) }, + decodeRequest: decoder(355), decodeResult: decoder(356), + 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(356)) }, { 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(353), decodeResult: decoder(354), - 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(354)) }, + decodeRequest: decoder(357), decodeResult: decoder(358), + 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(358)) }, { 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(355), decodeResult: decoder(356), - 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(356)) }, + decodeRequest: decoder(359), decodeResult: decoder(360), + 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(360)) }, { 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(357), decodeResult: decoder(358), - 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(358)) }, + decodeRequest: decoder(361), decodeResult: decoder(362), + 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(362)) }, { 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(359), decodeResult: decoder(360), - 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(360)) }, + decodeRequest: decoder(363), decodeResult: decoder(364), + 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(364)) }, { 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(361), decodeResult: decoder(362), - 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(362)) }, + decodeRequest: decoder(365), decodeResult: decoder(366), + 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(366)) }, { 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(363), decodeResult: decoder(364), - 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(364)) }, + decodeRequest: decoder(367), decodeResult: decoder(368), + 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(368)) }, { 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(365), decodeResult: decoder(366), - 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(366)) }, + decodeRequest: decoder(369), decodeResult: decoder(370), + 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(370)) }, { 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(367), decodeResult: decoder(368), - 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(368)) }, + decodeRequest: decoder(371), decodeResult: decoder(372), + 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(372)) }, { 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(369), decodeResult: decoder(362), - 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(362)) }, + decodeRequest: decoder(373), decodeResult: decoder(366), + 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(366)) }, { 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(370), decodeResult: decoder(371), - 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(371)) }, + decodeRequest: decoder(374), decodeResult: decoder(375), + 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(375)) }, { 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(372), decodeResult: decoder(373), - 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(373)) }, + decodeRequest: decoder(376), decodeResult: decoder(377), + 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(377)) }, { 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(374), decodeResult: decoder(364), - 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(364)) }, + decodeRequest: decoder(378), decodeResult: decoder(368), + 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(368)) }, { 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(375), decodeResult: decoder(362), - 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(362)) }, + decodeRequest: decoder(379), decodeResult: decoder(366), + 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(366)) }, { 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(376), decodeResult: decoder(368), - 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(368)) }, + decodeRequest: decoder(380), decodeResult: decoder(372), + 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(372)) }, { 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(377), decodeResult: decoder(360), - 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(360)) }, + decodeRequest: decoder(381), decodeResult: decoder(364), + 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(364)) }, { 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(378), decodeResult: decoder(362), - 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(362)) }, + decodeRequest: decoder(382), decodeResult: decoder(366), + 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(366)) }, { 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(379), decodeResult: decoder(360), - 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(360)) }, + decodeRequest: decoder(383), decodeResult: decoder(364), + 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(364)) }, { 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(380), decodeResult: decoder(362), - 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(362)) }, + decodeRequest: decoder(384), decodeResult: decoder(366), + 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(366)) }, { 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(381), decodeResult: decoder(382), - 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(382)) }, + decodeRequest: decoder(385), decodeResult: decoder(386), + 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(386)) }, ] as const; export type Operation = (typeof OPERATIONS)[number];