diff --git a/crates/tracedecay-api/src/http/application_operation_owner.rs b/crates/tracedecay-api/src/http/application_operation_owner.rs
index 3dc0f33cd5..883b20d0d9 100644
--- a/crates/tracedecay-api/src/http/application_operation_owner.rs
+++ b/crates/tracedecay-api/src/http/application_operation_owner.rs
@@ -166,7 +166,8 @@ pub const fn http_application_owner_kind(
         | ApplicationSurfaceOperation::Runtime
         | ApplicationSurfaceOperation::ProjectList
         | ApplicationSurfaceOperation::ProjectSearch
-        | ApplicationSurfaceOperation::ProjectContext => return None,
+        | ApplicationSurfaceOperation::ProjectContext
+        | ApplicationSurfaceOperation::AdminSync => return None,
         ApplicationSurfaceOperation::FactStoreCurate
         | ApplicationSurfaceOperation::FactStoreAdd
         | ApplicationSurfaceOperation::FactStoreSearch
diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 9ffa701fd4..27eca3e40f 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -3,6 +3,10 @@ use tracedecay_runtime_core::config::ProfileRoot;
 
 use tracedecay_project::project::TraceDecay;
 
+use tracedecay_contracts::graph_tool::GraphToolResultV1;
+use tracedecay_contracts::retrieval::{AdminSyncAdmissionV1, AdminSyncResultV1};
+use tracedecay_tool_catalog::ApplicationSurfaceOperation;
+
 use super::daemon::daemon_tool_json;
 
 /// True when the global DB has zero registered projects (or can't be opened
@@ -217,13 +221,7 @@ async fn brokered_init(
     // eventually demand it does not survive a daemon restart. Request the
     // reconciliation explicitly so the message below reports something that
     // actually happened.
-    let reconcile = tracedecay::daemon::call_default_tool_awaiting_project_open(
-        handshake,
-        "tracedecay_admin_sync",
-        serde_json::json!({}),
-        init_deadline,
-    )
-    .await;
+    let reconcile = admin_sync(handshake.clone(), init_deadline).await;
     let reconcile = match reconcile {
         Err(error) => {
             if !code_index_reconciliation_is_optional(project_path, &error).await {
@@ -237,27 +235,18 @@ async fn brokered_init(
         }
         Ok(reconcile) => reconcile,
     };
-    match admin_sync_status(&reconcile).as_deref() {
-        // Status `queued` means the daemon accepted the reconcile demand into
-        // its pre-mount queue. Init's user-facing confirmation names that
-        // request (`requested`), matching the brokered-init contract tests and
-        // dogfood journeys, not the internal queue noun.
-        Some("queued") => eprintln!(
+    match reconcile.status {
+        // `queued` means the daemon accepted the reconcile demand into its
+        // pre-mount queue. Init's confirmation names that request
+        // (`requested`), not the internal queue noun.
+        AdminSyncAdmissionV1::Queued => eprintln!(
             "initialized {}; daemon code-index reconciliation requested",
             project_path.display()
         ),
-        Some("not_applicable") => eprintln!(
+        AdminSyncAdmissionV1::NotApplicable => eprintln!(
             "initialized {}; code indexing does not apply to this non-Git project",
             project_path.display()
         ),
-        Some(status) => eprintln!(
-            "initialized {}; daemon code-index reconciliation status is {status}",
-            project_path.display()
-        ),
-        None => eprintln!(
-            "initialized {}; daemon code-index reconciliation returned no status",
-            project_path.display()
-        ),
     }
     Ok(())
 }
@@ -275,17 +264,26 @@ fn reject_brokered_folder_options(
     })
 }
 
-fn admin_sync_status(envelope: &serde_json::Value) -> Option<String> {
-    let text = envelope
-        .get("content")?
-        .as_array()?
-        .iter()
-        .find_map(|block| block.get("text").and_then(|text| text.as_str()))?;
-    serde_json::from_str::<serde_json::Value>(text)
-        .ok()?
-        .get("status")?
-        .as_str()
-        .map(str::to_owned)
+/// Asks the project's owner for the operator's code-index reconcile.
+async fn admin_sync(
+    handshake: tracedecay_daemon_protocol::DaemonHandshake,
+    deadline: tokio::time::Instant,
+) -> tracedecay_domain::errors::Result<AdminSyncResultV1> {
+    match crate::tool_command::owner_operation_result(
+        handshake,
+        ApplicationSurfaceOperation::AdminSync,
+        serde_json::json!({}),
+        deadline,
+    )
+    .await?
+    {
+        GraphToolResultV1::AdminSync(result) => Ok(result),
+        _ => Err(tracedecay_domain::errors::TraceDecayError::project_route(
+            "owner_result_mismatch",
+            false,
+            "the project owner answered tracedecay_admin_sync with another operation's result",
+        )),
+    }
 }
 
 async fn code_index_reconciliation_is_optional(
@@ -423,161 +421,47 @@ mod init_bootstrap_tests {
         );
     }
 
-    use super::daemon_precondition_tests::SocketEnvGuard;
-
-    static SOCKET_ENV_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
-
-    type RecordedRequests = std::sync::Arc<std::sync::Mutex<Vec<(String, serde_json::Value)>>>;
-
-    /// A daemon on `socket` that authenticates `connections` requests and
-    /// answers each with `respond(tool_name, request_id)`.
-    fn spawn_fixture_daemon(
-        temp: &Path,
-        socket: &Path,
-        connections: usize,
-        respond: fn(&str, serde_json::Value) -> serde_json::Value,
-    ) -> (tokio::task::JoinHandle<()>, RecordedRequests) {
-        use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
-
-        let authority = tracedecay_daemon_identity::authority::DaemonAuthority::acquire(
-            temp,
-            &tracedecay_daemon_protocol::DaemonEndpoint::Unix(socket.to_path_buf()),
-            env!("CARGO_PKG_VERSION"),
-        )
-        .expect("publish the fixture daemon's authority record");
-        let auth_token = authority.auth_token().to_owned();
-        let listener = tokio::net::UnixListener::bind(socket).unwrap();
-        let recorded = RecordedRequests::default();
-        let responder = {
-            let recorded = std::sync::Arc::clone(&recorded);
-            tokio::spawn(async move {
-                let _authority = authority;
-                for _ in 0..connections {
-                    let (stream, _addr) = listener.accept().await.unwrap();
-                    let (reader, mut writer) = stream.into_split();
-                    let mut lines = tokio::io::BufReader::new(reader).lines();
-                    let preface = lines.next_line().await.unwrap().unwrap();
-                    assert!(
-                        tracedecay_daemon_protocol::DaemonAuthPreface::from_line(preface.trim())
-                            .expect("auth preface")
-                            .authenticate(&auth_token),
-                        "init must present the daemon token"
-                    );
-                    let _handshake_line = lines.next_line().await.unwrap().unwrap();
-                    let request_line = lines.next_line().await.unwrap().unwrap();
-                    let request: serde_json::Value = serde_json::from_str(&request_line).unwrap();
-                    let name = request["params"]["name"]
-                        .as_str()
-                        .unwrap_or_default()
-                        .to_owned();
-                    recorded
-                        .lock()
-                        .unwrap()
-                        .push((name.clone(), request["params"]["arguments"].clone()));
-                    let response = respond(&name, request["id"].clone());
-                    writer
-                        .write_all(serde_json::to_string(&response).unwrap().as_bytes())
-                        .await
-                        .unwrap();
-                    writer.write_all(b"\n").await.unwrap();
-                    writer.shutdown().await.unwrap();
-                }
-            })
-        };
-        (responder, recorded)
-    }
-
-    fn empty_tool_result(_tool: &str, id: serde_json::Value) -> serde_json::Value {
-        serde_json::json!({
-            "jsonrpc": "2.0",
-            "id": id,
-            "result": { "content": [] },
-        })
-    }
-
-    /// Init's "daemon code-index reconciliation requested" must describe a
-    /// request that actually crossed the wire: admission first, then the
-    /// explicit `tracedecay_admin_sync` reconcile. Without the second call the
-    /// first index only starts if the background full-server upgrade survives
-    /// long enough to demand it, which a daemon restart silently discards.
-    #[tokio::test]
-    async fn brokered_init_requests_a_real_code_index_reconciliation() {
-        let _serialize = SOCKET_ENV_TEST_LOCK.lock().await;
-        let temp = tempfile::TempDir::new().unwrap();
-        let project = temp.path().join("project");
-        let profile = temp.path().join("profile");
-        std::fs::create_dir_all(&project).unwrap();
-        let socket = temp.path().join("daemon.sock");
-        let (responder, recorded) =
-            spawn_fixture_daemon(temp.path(), &socket, 2, empty_tool_result);
-        let _socket_env = SocketEnvGuard::set(&socket);
-
-        let handshake = test_handshake(&project, &profile);
-        brokered_init(&project, &[], &[], &handshake)
-            .await
-            .expect("brokered init against the fixture daemon");
-        tokio::time::timeout(std::time::Duration::from_secs(5), responder)
-            .await
-            .expect("fixture daemon must observe both requests")
-            .expect("fixture daemon task");
-
-        let recorded = recorded.lock().unwrap();
-        let names: Vec<&str> = recorded.iter().map(|(name, _)| name.as_str()).collect();
-        assert_eq!(
-            names,
-            ["tracedecay_status", "tracedecay_admin_sync"],
-            "init must request the reconcile it reports, after admission"
-        );
-        assert_eq!(
-            recorded[0].1["admission_only"],
-            serde_json::json!(true),
-            "the bootstrap status call stays admission-only"
-        );
-    }
-
     /// A worktree parked on a corrupt publication authority refuses the
     /// reconcile; the operator reads its cause and remedy as whole fields,
     /// not folded into one sentence cut at the diagnostic bound.
-    #[tokio::test]
-    async fn brokered_init_prints_a_parked_refusal_as_fields() {
-        fn refuse_sync(tool: &str, id: serde_json::Value) -> serde_json::Value {
-            if tool != "tracedecay_admin_sync" {
-                return empty_tool_result(tool, id);
-            }
-            let parked = tracedecay_contracts::code_index_freshness::CodeIndexConvergenceParkedV1 {
-                reason: format!("the publication authority is corrupt: {}", "x".repeat(600)),
-                blocked_reason: None,
-                remediation: "run `tracedecay daemon restart`".to_owned(),
-                parked_at_micros: 1,
-                observed_passes: 1,
-                retries_on_wake: false,
-            };
-            serde_json::to_value(tracedecay_mcp::tool_error_response(
-                id,
-                tool,
-                &parked.publication_authority_corrupt_error(),
-            ))
-            .unwrap()
-        }
-
-        let _serialize = SOCKET_ENV_TEST_LOCK.lock().await;
-        let temp = tempfile::TempDir::new().unwrap();
-        let project = temp.path().join("project");
-        let profile = temp.path().join("profile");
-        std::fs::create_dir_all(&project).unwrap();
-        let socket = temp.path().join("daemon.sock");
-        let (responder, _recorded) = spawn_fixture_daemon(temp.path(), &socket, 2, refuse_sync);
-        let _socket_env = SocketEnvGuard::set(&socket);
-
-        let error = brokered_init(&project, &[], &[], &test_handshake(&project, &profile))
-            .await
-            .expect_err("a parked worktree refuses the reconcile");
-        responder.await.expect("fixture daemon task");
+    #[test]
+    fn a_parked_admin_sync_refusal_prints_as_fields() {
+        let parked = tracedecay_contracts::code_index_freshness::CodeIndexConvergenceParkedV1 {
+            reason: format!("the publication authority is corrupt: {}", "x".repeat(600)),
+            blocked_reason: None,
+            remediation: "run `tracedecay daemon restart`".to_owned(),
+            parked_at_micros: 1,
+            observed_passes: 1,
+            retries_on_wake: false,
+        };
+        let detail = parked
+            .publication_authority_corrupt_error()
+            .project_route_typed_detail()
+            .cloned()
+            .expect("a parked refusal carries its typed detail");
+        let refusal = tracedecay_mcp::application_output::tool_result::ApplicationRefusal {
+            operation: ApplicationSurfaceOperation::AdminSync,
+            binding_id: tracedecay_tool_catalog::BindingId::new("binding.cli.admin_sync.v1")
+                .unwrap(),
+            problem: tracedecay_contracts::ApplicationProblemEnvelope::new(
+                tracedecay_contracts::ResultContractRef::new(
+                    tracedecay_tool_catalog::SchemaId::new(
+                        "schema.application.primitive.admin-sync.result",
+                    )
+                    .unwrap(),
+                    1,
+                )
+                .unwrap(),
+                tracedecay_contracts::RequestId::new("request.cli.admin-sync").unwrap(),
+                tracedecay_contracts::ApplicationProblem::from_detail(detail),
+            )
+            .unwrap(),
+        };
 
         assert_eq!(
-            crate::commands::process_error_text(error),
+            crate::commands::process_error_text(refusal.into_error()),
             format!(
-                "project route error (code_index_publication_authority_corrupt)\n\
+                "project route error (application.code-index.parked)\n\
                  Parked cause: the publication authority is corrupt: {}\n\
                  Parked remedy: run `tracedecay daemon restart`\n\
                  Retries on wake: false",
@@ -709,35 +593,20 @@ pub(crate) async fn handle_sync(
     )
     .await?;
     let handshake = super::daemon::client_handshake(profile, Some(&resolved.project_path))?;
-    let result = tracedecay::daemon::call_default_tool(
-        &handshake,
-        "tracedecay_admin_sync",
-        serde_json::json!({}),
-    )
-    .await?;
+    let deadline = tokio::time::Instant::now() + crate::tool_command::tool_command_deadline()?;
+    let result = admin_sync(handshake, deadline).await?;
     if verbose {
-        eprintln!(
-            "{}",
-            serde_json::to_string_pretty(&result).unwrap_or_default()
-        );
+        eprintln!("{}", serde_json::to_string_pretty(&result)?);
     }
-    match admin_sync_status(&result).as_deref() {
-        Some("queued") => eprintln!(
+    match result.status {
+        AdminSyncAdmissionV1::Queued => eprintln!(
             "code-index reconciliation queued via daemon for {}",
             resolved.project_path.display()
         ),
-        Some("not_applicable") => eprintln!(
+        AdminSyncAdmissionV1::NotApplicable => eprintln!(
             "code indexing does not apply to {}",
             resolved.project_path.display()
         ),
-        Some(status) => eprintln!(
-            "code-index reconciliation status is {status} for {}",
-            resolved.project_path.display()
-        ),
-        None => eprintln!(
-            "daemon code-index reconciliation returned no status for {}",
-            resolved.project_path.display()
-        ),
     }
     if doctor {
         tracedecay::doctor::run_doctor(profile, crate::cloud::doctor_network_probes()).await?;
diff --git a/crates/tracedecay-cli/src/tool_command.rs b/crates/tracedecay-cli/src/tool_command.rs
index b7863c0049..e1af057135 100644
--- a/crates/tracedecay-cli/src/tool_command.rs
+++ b/crates/tracedecay-cli/src/tool_command.rs
@@ -129,7 +129,7 @@ fn tool_deadline_range_error() -> TraceDecayError {
     }
 }
 
-fn tool_command_deadline() -> Result<Duration> {
+pub(crate) fn tool_command_deadline() -> Result<Duration> {
     tool_request_deadline()
 }
 
@@ -805,10 +805,6 @@ async fn dispatch_cli_graph_tool(
             ),
         });
     }
-    let request_id =
-        mint_global_request_id(GlobalRequestSurface::Cli).map_err(|_| TraceDecayError::Config {
-            message: "could not allocate an application surface request id".to_owned(),
-        })?;
     let handshake = tracedecay::daemon::handshake_for_current_client(
         profile,
         project.clone(),
@@ -816,11 +812,39 @@ async fn dispatch_cli_graph_tool(
         false,
         false,
     )?;
+    let outcome = invoke_cli_graph_tool(handshake, operation, &tool_args, deadline).await?;
+    let response_handle_root = cli_response_handle_root(profile, project.as_deref())?;
+    let mut result = match outcome {
+        Ok(completion) => tracedecay_mcp::handlers::graph_tool::render_graph_tool(
+            response_handle_root.as_deref(),
+            &tool_args,
+            completion,
+        )?,
+        Err(refusal) => refusal.render(response_handle_root.as_deref(), &tool_args)?,
+    };
+    account_tool_result(project.as_deref(), &mut result);
+    tracedecay_mcp::tool_errors::mark_semantic_tool_error(&mut result);
+    print_tool_output(&result.value, raw_json);
+    tool_result_process_outcome(&result.value, tool_name)
+}
+
+/// Run one graph-tool owner operation for `project` through the daemon and
+/// return its settled outcome.
+async fn invoke_cli_graph_tool(
+    handshake: DaemonHandshake,
+    operation: ApplicationSurfaceOperation,
+    tool_args: &Value,
+    deadline: Instant,
+) -> Result<tracedecay::mcp::tools::GraphToolOutcome> {
+    let request_id =
+        mint_global_request_id(GlobalRequestSurface::Cli).map_err(|_| TraceDecayError::Config {
+            message: "could not allocate an application surface request id".to_owned(),
+        })?;
     let client = tracedecay_daemon_identity::invocation_client_for_current(handshake)?;
     // A cold daemon refuses with the mounting problem while the project open
     // warms; that refusal precedes admission, so it is re-sent until the CLI
     // deadline like every other surface.
-    let outcome = loop {
+    loop {
         let (request_deadline, cancellation) = cli_request_controls(&request_id, deadline)?;
         let outcome = tracedecay::mcp::tools::execute_graph_tool_surface(
             tracedecay_tool_catalog::BindingSurface::Cli,
@@ -837,26 +861,27 @@ async fn dispatch_cli_graph_tool(
             .err()
             .and_then(|refusal| refusal.problem.problem.owner_mount_resend_delay())
         else {
-            break outcome;
+            return Ok(outcome);
         };
         if deadline.saturating_duration_since(Instant::now()) <= delay {
-            break outcome;
+            return Ok(outcome);
         }
         tokio::time::sleep(delay).await;
-    };
-    let response_handle_root = cli_response_handle_root(profile, project.as_deref())?;
-    let mut result = match outcome {
-        Ok(completion) => tracedecay_mcp::handlers::graph_tool::render_graph_tool(
-            response_handle_root.as_deref(),
-            &tool_args,
-            completion,
-        )?,
-        Err(refusal) => refusal.render(response_handle_root.as_deref(), &tool_args)?,
-    };
-    account_tool_result(project.as_deref(), &mut result);
-    tracedecay_mcp::tool_errors::mark_semantic_tool_error(&mut result);
-    print_tool_output(&result.value, raw_json);
-    tool_result_process_outcome(&result.value, tool_name)
+    }
+}
+
+/// The typed result a first-party command asks the project's owner for; a
+/// refusal is the command's error.
+pub(crate) async fn owner_operation_result(
+    handshake: DaemonHandshake,
+    operation: ApplicationSurfaceOperation,
+    arguments: Value,
+    deadline: Instant,
+) -> Result<tracedecay_contracts::graph_tool::GraphToolResultV1> {
+    match invoke_cli_graph_tool(handshake, operation, &arguments, deadline).await? {
+        Ok(completion) => Ok(completion.result),
+        Err(refusal) => Err(refusal.into_error()),
+    }
 }
 
 /// Run one profile registry read through the daemon's profile owner and print
diff --git a/crates/tracedecay-contracts/src/graph_tool.rs b/crates/tracedecay-contracts/src/graph_tool.rs
index f9510281a3..8683491dd4 100644
--- a/crates/tracedecay-contracts/src/graph_tool.rs
+++ b/crates/tracedecay-contracts/src/graph_tool.rs
@@ -12,11 +12,11 @@ use crate::retrieval::{
     StatusResultV1,
 };
 use crate::retrieval::{
-    AffectedResultV1, AnalyticsResultV1, AstGrepSearchResultV1, AutomationRunArtifactViewResultV1,
-    AutomationRunListResultV1, AutomationRunViewResultV1, BranchDiffResultV1, BranchListResultV1,
-    BranchSearchResultV1, ByQualifiedNameResultV1, ChangelogResultV1, CircularResultV1,
-    CommitContextResultV1, ComplexityReportV1, ConfigResultV1, ConstructorsResultV1,
-    ContextResultV1, CouplingResultV1, DashboardResultV1, DeadCodeResultV1,
+    AdminSyncResultV1, AffectedResultV1, AnalyticsResultV1, AstGrepSearchResultV1,
+    AutomationRunArtifactViewResultV1, AutomationRunListResultV1, AutomationRunViewResultV1,
+    BranchDiffResultV1, BranchListResultV1, BranchSearchResultV1, ByQualifiedNameResultV1,
+    ChangelogResultV1, CircularResultV1, CommitContextResultV1, ComplexityReportV1, ConfigResultV1,
+    ConstructorsResultV1, ContextResultV1, CouplingResultV1, DashboardResultV1, DeadCodeResultV1,
     DependencyDepthResultV1, DerivesResultV1, DiagnoseResultV1, DiffContextResultV1,
     DistributionResultV1, DocCoverageResultV1, DsmResultV1, FieldSitesResultV1, FilesResultV1,
     FindExactSymbolResultV1, GiniResultV1, GodClassResultV1, GrepSearchResultV1, HealthResultV1,
@@ -98,6 +98,7 @@ pub enum GraphToolResultV1 {
     ProjectList(ProjectRegistryListingResultV1),
     ProjectSearch(ProjectRegistryListingResultV1),
     ProjectContext(ProjectContextResultV1),
+    AdminSync(AdminSyncResultV1),
 }
 
 impl GraphToolResultV1 {
@@ -176,6 +177,7 @@ impl GraphToolResultV1 {
             Operation::ProjectList => Self::ProjectList(serde_json::from_value(value)?),
             Operation::ProjectSearch => Self::ProjectSearch(serde_json::from_value(value)?),
             Operation::ProjectContext => Self::ProjectContext(serde_json::from_value(value)?),
+            Operation::AdminSync => Self::AdminSync(serde_json::from_value(value)?),
             operation => {
                 return Err(serde::de::Error::custom(format!(
                     "{} is not a graph-tool operation",
@@ -253,6 +255,7 @@ impl GraphToolResultV1 {
             Self::Runtime(result) => serde_json::to_value(result),
             Self::ProjectList(result) | Self::ProjectSearch(result) => serde_json::to_value(result),
             Self::ProjectContext(result) => serde_json::to_value(result),
+            Self::AdminSync(result) => serde_json::to_value(result),
         }
     }
 }
diff --git a/crates/tracedecay-contracts/src/policy.rs b/crates/tracedecay-contracts/src/policy.rs
index 8c348c7187..dd1dcc9291 100644
--- a/crates/tracedecay-contracts/src/policy.rs
+++ b/crates/tracedecay-contracts/src/policy.rs
@@ -540,7 +540,8 @@ fn route_effect(effect: EffectClass) -> Result<CapabilityEffectClassV1, Applicat
         | EffectClass::ConfigurationWrite
         | EffectClass::Administrative
         | EffectClass::SpawnsProcess
-        | EffectClass::BindsServer => Err(ApplicationContractError::Inconsistent {
+        | EffectClass::BindsServer
+        | EffectClass::SchedulesWork => 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 9adb88f28c..b2dc79edc4 100644
--- a/crates/tracedecay-contracts/src/retrieval/catalog.rs
+++ b/crates/tracedecay-contracts/src/retrieval/catalog.rs
@@ -1,6 +1,6 @@
 use crate::retrieval::owner_effect_surface::{
-    DashboardResultV1, DashboardSurfaceRequestV1, RunAffectedTestsResultV1,
-    RunAffectedTestsSurfaceRequestV1,
+    AdminSyncResultV1, AdminSyncSurfaceRequestV1, DashboardResultV1, DashboardSurfaceRequestV1,
+    RunAffectedTestsResultV1, RunAffectedTestsSurfaceRequestV1,
 };
 use schemars::JsonSchema;
 use tracedecay_tool_catalog::{
@@ -278,6 +278,7 @@ const PRIMITIVE_READ_SPECS: &[PrimitiveReadSpec] = &[
     graph_report_spec("project_list"),
     graph_report_spec("project_search"),
     graph_report_spec("project_context"),
+    owner_side_effect_spec(ApplicationSurfaceOperation::AdminSync),
     git_context_spec("affected"),
     git_context_spec("diff_context"),
     git_context_spec("changelog"),
@@ -384,7 +385,8 @@ fn primitive_read_surfaces(spec: &PrimitiveReadSpec) -> &'static [BindingSurface
         | "runtime"
         | "project_list"
         | "project_search"
-        | "project_context" => &CLI_MCP_PRIMITIVE_SURFACES,
+        | "project_context"
+        | "admin_sync" => &CLI_MCP_PRIMITIVE_SURFACES,
         "health_read" | "storage_status" | "diagnostics_read" => &DASHBOARD_PRIMITIVE_SURFACES,
         _ => &PRE_DASHBOARD_PRIMITIVE_SURFACES,
     }
@@ -631,6 +633,9 @@ fn primitive_read_description(operation: &str) -> &'static str {
         "project_context" => {
             "Read one registered project's metadata, aliases, and store instances."
         }
+        "admin_sync" => {
+            "Queue the operator's code-index reconcile of the served project and report the scheduler's admission."
+        }
         _ => "Read bounded data from the admitted project's current retained state.",
     }
 }
@@ -679,7 +684,8 @@ const fn graph_report_spec(operation: &'static str) -> PrimitiveReadSpec {
 }
 
 /// A read observes cancellation until it answers. A spawned process is killed
-/// when its call is cancelled; binding a server is not interruptible.
+/// when its call is cancelled; binding a server or queueing scheduler work is
+/// not interruptible.
 fn primitive_cancellation(
     spec: &PrimitiveReadSpec,
 ) -> Result<CancellationContract, ApplicationContractError> {
@@ -700,9 +706,9 @@ fn primitive_cancellation(
 
 fn primitive_terminal_states(spec: &PrimitiveReadSpec) -> Vec<TerminalState> {
     let mut states = vec![TerminalState::Completed];
-    if !matches!(
+    if matches!(
         spec.side_effect.map(|entry| entry.effect),
-        Some(EffectClass::BindsServer)
+        None | Some(EffectClass::SpawnsProcess)
     ) {
         states.push(TerminalState::Cancelled);
     }
@@ -1188,6 +1194,7 @@ fn primitive_executable_schemas(
         ProjectContextSurfaceRequestV1,
         ProjectContextResultV1
     );
+    add!("admin_sync", AdminSyncSurfaceRequestV1, AdminSyncResultV1);
     Ok(schemas)
 }
 
diff --git a/crates/tracedecay-contracts/src/retrieval/mod.rs b/crates/tracedecay-contracts/src/retrieval/mod.rs
index afcdcd6849..5c4d173aed 100644
--- a/crates/tracedecay-contracts/src/retrieval/mod.rs
+++ b/crates/tracedecay-contracts/src/retrieval/mod.rs
@@ -178,6 +178,7 @@ pub use graph_report_surface::{
 };
 pub use grep_analysis::{DependencyDepthChainV1, DependencyDepthResultV1};
 pub use owner_effect_surface::{
+    AdminSyncAdmissionV1, AdminSyncReconcileScopeV1, AdminSyncResultV1, AdminSyncSurfaceRequestV1,
     AffectedTestErrorV1, AffectedTestOutcomeV1, AffectedTestRunV1, AffectedTestsNotRunV1,
     DashboardActionV1, DashboardBoundV1, DashboardResultV1, DashboardSurfaceRequestV1,
     ManagedTestTerminalV1, RunAffectedTestsResultV1, RunAffectedTestsSurfaceRequestV1,
diff --git a/crates/tracedecay-contracts/src/retrieval/owner_effect_surface.rs b/crates/tracedecay-contracts/src/retrieval/owner_effect_surface.rs
index 2b5aa0a1dc..1d9a77a64d 100644
--- a/crates/tracedecay-contracts/src/retrieval/owner_effect_surface.rs
+++ b/crates/tracedecay-contracts/src/retrieval/owner_effect_surface.rs
@@ -1,6 +1,6 @@
 //! Canonical CLI/MCP wire contracts for the side-effecting operations the
-//! project's graph-tool owner serves: a managed affected-test run and the
-//! project dashboard server.
+//! project's graph-tool owner serves: a managed affected-test run, the
+//! project dashboard server, and the operator's code-index reconcile.
 //!
 //! Presentation-only transport keys such as `format` are removed before these
 //! request bodies are decoded.
@@ -162,3 +162,33 @@ pub enum DashboardResultV1 {
     },
     NotRunning,
 }
+
+/// `tracedecay_admin_sync` takes no arguments: it reconciles the served
+/// project.
+#[derive(Clone, Debug, Default, Deserialize, JsonSchema, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct AdminSyncSurfaceRequestV1 {}
+
+/// What the reconcile covers.
+#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AdminSyncReconcileScopeV1 {
+    AuthoritativeProject,
+}
+
+/// The code-index scheduler's admission of the reconcile.
+#[derive(Clone, Copy, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AdminSyncAdmissionV1 {
+    Queued,
+    /// Code indexing does not apply to this project.
+    NotApplicable,
+}
+
+#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct AdminSyncResultV1 {
+    pub reconcile_scope: AdminSyncReconcileScopeV1,
+    pub status: AdminSyncAdmissionV1,
+    pub project_root: String,
+}
diff --git a/crates/tracedecay-contracts/src/sdk_catalog.rs b/crates/tracedecay-contracts/src/sdk_catalog.rs
index ee1b943fa7..d99cf2a4f4 100644
--- a/crates/tracedecay-contracts/src/sdk_catalog.rs
+++ b/crates/tracedecay-contracts/src/sdk_catalog.rs
@@ -174,7 +174,8 @@ pub fn application_http_route_path(operation: ApplicationSurfaceOperation) -> St
         | ApplicationSurfaceOperation::Runtime
         | ApplicationSurfaceOperation::ProjectList
         | ApplicationSurfaceOperation::ProjectSearch
-        | ApplicationSurfaceOperation::ProjectContext) => {
+        | ApplicationSurfaceOperation::ProjectContext
+        | ApplicationSurfaceOperation::AdminSync) => {
             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 0bb42012d3..c754f3b8fc 100644
--- a/crates/tracedecay-daemon-protocol/src/application_surface.rs
+++ b/crates/tracedecay-daemon-protocol/src/application_surface.rs
@@ -950,7 +950,8 @@ pub fn parse_application_surface_request(
         | ApplicationSurfaceOperation::Runtime
         | ApplicationSurfaceOperation::ProjectList
         | ApplicationSurfaceOperation::ProjectSearch
-        | ApplicationSurfaceOperation::ProjectContext => match value {
+        | ApplicationSurfaceOperation::ProjectContext
+        | ApplicationSurfaceOperation::AdminSync => 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 12e3d61957..5c17563014 100644
--- a/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs
+++ b/crates/tracedecay-daemon-protocol/src/application_surface/invocation.rs
@@ -927,6 +927,7 @@ pub fn application_surface_feedback_operation(
         | ApplicationSurfaceOperation::ProjectList
         | ApplicationSurfaceOperation::ProjectSearch
         | ApplicationSurfaceOperation::ProjectContext
+        | ApplicationSurfaceOperation::AdminSync
         | 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 a670b66ad4..4954c677c0 100644
--- a/crates/tracedecay-daemon-protocol/src/contract/mod.rs
+++ b/crates/tracedecay-daemon-protocol/src/contract/mod.rs
@@ -1083,7 +1083,8 @@ impl DaemonInvocationRequest {
             | ApplicationSurfaceOperation::Runtime
             | ApplicationSurfaceOperation::ProjectList
             | ApplicationSurfaceOperation::ProjectSearch
-            | ApplicationSurfaceOperation::ProjectContext => {
+            | ApplicationSurfaceOperation::ProjectContext
+            | ApplicationSurfaceOperation::AdminSync => {
                 unreachable!("graph-tool operations use their typed constructor")
             }
             ApplicationSurfaceOperation::FactStoreCurate
diff --git a/crates/tracedecay-daemon-service/src/adoption_observation.rs b/crates/tracedecay-daemon-service/src/adoption_observation.rs
index 7432aa315d..965f8b1bbb 100644
--- a/crates/tracedecay-daemon-service/src/adoption_observation.rs
+++ b/crates/tracedecay-daemon-service/src/adoption_observation.rs
@@ -316,6 +316,7 @@ mod tests {
                     "capability.application.primitive.active-project",
                     "available",
                 ),
+                ("capability.application.primitive.admin-sync", "available"),
                 ("capability.application.primitive.affected", "available"),
                 ("capability.application.primitive.analytics", "available"),
                 (
diff --git a/crates/tracedecay-mcp-catalog/src/definitions.rs b/crates/tracedecay-mcp-catalog/src/definitions.rs
index 2efe0756b9..e7c7dbfaca 100644
--- a/crates/tracedecay-mcp-catalog/src/definitions.rs
+++ b/crates/tracedecay-mcp-catalog/src/definitions.rs
@@ -700,7 +700,12 @@ static FORMAT_CAPABLE_TOOL_NAMES: LazyLock<Vec<&'static str>> = LazyLock::new(||
     FORMAT_CAPABLE_NON_APPLICATION_TOOL_NAMES
         .iter()
         .copied()
-        .chain(ApplicationSurfaceOperation::MCP_TOOL_NAMES)
+        .chain(
+            ApplicationSurfaceOperation::ALL
+                .into_iter()
+                .filter(|operation| !operation.is_internal())
+                .map(ApplicationSurfaceOperation::mcp_tool_name),
+        )
         .collect()
 });
 
diff --git a/crates/tracedecay-mcp-catalog/src/definitions/application.rs b/crates/tracedecay-mcp-catalog/src/definitions/application.rs
index e4a6110634..3161e9d349 100644
--- a/crates/tracedecay-mcp-catalog/src/definitions/application.rs
+++ b/crates/tracedecay-mcp-catalog/src/definitions/application.rs
@@ -147,7 +147,9 @@ pub(super) fn application_definitions() -> Result<Vec<ToolDefinition>, McpCatalo
 
     ApplicationSurfaceOperation::ALL
         .into_iter()
-        .filter(|operation| !HANDWRITTEN_DEFINITION_OPERATIONS.contains(operation))
+        .filter(|operation| {
+            !HANDWRITTEN_DEFINITION_OPERATIONS.contains(operation) && !operation.is_internal()
+        })
         .map(|operation| {
             let descriptor = handlers.for_surface_operation(operation).ok_or_else(|| {
                 invalid_application_definition(
@@ -417,6 +419,15 @@ mod tests {
                 );
                 continue;
             }
+            if operation.is_internal() {
+                assert!(
+                    advertised
+                        .iter()
+                        .all(|published| published.name != operation.mcp_tool_name()),
+                    "{operation:?} is served by name and never advertised"
+                );
+                continue;
+            }
             let definition = definitions
                 .iter()
                 .find(|definition| definition.name == operation.mcp_tool_name())
diff --git a/crates/tracedecay-mcp/src/application_output/tool_result.rs b/crates/tracedecay-mcp/src/application_output/tool_result.rs
index d49b7f8953..8855883df4 100644
--- a/crates/tracedecay-mcp/src/application_output/tool_result.rs
+++ b/crates/tracedecay-mcp/src/application_output/tool_result.rs
@@ -6,7 +6,7 @@ use std::path::Path;
 use serde_json::Value;
 use tracedecay_contracts::{ApplicationProblemEnvelope, ApplicationProblemKind, ApplicationResult};
 use tracedecay_daemon_protocol::{RequestedOutputFormat, requested_output_format};
-use tracedecay_domain::errors::Result;
+use tracedecay_domain::errors::{Result, TraceDecayError};
 use tracedecay_tool_catalog::{ApplicationSurfaceOperation, BindingId};
 
 use super::markdown;
@@ -37,6 +37,22 @@ impl ApplicationRefusal {
             requested_output_format(args),
         )
     }
+
+    /// The refusal as the error a first-party command returns: the owner's
+    /// reason code, retryability, and typed detail or diagnostic.
+    pub fn into_error(self) -> TraceDecayError {
+        let record = *self.problem.problem;
+        let (reason_code, message) = match record.diagnostic {
+            Some(diagnostic) => (diagnostic.code, diagnostic.message),
+            None => (record.code, record.message),
+        };
+        match record.detail {
+            Some(detail) => {
+                TraceDecayError::project_route_with_detail(reason_code, record.retryable, detail)
+            }
+            None => TraceDecayError::project_route(reason_code, record.retryable, message),
+        }
+    }
 }
 
 /// Renders one settled application call. A problem is a semantic failure
diff --git a/crates/tracedecay-mcp/src/tools/binding.rs b/crates/tracedecay-mcp/src/tools/binding.rs
index 2c49ba96b9..3054437d46 100644
--- a/crates/tracedecay-mcp/src/tools/binding.rs
+++ b/crates/tracedecay-mcp/src/tools/binding.rs
@@ -38,7 +38,6 @@ pub const INTERNAL_DAEMON_TOOL_NAMES: &[&str] = &[
     "tracedecay_admin_branch_add",
     "tracedecay_admin_cli",
     "tracedecay_admin_project",
-    "tracedecay_admin_sync",
     "tracedecay_hook_runtime",
 ];
 
@@ -47,7 +46,6 @@ pub const INTERNAL_DAEMON_TOOL_NAMES: &[&str] = &[
 pub enum McpToolDispatchGroup {
     ApplicationSurface,
     MultiRoot,
-    Info,
     Admin,
     Git,
     Work,
@@ -79,8 +77,7 @@ pub fn tool_branch_sensitivity(tool_name: &str) -> BranchSensitivity {
     }
     match dispatch_group_for_tool(tool_name) {
         Some(
-            McpToolDispatchGroup::Info
-            | McpToolDispatchGroup::Admin
+            McpToolDispatchGroup::Admin
             | McpToolDispatchGroup::Git
             | McpToolDispatchGroup::MultiRoot
             | McpToolDispatchGroup::ApplicationSurface,
@@ -301,6 +298,7 @@ fn application_surface_branch_sensitivity(
         | ApplicationSurfaceOperation::ProjectList
         | ApplicationSurfaceOperation::ProjectSearch
         | ApplicationSurfaceOperation::ProjectContext
+        | ApplicationSurfaceOperation::AdminSync
         | HealthRead
         | HealthDelta
         | DiagnosticsRead
@@ -350,9 +348,6 @@ macro_rules! binding_groups {
 /// access are one slice; a different access starts a new slice.
 #[rustfmt::skip]
 const BINDING_GROUPS: &[BindingGroup] = binding_groups![
-    [Some(McpToolDispatchGroup::Info), RegisteredProjectAccess::ActiveProjectOnly,
-        "tracedecay_admin_sync", "tracedecay_port_status", "tracedecay_port_order",
-        "tracedecay_todos"],
     [Some(McpToolDispatchGroup::Admin), RegisteredProjectAccess::ActiveProjectOnly,
         "tracedecay_hook_runtime", "tracedecay_admin_cli", "tracedecay_admin_project"],
     [Some(McpToolDispatchGroup::Git), RegisteredProjectAccess::ActiveProjectOnly,
diff --git a/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs b/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs
index 2a1041eb25..e955a5499e 100644
--- a/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs
+++ b/crates/tracedecay-mcp/src/tools/dispatch_ceiling.rs
@@ -39,7 +39,6 @@ const LONG_RUNNING_DISPATCH_TOOLS: &[&str] = &[
     "tracedecay_fact_store_curate",
     "tracedecay_admin_cli",
     "tracedecay_admin_project",
-    "tracedecay_admin_sync",
     "tracedecay_admin_branch_add",
 ];
 
diff --git a/crates/tracedecay-tool-catalog/src/manifest.rs b/crates/tracedecay-tool-catalog/src/manifest.rs
index c851ffd7ea..54a5d4981b 100644
--- a/crates/tracedecay-tool-catalog/src/manifest.rs
+++ b/crates/tracedecay-tool-catalog/src/manifest.rs
@@ -139,6 +139,9 @@ pub enum EffectClass {
     SpawnsProcess,
     /// Binds a listening server in the daemon process.
     BindsServer,
+    /// Queues work on a daemon-owned scheduler; the call answers with the
+    /// scheduler's admission, not the finished work.
+    SchedulesWork,
 }
 
 impl EffectClass {
@@ -149,7 +152,10 @@ impl EffectClass {
     /// 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)
+        matches!(
+            self,
+            Self::SpawnsProcess | Self::BindsServer | Self::SchedulesWork
+        )
     }
 
     pub const fn is_read_only(self) -> bool {
diff --git a/crates/tracedecay-tool-catalog/src/operation.rs b/crates/tracedecay-tool-catalog/src/operation.rs
index f07c447336..c7fd11cc95 100644
--- a/crates/tracedecay-tool-catalog/src/operation.rs
+++ b/crates/tracedecay-tool-catalog/src/operation.rs
@@ -24,14 +24,6 @@ macro_rules! application_surface_operations {
                 $(Self::$variant,)+
             ];
 
-            pub const MCP_TOOL_NAMES: [&'static str; [$(stringify!($variant)),+].len()] = [
-                $(
-                    application_surface_operations!(
-                        @mcp_tool_name $catalog_name $(, $mcp_name)?
-                    ),
-                )+
-            ];
-
             pub fn from_catalog_name(name: &str) -> Option<Self> {
                 Self::ALL
                     .into_iter()
@@ -226,6 +218,7 @@ application_surface_operations! {
     ProjectList => "project_list";
     ProjectSearch => "project_search";
     ProjectContext => "project_context";
+    AdminSync => "admin_sync";
     HealthRead => "health_read";
     HealthDelta => "health_delta";
     StorageStatus => "storage_status";
@@ -359,6 +352,7 @@ impl ApplicationSurfaceOperation {
         Self::ActiveProject,
         Self::RemoteStatus,
         Self::Runtime,
+        Self::AdminSync,
     ];
 
     /// Reads of the authenticated profile's project registry. They name no
@@ -367,10 +361,19 @@ impl ApplicationSurfaceOperation {
     pub const PROFILE_REGISTRY_OPERATIONS: &[Self] =
         &[Self::ProjectList, Self::ProjectSearch, Self::ProjectContext];
 
+    /// Owner-served operations that first-party CLI commands and host hooks
+    /// call by name. They are never advertised in `tools/list` or mounted on
+    /// HTTP, so an agent cannot discover or select them.
+    pub const INTERNAL_OPERATIONS: &[Self] = &[Self::AdminSync];
+
     pub fn is_graph_tool(self) -> bool {
         Self::GRAPH_TOOL_OPERATIONS.contains(&self)
     }
 
+    pub fn is_internal(self) -> bool {
+        Self::INTERNAL_OPERATIONS.contains(&self)
+    }
+
     pub fn is_profile_registry_read(self) -> bool {
         Self::PROFILE_REGISTRY_OPERATIONS.contains(&self)
     }
diff --git a/crates/tracedecay-tool-catalog/src/owner_side_effect.rs b/crates/tracedecay-tool-catalog/src/owner_side_effect.rs
index 39515d6bdd..1623ecd39d 100644
--- a/crates/tracedecay-tool-catalog/src/owner_side_effect.rs
+++ b/crates/tracedecay-tool-catalog/src/owner_side_effect.rs
@@ -42,6 +42,12 @@ impl ApplicationSurfaceOperation {
                 ceiling_millis: INTERACTIVE_CEILING_MILLIS,
                 identical_calls: IdenticalCallPolicyV1::RunEach,
             }),
+            // Admission can wait out the scheduler's cold mount.
+            Self::AdminSync => Some(OwnerSideEffectEntryV1 {
+                effect: EffectClass::SchedulesWork,
+                ceiling_millis: LONG_RUNNING_CEILING_MILLIS,
+                identical_calls: IdenticalCallPolicyV1::RunEach,
+            }),
             _ => None,
         }
     }
@@ -80,6 +86,14 @@ mod tests {
                         identical_calls: IdenticalCallPolicyV1::RunEach,
                     }
                 ),
+                (
+                    "admin_sync",
+                    OwnerSideEffectEntryV1 {
+                        effect: EffectClass::SchedulesWork,
+                        ceiling_millis: 600_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 b98ae72805..719c05476b 100644
--- a/crates/tracedecay/src/mcp/server/graph_tool_owner.rs
+++ b/crates/tracedecay/src/mcp/server/graph_tool_owner.rs
@@ -74,6 +74,7 @@ impl McpServer {
             verified_graph_query_port: self.verified_graph_query_port.clone(),
             code_index_freshness_reader: self.dashboard_code_index_freshness_reader.clone(),
             code_index_publication_identity: self.code_index_publication_identity.clone(),
+            code_index_reconcile_sink: self.code_index_reconcile_sink.clone(),
             code_index_ignored_dependency_admission: self
                 .code_index_ignored_dependency_admission
                 .clone(),
diff --git a/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs b/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs
index b4bcbd45b1..e3dce36fe0 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_groups.rs
@@ -13,8 +13,8 @@ use tracedecay_contracts::code_index_freshness::{
     CodeIndexFreshnessReader, CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitV1,
 };
 use tracedecay_contracts::retrieval::{
-    ActiveProjectSurfaceRequestV1, RemoteStatusSurfaceRequestV1, RuntimeSurfaceRequestV1,
-    StatusSurfaceRequestV1,
+    ActiveProjectSurfaceRequestV1, AdminSyncSurfaceRequestV1, RemoteStatusSurfaceRequestV1,
+    RuntimeSurfaceRequestV1, StatusSurfaceRequestV1,
 };
 use tracedecay_dashboard_api::AdmittedDoctorReportV1;
 use tracedecay_mcp::handlers::health as portable_health;
@@ -109,21 +109,6 @@ async fn admitted_graph_query_for_operation(
     Ok(query)
 }
 
-/// Dispatch the daemon-only `tracedecay_admin_sync`.
-#[hotpath::measure(future = true, label = "mcp.dispatch.info")]
-pub(super) async fn dispatch_info_tools(
-    tool_name: &str,
-    cg: &TraceDecay,
-    options: ToolCallRegistryOptions<'_>,
-) -> Result<ToolResult> {
-    match tool_name {
-        "tracedecay_admin_sync" => {
-            info::handle_admin_sync(cg, options.code_index_reconcile_sink.as_ref()).await
-        }
-        _ => Err(unknown_tool_error(tool_name)),
-    }
-}
-
 /// Dispatch administrative tools (`tracedecay_hook_runtime`,
 /// `tracedecay_admin_cli`, `tracedecay_admin_project`).
 #[hotpath::measure(future = true, label = "mcp.dispatch.admin")]
@@ -751,6 +736,13 @@ async fn compute_owner_side_effect(
             )
             .await;
         }
+        ApplicationSurfaceOperation::AdminSync => {
+            let AdminSyncSurfaceRequestV1 {} =
+                decode_primitive_request(&args, operation.mcp_tool_name())?;
+            GraphToolResultV1::AdminSync(
+                info::admin_sync(cg, options.code_index_reconcile_sink.as_ref()).await?,
+            )
+        }
         ApplicationSurfaceOperation::Dashboard => {
             let request = tracedecay_mcp::handlers::decode_primitive_request(
                 &args,
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 b3001c6346..766d2d3ed1 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_test_support.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_test_support.rs
@@ -386,7 +386,6 @@ pub(super) async fn concrete_dispatch_group_accepts(
         McpToolDispatchGroup::MultiRoot => {
             owned(handle_multi_root(tool_name, invalid_args, None, None, None, None).await)
         }
-        McpToolDispatchGroup::Info => owned(dispatch_info_tools(tool_name, cg, options).await),
         McpToolDispatchGroup::Admin => {
             owned(dispatch_admin_tools(tool_name, cg, invalid_args, options).await)
         }
diff --git a/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs b/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs
index a8e3a05b39..8107b246fe 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/dispatch_tests.rs
@@ -2088,7 +2088,7 @@ async fn admin_sync_reports_terminal_publication_corruption_without_queueing() {
         },
     );
 
-    let error = handle_tool_call_with_registry_options(
+    let error = dispatch_on_graph_authority(
         &cg,
         "tracedecay_admin_sync",
         json!({"format": "json"}),
diff --git a/crates/tracedecay/src/mcp/tools/handlers/info/mod.rs b/crates/tracedecay/src/mcp/tools/handlers/info/mod.rs
index 52de249752..f8a46991e4 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/info/mod.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/info/mod.rs
@@ -14,10 +14,7 @@
 mod remote_status_dispatch_tests;
 mod status;
 
-pub(super) use status::handle_admin_sync;
-
-pub(super) use serde_json::json;
+pub(super) use status::admin_sync;
 
 pub(super) use tracedecay_domain::errors::{Result, TraceDecayError};
-pub(super) use tracedecay_mcp::ToolResult;
 pub(super) use tracedecay_project::project::TraceDecay;
diff --git a/crates/tracedecay/src/mcp/tools/handlers/info/status.rs b/crates/tracedecay/src/mcp/tools/handlers/info/status.rs
index f02c7fc7a9..2fbe8baec2 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/info/status.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/info/status.rs
@@ -1,18 +1,23 @@
-//! Daemon-only `tracedecay_admin_sync`, still needs the code-index reconcile sink.
+//! `tracedecay_admin_sync`: the operator's code-index reconcile, which needs
+//! the daemon's code-index reconcile sink.
 
-use super::*;
 use tracedecay_code_index_runtime::code_index_scheduler::{
     CodeIndexDemandAdmissionV1, CodeIndexDemandV1,
 };
+use tracedecay_contracts::retrieval::{
+    AdminSyncAdmissionV1, AdminSyncReconcileScopeV1, AdminSyncResultV1,
+};
+
+use super::{Result, TraceDecay, TraceDecayError};
 
-/// Daemon-only sync entry point used by the first-party CLI. It is deliberately
-/// not advertised in the MCP catalog: external agents should rely on the
-/// daemon watcher while the CLI can request an explicit serialized refresh.
+/// Queues the reconcile the first-party CLI asks for (`tracedecay init` /
+/// `tracedecay sync`). It is never advertised: external agents rely on the
+/// daemon watcher.
 #[hotpath::measure(label = "mcp.info.admin_sync.total")]
-pub(crate) async fn handle_admin_sync(
+pub(crate) async fn admin_sync(
     cg: &TraceDecay,
     reconcile_sink: Option<&crate::mcp::server::CodeIndexReconcileSink>,
-) -> Result<ToolResult> {
+) -> Result<AdminSyncResultV1> {
     let project_root = cg.project_root().to_path_buf();
     let reconcile_sink = reconcile_sink.ok_or_else(|| {
         TraceDecayError::project_route(
@@ -21,16 +26,16 @@ pub(crate) async fn handle_admin_sync(
             "admin sync requires the daemon code-index scheduler",
         )
     })?;
-    // The operator named this route (`tracedecay init` / `tracedecay sync`):
-    // the one demand that may index a route the watcher policy keeps quiet.
+    // The operator named this route: the one demand that may index a route
+    // the watcher policy keeps quiet.
     let admission = hotpath::future!(
-        reconcile_sink(project_root.clone(), CodeIndexDemandV1::OperatorReconcile,),
+        reconcile_sink(project_root.clone(), CodeIndexDemandV1::OperatorReconcile),
         label = "mcp.info.admin_sync.reconcile"
     )
     .await;
     let status = match admission {
-        CodeIndexDemandAdmissionV1::Queued => "queued",
-        CodeIndexDemandAdmissionV1::NotApplicable => "not_applicable",
+        CodeIndexDemandAdmissionV1::Queued => AdminSyncAdmissionV1::Queued,
+        CodeIndexDemandAdmissionV1::NotApplicable => AdminSyncAdmissionV1::NotApplicable,
         CodeIndexDemandAdmissionV1::Terminal(parked) => {
             return Err(parked.publication_authority_corrupt_error());
         }
@@ -41,19 +46,9 @@ pub(crate) async fn handle_admin_sync(
             return Err(crate::mcp::server::code_index_unavailable_error(cause));
         }
     };
-    let output = json!({
-        "reconcile_scope": "authoritative_project",
-        "status": status,
-        "project_root": cg.project_root(),
-    });
-    let text = serde_json::to_string(&output)?;
-    Ok(ToolResult::new(
-        json!({
-            "content": [{
-                "type": "text",
-                "text": text,
-            }]
-        }),
-        Vec::new(),
-    ))
+    Ok(AdminSyncResultV1 {
+        reconcile_scope: AdminSyncReconcileScopeV1::AuthoritativeProject,
+        status,
+        project_root: project_root.to_string_lossy().into_owned(),
+    })
 }
diff --git a/crates/tracedecay/src/mcp/tools/handlers/mod.rs b/crates/tracedecay/src/mcp/tools/handlers/mod.rs
index 9084356cd8..968391ec60 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/mod.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/mod.rs
@@ -7,9 +7,9 @@
 mod application_surface;
 pub(crate) use application_surface::graph_tool_error_problem;
 pub use application_surface::{
-    RetainedSurfaceExecution, execute_graph_tool_surface, execute_retained_surface_tool,
-    render_application_surface_result, render_retained_execution, retained_tool_target,
-    run_retained_surface_tool,
+    GraphToolOutcome, RetainedSurfaceExecution, execute_graph_tool_surface,
+    execute_retained_surface_tool, render_application_surface_result, render_retained_execution,
+    retained_tool_target, run_retained_surface_tool,
 };
 pub(crate) use dispatch_groups::compute_graph_tool_for_owner;
 #[cfg(test)]
@@ -175,9 +175,7 @@ use tracedecay_contracts::{InvocationTarget, RetainedSurfaceOperation};
 use tracedecay_tool_catalog::{ApplicationSurfaceOperation, BindingSurface};
 
 use super::LegacyToolCompatibilityOwner;
-use dispatch_groups::{
-    dispatch_admin_tools, dispatch_application_surface_tools, dispatch_info_tools,
-};
+use dispatch_groups::{dispatch_admin_tools, dispatch_application_surface_tools};
 use tool_call_support::{boxed_send, rejected_tool_project_selector_present};
 use tracedecay_api::{WorkHttpRequest, WorkflowHttpRequest};
 use tracedecay_daemon_protocol::DaemonInvocationExecutor;
@@ -606,9 +604,6 @@ pub fn handle_tool_call_with_registry_options<'a>(
         let served_code_graph = options.served_code_graph.clone();
         let dispatched = async {
             match dispatch_group {
-                Some(McpToolDispatchGroup::Info) => {
-                    boxed_send(dispatch_info_tools(tool_name, cg, options)).await
-                }
                 Some(McpToolDispatchGroup::Admin) => {
                     boxed_send(dispatch_admin_tools(tool_name, cg, args, options)).await
                 }
diff --git a/crates/tracedecay/src/mcp/tools/mod.rs b/crates/tracedecay/src/mcp/tools/mod.rs
index 7227b757c6..b7a6d250b1 100644
--- a/crates/tracedecay/src/mcp/tools/mod.rs
+++ b/crates/tracedecay/src/mcp/tools/mod.rs
@@ -13,10 +13,11 @@ use tracedecay_mcp::get_tool_definitions;
 use tracedecay_mcp::tools::dispatch::McpDispatchMetadataError;
 
 pub use handlers::{
-    RetainedSurfaceExecution, ToolCallRegistryOptions, execute_graph_tool_surface,
-    execute_retained_surface_tool, execute_work_tool_surface, execute_workflow_tool_surface,
-    handle_tool_call, handle_tool_call_with_registry_options, render_application_surface_result,
-    render_retained_execution, retained_tool_target, run_retained_surface_tool,
+    GraphToolOutcome, RetainedSurfaceExecution, ToolCallRegistryOptions,
+    execute_graph_tool_surface, execute_retained_surface_tool, execute_work_tool_surface,
+    execute_workflow_tool_surface, handle_tool_call, handle_tool_call_with_registry_options,
+    render_application_surface_result, render_retained_execution, retained_tool_target,
+    run_retained_surface_tool,
 };
 pub(crate) use handlers::{compute_graph_tool_for_owner, graph_tool_error_problem};
 
diff --git a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/info_health_request_test.rs b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/info_health_request_test.rs
index 05a93af70f..2cdda2e1b3 100644
--- a/crates/tracedecay/tests/mcp_suite/mcp_handler_test/info_health_request_test.rs
+++ b/crates/tracedecay/tests/mcp_suite/mcp_handler_test/info_health_request_test.rs
@@ -1,7 +1,8 @@
-//! The project-info, registry, and runtime reads decode their arguments
-//! against a typed request over the production MCP `tools/call` path: an
-//! argument outside the request contract is refused instead of being silently
-//! ignored, and a valid call answers the typed result through its owner.
+//! The project-info, registry, and runtime reads, and the admin sync the CLI
+//! requests, decode their arguments against a typed request over the
+//! production MCP `tools/call` path: an argument outside the request contract
+//! is refused instead of being silently ignored, and a valid call answers the
+//! typed result through its owner.
 
 #![cfg(feature = "test-transport")]
 
@@ -312,3 +313,39 @@ async fn info_and_runtime_reads_refuse_arguments_outside_their_typed_request() {
 
     fixture.harness.shutdown().await;
 }
+
+/// `tracedecay_admin_sync` is the owner's side effect the CLI's `init` and
+/// `sync` request by name: it answers the code-index scheduler's typed
+/// admission and refuses any argument, since it always reconciles the served
+/// project.
+#[tokio::test]
+async fn admin_sync_answers_the_scheduler_admission_and_refuses_arguments() {
+    let fixture = production_composition_fixture().await;
+    let root = canonical_existing_identity(&fixture.project_root)
+        .expect("canonical project root")
+        .display()
+        .to_string();
+
+    assert_eq!(
+        call_json(&fixture, "tracedecay_admin_sync", json!({})).await,
+        json!({
+            "reconcile_scope": "authoritative_project",
+            "status": "queued",
+            "project_root": root,
+        })
+    );
+    assert_eq!(
+        refusal(
+            &fixture,
+            "tracedecay_admin_sync",
+            json!({"project_root": "/elsewhere"})
+        )
+        .await,
+        invalid(
+            "tracedecay_admin_sync",
+            "unknown field `project_root`, there are no fields"
+        )
+    );
+
+    fixture.harness.shutdown().await;
+}
diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json
index 8a63a3f82f..fb806d063a 100644
--- a/dashboard/codegen/schemas/dashboard-contracts.schema.json
+++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json
@@ -11226,6 +11226,11 @@
           "const": "binds_server",
           "description": "Binds a listening server in the daemon process.",
           "type": "string"
+        },
+        {
+          "const": "schedules_work",
+          "description": "Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.",
+          "type": "string"
         }
       ]
     },
diff --git a/dashboard/src/contracts/generated.ts b/dashboard/src/contracts/generated.ts
index 1bf9419244..62749908a8 100644
--- a/dashboard/src/contracts/generated.ts
+++ b/dashboard/src/contracts/generated.ts
@@ -2390,7 +2390,7 @@ export type DuplicateEffortKindV1 = z.infer<typeof DuplicateEffortKindV1Schema>;
 
 Git index writes remain separate classes so policy cannot accidentally
 substitute one index mutation for another. */
-export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server")]);
+export const EffectClassSchema = z.union([z.enum(["administrative", "configuration_write", "git_index_commit", "git_index_stage", "git_index_unstage", "preview", "read", "source_edit"]), z.literal("spawns_process"), z.literal("binds_server"), z.literal("schedules_work")]);
 export type EffectClass = z.infer<typeof EffectClassSchema>;
 
 /** 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 1a5f04c49a..b32557898c 100644
--- a/sdks/typescript/src/operations.ts
+++ b/sdks/typescript/src/operations.ts
@@ -37,6 +37,8 @@ export type ActiveProjectStorageV1 = { readonly class: string; readonly data_roo
 export type ActorId = string;
 export type AddWorkTaskRequestV1 = { readonly item: WorkItemV1; readonly mutation: WorkProductMutationIdentityV1; readonly selection: WorkProductSelectionScopeV1 };
 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 AdminSyncAdmissionV1 = "queued" | "not_applicable";
+export type AdminSyncReconcileScopeV1 = "authoritative_project";
 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 };
@@ -324,7 +326,7 @@ export type DsmStatsV1 = { readonly clusters: number; readonly density: number;
 export type DuplicateEffectOutcomeV1 = "prevented" | "committed" | "unknown" | "not_applicable";
 export type DuplicateEffortKindV1 = "exact_duplicate" | "superseded_overlap" | "repeated_investigation" | "duplicate_effect" | "not_duplicate" | "censored" | "unknown";
 export type EditResult = { readonly diff?: string | null; readonly dry_run?: boolean; readonly file_path: string; readonly matched_str: string; readonly message: string; readonly new_str: string; readonly replaced_span?: string | null; readonly success: boolean; readonly [key: string]: unknown };
-export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server";
+export type EffectClass = "read" | "preview" | "source_edit" | "git_index_stage" | "git_index_unstage" | "git_index_commit" | "configuration_write" | "administrative" | "spawns_process" | "binds_server" | "schedules_work";
 export type 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";
@@ -1259,6 +1261,8 @@ export type WorktreeRootPolicyV1 = { readonly locator: SensitiveFilesystemLocato
 
 export type OperationApplicationActiveProjectRequest = {  };
 export type OperationApplicationActiveProjectResult = { readonly branch: ActiveProjectBranchV1; readonly project_id?: string | null; readonly project_root: string; readonly repository_id: string; readonly resolution_source: ActiveProjectResolutionSourceV1; readonly scope_prefix?: string | null; readonly storage: ActiveProjectStorageV1 };
+export type OperationApplicationAdminSyncRequest = {  };
+export type OperationApplicationAdminSyncResult = { readonly project_root: string; readonly reconcile_scope: AdminSyncReconcileScopeV1; readonly status: AdminSyncAdmissionV1 };
 export type OperationApplicationAffectedRequest = { readonly depth?: number | null; readonly files: readonly string[]; readonly filter?: string | null };
 export type OperationApplicationAffectedResult = { readonly affected_tests: readonly string[]; readonly changed_files: readonly string[]; readonly count: number; readonly ranked_tests: readonly RankedAffectedTestV1[]; readonly ranking_metadata: AffectedRankingMetadataV1; readonly recommended_tests: readonly string[] };
 export type OperationApplicationAffectedTestsRequest = { readonly request_handle: string };
@@ -1738,6 +1742,8 @@ const DEFINITIONS = {
   ActorId: {"description":"Strongly typed canonical identity: `ActorId`.","type":"string"},
   AddWorkTaskRequestV1: {"additionalProperties":false,"properties":{"item":{"$ref":"#/$defs/WorkItemV1"},"mutation":{"$ref":"#/$defs/WorkProductMutationIdentityV1"},"selection":{"$ref":"#/$defs/WorkProductSelectionScopeV1"}},"required":["selection","item","mutation"],"type":"object"},
   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"},
+  AdminSyncAdmissionV1: {"description":"The code-index scheduler's admission of the reconcile.","oneOf":[{"enum":["queued"],"type":"string"},{"const":"not_applicable","description":"Code indexing does not apply to this project.","type":"string"}]},
+  AdminSyncReconcileScopeV1: {"description":"What the reconcile covers.","enum":["authoritative_project"],"type":"string"},
   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"},
@@ -2025,7 +2031,7 @@ const DEFINITIONS = {
   DuplicateEffectOutcomeV1: {"enum":["prevented","committed","unknown","not_applicable"],"type":"string"},
   DuplicateEffortKindV1: {"enum":["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],"type":"string"},
   EditResult: {"description":"Result of a single string replacement edit.","properties":{"diff":{"description":"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.","type":["string","null"]},"dry_run":{"description":"True when this was a dry run: validation, spans, and the resulting\ncontent were all computed, but nothing was written to disk.","type":"boolean"},"file_path":{"type":"string"},"matched_str":{"type":"string"},"message":{"type":"string"},"new_str":{"type":"string"},"replaced_span":{"description":"The exact source text that was replaced. For `replace_symbol` this is\nthe item's full span, including any leading doc-comment / attribute\nblock, so callers can recover its docs/attrs if the replacement\ndropped them; for `str_replace` it is the matched `old_str` text.\n`None` only on a failed edit, where nothing was resolved to replace.","type":["string","null"]},"success":{"type":"boolean"}},"required":["success","file_path","matched_str","new_str","message"],"type":"object"},
-  EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"}]},
+  EffectClass: {"description":"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.","oneOf":[{"enum":["read","preview","source_edit","git_index_stage","git_index_unstage","git_index_commit","configuration_write","administrative"],"type":"string"},{"const":"spawns_process","description":"Runs a child process in the project (e.g. the project's test runner).","type":"string"},{"const":"binds_server","description":"Binds a listening server in the daemon process.","type":"string"},{"const":"schedules_work","description":"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.","type":"string"}]},
   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"},
@@ -2961,6 +2967,8 @@ const DEFINITIONS = {
 const SCHEMAS: readonly CanonicalJsonSchema[] = [
   {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"title":"ActiveProjectSurfaceRequestV1","type":"object"},
   {"$defs":{"ActiveProjectBranchV1":DEFINITIONS.ActiveProjectBranchV1,"ActiveProjectResolutionSourceV1":DEFINITIONS.ActiveProjectResolutionSourceV1,"ActiveProjectStorageV1":DEFINITIONS.ActiveProjectStorageV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"description":"The resolved active project of this MCP session.","properties":{"branch":{"$ref":"#/$defs/ActiveProjectBranchV1"},"project_id":{"type":["string","null"]},"project_root":{"type":"string"},"repository_id":{"type":"string"},"resolution_source":{"$ref":"#/$defs/ActiveProjectResolutionSourceV1"},"scope_prefix":{"type":["string","null"]},"storage":{"$ref":"#/$defs/ActiveProjectStorageV1"}},"required":["repository_id","project_root","resolution_source","storage","branch"],"title":"ActiveProjectResultV1","type":"object"},
+  {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"description":"`tracedecay_admin_sync` takes no arguments: it reconciles the served\nproject.","title":"AdminSyncSurfaceRequestV1","type":"object"},
+  {"$defs":{"AdminSyncAdmissionV1":DEFINITIONS.AdminSyncAdmissionV1,"AdminSyncReconcileScopeV1":DEFINITIONS.AdminSyncReconcileScopeV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"project_root":{"type":"string"},"reconcile_scope":{"$ref":"#/$defs/AdminSyncReconcileScopeV1"},"status":{"$ref":"#/$defs/AdminSyncAdmissionV1"}},"required":["reconcile_scope","status","project_root"],"title":"AdminSyncResultV1","type":"object"},
   {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"depth":{"description":"Maximum dependency traversal depth (default: 5, at most 10).","format":"uint32","minimum":0,"type":["integer","null"]},"files":{"description":"List of changed file paths to analyze.","items":{"type":"string"},"type":"array"},"filter":{"description":"Custom glob pattern for test files (default: common test patterns).","type":["string","null"]}},"required":["files"],"title":"AffectedSurfaceRequestV1","type":"object"},
   {"$defs":{"AffectedRankingMetadataV1":DEFINITIONS.AffectedRankingMetadataV1,"RankedAffectedTestV1":DEFINITIONS.RankedAffectedTestV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"affected_tests":{"items":{"type":"string"},"type":"array"},"changed_files":{"items":{"type":"string"},"type":"array"},"count":{"format":"uint","minimum":0,"type":"integer"},"ranked_tests":{"items":{"$ref":"#/$defs/RankedAffectedTestV1"},"type":"array"},"ranking_metadata":{"$ref":"#/$defs/AffectedRankingMetadataV1"},"recommended_tests":{"description":"Tests within two dependency hops of a changed file.","items":{"type":"string"},"type":"array"}},"required":["changed_files","affected_tests","count","ranked_tests","recommended_tests","ranking_metadata"],"title":"AffectedResultV1","type":"object"},
   {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"description":"Opaque daemon-minted handle accepted by the first feedback read invocation.","properties":{"request_handle":{"type":"string"}},"required":["request_handle"],"title":"FeedbackHandleRequestV1","type":"object"},
@@ -3368,1086 +3376,1090 @@ export const OPERATIONS = [
     requestSchema: { schemaId: "schema.application.primitive.active-project.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.active-project.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<OperationApplicationActiveProjectRequest>(0), decodeResult: decoder<OperationApplicationActiveProjectResult>(1) },
+  { operation: "admin_sync", operationId: "operation.application.admin_sync", transport: { kind: "mcp_tool", toolName: "tracedecay_admin_sync" }, effect: "schedules_work", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.admin_sync.v1",
+    requestSchema: { schemaId: "schema.application.primitive.admin-sync.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.admin-sync.result", revision: 1 },
+    cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_operation_receipt","maximum_millis":600000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","timed_out","failed","unavailable","partial"],
+    decodeRequest: decoder<OperationApplicationAdminSyncRequest>(2), decodeResult: decoder<OperationApplicationAdminSyncResult>(3) },
   { operation: "affected", operationId: "operation.application.affected", transport: { kind: "mcp_tool", toolName: "tracedecay_affected" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.affected.v1",
     requestSchema: { schemaId: "schema.application.primitive.affected.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.affected.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<OperationApplicationAffectedRequest>(2), decodeResult: decoder<OperationApplicationAffectedResult>(3) },
+    decodeRequest: decoder<OperationApplicationAffectedRequest>(4), decodeResult: decoder<OperationApplicationAffectedResult>(5) },
   { operation: "application_affected_tests", operationId: "operation.application.affected_tests", transport: { kind: "http", route: "/application/tests/affected", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.affected_tests.v1",
     requestSchema: { schemaId: "schema.application.feedback.affected-tests.request", revision: 1 }, resultSchema: { schemaId: "schema.application.feedback.affected-tests.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<OperationApplicationAffectedTestsRequest>(4), decodeResult: decoder<OperationApplicationAffectedTestsResult>(5),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.affected_tests.v1", "schema.application.feedback.affected-tests.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationAffectedTestsResult>(5)) },
+    decodeRequest: decoder<OperationApplicationAffectedTestsRequest>(6), decodeResult: decoder<OperationApplicationAffectedTestsResult>(7),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.affected_tests.v1", "schema.application.feedback.affected-tests.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationAffectedTestsResult>(7)) },
   { operation: "analytics", operationId: "operation.application.analytics", transport: { kind: "mcp_tool", toolName: "tracedecay_analytics" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.analytics.v1",
     requestSchema: { schemaId: "schema.application.primitive.analytics.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.analytics.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<OperationApplicationAnalyticsRequest>(6), decodeResult: decoder<OperationApplicationAnalyticsResult>(7) },
+    decodeRequest: decoder<OperationApplicationAnalyticsRequest>(8), decodeResult: decoder<OperationApplicationAnalyticsResult>(9) },
   { operation: "apply_native_integration", operationId: "operation.application.apply_native_integration", transport: { kind: "mcp_tool", toolName: "tracedecay_apply_native_integration" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.apply_native_integration.v1",
     requestSchema: { schemaId: "schema.application.native-integration.apply.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.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<OperationApplicationApplyNativeIntegrationRequest>(8), decodeResult: decoder<OperationApplicationApplyNativeIntegrationResult>(9) },
+    decodeRequest: decoder<OperationApplicationApplyNativeIntegrationRequest>(10), decodeResult: decoder<OperationApplicationApplyNativeIntegrationResult>(11) },
   { operation: "approve_native_integration", operationId: "operation.application.approve_native_integration", transport: { kind: "mcp_tool", toolName: "tracedecay_approve_native_integration" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.approve_native_integration.v1",
     requestSchema: { schemaId: "schema.application.native-integration.approve.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.approve.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<OperationApplicationApproveNativeIntegrationRequest>(10), decodeResult: decoder<OperationApplicationApproveNativeIntegrationResult>(9) },
+    decodeRequest: decoder<OperationApplicationApproveNativeIntegrationRequest>(12), decodeResult: decoder<OperationApplicationApproveNativeIntegrationResult>(11) },
   { operation: "ast_grep_rewrite", operationId: "operation.application.ast_grep_rewrite", transport: { kind: "mcp_tool", toolName: "tracedecay_ast_grep_rewrite" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.ast_grep_rewrite.v1",
     requestSchema: { schemaId: "schema.application.source-edit.ast-grep-rewrite.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.ast-grep-rewrite.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<OperationApplicationAstGrepRewriteRequest>(11), decodeResult: decoder<OperationApplicationAstGrepRewriteResult>(12) },
+    decodeRequest: decoder<OperationApplicationAstGrepRewriteRequest>(13), decodeResult: decoder<OperationApplicationAstGrepRewriteResult>(14) },
   { operation: "ast_grep_search", operationId: "operation.application.ast_grep_search", transport: { kind: "mcp_tool", toolName: "tracedecay_ast_grep_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.ast_grep_search.v1",
     requestSchema: { schemaId: "schema.application.primitive.ast-grep-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.ast-grep-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<OperationApplicationAstGrepSearchRequest>(13), decodeResult: decoder<OperationApplicationAstGrepSearchResult>(14) },
+    decodeRequest: decoder<OperationApplicationAstGrepSearchRequest>(15), decodeResult: decoder<OperationApplicationAstGrepSearchResult>(16) },
   { operation: "automation_run_artifact_view", operationId: "operation.application.automation_run_artifact_view", transport: { kind: "mcp_tool", toolName: "tracedecay_automation_run_artifact_view" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.automation_run_artifact_view.v1",
     requestSchema: { schemaId: "schema.application.primitive.automation-run-artifact-view.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.automation-run-artifact-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<OperationApplicationAutomationRunArtifactViewRequest>(15), decodeResult: decoder<OperationApplicationAutomationRunArtifactViewResult>(16) },
+    decodeRequest: decoder<OperationApplicationAutomationRunArtifactViewRequest>(17), decodeResult: decoder<OperationApplicationAutomationRunArtifactViewResult>(18) },
   { operation: "automation_run_list", operationId: "operation.application.automation_run_list", transport: { kind: "mcp_tool", toolName: "tracedecay_automation_run_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.automation_run_list.v1",
     requestSchema: { schemaId: "schema.application.primitive.automation-run-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.automation-run-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<OperationApplicationAutomationRunListRequest>(17), decodeResult: decoder<OperationApplicationAutomationRunListResult>(18) },
+    decodeRequest: decoder<OperationApplicationAutomationRunListRequest>(19), decodeResult: decoder<OperationApplicationAutomationRunListResult>(20) },
   { operation: "automation_run_view", operationId: "operation.application.automation_run_view", transport: { kind: "mcp_tool", toolName: "tracedecay_automation_run_view" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.automation_run_view.v1",
     requestSchema: { schemaId: "schema.application.primitive.automation-run-view.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.automation-run-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<OperationApplicationAutomationRunViewRequest>(19), decodeResult: decoder<OperationApplicationAutomationRunViewResult>(20) },
+    decodeRequest: decoder<OperationApplicationAutomationRunViewRequest>(21), decodeResult: decoder<OperationApplicationAutomationRunViewResult>(22) },
   { operation: "branch_diff", operationId: "operation.application.branch_diff", transport: { kind: "mcp_tool", toolName: "tracedecay_branch_diff" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.branch_diff.v1",
     requestSchema: { schemaId: "schema.application.primitive.branch-diff.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.branch-diff.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<OperationApplicationBranchDiffRequest>(21), decodeResult: decoder<OperationApplicationBranchDiffResult>(22) },
+    decodeRequest: decoder<OperationApplicationBranchDiffRequest>(23), decodeResult: decoder<OperationApplicationBranchDiffResult>(24) },
   { operation: "branch_list", operationId: "operation.application.branch_list", transport: { kind: "mcp_tool", toolName: "tracedecay_branch_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.branch_list.v1",
     requestSchema: { schemaId: "schema.application.primitive.branch-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.branch-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<OperationApplicationBranchListRequest>(23), decodeResult: decoder<OperationApplicationBranchListResult>(24) },
+    decodeRequest: decoder<OperationApplicationBranchListRequest>(25), decodeResult: decoder<OperationApplicationBranchListResult>(26) },
   { operation: "branch_search", operationId: "operation.application.branch_search", transport: { kind: "mcp_tool", toolName: "tracedecay_branch_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.branch_search.v1",
     requestSchema: { schemaId: "schema.application.primitive.branch-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.branch-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<OperationApplicationBranchSearchRequest>(25), decodeResult: decoder<OperationApplicationBranchSearchResult>(26) },
+    decodeRequest: decoder<OperationApplicationBranchSearchRequest>(27), decodeResult: decoder<OperationApplicationBranchSearchResult>(28) },
   { operation: "by_qualified_name", operationId: "operation.application.by_qualified_name", transport: { kind: "mcp_tool", toolName: "tracedecay_by_qualified_name" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.by_qualified_name.v1",
     requestSchema: { schemaId: "schema.application.primitive.by-qualified-name.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.by-qualified-name.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<OperationApplicationByQualifiedNameRequest>(27), decodeResult: decoder<OperationApplicationByQualifiedNameResult>(28) },
+    decodeRequest: decoder<OperationApplicationByQualifiedNameRequest>(29), decodeResult: decoder<OperationApplicationByQualifiedNameResult>(30) },
   { operation: "application_call_chain", operationId: "operation.application.call_chain", transport: { kind: "http", route: "/application/primitives/call_chain", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.call_chain.v1",
     requestSchema: { schemaId: "schema.application.primitive.call-chain.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.call-chain.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<OperationApplicationCallChainRequest>(29), decodeResult: decoder<OperationApplicationCallChainResult>(30),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.call_chain.v1", "schema.application.primitive.call-chain.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCallChainResult>(30)) },
+    decodeRequest: decoder<OperationApplicationCallChainRequest>(31), decodeResult: decoder<OperationApplicationCallChainResult>(32),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.call_chain.v1", "schema.application.primitive.call-chain.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCallChainResult>(32)) },
   { operation: "cancel_native_integration", operationId: "operation.application.cancel_native_integration", transport: { kind: "mcp_tool", toolName: "tracedecay_cancel_native_integration" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.cancel_native_integration.v1",
     requestSchema: { schemaId: "schema.application.native-integration.cancel.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.cancel.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<OperationApplicationCancelNativeIntegrationRequest>(31), decodeResult: decoder<OperationApplicationCancelNativeIntegrationResult>(9) },
+    decodeRequest: decoder<OperationApplicationCancelNativeIntegrationRequest>(33), decodeResult: decoder<OperationApplicationCancelNativeIntegrationResult>(11) },
   { operation: "changelog", operationId: "operation.application.changelog", transport: { kind: "mcp_tool", toolName: "tracedecay_changelog" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.changelog.v1",
     requestSchema: { schemaId: "schema.application.primitive.changelog.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.changelog.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<OperationApplicationChangelogRequest>(32), decodeResult: decoder<OperationApplicationChangelogResult>(33) },
+    decodeRequest: decoder<OperationApplicationChangelogRequest>(34), decodeResult: decoder<OperationApplicationChangelogResult>(35) },
   { operation: "circular", operationId: "operation.application.circular", transport: { kind: "mcp_tool", toolName: "tracedecay_circular" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.circular.v1",
     requestSchema: { schemaId: "schema.application.primitive.circular.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.circular.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<OperationApplicationCircularRequest>(34), decodeResult: decoder<OperationApplicationCircularResult>(35) },
+    decodeRequest: decoder<OperationApplicationCircularRequest>(36), decodeResult: decoder<OperationApplicationCircularResult>(37) },
   { operation: "code_callees", operationId: "operation.application.code_callees", transport: { kind: "http", route: "/application/code/code_callees", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_callees.v1",
     requestSchema: { schemaId: "schema.application.code-query.callees.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.callees.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<OperationApplicationCodeCalleesRequest>(36), decodeResult: decoder<OperationApplicationCodeCalleesResult>(37),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_callees.v1", "schema.application.code-query.callees.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeCalleesResult>(37)) },
+    decodeRequest: decoder<OperationApplicationCodeCalleesRequest>(38), decodeResult: decoder<OperationApplicationCodeCalleesResult>(39),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_callees.v1", "schema.application.code-query.callees.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeCalleesResult>(39)) },
   { operation: "code_callers", operationId: "operation.application.code_callers", transport: { kind: "http", route: "/application/code/code_callers", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_callers.v1",
     requestSchema: { schemaId: "schema.application.primitive.code-callers.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.code-callers.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<OperationApplicationCodeCallersRequest>(38), decodeResult: decoder<OperationApplicationCodeCallersResult>(39),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_callers.v1", "schema.application.primitive.code-callers.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeCallersResult>(39)) },
+    decodeRequest: decoder<OperationApplicationCodeCallersRequest>(40), decodeResult: decoder<OperationApplicationCodeCallersResult>(41),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_callers.v1", "schema.application.primitive.code-callers.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeCallersResult>(41)) },
   { operation: "code_declaration", operationId: "operation.application.code_declaration", transport: { kind: "http", route: "/application/code/code_declaration", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_declaration.v1",
     requestSchema: { schemaId: "schema.application.code-query.declaration.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.declaration.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<OperationApplicationCodeDeclarationRequest>(40), decodeResult: decoder<OperationApplicationCodeDeclarationResult>(41),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_declaration.v1", "schema.application.code-query.declaration.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeDeclarationResult>(41)) },
+    decodeRequest: decoder<OperationApplicationCodeDeclarationRequest>(42), decodeResult: decoder<OperationApplicationCodeDeclarationResult>(43),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_declaration.v1", "schema.application.code-query.declaration.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeDeclarationResult>(43)) },
   { operation: "code_exact_occurrence", operationId: "operation.application.code_exact_occurrence", transport: { kind: "http", route: "/application/code/code_exact_occurrence", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_exact_occurrence.v1",
     requestSchema: { schemaId: "schema.application.code-query.exact-occurrence.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.exact-occurrence.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<OperationApplicationCodeExactOccurrenceRequest>(42), decodeResult: decoder<OperationApplicationCodeExactOccurrenceResult>(43),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_exact_occurrence.v1", "schema.application.code-query.exact-occurrence.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeExactOccurrenceResult>(43)) },
+    decodeRequest: decoder<OperationApplicationCodeExactOccurrenceRequest>(44), decodeResult: decoder<OperationApplicationCodeExactOccurrenceResult>(45),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_exact_occurrence.v1", "schema.application.code-query.exact-occurrence.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeExactOccurrenceResult>(45)) },
   { operation: "code_facets", operationId: "operation.application.code_facets", transport: { kind: "http", route: "/application/code/code_facets", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_facets.v1",
     requestSchema: { schemaId: "schema.application.code-query.facets.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.facets.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<OperationApplicationCodeFacetsRequest>(44), decodeResult: decoder<OperationApplicationCodeFacetsResult>(45),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_facets.v1", "schema.application.code-query.facets.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeFacetsResult>(45)) },
+    decodeRequest: decoder<OperationApplicationCodeFacetsRequest>(46), decodeResult: decoder<OperationApplicationCodeFacetsResult>(47),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_facets.v1", "schema.application.code-query.facets.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeFacetsResult>(47)) },
   { operation: "code_implementations", operationId: "operation.application.code_implementations", transport: { kind: "http", route: "/application/code/code_implementations", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_implementations.v1",
     requestSchema: { schemaId: "schema.application.primitive.code-implementations.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.code-implementations.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<OperationApplicationCodeImplementationsRequest>(46), decodeResult: decoder<OperationApplicationCodeImplementationsResult>(47),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_implementations.v1", "schema.application.primitive.code-implementations.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeImplementationsResult>(47)) },
+    decodeRequest: decoder<OperationApplicationCodeImplementationsRequest>(48), decodeResult: decoder<OperationApplicationCodeImplementationsResult>(49),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_implementations.v1", "schema.application.primitive.code-implementations.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeImplementationsResult>(49)) },
   { operation: "code_phrase_search", operationId: "operation.application.code_phrase_search", transport: { kind: "http", route: "/application/code/code_phrase_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_phrase_search.v1",
     requestSchema: { schemaId: "schema.application.code-query.phrase-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.phrase-search.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<OperationApplicationCodePhraseSearchRequest>(48), decodeResult: decoder<OperationApplicationCodePhraseSearchResult>(49),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_phrase_search.v1", "schema.application.code-query.phrase-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodePhraseSearchResult>(49)) },
+    decodeRequest: decoder<OperationApplicationCodePhraseSearchRequest>(50), decodeResult: decoder<OperationApplicationCodePhraseSearchResult>(51),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_phrase_search.v1", "schema.application.code-query.phrase-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodePhraseSearchResult>(51)) },
   { operation: "code_references", operationId: "operation.application.code_references", transport: { kind: "http", route: "/application/code/code_references", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_references.v1",
     requestSchema: { schemaId: "schema.application.code-query.references.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.references.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<OperationApplicationCodeReferencesRequest>(40), decodeResult: decoder<OperationApplicationCodeReferencesResult>(37),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_references.v1", "schema.application.code-query.references.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeReferencesResult>(37)) },
+    decodeRequest: decoder<OperationApplicationCodeReferencesRequest>(42), decodeResult: decoder<OperationApplicationCodeReferencesResult>(39),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_references.v1", "schema.application.code-query.references.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeReferencesResult>(39)) },
   { operation: "code_signature_search", operationId: "operation.application.code_signature_search", transport: { kind: "http", route: "/application/code/code_signature_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_signature_search.v1",
     requestSchema: { schemaId: "schema.application.primitive.code-signature-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.code-signature-search.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<OperationApplicationCodeSignatureSearchRequest>(50), decodeResult: decoder<OperationApplicationCodeSignatureSearchResult>(51),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_signature_search.v1", "schema.application.primitive.code-signature-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeSignatureSearchResult>(51)) },
+    decodeRequest: decoder<OperationApplicationCodeSignatureSearchRequest>(52), decodeResult: decoder<OperationApplicationCodeSignatureSearchResult>(53),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_signature_search.v1", "schema.application.primitive.code-signature-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeSignatureSearchResult>(53)) },
   { operation: "code_symbol_search", operationId: "operation.application.code_symbol_search", transport: { kind: "http", route: "/application/code/code_symbol_search", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_symbol_search.v1",
     requestSchema: { schemaId: "schema.application.symbol-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.symbol-search.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<OperationApplicationCodeSymbolSearchRequest>(52), decodeResult: decoder<OperationApplicationCodeSymbolSearchResult>(51),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_symbol_search.v1", "schema.application.symbol-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeSymbolSearchResult>(51)) },
+    decodeRequest: decoder<OperationApplicationCodeSymbolSearchRequest>(54), decodeResult: decoder<OperationApplicationCodeSymbolSearchResult>(53),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_symbol_search.v1", "schema.application.symbol-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeSymbolSearchResult>(53)) },
   { operation: "code_timeline", operationId: "operation.application.code_timeline", transport: { kind: "http", route: "/application/code/code_timeline", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_timeline.v1",
     requestSchema: { schemaId: "schema.application.code-query.timeline.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.timeline.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<OperationApplicationCodeTimelineRequest>(53), decodeResult: decoder<OperationApplicationCodeTimelineResult>(54),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_timeline.v1", "schema.application.code-query.timeline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeTimelineResult>(54)) },
+    decodeRequest: decoder<OperationApplicationCodeTimelineRequest>(55), decodeResult: decoder<OperationApplicationCodeTimelineResult>(56),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_timeline.v1", "schema.application.code-query.timeline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeTimelineResult>(56)) },
   { operation: "code_type_definition", operationId: "operation.application.code_type_definition", transport: { kind: "http", route: "/application/code/code_type_definition", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_type_definition.v1",
     requestSchema: { schemaId: "schema.application.code-query.type-definition.request", revision: 1 }, resultSchema: { schemaId: "schema.application.code-query.type-definition.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<OperationApplicationCodeTypeDefinitionRequest>(40), decodeResult: decoder<OperationApplicationCodeTypeDefinitionResult>(41),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_type_definition.v1", "schema.application.code-query.type-definition.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeTypeDefinitionResult>(41)) },
+    decodeRequest: decoder<OperationApplicationCodeTypeDefinitionRequest>(42), decodeResult: decoder<OperationApplicationCodeTypeDefinitionResult>(43),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_type_definition.v1", "schema.application.code-query.type-definition.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeTypeDefinitionResult>(43)) },
   { operation: "code_type_hierarchy", operationId: "operation.application.code_type_hierarchy", transport: { kind: "http", route: "/application/code/code_type_hierarchy", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.code_type_hierarchy.v1",
     requestSchema: { schemaId: "schema.application.primitive.code-type-hierarchy.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.code-type-hierarchy.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<OperationApplicationCodeTypeHierarchyRequest>(55), decodeResult: decoder<OperationApplicationCodeTypeHierarchyResult>(56),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_type_hierarchy.v1", "schema.application.primitive.code-type-hierarchy.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeTypeHierarchyResult>(56)) },
+    decodeRequest: decoder<OperationApplicationCodeTypeHierarchyRequest>(57), decodeResult: decoder<OperationApplicationCodeTypeHierarchyResult>(58),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.code_type_hierarchy.v1", "schema.application.primitive.code-type-hierarchy.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationCodeTypeHierarchyResult>(58)) },
   { operation: "commit_context", operationId: "operation.application.commit_context", transport: { kind: "mcp_tool", toolName: "tracedecay_commit_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.commit_context.v1",
     requestSchema: { schemaId: "schema.application.primitive.commit-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.commit-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<OperationApplicationCommitContextRequest>(57), decodeResult: decoder<OperationApplicationCommitContextResult>(58) },
+    decodeRequest: decoder<OperationApplicationCommitContextRequest>(59), decodeResult: decoder<OperationApplicationCommitContextResult>(60) },
   { operation: "complexity", operationId: "operation.application.complexity", transport: { kind: "mcp_tool", toolName: "tracedecay_complexity" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.complexity.v1",
     requestSchema: { schemaId: "schema.application.primitive.complexity.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.complexity.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<OperationApplicationComplexityRequest>(59), decodeResult: decoder<OperationApplicationComplexityResult>(60) },
+    decodeRequest: decoder<OperationApplicationComplexityRequest>(61), decodeResult: decoder<OperationApplicationComplexityResult>(62) },
   { operation: "config", operationId: "operation.application.config", transport: { kind: "mcp_tool", toolName: "tracedecay_config" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.config.v1",
     requestSchema: { schemaId: "schema.application.primitive.config.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.config.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<OperationApplicationConfigRequest>(61), decodeResult: decoder<OperationApplicationConfigResult>(62) },
+    decodeRequest: decoder<OperationApplicationConfigRequest>(63), decodeResult: decoder<OperationApplicationConfigResult>(64) },
   { operation: "application_configuration_audit", operationId: "operation.application.configuration_audit", transport: { kind: "http", route: "/application/configuration/configuration_audit", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_audit.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_audit.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_audit.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","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationAuditRequest>(63), decodeResult: decoder<OperationApplicationConfigurationAuditResult>(64),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_audit.v1", "schema.application.configuration.configuration_audit.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationAuditResult>(64)) },
+    decodeRequest: decoder<OperationApplicationConfigurationAuditRequest>(65), decodeResult: decoder<OperationApplicationConfigurationAuditResult>(66),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_audit.v1", "schema.application.configuration.configuration_audit.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationAuditResult>(66)) },
   { operation: "application_configuration_batch", operationId: "operation.application.configuration_batch", transport: { kind: "http", route: "/application/configuration/configuration_batch", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_batch.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_batch.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_batch.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationBatchRequest>(65), decodeResult: decoder<OperationApplicationConfigurationBatchResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_batch.v1", "schema.application.configuration.configuration_batch.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationBatchResult>(66)) },
+    decodeRequest: decoder<OperationApplicationConfigurationBatchRequest>(67), decodeResult: decoder<OperationApplicationConfigurationBatchResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_batch.v1", "schema.application.configuration.configuration_batch.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationBatchResult>(68)) },
   { operation: "application_configuration_get", operationId: "operation.application.configuration_get", transport: { kind: "http", route: "/application/configuration/configuration_get", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_get.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_get.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_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","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationGetRequest>(67), decodeResult: decoder<OperationApplicationConfigurationGetResult>(68),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_get.v1", "schema.application.configuration.configuration_get.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationGetResult>(68)) },
+    decodeRequest: decoder<OperationApplicationConfigurationGetRequest>(69), decodeResult: decoder<OperationApplicationConfigurationGetResult>(70),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_get.v1", "schema.application.configuration.configuration_get.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationGetResult>(70)) },
   { operation: "application_configuration_list", operationId: "operation.application.configuration_list", transport: { kind: "http", route: "/application/configuration/configuration_list", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_list.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_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","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationListRequest>(69), decodeResult: decoder<OperationApplicationConfigurationListResult>(70),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_list.v1", "schema.application.configuration.configuration_list.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationListResult>(70)) },
+    decodeRequest: decoder<OperationApplicationConfigurationListRequest>(71), decodeResult: decoder<OperationApplicationConfigurationListResult>(72),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_list.v1", "schema.application.configuration.configuration_list.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationListResult>(72)) },
   { operation: "application_configuration_observed_state", operationId: "operation.application.configuration_observed_state", transport: { kind: "http", route: "/application/configuration/configuration_observed_state", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_observed_state.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_observed_state.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_observed_state.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","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationObservedStateRequest>(71), decodeResult: decoder<OperationApplicationConfigurationObservedStateResult>(72),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_observed_state.v1", "schema.application.configuration.configuration_observed_state.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationObservedStateResult>(72)) },
+    decodeRequest: decoder<OperationApplicationConfigurationObservedStateRequest>(73), decodeResult: decoder<OperationApplicationConfigurationObservedStateResult>(74),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_observed_state.v1", "schema.application.configuration.configuration_observed_state.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationObservedStateResult>(74)) },
   { operation: "application_configuration_protected_apply", operationId: "operation.application.configuration_protected_apply", transport: { kind: "http", route: "/application/configuration/configuration_protected_apply", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_protected_apply.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_protected_apply.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_protected_apply.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationProtectedApplyRequest>(73), decodeResult: decoder<OperationApplicationConfigurationProtectedApplyResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_protected_apply.v1", "schema.application.configuration.configuration_protected_apply.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationProtectedApplyResult>(66)) },
+    decodeRequest: decoder<OperationApplicationConfigurationProtectedApplyRequest>(75), decodeResult: decoder<OperationApplicationConfigurationProtectedApplyResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_protected_apply.v1", "schema.application.configuration.configuration_protected_apply.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationProtectedApplyResult>(68)) },
   { operation: "application_configuration_protected_preview", operationId: "operation.application.configuration_protected_preview", transport: { kind: "http", route: "/application/configuration/configuration_protected_preview", method: "POST" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_protected_preview.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_protected_preview.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_protected_preview.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","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationProtectedPreviewRequest>(74), decodeResult: decoder<OperationApplicationConfigurationProtectedPreviewResult>(75),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_protected_preview.v1", "schema.application.configuration.configuration_protected_preview.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationProtectedPreviewResult>(75)) },
+    decodeRequest: decoder<OperationApplicationConfigurationProtectedPreviewRequest>(76), decodeResult: decoder<OperationApplicationConfigurationProtectedPreviewResult>(77),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_protected_preview.v1", "schema.application.configuration.configuration_protected_preview.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationProtectedPreviewResult>(77)) },
   { operation: "application_configuration_rollback_apply", operationId: "operation.application.configuration_rollback_apply", transport: { kind: "http", route: "/application/configuration/configuration_rollback_apply", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_rollback_apply.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_rollback_apply.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_rollback_apply.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationRollbackApplyRequest>(73), decodeResult: decoder<OperationApplicationConfigurationRollbackApplyResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_rollback_apply.v1", "schema.application.configuration.configuration_rollback_apply.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationRollbackApplyResult>(66)) },
+    decodeRequest: decoder<OperationApplicationConfigurationRollbackApplyRequest>(75), decodeResult: decoder<OperationApplicationConfigurationRollbackApplyResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_rollback_apply.v1", "schema.application.configuration.configuration_rollback_apply.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationRollbackApplyResult>(68)) },
   { operation: "application_configuration_rollback_preview", operationId: "operation.application.configuration_rollback_preview", transport: { kind: "http", route: "/application/configuration/configuration_rollback_preview", method: "POST" }, effect: "preview", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_rollback_preview.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_rollback_preview.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_rollback_preview.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","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationRollbackPreviewRequest>(76), decodeResult: decoder<OperationApplicationConfigurationRollbackPreviewResult>(75),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_rollback_preview.v1", "schema.application.configuration.configuration_rollback_preview.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationRollbackPreviewResult>(75)) },
+    decodeRequest: decoder<OperationApplicationConfigurationRollbackPreviewRequest>(78), decodeResult: decoder<OperationApplicationConfigurationRollbackPreviewResult>(77),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_rollback_preview.v1", "schema.application.configuration.configuration_rollback_preview.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationConfigurationRollbackPreviewResult>(77)) },
   { operation: "application_configuration_set", operationId: "operation.application.configuration_set", transport: { kind: "http", route: "/application/configuration/configuration_set", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_set.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_set.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_set.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationSetRequest>(77), decodeResult: decoder<OperationApplicationConfigurationSetResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_set.v1", "schema.application.configuration.configuration_set.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationSetResult>(66)) },
+    decodeRequest: decoder<OperationApplicationConfigurationSetRequest>(79), decodeResult: decoder<OperationApplicationConfigurationSetResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_set.v1", "schema.application.configuration.configuration_set.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationSetResult>(68)) },
   { operation: "application_configuration_unset", operationId: "operation.application.configuration_unset", transport: { kind: "http", route: "/application/configuration/configuration_unset", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.configuration_unset.v1",
     requestSchema: { schemaId: "schema.application.configuration.configuration_unset.request", revision: 1 }, resultSchema: { schemaId: "schema.application.configuration.configuration_unset.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationConfigurationUnsetRequest>(78), decodeResult: decoder<OperationApplicationConfigurationUnsetResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_unset.v1", "schema.application.configuration.configuration_unset.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationUnsetResult>(66)) },
+    decodeRequest: decoder<OperationApplicationConfigurationUnsetRequest>(80), decodeResult: decoder<OperationApplicationConfigurationUnsetResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.configuration_unset.v1", "schema.application.configuration.configuration_unset.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationConfigurationUnsetResult>(68)) },
   { operation: "constructors", operationId: "operation.application.constructors", transport: { kind: "mcp_tool", toolName: "tracedecay_constructors" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.constructors.v1",
     requestSchema: { schemaId: "schema.application.primitive.constructors.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.constructors.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<OperationApplicationConstructorsRequest>(79), decodeResult: decoder<OperationApplicationConstructorsResult>(80) },
+    decodeRequest: decoder<OperationApplicationConstructorsRequest>(81), decodeResult: decoder<OperationApplicationConstructorsResult>(82) },
   { operation: "context", operationId: "operation.application.context", transport: { kind: "mcp_tool", toolName: "tracedecay_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.context.v1",
     requestSchema: { schemaId: "schema.application.primitive.context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.context.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<OperationApplicationContextRequest>(81), decodeResult: decoder<OperationApplicationContextResult>(82) },
+    decodeRequest: decoder<OperationApplicationContextRequest>(83), decodeResult: decoder<OperationApplicationContextResult>(84) },
   { operation: "application_context_scout_budget", operationId: "operation.application.context_scout_budget", transport: { kind: "http", route: "/application/context-scout/context_scout_budget", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_budget.v1",
     requestSchema: { schemaId: "schema.application.context-scout-budget.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-budget.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","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutBudgetRequest>(83), decodeResult: decoder<OperationApplicationContextScoutBudgetResult>(84),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_budget.v1", "schema.application.context-scout-budget.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutBudgetResult>(84)) },
+    decodeRequest: decoder<OperationApplicationContextScoutBudgetRequest>(85), decodeResult: decoder<OperationApplicationContextScoutBudgetResult>(86),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_budget.v1", "schema.application.context-scout-budget.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutBudgetResult>(86)) },
   { operation: "application_context_scout_cancel", operationId: "operation.application.context_scout_cancel", transport: { kind: "http", route: "/application/context-scout/context_scout_cancel", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_cancel.v1",
     requestSchema: { schemaId: "schema.application.context-scout-cancel.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-cancel.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutCancelRequest>(85), decodeResult: decoder<OperationApplicationContextScoutCancelResult>(86),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_cancel.v1", "schema.application.context-scout-cancel.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutCancelResult>(86)) },
+    decodeRequest: decoder<OperationApplicationContextScoutCancelRequest>(87), decodeResult: decoder<OperationApplicationContextScoutCancelResult>(88),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_cancel.v1", "schema.application.context-scout-cancel.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutCancelResult>(88)) },
   { operation: "application_context_scout_capability", operationId: "operation.application.context_scout_capability", transport: { kind: "http", route: "/application/context-scout/context_scout_capability", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_capability.v1",
     requestSchema: { schemaId: "schema.application.context-scout-capability.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-capability.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","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutCapabilityRequest>(83), decodeResult: decoder<OperationApplicationContextScoutCapabilityResult>(87),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_capability.v1", "schema.application.context-scout-capability.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutCapabilityResult>(87)) },
+    decodeRequest: decoder<OperationApplicationContextScoutCapabilityRequest>(85), decodeResult: decoder<OperationApplicationContextScoutCapabilityResult>(89),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_capability.v1", "schema.application.context-scout-capability.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutCapabilityResult>(89)) },
   { operation: "application_context_scout_claim", operationId: "operation.application.context_scout_claim", transport: { kind: "http", route: "/application/context-scout/context_scout_claim", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_claim.v1",
     requestSchema: { schemaId: "schema.application.context-scout-claim.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-claim.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutClaimRequest>(88), decodeResult: decoder<OperationApplicationContextScoutClaimResult>(89),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_claim.v1", "schema.application.context-scout-claim.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutClaimResult>(89)) },
+    decodeRequest: decoder<OperationApplicationContextScoutClaimRequest>(90), decodeResult: decoder<OperationApplicationContextScoutClaimResult>(91),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_claim.v1", "schema.application.context-scout-claim.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutClaimResult>(91)) },
   { operation: "application_context_scout_delivery", operationId: "operation.application.context_scout_delivery", transport: { kind: "http", route: "/application/context-scout/context_scout_delivery", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_delivery.v1",
     requestSchema: { schemaId: "schema.application.context-scout-delivery.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-delivery.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutDeliveryRequest>(90), decodeResult: decoder<OperationApplicationContextScoutDeliveryResult>(91),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_delivery.v1", "schema.application.context-scout-delivery.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutDeliveryResult>(91)) },
+    decodeRequest: decoder<OperationApplicationContextScoutDeliveryRequest>(92), decodeResult: decoder<OperationApplicationContextScoutDeliveryResult>(93),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_delivery.v1", "schema.application.context-scout-delivery.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutDeliveryResult>(93)) },
   { operation: "application_context_scout_explain", operationId: "operation.application.context_scout_explain", transport: { kind: "http", route: "/application/context-scout/context_scout_explain", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_explain.v1",
     requestSchema: { schemaId: "schema.application.context-scout-explain.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-explain.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","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutExplainRequest>(92), decodeResult: decoder<OperationApplicationContextScoutExplainResult>(93),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_explain.v1", "schema.application.context-scout-explain.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutExplainResult>(93)) },
+    decodeRequest: decoder<OperationApplicationContextScoutExplainRequest>(94), decodeResult: decoder<OperationApplicationContextScoutExplainResult>(95),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_explain.v1", "schema.application.context-scout-explain.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutExplainResult>(95)) },
   { operation: "application_context_scout_feedback", operationId: "operation.application.context_scout_feedback", transport: { kind: "http", route: "/application/context-scout/context_scout_feedback", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_feedback.v1",
     requestSchema: { schemaId: "schema.application.context-scout-feedback.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-feedback.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutFeedbackRequest>(94), decodeResult: decoder<OperationApplicationContextScoutFeedbackResult>(86),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_feedback.v1", "schema.application.context-scout-feedback.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutFeedbackResult>(86)) },
+    decodeRequest: decoder<OperationApplicationContextScoutFeedbackRequest>(96), decodeResult: decoder<OperationApplicationContextScoutFeedbackResult>(88),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_feedback.v1", "schema.application.context-scout-feedback.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutFeedbackResult>(88)) },
   { operation: "application_context_scout_pause", operationId: "operation.application.context_scout_pause", transport: { kind: "http", route: "/application/context-scout/context_scout_pause", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_pause.v1",
     requestSchema: { schemaId: "schema.application.context-scout-pause.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-pause.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutPauseRequest>(95), decodeResult: decoder<OperationApplicationContextScoutPauseResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_pause.v1", "schema.application.context-scout-pause.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutPauseResult>(66)) },
+    decodeRequest: decoder<OperationApplicationContextScoutPauseRequest>(97), decodeResult: decoder<OperationApplicationContextScoutPauseResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_pause.v1", "schema.application.context-scout-pause.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutPauseResult>(68)) },
   { operation: "application_context_scout_recent", operationId: "operation.application.context_scout_recent", transport: { kind: "http", route: "/application/context-scout/context_scout_recent", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_recent.v1",
     requestSchema: { schemaId: "schema.application.context-scout-recent.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-recent.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","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutRecentRequest>(92), decodeResult: decoder<OperationApplicationContextScoutRecentResult>(96),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_recent.v1", "schema.application.context-scout-recent.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutRecentResult>(96)) },
+    decodeRequest: decoder<OperationApplicationContextScoutRecentRequest>(94), decodeResult: decoder<OperationApplicationContextScoutRecentResult>(98),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_recent.v1", "schema.application.context-scout-recent.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutRecentResult>(98)) },
   { operation: "application_context_scout_resume", operationId: "operation.application.context_scout_resume", transport: { kind: "http", route: "/application/context-scout/context_scout_resume", method: "POST" }, effect: "configuration_write", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_resume.v1",
     requestSchema: { schemaId: "schema.application.context-scout-resume.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-resume.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":15000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutResumeRequest>(95), decodeResult: decoder<OperationApplicationContextScoutResumeResult>(66),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_resume.v1", "schema.application.context-scout-resume.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutResumeResult>(66)) },
+    decodeRequest: decoder<OperationApplicationContextScoutResumeRequest>(97), decodeResult: decoder<OperationApplicationContextScoutResumeResult>(68),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_resume.v1", "schema.application.context-scout-resume.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationApplicationContextScoutResumeResult>(68)) },
   { operation: "application_context_scout_status", operationId: "operation.application.context_scout_status", transport: { kind: "http", route: "/application/context-scout/context_scout_status", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.context_scout_status.v1",
     requestSchema: { schemaId: "schema.application.context-scout-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.context-scout-status.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","partial"],
-    decodeRequest: decoder<OperationApplicationContextScoutStatusRequest>(83), decodeResult: decoder<OperationApplicationContextScoutStatusResult>(97),
-    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_status.v1", "schema.application.context-scout-status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutStatusResult>(97)) },
+    decodeRequest: decoder<OperationApplicationContextScoutStatusRequest>(85), decodeResult: decoder<OperationApplicationContextScoutStatusResult>(99),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.context_scout_status.v1", "schema.application.context-scout-status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationContextScoutStatusResult>(99)) },
   { operation: "coupling", operationId: "operation.application.coupling", transport: { kind: "mcp_tool", toolName: "tracedecay_coupling" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.coupling.v1",
     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<OperationApplicationCouplingRequest>(98), decodeResult: decoder<OperationApplicationCouplingResult>(99) },
+    decodeRequest: decoder<OperationApplicationCouplingRequest>(100), decodeResult: decoder<OperationApplicationCouplingResult>(101) },
   { 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<OperationApplicationDashboardRequest>(100), decodeResult: decoder<OperationApplicationDashboardResult>(101) },
+    decodeRequest: decoder<OperationApplicationDashboardRequest>(102), decodeResult: decoder<OperationApplicationDashboardResult>(103) },
   { 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<OperationApplicationDeadCodeRequest>(102), decodeResult: decoder<OperationApplicationDeadCodeResult>(103) },
+    decodeRequest: decoder<OperationApplicationDeadCodeRequest>(104), decodeResult: decoder<OperationApplicationDeadCodeResult>(105) },
   { 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<OperationApplicationDependencyDepthRequest>(104), decodeResult: decoder<OperationApplicationDependencyDepthResult>(105) },
+    decodeRequest: decoder<OperationApplicationDependencyDepthRequest>(106), decodeResult: decoder<OperationApplicationDependencyDepthResult>(107) },
   { 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<OperationApplicationDerivesRequest>(106), decodeResult: decoder<OperationApplicationDerivesResult>(107) },
+    decodeRequest: decoder<OperationApplicationDerivesRequest>(108), decodeResult: decoder<OperationApplicationDerivesResult>(109) },
   { 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<OperationApplicationDiagnoseRequest>(108), decodeResult: decoder<OperationApplicationDiagnoseResult>(109) },
+    decodeRequest: decoder<OperationApplicationDiagnoseRequest>(110), decodeResult: decoder<OperationApplicationDiagnoseResult>(111) },
   { 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<OperationApplicationDiagnosticsReadRequest>(110), decodeResult: decoder<OperationApplicationDiagnosticsReadResult>(111),
-    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<OperationApplicationDiagnosticsReadResult>(111)) },
+    decodeRequest: decoder<OperationApplicationDiagnosticsReadRequest>(112), decodeResult: decoder<OperationApplicationDiagnosticsReadResult>(113),
+    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<OperationApplicationDiagnosticsReadResult>(113)) },
   { 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<OperationApplicationDiffContextRequest>(112), decodeResult: decoder<OperationApplicationDiffContextResult>(113) },
+    decodeRequest: decoder<OperationApplicationDiffContextRequest>(114), decodeResult: decoder<OperationApplicationDiffContextResult>(115) },
   { 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<OperationApplicationDistributionRequest>(114), decodeResult: decoder<OperationApplicationDistributionResult>(115) },
+    decodeRequest: decoder<OperationApplicationDistributionRequest>(116), decodeResult: decoder<OperationApplicationDistributionResult>(117) },
   { 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<OperationApplicationDocCoverageRequest>(116), decodeResult: decoder<OperationApplicationDocCoverageResult>(117) },
+    decodeRequest: decoder<OperationApplicationDocCoverageRequest>(118), decodeResult: decoder<OperationApplicationDocCoverageResult>(119) },
   { 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<OperationApplicationDsmRequest>(118), decodeResult: decoder<OperationApplicationDsmResult>(119) },
+    decodeRequest: decoder<OperationApplicationDsmRequest>(120), decodeResult: decoder<OperationApplicationDsmResult>(121) },
   { 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<OperationApplicationFactFeedbackRequest>(120), decodeResult: decoder<OperationApplicationFactFeedbackResult>(121),
-    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<OperationApplicationFactFeedbackResult>(121)) },
+    decodeRequest: decoder<OperationApplicationFactFeedbackRequest>(122), decodeResult: decoder<OperationApplicationFactFeedbackResult>(123),
+    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<OperationApplicationFactFeedbackResult>(123)) },
   { 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<OperationApplicationFactStoreAddRequest>(122), decodeResult: decoder<OperationApplicationFactStoreAddResult>(123),
-    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<OperationApplicationFactStoreAddResult>(123)) },
+    decodeRequest: decoder<OperationApplicationFactStoreAddRequest>(124), decodeResult: decoder<OperationApplicationFactStoreAddResult>(125),
+    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<OperationApplicationFactStoreAddResult>(125)) },
   { 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<OperationApplicationFactStoreContradictRequest>(124), decodeResult: decoder<OperationApplicationFactStoreContradictResult>(125),
-    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<OperationApplicationFactStoreContradictResult>(125)) },
+    decodeRequest: decoder<OperationApplicationFactStoreContradictRequest>(126), decodeResult: decoder<OperationApplicationFactStoreContradictResult>(127),
+    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<OperationApplicationFactStoreContradictResult>(127)) },
   { 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<OperationApplicationFactStoreCurateRequest>(126), decodeResult: decoder<OperationApplicationFactStoreCurateResult>(127),
-    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<OperationApplicationFactStoreCurateResult>(127)) },
+    decodeRequest: decoder<OperationApplicationFactStoreCurateRequest>(128), decodeResult: decoder<OperationApplicationFactStoreCurateResult>(129),
+    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<OperationApplicationFactStoreCurateResult>(129)) },
   { 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<OperationApplicationFactStoreGetRequest>(128), decodeResult: decoder<OperationApplicationFactStoreGetResult>(129),
-    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<OperationApplicationFactStoreGetResult>(129)) },
+    decodeRequest: decoder<OperationApplicationFactStoreGetRequest>(130), decodeResult: decoder<OperationApplicationFactStoreGetResult>(131),
+    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<OperationApplicationFactStoreGetResult>(131)) },
   { 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<OperationApplicationFactStoreListRequest>(130), decodeResult: decoder<OperationApplicationFactStoreListResult>(131),
-    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<OperationApplicationFactStoreListResult>(131)) },
+    decodeRequest: decoder<OperationApplicationFactStoreListRequest>(132), decodeResult: decoder<OperationApplicationFactStoreListResult>(133),
+    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<OperationApplicationFactStoreListResult>(133)) },
   { 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<OperationApplicationFactStoreProbeRequest>(132), decodeResult: decoder<OperationApplicationFactStoreProbeResult>(133),
-    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<OperationApplicationFactStoreProbeResult>(133)) },
+    decodeRequest: decoder<OperationApplicationFactStoreProbeRequest>(134), decodeResult: decoder<OperationApplicationFactStoreProbeResult>(135),
+    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<OperationApplicationFactStoreProbeResult>(135)) },
   { 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<OperationApplicationFactStoreReasonRequest>(134), decodeResult: decoder<OperationApplicationFactStoreReasonResult>(135),
-    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<OperationApplicationFactStoreReasonResult>(135)) },
+    decodeRequest: decoder<OperationApplicationFactStoreReasonRequest>(136), decodeResult: decoder<OperationApplicationFactStoreReasonResult>(137),
+    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<OperationApplicationFactStoreReasonResult>(137)) },
   { 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<OperationApplicationFactStoreRelatedRequest>(136), decodeResult: decoder<OperationApplicationFactStoreRelatedResult>(137),
-    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<OperationApplicationFactStoreRelatedResult>(137)) },
+    decodeRequest: decoder<OperationApplicationFactStoreRelatedRequest>(138), decodeResult: decoder<OperationApplicationFactStoreRelatedResult>(139),
+    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<OperationApplicationFactStoreRelatedResult>(139)) },
   { 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<OperationApplicationFactStoreRemoveRequest>(138), decodeResult: decoder<OperationApplicationFactStoreRemoveResult>(139),
-    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<OperationApplicationFactStoreRemoveResult>(139)) },
+    decodeRequest: decoder<OperationApplicationFactStoreRemoveRequest>(140), decodeResult: decoder<OperationApplicationFactStoreRemoveResult>(141),
+    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<OperationApplicationFactStoreRemoveResult>(141)) },
   { 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<OperationApplicationFactStoreSearchRequest>(140), decodeResult: decoder<OperationApplicationFactStoreSearchResult>(141),
-    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<OperationApplicationFactStoreSearchResult>(141)) },
+    decodeRequest: decoder<OperationApplicationFactStoreSearchRequest>(142), decodeResult: decoder<OperationApplicationFactStoreSearchResult>(143),
+    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<OperationApplicationFactStoreSearchResult>(143)) },
   { 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<OperationApplicationFactStoreSupersedeRequest>(142), decodeResult: decoder<OperationApplicationFactStoreSupersedeResult>(143),
-    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<OperationApplicationFactStoreSupersedeResult>(143)) },
+    decodeRequest: decoder<OperationApplicationFactStoreSupersedeRequest>(144), decodeResult: decoder<OperationApplicationFactStoreSupersedeResult>(145),
+    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<OperationApplicationFactStoreSupersedeResult>(145)) },
   { 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<OperationApplicationFactStoreUpdateRequest>(144), decodeResult: decoder<OperationApplicationFactStoreUpdateResult>(145),
-    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<OperationApplicationFactStoreUpdateResult>(145)) },
+    decodeRequest: decoder<OperationApplicationFactStoreUpdateRequest>(146), decodeResult: decoder<OperationApplicationFactStoreUpdateResult>(147),
+    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<OperationApplicationFactStoreUpdateResult>(147)) },
   { 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<OperationApplicationFeedbackAdvisoryCycleRequest>(146), decodeResult: decoder<OperationApplicationFeedbackAdvisoryCycleResult>(147),
-    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<OperationApplicationFeedbackAdvisoryCycleResult>(147)) },
+    decodeRequest: decoder<OperationApplicationFeedbackAdvisoryCycleRequest>(148), decodeResult: decoder<OperationApplicationFeedbackAdvisoryCycleResult>(149),
+    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<OperationApplicationFeedbackAdvisoryCycleResult>(149)) },
   { 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<OperationApplicationFeedbackDiagnosticsRequest>(4), decodeResult: decoder<OperationApplicationFeedbackDiagnosticsResult>(148),
-    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<OperationApplicationFeedbackDiagnosticsResult>(148)) },
+    decodeRequest: decoder<OperationApplicationFeedbackDiagnosticsRequest>(6), decodeResult: decoder<OperationApplicationFeedbackDiagnosticsResult>(150),
+    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<OperationApplicationFeedbackDiagnosticsResult>(150)) },
   { 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<OperationApplicationFeedbackExpandRequest>(4), decodeResult: decoder<OperationApplicationFeedbackExpandResult>(149),
-    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<OperationApplicationFeedbackExpandResult>(149)) },
+    decodeRequest: decoder<OperationApplicationFeedbackExpandRequest>(6), decodeResult: decoder<OperationApplicationFeedbackExpandResult>(151),
+    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<OperationApplicationFeedbackExpandResult>(151)) },
   { 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<OperationApplicationFeedbackGetRequest>(4), decodeResult: decoder<OperationApplicationFeedbackGetResult>(150),
-    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<OperationApplicationFeedbackGetResult>(150)) },
+    decodeRequest: decoder<OperationApplicationFeedbackGetRequest>(6), decodeResult: decoder<OperationApplicationFeedbackGetResult>(152),
+    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<OperationApplicationFeedbackGetResult>(152)) },
   { 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<OperationApplicationFeedbackImpactRequest>(4), decodeResult: decoder<OperationApplicationFeedbackImpactResult>(151),
-    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<OperationApplicationFeedbackImpactResult>(151)) },
+    decodeRequest: decoder<OperationApplicationFeedbackImpactRequest>(6), decodeResult: decoder<OperationApplicationFeedbackImpactResult>(153),
+    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<OperationApplicationFeedbackImpactResult>(153)) },
   { 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<OperationApplicationFeedbackListRequest>(4), decodeResult: decoder<OperationApplicationFeedbackListResult>(152),
-    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<OperationApplicationFeedbackListResult>(152)) },
+    decodeRequest: decoder<OperationApplicationFeedbackListRequest>(6), decodeResult: decoder<OperationApplicationFeedbackListResult>(154),
+    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<OperationApplicationFeedbackListResult>(154)) },
   { 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<OperationApplicationFeedbackProximityRequest>(153), decodeResult: decoder<OperationApplicationFeedbackProximityResult>(154),
-    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<OperationApplicationFeedbackProximityResult>(154)) },
+    decodeRequest: decoder<OperationApplicationFeedbackProximityRequest>(155), decodeResult: decoder<OperationApplicationFeedbackProximityResult>(156),
+    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<OperationApplicationFeedbackProximityResult>(156)) },
   { 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<OperationApplicationFieldSitesRequest>(155), decodeResult: decoder<OperationApplicationFieldSitesResult>(156) },
+    decodeRequest: decoder<OperationApplicationFieldSitesRequest>(157), decodeResult: decoder<OperationApplicationFieldSitesResult>(158) },
   { 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<OperationApplicationFileDependentsRequest>(157), decodeResult: decoder<OperationApplicationFileDependentsResult>(158),
-    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<OperationApplicationFileDependentsResult>(158)) },
+    decodeRequest: decoder<OperationApplicationFileDependentsRequest>(159), decodeResult: decoder<OperationApplicationFileDependentsResult>(160),
+    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<OperationApplicationFileDependentsResult>(160)) },
   { 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<OperationApplicationFilesRequest>(159), decodeResult: decoder<OperationApplicationFilesResult>(160) },
+    decodeRequest: decoder<OperationApplicationFilesRequest>(161), decodeResult: decoder<OperationApplicationFilesResult>(162) },
   { 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<OperationApplicationFindExactSymbolRequest>(161), decodeResult: decoder<OperationApplicationFindExactSymbolResult>(162) },
+    decodeRequest: decoder<OperationApplicationFindExactSymbolRequest>(163), decodeResult: decoder<OperationApplicationFindExactSymbolResult>(164) },
   { 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<OperationApplicationGiniRequest>(163), decodeResult: decoder<OperationApplicationGiniResult>(164) },
+    decodeRequest: decoder<OperationApplicationGiniRequest>(165), decodeResult: decoder<OperationApplicationGiniResult>(166) },
   { 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<OperationApplicationGitApplyRequest>(165), decodeResult: decoder<OperationApplicationGitApplyResult>(166) },
+    decodeRequest: decoder<OperationApplicationGitApplyRequest>(167), decodeResult: decoder<OperationApplicationGitApplyResult>(168) },
   { 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<OperationApplicationGitBlameRequest>(167), decodeResult: decoder<OperationApplicationGitBlameResult>(168),
-    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<OperationApplicationGitBlameResult>(168)) },
+    decodeRequest: decoder<OperationApplicationGitBlameRequest>(169), decodeResult: decoder<OperationApplicationGitBlameResult>(170),
+    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<OperationApplicationGitBlameResult>(170)) },
   { 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<OperationApplicationGitDiffRequest>(169), decodeResult: decoder<OperationApplicationGitDiffResult>(168),
-    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<OperationApplicationGitDiffResult>(168)) },
+    decodeRequest: decoder<OperationApplicationGitDiffRequest>(171), decodeResult: decoder<OperationApplicationGitDiffResult>(170),
+    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<OperationApplicationGitDiffResult>(170)) },
   { 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<OperationApplicationGitHistoryRequest>(170), decodeResult: decoder<OperationApplicationGitHistoryResult>(168),
-    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<OperationApplicationGitHistoryResult>(168)) },
+    decodeRequest: decoder<OperationApplicationGitHistoryRequest>(172), decodeResult: decoder<OperationApplicationGitHistoryResult>(170),
+    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<OperationApplicationGitHistoryResult>(170)) },
   { 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<OperationApplicationGitHunksRequest>(171), decodeResult: decoder<OperationApplicationGitHunksResult>(168),
-    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<OperationApplicationGitHunksResult>(168)) },
+    decodeRequest: decoder<OperationApplicationGitHunksRequest>(173), decodeResult: decoder<OperationApplicationGitHunksResult>(170),
+    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<OperationApplicationGitHunksResult>(170)) },
   { 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<OperationApplicationGitPreviewRequest>(172), decodeResult: decoder<OperationApplicationGitPreviewResult>(173) },
+    decodeRequest: decoder<OperationApplicationGitPreviewRequest>(174), decodeResult: decoder<OperationApplicationGitPreviewResult>(175) },
   { 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<OperationApplicationGitStatusRequest>(174), decodeResult: decoder<OperationApplicationGitStatusResult>(168),
-    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<OperationApplicationGitStatusResult>(168)) },
+    decodeRequest: decoder<OperationApplicationGitStatusRequest>(176), decodeResult: decoder<OperationApplicationGitStatusResult>(170),
+    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<OperationApplicationGitStatusResult>(170)) },
   { 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<OperationApplicationGithubStackSignalExpandRequest>(175), decodeResult: decoder<OperationApplicationGithubStackSignalExpandResult>(176),
-    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<OperationApplicationGithubStackSignalExpandResult>(176)) },
+    decodeRequest: decoder<OperationApplicationGithubStackSignalExpandRequest>(177), decodeResult: decoder<OperationApplicationGithubStackSignalExpandResult>(178),
+    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<OperationApplicationGithubStackSignalExpandResult>(178)) },
   { 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<OperationApplicationGodClassRequest>(177), decodeResult: decoder<OperationApplicationGodClassResult>(178) },
+    decodeRequest: decoder<OperationApplicationGodClassRequest>(179), decodeResult: decoder<OperationApplicationGodClassResult>(180) },
   { 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<OperationApplicationGrepRequest>(179), decodeResult: decoder<OperationApplicationGrepResult>(180) },
+    decodeRequest: decoder<OperationApplicationGrepRequest>(181), decodeResult: decoder<OperationApplicationGrepResult>(182) },
   { 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<OperationApplicationHealthRequest>(181), decodeResult: decoder<OperationApplicationHealthResult>(182) },
+    decodeRequest: decoder<OperationApplicationHealthRequest>(183), decodeResult: decoder<OperationApplicationHealthResult>(184) },
   { 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<OperationApplicationHealthDeltaRequest>(183), decodeResult: decoder<OperationApplicationHealthDeltaResult>(184),
-    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<OperationApplicationHealthDeltaResult>(184)) },
+    decodeRequest: decoder<OperationApplicationHealthDeltaRequest>(185), decodeResult: decoder<OperationApplicationHealthDeltaResult>(186),
+    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<OperationApplicationHealthDeltaResult>(186)) },
   { 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<OperationApplicationHealthReadRequest>(185), decodeResult: decoder<OperationApplicationHealthReadResult>(186),
-    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<OperationApplicationHealthReadResult>(186)) },
+    decodeRequest: decoder<OperationApplicationHealthReadRequest>(187), decodeResult: decoder<OperationApplicationHealthReadResult>(188),
+    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<OperationApplicationHealthReadResult>(188)) },
   { 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<OperationApplicationHermesSkillBridgeRequest>(187), decodeResult: decoder<OperationApplicationHermesSkillBridgeResult>(188) },
+    decodeRequest: decoder<OperationApplicationHermesSkillBridgeRequest>(189), decodeResult: decoder<OperationApplicationHermesSkillBridgeResult>(190) },
   { 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<OperationApplicationHotspotsRequest>(189), decodeResult: decoder<OperationApplicationHotspotsResult>(190) },
+    decodeRequest: decoder<OperationApplicationHotspotsRequest>(191), decodeResult: decoder<OperationApplicationHotspotsResult>(192) },
   { 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<OperationApplicationImpactRequest>(191), decodeResult: decoder<OperationApplicationImpactResult>(192) },
+    decodeRequest: decoder<OperationApplicationImpactRequest>(193), decodeResult: decoder<OperationApplicationImpactResult>(194) },
   { 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<OperationApplicationInheritanceDepthRequest>(193), decodeResult: decoder<OperationApplicationInheritanceDepthResult>(194) },
+    decodeRequest: decoder<OperationApplicationInheritanceDepthRequest>(195), decodeResult: decoder<OperationApplicationInheritanceDepthResult>(196) },
   { 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<OperationApplicationInsertAtRequest>(195), decodeResult: decoder<OperationApplicationInsertAtResult>(12) },
+    decodeRequest: decoder<OperationApplicationInsertAtRequest>(197), decodeResult: decoder<OperationApplicationInsertAtResult>(14) },
   { operation: "insert_at_symbol", operationId: "operation.application.insert_at_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_insert_at_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.insert_at_symbol.v1",
     requestSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.insert-at-symbol.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationInsertAtSymbolRequest>(196), decodeResult: decoder<OperationApplicationInsertAtSymbolResult>(12) },
+    decodeRequest: decoder<OperationApplicationInsertAtSymbolRequest>(198), decodeResult: decoder<OperationApplicationInsertAtSymbolResult>(14) },
   { operation: "largest", operationId: "operation.application.largest", transport: { kind: "mcp_tool", toolName: "tracedecay_largest" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.largest.v1",
     requestSchema: { schemaId: "schema.application.primitive.largest.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.largest.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationLargestRequest>(197), decodeResult: decoder<OperationApplicationLargestResult>(198) },
+    decodeRequest: decoder<OperationApplicationLargestRequest>(199), decodeResult: decoder<OperationApplicationLargestResult>(200) },
   { 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<OperationApplicationLcmDescribeRequest>(199), decodeResult: decoder<OperationApplicationLcmDescribeResult>(200),
-    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<OperationApplicationLcmDescribeResult>(200)) },
+    decodeRequest: decoder<OperationApplicationLcmDescribeRequest>(201), decodeResult: decoder<OperationApplicationLcmDescribeResult>(202),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_describe.v1", "schema.application.retained.lcm-describe.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmDescribeResult>(202)) },
   { 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<OperationApplicationLcmDoctorRequest>(201), decodeResult: decoder<OperationApplicationLcmDoctorResult>(202),
-    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<OperationApplicationLcmDoctorResult>(202)) },
+    decodeRequest: decoder<OperationApplicationLcmDoctorRequest>(203), decodeResult: decoder<OperationApplicationLcmDoctorResult>(204),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_doctor.v1", "schema.application.retained.lcm-doctor.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmDoctorResult>(204)) },
   { 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<OperationApplicationLcmExpandRequest>(203), decodeResult: decoder<OperationApplicationLcmExpandResult>(204),
-    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<OperationApplicationLcmExpandResult>(204)) },
+    decodeRequest: decoder<OperationApplicationLcmExpandRequest>(205), decodeResult: decoder<OperationApplicationLcmExpandResult>(206),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand.v1", "schema.application.retained.lcm-expand.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmExpandResult>(206)) },
   { 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<OperationApplicationLcmExpandQueryRequest>(205), decodeResult: decoder<OperationApplicationLcmExpandQueryResult>(206),
-    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<OperationApplicationLcmExpandQueryResult>(206)) },
+    decodeRequest: decoder<OperationApplicationLcmExpandQueryRequest>(207), decodeResult: decoder<OperationApplicationLcmExpandQueryResult>(208),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_expand_query.v1", "schema.application.retained.lcm-expand-query.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmExpandQueryResult>(208)) },
   { 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<OperationApplicationLcmGrepRequest>(207), decodeResult: decoder<OperationApplicationLcmGrepResult>(208),
-    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<OperationApplicationLcmGrepResult>(208)) },
+    decodeRequest: decoder<OperationApplicationLcmGrepRequest>(209), decodeResult: decoder<OperationApplicationLcmGrepResult>(210),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_grep.v1", "schema.application.retained.lcm-grep.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmGrepResult>(210)) },
   { 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<OperationApplicationLcmLoadSessionRequest>(209), decodeResult: decoder<OperationApplicationLcmLoadSessionResult>(210),
-    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<OperationApplicationLcmLoadSessionResult>(210)) },
+    decodeRequest: decoder<OperationApplicationLcmLoadSessionRequest>(211), decodeResult: decoder<OperationApplicationLcmLoadSessionResult>(212),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_load_session.v1", "schema.application.retained.lcm-load-session.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmLoadSessionResult>(212)) },
   { 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<OperationApplicationLcmStatusRequest>(211), decodeResult: decoder<OperationApplicationLcmStatusResult>(212),
-    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<OperationApplicationLcmStatusResult>(212)) },
+    decodeRequest: decoder<OperationApplicationLcmStatusRequest>(213), decodeResult: decoder<OperationApplicationLcmStatusResult>(214),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.lcm_status.v1", "schema.application.retained.lcm-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationLcmStatusResult>(214)) },
   { 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<OperationApplicationMemoryStatusRequest>(213), decodeResult: decoder<OperationApplicationMemoryStatusResult>(214),
-    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<OperationApplicationMemoryStatusResult>(214)) },
+    decodeRequest: decoder<OperationApplicationMemoryStatusRequest>(215), decodeResult: decoder<OperationApplicationMemoryStatusResult>(216),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.memory_status.v1", "schema.application.retained.memory-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationMemoryStatusResult>(216)) },
   { 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<OperationApplicationMessageSearchRequest>(215), decodeResult: decoder<OperationApplicationMessageSearchResult>(216),
-    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<OperationApplicationMessageSearchResult>(216)) },
+    decodeRequest: decoder<OperationApplicationMessageSearchRequest>(217), decodeResult: decoder<OperationApplicationMessageSearchResult>(218),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.message_search.v1", "schema.application.retained.message-search.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationMessageSearchResult>(218)) },
   { 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<OperationApplicationModuleApiRequest>(217), decodeResult: decoder<OperationApplicationModuleApiResult>(218),
-    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<OperationApplicationModuleApiResult>(218)) },
+    decodeRequest: decoder<OperationApplicationModuleApiRequest>(219), decodeResult: decoder<OperationApplicationModuleApiResult>(220),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.module_api.v1", "schema.application.primitive.module-api.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationModuleApiResult>(220)) },
   { 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<OperationApplicationMoveSymbolRequest>(219), decodeResult: decoder<OperationApplicationMoveSymbolResult>(12) },
+    decodeRequest: decoder<OperationApplicationMoveSymbolRequest>(221), decodeResult: decoder<OperationApplicationMoveSymbolResult>(14) },
   { operation: "multi_str_replace", operationId: "operation.application.multi_str_replace", transport: { kind: "mcp_tool", toolName: "tracedecay_multi_str_replace" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.multi_str_replace.v1",
     requestSchema: { schemaId: "schema.application.source-edit.multi-str-replace.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.multi-str-replace.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationMultiStrReplaceRequest>(220), decodeResult: decoder<OperationApplicationMultiStrReplaceResult>(12) },
+    decodeRequest: decoder<OperationApplicationMultiStrReplaceRequest>(222), decodeResult: decoder<OperationApplicationMultiStrReplaceResult>(14) },
   { operation: "native_integration_status", operationId: "operation.application.native_integration_status", transport: { kind: "mcp_tool", toolName: "tracedecay_native_integration_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.native_integration_status.v1",
     requestSchema: { schemaId: "schema.application.native-integration.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.status.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"],
-    decodeRequest: decoder<OperationApplicationNativeIntegrationStatusRequest>(221), decodeResult: decoder<OperationApplicationNativeIntegrationStatusResult>(9) },
+    decodeRequest: decoder<OperationApplicationNativeIntegrationStatusRequest>(223), decodeResult: decoder<OperationApplicationNativeIntegrationStatusResult>(11) },
   { operation: "node", operationId: "operation.application.node", transport: { kind: "mcp_tool", toolName: "tracedecay_node" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.node.v1",
     requestSchema: { schemaId: "schema.application.primitive.node.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.node.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationNodeRequest>(222), decodeResult: decoder<OperationApplicationNodeResult>(223) },
+    decodeRequest: decoder<OperationApplicationNodeRequest>(224), decodeResult: decoder<OperationApplicationNodeResult>(225) },
   { 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<OperationApplicationObservatoryReadRequest>(224), decodeResult: decoder<OperationApplicationObservatoryReadResult>(225) },
+    decodeRequest: decoder<OperationApplicationObservatoryReadRequest>(226), decodeResult: decoder<OperationApplicationObservatoryReadResult>(227) },
   { 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<OperationApplicationPortOrderRequest>(226), decodeResult: decoder<OperationApplicationPortOrderResult>(227) },
+    decodeRequest: decoder<OperationApplicationPortOrderRequest>(228), decodeResult: decoder<OperationApplicationPortOrderResult>(229) },
   { 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<OperationApplicationPortStatusRequest>(228), decodeResult: decoder<OperationApplicationPortStatusResult>(229) },
+    decodeRequest: decoder<OperationApplicationPortStatusRequest>(230), decodeResult: decoder<OperationApplicationPortStatusResult>(231) },
   { 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<OperationApplicationPrContextRequest>(230), decodeResult: decoder<OperationApplicationPrContextResult>(231) },
+    decodeRequest: decoder<OperationApplicationPrContextRequest>(232), decodeResult: decoder<OperationApplicationPrContextResult>(233) },
   { 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<OperationApplicationPreflightNativeIntegrationRequest>(232), decodeResult: decoder<OperationApplicationPreflightNativeIntegrationResult>(9) },
+    decodeRequest: decoder<OperationApplicationPreflightNativeIntegrationRequest>(234), decodeResult: decoder<OperationApplicationPreflightNativeIntegrationResult>(11) },
   { operation: "project_context", operationId: "operation.application.project_context", transport: { kind: "mcp_tool", toolName: "tracedecay_project_context" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_context.v1",
     requestSchema: { schemaId: "schema.application.primitive.project-context.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-context.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationProjectContextRequest>(233), decodeResult: decoder<OperationApplicationProjectContextResult>(234) },
+    decodeRequest: decoder<OperationApplicationProjectContextRequest>(235), decodeResult: decoder<OperationApplicationProjectContextResult>(236) },
   { operation: "project_list", operationId: "operation.application.project_list", transport: { kind: "mcp_tool", toolName: "tracedecay_project_list" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_list.v1",
     requestSchema: { schemaId: "schema.application.primitive.project-list.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-list.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationProjectListRequest>(235), decodeResult: decoder<OperationApplicationProjectListResult>(236) },
+    decodeRequest: decoder<OperationApplicationProjectListRequest>(237), decodeResult: decoder<OperationApplicationProjectListResult>(238) },
   { operation: "project_search", operationId: "operation.application.project_search", transport: { kind: "mcp_tool", toolName: "tracedecay_project_search" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.project_search.v1",
     requestSchema: { schemaId: "schema.application.primitive.project-search.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.project-search.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationProjectSearchRequest>(237), decodeResult: decoder<OperationApplicationProjectSearchResult>(236) },
+    decodeRequest: decoder<OperationApplicationProjectSearchRequest>(239), decodeResult: decoder<OperationApplicationProjectSearchResult>(238) },
   { 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<OperationApplicationQualifiedNameRequest>(238), decodeResult: decoder<OperationApplicationQualifiedNameResult>(239),
-    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<OperationApplicationQualifiedNameResult>(239)) },
+    decodeRequest: decoder<OperationApplicationQualifiedNameRequest>(240), decodeResult: decoder<OperationApplicationQualifiedNameResult>(241),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.qualified_name.v1", "schema.application.primitive.qualified-name.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationQualifiedNameResult>(241)) },
   { 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<OperationApplicationRankRequest>(240), decodeResult: decoder<OperationApplicationRankResult>(241) },
+    decodeRequest: decoder<OperationApplicationRankRequest>(242), decodeResult: decoder<OperationApplicationRankResult>(243) },
   { 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<OperationApplicationRecursionRequest>(242), decodeResult: decoder<OperationApplicationRecursionResult>(243) },
+    decodeRequest: decoder<OperationApplicationRecursionRequest>(244), decodeResult: decoder<OperationApplicationRecursionResult>(245) },
   { 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<OperationApplicationRedundancyRequest>(244), decodeResult: decoder<OperationApplicationRedundancyResult>(245) },
+    decodeRequest: decoder<OperationApplicationRedundancyRequest>(246), decodeResult: decoder<OperationApplicationRedundancyResult>(247) },
   { operation: "remote_status", operationId: "operation.application.remote_status", transport: { kind: "mcp_tool", toolName: "tracedecay_remote_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.remote_status.v1",
     requestSchema: { schemaId: "schema.application.primitive.remote-status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.remote-status.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationRemoteStatusRequest>(246), decodeResult: decoder<OperationApplicationRemoteStatusResult>(247) },
+    decodeRequest: decoder<OperationApplicationRemoteStatusRequest>(248), decodeResult: decoder<OperationApplicationRemoteStatusResult>(249) },
   { 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<OperationApplicationRenamePreviewRequest>(248), decodeResult: decoder<OperationApplicationRenamePreviewResult>(249) },
+    decodeRequest: decoder<OperationApplicationRenamePreviewRequest>(250), decodeResult: decoder<OperationApplicationRenamePreviewResult>(251) },
   { 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<OperationApplicationRenameSymbolRequest>(250), decodeResult: decoder<OperationApplicationRenameSymbolResult>(12) },
+    decodeRequest: decoder<OperationApplicationRenameSymbolRequest>(252), decodeResult: decoder<OperationApplicationRenameSymbolResult>(14) },
   { operation: "replace_symbol", operationId: "operation.application.replace_symbol", transport: { kind: "mcp_tool", toolName: "tracedecay_replace_symbol" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.replace_symbol.v1",
     requestSchema: { schemaId: "schema.application.source-edit.replace-symbol.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.replace-symbol.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationReplaceSymbolRequest>(251), decodeResult: decoder<OperationApplicationReplaceSymbolResult>(12) },
+    decodeRequest: decoder<OperationApplicationReplaceSymbolRequest>(253), decodeResult: decoder<OperationApplicationReplaceSymbolResult>(14) },
   { operation: "retrieve", operationId: "operation.application.retrieve", transport: { kind: "mcp_tool", toolName: "tracedecay_retrieve" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.retrieve.v1",
     requestSchema: { schemaId: "schema.application.primitive.retrieve.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.retrieve.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationRetrieveRequest>(252), decodeResult: decoder<OperationApplicationRetrieveResult>(253) },
+    decodeRequest: decoder<OperationApplicationRetrieveRequest>(254), decodeResult: decoder<OperationApplicationRetrieveResult>(255) },
   { 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<OperationApplicationRunAffectedTestsRequest>(254), decodeResult: decoder<OperationApplicationRunAffectedTestsResult>(255) },
+    decodeRequest: decoder<OperationApplicationRunAffectedTestsRequest>(256), decodeResult: decoder<OperationApplicationRunAffectedTestsResult>(257) },
   { operation: "runtime", operationId: "operation.application.runtime", transport: { kind: "mcp_tool", toolName: "tracedecay_runtime" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.runtime.v1",
     requestSchema: { schemaId: "schema.application.primitive.runtime.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.runtime.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationRuntimeRequest>(256), decodeResult: decoder<OperationApplicationRuntimeResult>(257) },
+    decodeRequest: decoder<OperationApplicationRuntimeRequest>(258), decodeResult: decoder<OperationApplicationRuntimeResult>(259) },
   { 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<OperationApplicationSearchRequest>(258), decodeResult: decoder<OperationApplicationSearchResult>(259) },
+    decodeRequest: decoder<OperationApplicationSearchRequest>(260), decodeResult: decoder<OperationApplicationSearchResult>(261) },
   { 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<OperationApplicationSessionLookupRequest>(260), decodeResult: decoder<OperationApplicationSessionLookupResult>(261) },
+    decodeRequest: decoder<OperationApplicationSessionLookupRequest>(262), decodeResult: decoder<OperationApplicationSessionLookupResult>(263) },
   { 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<OperationApplicationSessionRefreshBeginRequest>(262), decodeResult: decoder<OperationApplicationSessionRefreshBeginResult>(263),
-    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<OperationApplicationSessionRefreshBeginResult>(263)) },
+    decodeRequest: decoder<OperationApplicationSessionRefreshBeginRequest>(264), decodeResult: decoder<OperationApplicationSessionRefreshBeginResult>(265),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_begin.v1", "schema.application.retained.session-refresh-begin.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder<OperationApplicationSessionRefreshBeginResult>(265)) },
   { 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<OperationApplicationSessionRefreshCancelRequest>(262), decodeResult: decoder<OperationApplicationSessionRefreshCancelResult>(264),
-    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<OperationApplicationSessionRefreshCancelResult>(264)) },
+    decodeRequest: decoder<OperationApplicationSessionRefreshCancelRequest>(264), decodeResult: decoder<OperationApplicationSessionRefreshCancelResult>(266),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_cancel.v1", "schema.application.retained.session-refresh-cancel.result", 1, ["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]}, "durable_effect", "required", decoder<OperationApplicationSessionRefreshCancelResult>(266)) },
   { 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<OperationApplicationSessionRefreshStatusRequest>(262), decodeResult: decoder<OperationApplicationSessionRefreshStatusResult>(265),
-    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<OperationApplicationSessionRefreshStatusResult>(265)) },
+    decodeRequest: decoder<OperationApplicationSessionRefreshStatusRequest>(264), decodeResult: decoder<OperationApplicationSessionRefreshStatusResult>(267),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.session_refresh_status.v1", "schema.application.retained.session-refresh-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationSessionRefreshStatusResult>(267)) },
   { 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<OperationApplicationSessionsForRequest>(266), decodeResult: decoder<OperationApplicationSessionsForResult>(267),
-    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<OperationApplicationSessionsForResult>(267)) },
+    decodeRequest: decoder<OperationApplicationSessionsForRequest>(268), decodeResult: decoder<OperationApplicationSessionsForResult>(269),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.sessions_for.v1", "schema.application.retained.sessions-for.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationSessionsForResult>(269)) },
   { 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<OperationApplicationSignatureRequest>(106), decodeResult: decoder<OperationApplicationSignatureResult>(268) },
+    decodeRequest: decoder<OperationApplicationSignatureRequest>(108), decodeResult: decoder<OperationApplicationSignatureResult>(270) },
   { 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<OperationApplicationSimilarRequest>(269), decodeResult: decoder<OperationApplicationSimilarResult>(270) },
+    decodeRequest: decoder<OperationApplicationSimilarRequest>(271), decodeResult: decoder<OperationApplicationSimilarResult>(272) },
   { 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<OperationApplicationSkillListRequest>(271), decodeResult: decoder<OperationApplicationSkillListResult>(272) },
+    decodeRequest: decoder<OperationApplicationSkillListRequest>(273), decodeResult: decoder<OperationApplicationSkillListResult>(274) },
   { 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<OperationApplicationSkillViewRequest>(273), decodeResult: decoder<OperationApplicationSkillViewResult>(274) },
+    decodeRequest: decoder<OperationApplicationSkillViewRequest>(275), decodeResult: decoder<OperationApplicationSkillViewResult>(276) },
   { 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<OperationApplicationSourceBodyRequest>(275), decodeResult: decoder<OperationApplicationSourceBodyResult>(276),
-    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<OperationApplicationSourceBodyResult>(276)) },
+    decodeRequest: decoder<OperationApplicationSourceBodyRequest>(277), decodeResult: decoder<OperationApplicationSourceBodyResult>(278),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_body.v1", "schema.application.primitive.source-body.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationSourceBodyResult>(278)) },
   { 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<OperationApplicationSourceEditReconcileRequest>(277), decodeResult: decoder<OperationApplicationSourceEditReconcileResult>(12) },
+    decodeRequest: decoder<OperationApplicationSourceEditReconcileRequest>(279), decodeResult: decoder<OperationApplicationSourceEditReconcileResult>(14) },
   { operation: "source_edit_rollback", operationId: "operation.application.source_edit_rollback", transport: { kind: "mcp_tool", toolName: "tracedecay_source_edit_rollback" }, effect: "source_edit", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.source_edit_rollback.v1",
     requestSchema: { schemaId: "schema.application.source-edit.rollback.request", revision: 1 }, resultSchema: { schemaId: "schema.application.source-edit.rollback.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationSourceEditRollbackRequest>(278), decodeResult: decoder<OperationApplicationSourceEditRollbackResult>(12) },
+    decodeRequest: decoder<OperationApplicationSourceEditRollbackRequest>(280), decodeResult: decoder<OperationApplicationSourceEditRollbackResult>(14) },
   { operation: "application_source_lines", operationId: "operation.application.source_lines", transport: { kind: "http", route: "/application/primitives/source_lines", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.source_lines.v1",
     requestSchema: { schemaId: "schema.application.primitive.source-lines.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.source-lines.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":10000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationSourceLinesRequest>(279), decodeResult: decoder<OperationApplicationSourceLinesResult>(280),
-    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<OperationApplicationSourceLinesResult>(280)) },
+    decodeRequest: decoder<OperationApplicationSourceLinesRequest>(281), decodeResult: decoder<OperationApplicationSourceLinesResult>(282),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_lines.v1", "schema.application.primitive.source-lines.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationSourceLinesResult>(282)) },
   { 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<OperationApplicationSourceOutlineRequest>(281), decodeResult: decoder<OperationApplicationSourceOutlineResult>(282),
-    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<OperationApplicationSourceOutlineResult>(282)) },
+    decodeRequest: decoder<OperationApplicationSourceOutlineRequest>(283), decodeResult: decoder<OperationApplicationSourceOutlineResult>(284),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.source_outline.v1", "schema.application.primitive.source-outline.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationSourceOutlineResult>(284)) },
   { 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<OperationApplicationStackSnapshotRequest>(283), decodeResult: decoder<OperationApplicationStackSnapshotResult>(9) },
+    decodeRequest: decoder<OperationApplicationStackSnapshotRequest>(285), decodeResult: decoder<OperationApplicationStackSnapshotResult>(11) },
   { operation: "status", operationId: "operation.application.status", transport: { kind: "mcp_tool", toolName: "tracedecay_status" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.status.v1",
     requestSchema: { schemaId: "schema.application.primitive.status.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.status.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationStatusRequest>(284), decodeResult: decoder<OperationApplicationStatusResult>(285) },
+    decodeRequest: decoder<OperationApplicationStatusRequest>(286), decodeResult: decoder<OperationApplicationStatusResult>(287) },
   { 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<OperationApplicationStorageStatusRequest>(286), decodeResult: decoder<OperationApplicationStorageStatusResult>(287),
-    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<OperationApplicationStorageStatusResult>(287)) },
+    decodeRequest: decoder<OperationApplicationStorageStatusRequest>(288), decodeResult: decoder<OperationApplicationStorageStatusResult>(289),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.storage_status.v1", "schema.application.primitive.storage-status.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationStorageStatusResult>(289)) },
   { 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<OperationApplicationStrReplaceRequest>(288), decodeResult: decoder<OperationApplicationStrReplaceResult>(12) },
+    decodeRequest: decoder<OperationApplicationStrReplaceRequest>(290), decodeResult: decoder<OperationApplicationStrReplaceResult>(14) },
   { operation: "test_map", operationId: "operation.application.test_map", transport: { kind: "mcp_tool", toolName: "tracedecay_test_map" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.mcp.test_map.v1",
     requestSchema: { schemaId: "schema.application.primitive.test-map.request", revision: 1 }, resultSchema: { schemaId: "schema.application.primitive.test-map.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":120000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","unavailable","partial"],
-    decodeRequest: decoder<OperationApplicationTestMapRequest>(289), decodeResult: decoder<OperationApplicationTestMapResult>(290) },
+    decodeRequest: decoder<OperationApplicationTestMapRequest>(291), decodeResult: decoder<OperationApplicationTestMapResult>(292) },
   { 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<OperationApplicationTestResultsRequest>(291), decodeResult: decoder<OperationApplicationTestResultsResult>(292),
-    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<OperationApplicationTestResultsResult>(292)) },
+    decodeRequest: decoder<OperationApplicationTestResultsRequest>(293), decodeResult: decoder<OperationApplicationTestResultsResult>(294),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.test_results.v1", "schema.application.feedback.test-results.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationTestResultsResult>(294)) },
   { 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<OperationApplicationTestRiskRequest>(293), decodeResult: decoder<OperationApplicationTestRiskResult>(294) },
+    decodeRequest: decoder<OperationApplicationTestRiskRequest>(295), decodeResult: decoder<OperationApplicationTestRiskResult>(296) },
   { 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<OperationApplicationTodosRequest>(295), decodeResult: decoder<OperationApplicationTodosResult>(296) },
+    decodeRequest: decoder<OperationApplicationTodosRequest>(297), decodeResult: decoder<OperationApplicationTodosResult>(298) },
   { 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<OperationApplicationUnmountedFilesRequest>(297), decodeResult: decoder<OperationApplicationUnmountedFilesResult>(298) },
+    decodeRequest: decoder<OperationApplicationUnmountedFilesRequest>(299), decodeResult: decoder<OperationApplicationUnmountedFilesResult>(300) },
   { 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<OperationApplicationUnsafePatternsRequest>(299), decodeResult: decoder<OperationApplicationUnsafePatternsResult>(300) },
+    decodeRequest: decoder<OperationApplicationUnsafePatternsRequest>(301), decodeResult: decoder<OperationApplicationUnsafePatternsResult>(302) },
   { 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<OperationApplicationWorkflowsRequest>(301), decodeResult: decoder<OperationApplicationWorkflowsResult>(302),
-    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<OperationApplicationWorkflowsResult>(302)) },
+    decodeRequest: decoder<OperationApplicationWorkflowsRequest>(303), decodeResult: decoder<OperationApplicationWorkflowsResult>(304),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflows.v1", "schema.application.retained.workflows.result", 1, ["completed","cancelled","timed_out","failed","unavailable","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationWorkflowsResult>(304)) },
   { 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<OperationApplicationWorktreeCleanupConfirmRequest>(303), decodeResult: decoder<OperationApplicationWorktreeCleanupConfirmResult>(9),
-    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<OperationApplicationWorktreeCleanupConfirmResult>(9)) },
+    decodeRequest: decoder<OperationApplicationWorktreeCleanupConfirmRequest>(305), decodeResult: decoder<OperationApplicationWorktreeCleanupConfirmResult>(11),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_confirm.v1", "schema.application.native-integration.worktree-cleanup-confirm.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationWorktreeCleanupConfirmResult>(11)) },
   { operation: "application_worktree_cleanup_inspect", operationId: "operation.application.worktree_cleanup_inspect", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_inspect", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_inspect.v1",
     requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-inspect.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"],
-    decodeRequest: decoder<OperationApplicationWorktreeCleanupInspectRequest>(304), decodeResult: decoder<OperationApplicationWorktreeCleanupInspectResult>(9),
-    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<OperationApplicationWorktreeCleanupInspectResult>(9)) },
+    decodeRequest: decoder<OperationApplicationWorktreeCleanupInspectRequest>(306), decodeResult: decoder<OperationApplicationWorktreeCleanupInspectResult>(11),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_inspect.v1", "schema.application.native-integration.worktree-cleanup-inspect.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationWorktreeCleanupInspectResult>(11)) },
   { operation: "application_worktree_cleanup_reconcile", operationId: "operation.application.worktree_cleanup_reconcile", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_reconcile", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_reconcile.v1",
     requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-reconcile.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"],
-    decodeRequest: decoder<OperationApplicationWorktreeCleanupReconcileRequest>(305), decodeResult: decoder<OperationApplicationWorktreeCleanupReconcileResult>(9),
-    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<OperationApplicationWorktreeCleanupReconcileResult>(9)) },
+    decodeRequest: decoder<OperationApplicationWorktreeCleanupReconcileRequest>(307), decodeResult: decoder<OperationApplicationWorktreeCleanupReconcileResult>(11),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_reconcile.v1", "schema.application.native-integration.worktree-cleanup-reconcile.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationWorktreeCleanupReconcileResult>(11)) },
   { operation: "application_worktree_cleanup_remove", operationId: "operation.application.worktree_cleanup_remove", transport: { kind: "http", route: "/application/native-integration/worktree_cleanup_remove", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_cleanup_remove.v1",
     requestSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-cleanup-remove.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","cancelled","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationApplicationWorktreeCleanupRemoveRequest>(306), decodeResult: decoder<OperationApplicationWorktreeCleanupRemoveResult>(9),
-    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<OperationApplicationWorktreeCleanupRemoveResult>(9)) },
+    decodeRequest: decoder<OperationApplicationWorktreeCleanupRemoveRequest>(308), decodeResult: decoder<OperationApplicationWorktreeCleanupRemoveResult>(11),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_cleanup_remove.v1", "schema.application.native-integration.worktree-cleanup-remove.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationApplicationWorktreeCleanupRemoveResult>(11)) },
   { operation: "application_worktree_inventory", operationId: "operation.application.worktree_inventory", transport: { kind: "http", route: "/application/native-integration/worktree_inventory", method: "POST" }, effect: "read", idempotency: "not_required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.worktree_inventory.v1",
     requestSchema: { schemaId: "schema.application.native-integration.worktree-inventory.request", revision: 1 }, resultSchema: { schemaId: "schema.application.native-integration.worktree-inventory.result", revision: 1 },
     cancellation: {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, deadline: {"behavior":"return_operation_receipt","maximum_millis":30000}, reconciliation: "not_required", receipt: "operation", terminalStates: ["completed","cancelled","timed_out","failed","partial"],
-    decodeRequest: decoder<OperationApplicationWorktreeInventoryRequest>(307), decodeResult: decoder<OperationApplicationWorktreeInventoryResult>(9),
-    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<OperationApplicationWorktreeInventoryResult>(9)) },
+    decodeRequest: decoder<OperationApplicationWorktreeInventoryRequest>(309), decodeResult: decoder<OperationApplicationWorktreeInventoryResult>(11),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.worktree_inventory.v1", "schema.application.native-integration.worktree-inventory.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationApplicationWorktreeInventoryResult>(11)) },
   { operation: "handoff_issue_task_handoff", operationId: "operation.handoff.issue_task_handoff", transport: { kind: "http", route: "/application/handoff/issue-task", method: "POST" }, effect: "administrative", idempotency: "required", requestIdControl: "server_minted", resultSemantics: "schema_only", bindingId: "binding.http.handoff.issue_task_handoff",
     requestSchema: { schemaId: "schema.handoff.issue_task_handoff.request", revision: 1 }, resultSchema: { schemaId: "schema.handoff.issue_task_handoff.result", revision: 1 },
     cancellation: {"mode":"not_cancellable"}, deadline: {"behavior":"return_effect_receipt","maximum_millis":30000}, reconciliation: "required", receipt: "durable_effect", terminalStates: ["completed","timed_out","failed","effect_unknown","partial"],
-    decodeRequest: decoder<OperationHandoffIssueTaskHandoffRequest>(308), decodeResult: decoder<OperationHandoffIssueTaskHandoffResult>(309),
-    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<OperationHandoffIssueTaskHandoffResult>(309)) },
+    decodeRequest: decoder<OperationHandoffIssueTaskHandoffRequest>(310), decodeResult: decoder<OperationHandoffIssueTaskHandoffResult>(311),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.issue_task_handoff", "schema.handoff.issue_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationHandoffIssueTaskHandoffResult>(311)) },
   { 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<OperationHandoffListTaskHandoffsRequest>(310), decodeResult: decoder<OperationHandoffListTaskHandoffsResult>(311),
-    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<OperationHandoffListTaskHandoffsResult>(311)) },
+    decodeRequest: decoder<OperationHandoffListTaskHandoffsRequest>(312), decodeResult: decoder<OperationHandoffListTaskHandoffsResult>(313),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.list_task_handoffs", "schema.handoff.list_task_handoffs.result", 1, ["completed","timed_out","failed","partial"], {"mode":"not_cancellable"}, "operation", "not_required", decoder<OperationHandoffListTaskHandoffsResult>(313)) },
   { 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<OperationHandoffOpenInvestigationHandoffRequest>(312), decodeResult: decoder<OperationHandoffOpenInvestigationHandoffResult>(313),
-    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<OperationHandoffOpenInvestigationHandoffResult>(313)) },
+    decodeRequest: decoder<OperationHandoffOpenInvestigationHandoffRequest>(314), decodeResult: decoder<OperationHandoffOpenInvestigationHandoffResult>(315),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_investigation_handoff", "schema.handoff.open_investigation_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationHandoffOpenInvestigationHandoffResult>(315)) },
   { 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<OperationHandoffOpenTaskHandoffRequest>(314), decodeResult: decoder<OperationHandoffOpenTaskHandoffResult>(315),
-    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<OperationHandoffOpenTaskHandoffResult>(315)) },
+    decodeRequest: decoder<OperationHandoffOpenTaskHandoffRequest>(316), decodeResult: decoder<OperationHandoffOpenTaskHandoffResult>(317),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.handoff.open_task_handoff", "schema.handoff.open_task_handoff.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationHandoffOpenTaskHandoffResult>(317)) },
   { 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<OperationMultiRootExecuteRequest>(316), decodeResult: decoder<OperationMultiRootExecuteResult>(317),
-    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<OperationMultiRootExecuteResult>(317)) },
+    decodeRequest: decoder<OperationMultiRootExecuteRequest>(318), decodeResult: decoder<OperationMultiRootExecuteResult>(319),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.execute.v1", "schema.tracedecay.multi-root.execute-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationMultiRootExecuteResult>(319)) },
   { 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<OperationMultiRootScopeSetCompareAndSwapRequest>(318), decodeResult: decoder<OperationMultiRootScopeSetCompareAndSwapResult>(319),
-    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<OperationMultiRootScopeSetCompareAndSwapResult>(319)) },
+    decodeRequest: decoder<OperationMultiRootScopeSetCompareAndSwapRequest>(320), decodeResult: decoder<OperationMultiRootScopeSetCompareAndSwapResult>(321),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_compare_and_swap.v1", "schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationMultiRootScopeSetCompareAndSwapResult>(321)) },
   { 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<OperationMultiRootScopeSetReadRequest>(320), decodeResult: decoder<OperationMultiRootScopeSetReadResult>(321),
-    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<OperationMultiRootScopeSetReadResult>(321)) },
+    decodeRequest: decoder<OperationMultiRootScopeSetReadRequest>(322), decodeResult: decoder<OperationMultiRootScopeSetReadResult>(323),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.multi_root.scope_set_read.v1", "schema.tracedecay.multi-root.scope-set-read-result.v1", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationMultiRootScopeSetReadResult>(323)) },
   { 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<OperationWorkAcceptProposalRequest>(322), decodeResult: decoder<OperationWorkAcceptProposalResult>(323),
-    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<OperationWorkAcceptProposalResult>(323)) },
+    decodeRequest: decoder<OperationWorkAcceptProposalRequest>(324), decodeResult: decoder<OperationWorkAcceptProposalResult>(325),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.accept_proposal", "schema.work.accept_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkAcceptProposalResult>(325)) },
   { 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<OperationWorkAdjudicateDuplicateRequest>(324), decodeResult: decoder<OperationWorkAdjudicateDuplicateResult>(325),
-    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<OperationWorkAdjudicateDuplicateResult>(325)) },
+    decodeRequest: decoder<OperationWorkAdjudicateDuplicateRequest>(326), decodeResult: decoder<OperationWorkAdjudicateDuplicateResult>(327),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_duplicate", "schema.work.adjudicate_duplicate.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkAdjudicateDuplicateResult>(327)) },
   { 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<OperationWorkAdjudicateLeakRequest>(326), decodeResult: decoder<OperationWorkAdjudicateLeakResult>(327),
-    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<OperationWorkAdjudicateLeakResult>(327)) },
+    decodeRequest: decoder<OperationWorkAdjudicateLeakRequest>(328), decodeResult: decoder<OperationWorkAdjudicateLeakResult>(329),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.adjudicate_leak", "schema.work.adjudicate_leak.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkAdjudicateLeakResult>(329)) },
   { 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<OperationWorkAdmitExecutionRequest>(328), decodeResult: decoder<OperationWorkAdmitExecutionResult>(329),
-    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<OperationWorkAdmitExecutionResult>(329)) },
+    decodeRequest: decoder<OperationWorkAdmitExecutionRequest>(330), decodeResult: decoder<OperationWorkAdmitExecutionResult>(331),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_execution", "schema.work.admit_execution.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkAdmitExecutionResult>(331)) },
   { 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<OperationWorkAdmitPlacementRequest>(330), decodeResult: decoder<OperationWorkAdmitPlacementResult>(331),
-    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<OperationWorkAdmitPlacementResult>(331)) },
+    decodeRequest: decoder<OperationWorkAdmitPlacementRequest>(332), decodeResult: decoder<OperationWorkAdmitPlacementResult>(333),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.admit_placement", "schema.work.admit_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkAdmitPlacementResult>(333)) },
   { 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<OperationWorkAttemptStatusRequest>(332), decodeResult: decoder<OperationWorkAttemptStatusResult>(333),
-    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<OperationWorkAttemptStatusResult>(333)) },
+    decodeRequest: decoder<OperationWorkAttemptStatusRequest>(334), decodeResult: decoder<OperationWorkAttemptStatusResult>(335),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.attempt_status", "schema.work.attempt_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkAttemptStatusResult>(335)) },
   { 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<OperationWorkCancelAttemptRequest>(334), decodeResult: decoder<OperationWorkCancelAttemptResult>(333),
-    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<OperationWorkCancelAttemptResult>(333)) },
+    decodeRequest: decoder<OperationWorkCancelAttemptRequest>(336), decodeResult: decoder<OperationWorkCancelAttemptResult>(335),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.cancel_attempt", "schema.work.cancel_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkCancelAttemptResult>(335)) },
   { 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<OperationWorkCompareProposalRequest>(335), decodeResult: decoder<OperationWorkCompareProposalResult>(336),
-    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<OperationWorkCompareProposalResult>(336)) },
+    decodeRequest: decoder<OperationWorkCompareProposalRequest>(337), decodeResult: decoder<OperationWorkCompareProposalResult>(338),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.compare_proposal", "schema.work.compare_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkCompareProposalResult>(338)) },
   { 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<OperationWorkCreateRequest>(337), decodeResult: decoder<OperationWorkCreateResult>(323),
-    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<OperationWorkCreateResult>(323)) },
+    decodeRequest: decoder<OperationWorkCreateRequest>(339), decodeResult: decoder<OperationWorkCreateResult>(325),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.create", "schema.work.create.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkCreateResult>(325)) },
   { 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<OperationWorkExecutionHistoryRequest>(338), decodeResult: decoder<OperationWorkExecutionHistoryResult>(339),
-    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<OperationWorkExecutionHistoryResult>(339)) },
+    decodeRequest: decoder<OperationWorkExecutionHistoryRequest>(340), decodeResult: decoder<OperationWorkExecutionHistoryResult>(341),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.execution_history", "schema.work.execution_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkExecutionHistoryResult>(341)) },
   { 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<OperationWorkExperienceRequest>(340), decodeResult: decoder<OperationWorkExperienceResult>(341),
-    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<OperationWorkExperienceResult>(341)) },
+    decodeRequest: decoder<OperationWorkExperienceRequest>(342), decodeResult: decoder<OperationWorkExperienceResult>(343),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.experience", "schema.work.experience.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkExperienceResult>(343)) },
   { 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<OperationWorkGenerateProposalRequest>(342), decodeResult: decoder<OperationWorkGenerateProposalResult>(343),
-    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<OperationWorkGenerateProposalResult>(343)) },
+    decodeRequest: decoder<OperationWorkGenerateProposalRequest>(344), decodeResult: decoder<OperationWorkGenerateProposalResult>(345),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.generate_proposal", "schema.work.generate_proposal.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkGenerateProposalResult>(345)) },
   { 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<OperationWorkHydrateArtifactsRequest>(344), decodeResult: decoder<OperationWorkHydrateArtifactsResult>(345),
-    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<OperationWorkHydrateArtifactsResult>(345)) },
+    decodeRequest: decoder<OperationWorkHydrateArtifactsRequest>(346), decodeResult: decoder<OperationWorkHydrateArtifactsResult>(347),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.hydrate_artifacts", "schema.work.hydrate_artifacts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkHydrateArtifactsResult>(347)) },
   { 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<OperationWorkListAttemptsRequest>(338), decodeResult: decoder<OperationWorkListAttemptsResult>(346),
-    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<OperationWorkListAttemptsResult>(346)) },
+    decodeRequest: decoder<OperationWorkListAttemptsRequest>(340), decodeResult: decoder<OperationWorkListAttemptsResult>(348),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.list_attempts", "schema.work.list_attempts.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkListAttemptsResult>(348)) },
   { 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<OperationWorkMutateGraphRequest>(347), decodeResult: decoder<OperationWorkMutateGraphResult>(323),
-    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<OperationWorkMutateGraphResult>(323)) },
+    decodeRequest: decoder<OperationWorkMutateGraphRequest>(349), decodeResult: decoder<OperationWorkMutateGraphResult>(325),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.mutate_graph", "schema.work.mutate_graph.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkMutateGraphResult>(325)) },
   { 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<OperationWorkPauseRunRequest>(348), decodeResult: decoder<OperationWorkPauseRunResult>(349),
-    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<OperationWorkPauseRunResult>(349)) },
+    decodeRequest: decoder<OperationWorkPauseRunRequest>(350), decodeResult: decoder<OperationWorkPauseRunResult>(351),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.pause_run", "schema.work.pause_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkPauseRunResult>(351)) },
   { 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<OperationWorkPlacementPreflightRequest>(350), decodeResult: decoder<OperationWorkPlacementPreflightResult>(351),
-    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<OperationWorkPlacementPreflightResult>(351)) },
+    decodeRequest: decoder<OperationWorkPlacementPreflightRequest>(352), decodeResult: decoder<OperationWorkPlacementPreflightResult>(353),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_preflight", "schema.work.placement_preflight.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkPlacementPreflightResult>(353)) },
   { 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<OperationWorkPlacementStatusRequest>(352), decodeResult: decoder<OperationWorkPlacementStatusResult>(353),
-    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<OperationWorkPlacementStatusResult>(353)) },
+    decodeRequest: decoder<OperationWorkPlacementStatusRequest>(354), decodeResult: decoder<OperationWorkPlacementStatusResult>(355),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.placement_status", "schema.work.placement_status.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkPlacementStatusResult>(355)) },
   { 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<OperationWorkPrepareDuplicateAdjudicationRequest>(354), decodeResult: decoder<OperationWorkPrepareDuplicateAdjudicationResult>(324),
-    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<OperationWorkPrepareDuplicateAdjudicationResult>(324)) },
+    decodeRequest: decoder<OperationWorkPrepareDuplicateAdjudicationRequest>(356), decodeResult: decoder<OperationWorkPrepareDuplicateAdjudicationResult>(326),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_duplicate_adjudication", "schema.work.prepare_duplicate_adjudication.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkPrepareDuplicateAdjudicationResult>(326)) },
   { 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<OperationWorkPrepareGraphMutationRequest>(355), decodeResult: decoder<OperationWorkPrepareGraphMutationResult>(347),
-    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<OperationWorkPrepareGraphMutationResult>(347)) },
+    decodeRequest: decoder<OperationWorkPrepareGraphMutationRequest>(357), decodeResult: decoder<OperationWorkPrepareGraphMutationResult>(349),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.prepare_graph_mutation", "schema.work.prepare_graph_mutation.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkPrepareGraphMutationResult>(349)) },
   { 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<OperationWorkReleasePlacementRequest>(356), decodeResult: decoder<OperationWorkReleasePlacementResult>(331),
-    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<OperationWorkReleasePlacementResult>(331)) },
+    decodeRequest: decoder<OperationWorkReleasePlacementRequest>(358), decodeResult: decoder<OperationWorkReleasePlacementResult>(333),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.release_placement", "schema.work.release_placement.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkReleasePlacementResult>(333)) },
   { 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<OperationWorkResumeAttemptsRequest>(357), decodeResult: decoder<OperationWorkResumeAttemptsResult>(358),
-    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<OperationWorkResumeAttemptsResult>(358)) },
+    decodeRequest: decoder<OperationWorkResumeAttemptsRequest>(359), decodeResult: decoder<OperationWorkResumeAttemptsResult>(360),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_attempts", "schema.work.resume_attempts.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkResumeAttemptsResult>(360)) },
   { 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<OperationWorkResumeRunRequest>(359), decodeResult: decoder<OperationWorkResumeRunResult>(349),
-    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<OperationWorkResumeRunResult>(349)) },
+    decodeRequest: decoder<OperationWorkResumeRunRequest>(361), decodeResult: decoder<OperationWorkResumeRunResult>(351),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.resume_run", "schema.work.resume_run.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkResumeRunResult>(351)) },
   { 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<OperationWorkRetrieveEvidenceRequest>(360), decodeResult: decoder<OperationWorkRetrieveEvidenceResult>(361),
-    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<OperationWorkRetrieveEvidenceResult>(361)) },
+    decodeRequest: decoder<OperationWorkRetrieveEvidenceRequest>(362), decodeResult: decoder<OperationWorkRetrieveEvidenceResult>(363),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retrieve_evidence", "schema.work.retrieve_evidence.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkRetrieveEvidenceResult>(363)) },
   { 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<OperationWorkRetryAttemptRequest>(362), decodeResult: decoder<OperationWorkRetryAttemptResult>(363),
-    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<OperationWorkRetryAttemptResult>(363)) },
+    decodeRequest: decoder<OperationWorkRetryAttemptRequest>(364), decodeResult: decoder<OperationWorkRetryAttemptResult>(365),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.retry_attempt", "schema.work.retry_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkRetryAttemptResult>(365)) },
   { 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<OperationWorkReviewProposalRequest>(364), decodeResult: decoder<OperationWorkReviewProposalResult>(323),
-    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<OperationWorkReviewProposalResult>(323)) },
+    decodeRequest: decoder<OperationWorkReviewProposalRequest>(366), decodeResult: decoder<OperationWorkReviewProposalResult>(325),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.review_proposal", "schema.work.review_proposal.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkReviewProposalResult>(325)) },
   { 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<OperationWorkRunControlRequest>(365), decodeResult: decoder<OperationWorkRunControlResult>(366),
-    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<OperationWorkRunControlResult>(366)) },
+    decodeRequest: decoder<OperationWorkRunControlRequest>(367), decodeResult: decoder<OperationWorkRunControlResult>(368),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.run_control", "schema.work.run_control.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkRunControlResult>(368)) },
   { 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<OperationWorkStartAttemptRequest>(367), decodeResult: decoder<OperationWorkStartAttemptResult>(333),
-    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<OperationWorkStartAttemptResult>(333)) },
+    decodeRequest: decoder<OperationWorkStartAttemptRequest>(369), decodeResult: decoder<OperationWorkStartAttemptResult>(335),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.start_attempt", "schema.work.start_attempt.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkStartAttemptResult>(335)) },
   { 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<OperationWorkSynthesizeRequest>(368), decodeResult: decoder<OperationWorkSynthesizeResult>(369),
-    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<OperationWorkSynthesizeResult>(369)) },
+    decodeRequest: decoder<OperationWorkSynthesizeRequest>(370), decodeResult: decoder<OperationWorkSynthesizeResult>(371),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.synthesize", "schema.work.synthesize.result", 1, ["completed","cancelled","timed_out","failed","effect_unknown","partial"], {"mode":"cooperative","points":["before_admission","before_effect","effect_in_flight","after_commit"]}, "durable_effect", "required", decoder<OperationWorkSynthesizeResult>(371)) },
   { 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<OperationWorkTopologyRequest>(370), decodeResult: decoder<OperationWorkTopologyResult>(371),
-    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<OperationWorkTopologyResult>(371)) },
+    decodeRequest: decoder<OperationWorkTopologyRequest>(372), decodeResult: decoder<OperationWorkTopologyResult>(373),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology", "schema.work.topology.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkTopologyResult>(373)) },
   { 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<OperationWorkTopologyMetricsRequest>(372), decodeResult: decoder<OperationWorkTopologyMetricsResult>(373),
-    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<OperationWorkTopologyMetricsResult>(373)) },
+    decodeRequest: decoder<OperationWorkTopologyMetricsRequest>(374), decodeResult: decoder<OperationWorkTopologyMetricsResult>(375),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.topology_metrics", "schema.work.topology_metrics.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkTopologyMetricsResult>(375)) },
   { 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<OperationWorkViewsRequest>(374), decodeResult: decoder<OperationWorkViewsResult>(375),
-    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<OperationWorkViewsResult>(375)) },
+    decodeRequest: decoder<OperationWorkViewsRequest>(376), decodeResult: decoder<OperationWorkViewsResult>(377),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.work.views", "schema.work.views.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkViewsResult>(377)) },
   { 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<OperationWorkflowActivateDefinitionRequest>(376), decodeResult: decoder<OperationWorkflowActivateDefinitionResult>(377),
-    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<OperationWorkflowActivateDefinitionResult>(377)) },
+    decodeRequest: decoder<OperationWorkflowActivateDefinitionRequest>(378), decodeResult: decoder<OperationWorkflowActivateDefinitionResult>(379),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.activate_definition", "schema.workflow.activate_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowActivateDefinitionResult>(379)) },
   { 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<OperationWorkflowCancelRunRequest>(378), decodeResult: decoder<OperationWorkflowCancelRunResult>(379),
-    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<OperationWorkflowCancelRunResult>(379)) },
+    decodeRequest: decoder<OperationWorkflowCancelRunRequest>(380), decodeResult: decoder<OperationWorkflowCancelRunResult>(381),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.cancel_run", "schema.workflow.cancel_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowCancelRunResult>(381)) },
   { 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<OperationWorkflowDefinitionHistoryRequest>(380), decodeResult: decoder<OperationWorkflowDefinitionHistoryResult>(381),
-    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<OperationWorkflowDefinitionHistoryResult>(381)) },
+    decodeRequest: decoder<OperationWorkflowDefinitionHistoryRequest>(382), decodeResult: decoder<OperationWorkflowDefinitionHistoryResult>(383),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.definition_history", "schema.workflow.definition_history.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkflowDefinitionHistoryResult>(383)) },
   { 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<OperationWorkflowDiffDefinitionRequest>(382), decodeResult: decoder<OperationWorkflowDiffDefinitionResult>(383),
-    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<OperationWorkflowDiffDefinitionResult>(383)) },
+    decodeRequest: decoder<OperationWorkflowDiffDefinitionRequest>(384), decodeResult: decoder<OperationWorkflowDiffDefinitionResult>(385),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.diff_definition", "schema.workflow.diff_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkflowDiffDefinitionResult>(385)) },
   { 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<OperationWorkflowGetDefinitionRequest>(384), decodeResult: decoder<OperationWorkflowGetDefinitionResult>(385),
-    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<OperationWorkflowGetDefinitionResult>(385)) },
+    decodeRequest: decoder<OperationWorkflowGetDefinitionRequest>(386), decodeResult: decoder<OperationWorkflowGetDefinitionResult>(387),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_definition", "schema.workflow.get_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkflowGetDefinitionResult>(387)) },
   { 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<OperationWorkflowGetRunRequest>(386), decodeResult: decoder<OperationWorkflowGetRunResult>(379),
-    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<OperationWorkflowGetRunResult>(379)) },
+    decodeRequest: decoder<OperationWorkflowGetRunRequest>(388), decodeResult: decoder<OperationWorkflowGetRunResult>(381),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.get_run", "schema.workflow.get_run.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkflowGetRunResult>(381)) },
   { 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<OperationWorkflowHandoffIssueRequest>(387), decodeResult: decoder<OperationWorkflowHandoffIssueResult>(388),
-    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<OperationWorkflowHandoffIssueResult>(388)) },
+    decodeRequest: decoder<OperationWorkflowHandoffIssueRequest>(389), decodeResult: decoder<OperationWorkflowHandoffIssueResult>(390),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_issue", "schema.workflow.handoff_issue.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowHandoffIssueResult>(390)) },
   { 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<OperationWorkflowHandoffRedeemRequest>(389), decodeResult: decoder<OperationWorkflowHandoffRedeemResult>(390),
-    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<OperationWorkflowHandoffRedeemResult>(390)) },
+    decodeRequest: decoder<OperationWorkflowHandoffRedeemRequest>(391), decodeResult: decoder<OperationWorkflowHandoffRedeemResult>(392),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.handoff_redeem", "schema.workflow.handoff_redeem.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowHandoffRedeemResult>(392)) },
   { 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<OperationWorkflowListDefinitionsRequest>(391), decodeResult: decoder<OperationWorkflowListDefinitionsResult>(381),
-    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<OperationWorkflowListDefinitionsResult>(381)) },
+    decodeRequest: decoder<OperationWorkflowListDefinitionsRequest>(393), decodeResult: decoder<OperationWorkflowListDefinitionsResult>(383),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.list_definitions", "schema.workflow.list_definitions.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkflowListDefinitionsResult>(383)) },
   { 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<OperationWorkflowPauseRunRequest>(392), decodeResult: decoder<OperationWorkflowPauseRunResult>(379),
-    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<OperationWorkflowPauseRunResult>(379)) },
+    decodeRequest: decoder<OperationWorkflowPauseRunRequest>(394), decodeResult: decoder<OperationWorkflowPauseRunResult>(381),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.pause_run", "schema.workflow.pause_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowPauseRunResult>(381)) },
   { 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<OperationWorkflowRegisterDefinitionRequest>(393), decodeResult: decoder<OperationWorkflowRegisterDefinitionResult>(385),
-    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<OperationWorkflowRegisterDefinitionResult>(385)) },
+    decodeRequest: decoder<OperationWorkflowRegisterDefinitionRequest>(395), decodeResult: decoder<OperationWorkflowRegisterDefinitionResult>(387),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.register_definition", "schema.workflow.register_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowRegisterDefinitionResult>(387)) },
   { 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<OperationWorkflowRejectDefinitionRequest>(394), decodeResult: decoder<OperationWorkflowRejectDefinitionResult>(377),
-    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<OperationWorkflowRejectDefinitionResult>(377)) },
+    decodeRequest: decoder<OperationWorkflowRejectDefinitionRequest>(396), decodeResult: decoder<OperationWorkflowRejectDefinitionResult>(379),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.reject_definition", "schema.workflow.reject_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowRejectDefinitionResult>(379)) },
   { 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<OperationWorkflowResumeRunRequest>(395), decodeResult: decoder<OperationWorkflowResumeRunResult>(379),
-    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<OperationWorkflowResumeRunResult>(379)) },
+    decodeRequest: decoder<OperationWorkflowResumeRunRequest>(397), decodeResult: decoder<OperationWorkflowResumeRunResult>(381),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.resume_run", "schema.workflow.resume_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowResumeRunResult>(381)) },
   { 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<OperationWorkflowRetireDefinitionRequest>(396), decodeResult: decoder<OperationWorkflowRetireDefinitionResult>(377),
-    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<OperationWorkflowRetireDefinitionResult>(377)) },
+    decodeRequest: decoder<OperationWorkflowRetireDefinitionRequest>(398), decodeResult: decoder<OperationWorkflowRetireDefinitionResult>(379),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.retire_definition", "schema.workflow.retire_definition.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowRetireDefinitionResult>(379)) },
   { 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<OperationWorkflowStartRunRequest>(397), decodeResult: decoder<OperationWorkflowStartRunResult>(379),
-    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<OperationWorkflowStartRunResult>(379)) },
+    decodeRequest: decoder<OperationWorkflowStartRunRequest>(399), decodeResult: decoder<OperationWorkflowStartRunResult>(381),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.start_run", "schema.workflow.start_run.result", 1, ["completed","timed_out","failed","effect_unknown","partial"], {"mode":"not_cancellable"}, "durable_effect", "required", decoder<OperationWorkflowStartRunResult>(381)) },
   { 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<OperationWorkflowValidateDefinitionRequest>(398), decodeResult: decoder<OperationWorkflowValidateDefinitionResult>(399),
-    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<OperationWorkflowValidateDefinitionResult>(399)) },
+    decodeRequest: decoder<OperationWorkflowValidateDefinitionRequest>(400), decodeResult: decoder<OperationWorkflowValidateDefinitionResult>(401),
+    decodeSuccess: (value: unknown) => decodeHttpSuccessEnvelope(value, "binding.http.workflow.validate_definition", "schema.workflow.validate_definition.result", 1, ["completed","cancelled","timed_out","failed","partial"], {"mode":"cooperative","points":["before_admission","before_read","during_read"]}, "operation", "not_required", decoder<OperationWorkflowValidateDefinitionResult>(401)) },
 ] as const;
 
 export type Operation = (typeof OPERATIONS)[number];