feat(coding): omp core-tool contract + engines + benchmark arm (issue #7392, slices 1-4)

Cargo.toml

@@ -483,6 +483,10 @@ path = "tests/integration/webui_v2_router_smoke.rs"
 name = "reborn_integration_wiring_parity"
 path = "tests/integration/wiring_parity.rs"
 
+[[test]]
+name = "reborn_omp_registration"
+path = "tests/integration/reborn_omp_registration.rs"
+
 [profile.release]
 strip = true          # Remove debug symbols from release binaries
 

crates/app/ironclaw_architecture_tests/tests/reborn_dependency_boundaries.rs

@@ -636,7 +636,12 @@ fn reborn_contracts_crates_carry_a_checked_size_ceiling() {
         // sandbox transport now exposes graceful lifecycle release. This is
         // contract vocabulary; execution and provider cleanup remain in the
         // sandbox runtime lane.
-        ("ironclaw_host_api", 18_799),
+        // Raised 18_799 -> 18_808 (2026-08-08, #7392 slice 3): the additive
+        // `provider_tool_name` override field on CapabilityDescriptor (serde
+        // default None + skip_serializing_if) plus its doc comment — pure
+        // declarative vocabulary, 9 lines. Count read from this test's own
+        // failure message.
+        ("ironclaw_host_api", 18_808),
         // 14_479 -> 13_949 (2026-08-07, #7157): downward re-capture after the
         // delivery-heuristic vocabulary (stored trigger delivery targets and
         // their run-profile plumbing) left this crate with the two-lane
@@ -1768,6 +1773,34 @@ fn provider_tool_names_stay_at_model_protocol_boundaries() {
         "crates/ironclaw_host_api/src/ids.rs",
         "crates/ironclaw_safety/src/lib.rs",
         "crates/ironclaw_safety/src/provider_validation.rs",
+        // Issue #7392 provider-name resolver: the additive declarative field
+        // (`provider_tool_name`) lives on the capability declaration and the
+        // runtime descriptor as plain serialized data, validated as
+        // `ProviderToolName` only where it becomes provider-protocol identity
+        // (manifest parse + the loop boundary). These files are declarative
+        // storage/propagation, not routing or product logic.
+        "crates/ironclaw_host_api/src/capability.rs",
+        "crates/ironclaw_extension_registry/src/v2.rs",
+        "crates/ironclaw_extension_registry/src/v3.rs",
+        "crates/ironclaw_extension_registry/src/package.rs",
+        "crates/ironclaw_extension_registry/src/hosted_mcp_discovery.rs",
+        // Host-owned manifest/descriptor builders that carry the additive
+        // declarative field through to the descriptor (same storage role as
+        // the registry mappings above).
+        "crates/ironclaw_extension_host/src/active.rs",
+        "crates/ironclaw_extension_host/src/generic_host.rs",
+        "crates/ironclaw_extension_host/src/hosted_mcp_manifest.rs",
+        "crates/ironclaw_extension_host/src/mcp.rs",
+        "crates/ironclaw_extension_manager/src/admin_configuration_capability.rs",
+        "crates/ironclaw_extension_manager/src/extension_lifecycle_capabilities.rs",
+        "crates/ironclaw_extension_manager/src/operator_config_capability.rs",
+        "crates/ironclaw_extension_manager/src/skill_auto_activate_capability.rs",
+        "crates/ironclaw_extension_manager/src/ironhub/capabilities.rs",
+        "crates/ironclaw_host_runtime/src/first_party_tools/mod.rs",
+        // Test-support-gated omp registration seam (issue #7392 slice 3):
+        // builds the builtin package plus the five omp capabilities with
+        // their exact-name overrides; compiled out of production binaries.
+        "crates/ironclaw_host_runtime/src/first_party_tools/omp.rs",
         // Host loop/run/thread protocol structs that preserve exact model
         // provider names for tool-result roundtrips and historical replay.
         // The provider-tool-call DTOs live in the `capability` submodule of the

crates/app/ironclaw_composition/src/builtin_capability_policy.toml

@@ -190,6 +190,27 @@ effects = ["dispatch_capability", "read_filesystem", "write_filesystem"]
 mounts = "workspace"
 network = "default"
 
+# ⚠️ TEMPORARY benchmark override (issue #7392 bench arm): grants for the
+# omp-parity capability ids so the /benchmark surface advertises read/write/edit
+# alongside glob/grep. Revert at cutover alongside the omp.rs override.
+[[grants]]
+capability = "builtin.read"
+effects = ["dispatch_capability", "read_filesystem", "write_filesystem"]
+mounts = "workspace"
+network = "default"
+
+[[grants]]
+capability = "builtin.write"
+effects = ["dispatch_capability", "read_filesystem", "write_filesystem"]
+mounts = "workspace"
+network = "default"
+
+[[grants]]
+capability = "builtin.edit"
+effects = ["dispatch_capability", "read_filesystem", "write_filesystem"]
+mounts = "workspace"
+network = "default"
+
 [[grants]]
 capability = "builtin.list_dir"
 effects = ["dispatch_capability", "read_filesystem", "write_filesystem"]

crates/app/ironclaw_composition/src/capability_authorization/tests.rs

@@ -375,6 +375,7 @@ fn local_host_shell_authorization_inputs(
         resource_profile: None,
         origin_gate_matrix: None,
         standard_op: None,
+        provider_tool_name: None,
     };
     let policy = builtin_capability_policy().expect("capability policy");
     let grants = policy.builtin_grants(
@@ -429,6 +430,7 @@ async fn trace_commons_authorize_decision(
         resource_profile: None,
         origin_gate_matrix: None,
         standard_op: None,
+        provider_tool_name: None,
     };
     let policy = Arc::new(builtin_capability_policy().expect("capability policy"));
     let provider_id = ExtensionId::new(BUILTIN_FIRST_PARTY_PROVIDER).expect("provider id");

crates/app/ironclaw_composition/src/factory.rs

@@ -124,7 +124,7 @@ use ironclaw_extension_manager::{
 };
 use ironclaw_extension_registry::{
     ExtensionInstallationStore, ExtensionInstallationStorePort, ExtensionLifecycleService,
-    ExtensionRegistry, ManifestSource, SharedExtensionRegistry,
+    ExtensionPackage, ExtensionRegistry, ManifestSource, SharedExtensionRegistry,
 };
 use ironclaw_filesystem::ScopedFilesystem;
 #[cfg(test)]
@@ -1115,13 +1115,29 @@ fn production_builtin_extension_registry(
     process_backend: ProcessBackendKind,
     memory_package: Option<&ironclaw_extension_registry::ExtensionPackage>,
 ) -> Result<ExtensionRegistry, RebornBuildError> {
-    let mut registry = ExtensionRegistry::new();
     let package =
         builtin_first_party_package_for_process_backend(process_backend).map_err(|error| {
             RebornBuildError::InvalidConfig {
                 reason: format!("built-in first-party package is invalid: {error}"),
             }
         })?;
+    let package = extend_builtin_package(package)?;
+    let mut registry = ExtensionRegistry::new();
+    registry
+        .insert(package)
+        .map_err(|error| RebornBuildError::InvalidConfig {
+            reason: format!("built-in first-party registry is invalid: {error}"),
+        })?;
+    insert_bound_memory_package(&mut registry, memory_package)?;
+    Ok(registry)
+}
+
+/// The host-owned extension packages layered on top of the built-in
+/// first-party package (extension lifecycle, IronHub, admin configuration,
+/// operator configuration, skill auto-activation) — shared by the stock and
+/// omp-extended builtin registries so the omp arm differs ONLY in the five
+/// omp capabilities, never in the extension layers.
+fn extend_builtin_package(package: ExtensionPackage) -> Result<ExtensionPackage, RebornBuildError> {
     let package = extend_builtin_first_party_package(package).map_err(|error| {
         RebornBuildError::InvalidConfig {
             reason: format!("extension lifecycle package is invalid: {error}"),
@@ -1147,10 +1163,31 @@ fn production_builtin_extension_registry(
             reason: format!("skill auto-activation package is invalid: {error}"),
         }
     })?;
+    Ok(package)
+}
+
+/// Issue #7392 slice 3 seam (test-support only): the built-in first-party
+/// registry whose coding capabilities are the omp-extended package
+/// (`ironclaw_host_runtime::omp_coding_package`) — the stock surface plus
+/// the five omp tools under the exact `read`/`write`/`edit`/`glob`/`grep`
+/// names. The extension layers and the bound memory package ride on top
+/// exactly as in production.
+#[cfg(any(test, feature = "test-support"))]
+pub(crate) fn omp_extended_builtin_extension_registry(
+    process_backend: ProcessBackendKind,
+    memory_package: Option<&ironclaw_extension_registry::ExtensionPackage>,
+) -> Result<ExtensionRegistry, RebornBuildError> {
+    let package = ironclaw_host_runtime::omp_coding_package(process_backend).map_err(|error| {
+        RebornBuildError::InvalidConfig {
+            reason: format!("omp-extended built-in package is invalid: {error}"),
+        }
+    })?;
+    let package = extend_builtin_package(package)?;
+    let mut registry = ExtensionRegistry::new();
     registry
         .insert(package)
         .map_err(|error| RebornBuildError::InvalidConfig {
-            reason: format!("built-in first-party registry is invalid: {error}"),
+            reason: format!("omp-extended first-party registry is invalid: {error}"),
         })?;
     insert_bound_memory_package(&mut registry, memory_package)?;
     Ok(registry)

crates/app/ironclaw_composition/src/factory/production_backend_assembly.rs

@@ -350,6 +350,8 @@ pub(super) async fn build_backend_production(
         network_http_egress_for_test,
         #[cfg(any(test, feature = "test-support"))]
         trust_fixture_extensions_for_test,
+        #[cfg(any(test, feature = "test-support"))]
+        omp_coding_tools_for_test,
     } = context;
     let deployment_is_local_single_user = matches!(
         production_wiring.runtime_policy.deployment,
@@ -478,6 +480,13 @@ pub(super) async fn build_backend_production(
         Arc::new(crate::outbound::MutableOutboundDeliveryTargetRegistry::default());
     let skill_auto_activate_learned = Arc::new(AtomicBool::new(true));
     let process_backend = production_wiring.runtime_policy.process_backend;
+    #[cfg(any(test, feature = "test-support"))]
+    let extension_registry = if omp_coding_tools_for_test {
+        omp_extended_builtin_extension_registry(process_backend, resolved_memory.package.as_ref())?
+    } else {
+        production_builtin_extension_registry(process_backend, resolved_memory.package.as_ref())?
+    };
+    #[cfg(not(any(test, feature = "test-support")))]
     let extension_registry =
         production_builtin_extension_registry(process_backend, resolved_memory.package.as_ref())?;
     let extension_registry = Arc::new(extension_registry);
@@ -590,6 +599,17 @@ pub(super) async fn build_backend_production(
         trigger_active_run_lookup,
         process_backend,
     )?;
+    #[cfg(any(test, feature = "test-support"))]
+    if omp_coding_tools_for_test {
+        // The omp handler adapter replaces the stock builtin handler for
+        // `builtin.glob`/`builtin.grep` and adds `builtin.read`/`write`/`edit`
+        // (issue #7392 slice 3 registration seam).
+        ironclaw_host_runtime::insert_omp_coding_handlers(&mut first_party_registry).map_err(
+            |error| RebornBuildError::InvalidConfig {
+                reason: format!("omp first-party handlers are invalid: {error}"),
+            },
+        )?;
+    }
     if let (Some(package), Some(handler)) = (
         resolved_memory.package.as_ref(),
         resolved_memory.tool_handler.as_ref(),

crates/app/ironclaw_composition/src/factory/production_build_assembly.rs

@@ -21,6 +21,8 @@ pub(super) async fn build_production_shaped(
         network_http_egress_for_test,
         #[cfg(any(test, feature = "test-support"))]
         trust_fixture_extensions_for_test,
+        #[cfg(any(test, feature = "test-support"))]
+        omp_coding_tools_for_test,
         memory_binding_policy,
         memory_provider_connection,
         ..
@@ -94,6 +96,8 @@ pub(super) async fn build_production_shaped(
         network_http_egress_for_test,
         #[cfg(any(test, feature = "test-support"))]
         trust_fixture_extensions_for_test,
+        #[cfg(any(test, feature = "test-support"))]
+        omp_coding_tools_for_test,
     };
     match storage {
         RebornStorageInput::Disabled => Err(RebornBuildError::InvalidConfig {
@@ -373,6 +377,11 @@ pub(super) struct RebornProductionBuildContext {
     pub(super) network_http_egress_for_test: Option<Arc<dyn ironclaw_network::NetworkHttpEgress>>,
     #[cfg(any(test, feature = "test-support"))]
     pub(super) trust_fixture_extensions_for_test: bool,
+    /// Issue #7392 slice 3 seam: select the omp-extended built-in package +
+    /// handlers. Test-support only; default `false` keeps the stock surface
+    /// byte-identical.
+    #[cfg(any(test, feature = "test-support"))]
+    pub(super) omp_coding_tools_for_test: bool,
 }
 
 fn production_wiring(

crates/app/ironclaw_composition/src/input.rs

@@ -190,6 +190,13 @@ pub struct RebornHostBindings {
     /// `InstalledLocal` (#5459).
     #[cfg(any(test, feature = "test-support"))]
     pub(crate) trust_fixture_extensions_for_test: bool,
+    /// Issue #7392 slice 3 seam: when `true`, the built-in first-party
+    /// package and handler registry are replaced by the omp-extended
+    /// variants (exact `read`/`write`/`edit`/`glob`/`grep` model surface).
+    /// Test-support only; the harness never sets it by default and the field
+    /// ships zero bytes in production builds.
+    #[cfg(any(test, feature = "test-support"))]
+    pub(crate) omp_coding_tools_for_test: bool,
     pub(crate) product_auth_ports: Option<RebornProductAuthServicePorts>,
     /// `first_party`-runtime extension factories the binary assembles
     /// (extension-runtime P2). Empty until concrete extension crates extract
@@ -842,6 +849,17 @@ impl RebornHostBindings {
         self
     }
 
+    /// Select the omp-extended built-in first-party package + handler
+    /// registry (issue #7392 slice 3): the stock builtin surface plus the
+    /// five omp capabilities under the exact `read`/`write`/`edit`/`glob`/
+    /// `grep` names. Test-support only; the default surface is
+    /// byte-identical to today.
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn with_omp_coding_tools_for_test(mut self) -> Self {
+        self.omp_coding_tools_for_test = true;
+        self
+    }
+
     /// Inject Reborn-native product-auth service ports.
     ///
     /// Production callers should provide durable implementations here. The
@@ -928,6 +946,8 @@ impl RebornHostBindings {
             network_http_egress_for_test: None,
             #[cfg(any(test, feature = "test-support"))]
             trust_fixture_extensions_for_test: false,
+            #[cfg(any(test, feature = "test-support"))]
+            omp_coding_tools_for_test: false,
             product_auth_ports: None,
             native_extension_factories: Vec::new(),
             channel_extension_bindings: Vec::new(),

crates/app/ironclaw_composition/src/product_capability.rs

@@ -949,6 +949,7 @@ mod tests {
             resource_profile: None,
             origin_gate_matrix: None,
             standard_op: None,
+            provider_tool_name: None,
         }
     }
 

crates/app/ironclaw_composition/src/runtime/capability_host/workspace_scoping_tests.rs

@@ -170,6 +170,32 @@ fn assert_tool_succeeded(outcome: &ToolOutcome, label: &str) {
     );
 }
 
+/// Assert the tool completed with a recoverable failure whose model-visible
+/// diagnostic contains `needle`. The omp glob/grep engines (⚠️ TEMPORARY
+/// benchmark override, issue #7392) error with the pinned `Path not found`
+/// text when the caller's workspace root does not exist yet — the v1 tools
+/// returned empty results for the same input.
+fn assert_tool_failed_containing(outcome: &ToolOutcome, label: &str, needle: &str) {
+    let Resolution::Done(done) = &outcome.resolution else {
+        panic!("{label} should complete, got {:?}", outcome.resolution);
+    };
+    let ironclaw_host_api::resolution::ToolVerdict::RecoverableFailure { diagnostic, .. } =
+        &done.verdict
+    else {
+        panic!(
+            "{label} should fail recoverably, got {:?}",
+            done.verdict
+        );
+    };
+    let text = diagnostic
+        .model_visible_text()
+        .unwrap_or_else(|| panic!("{label} failure must carry free-text cause, got {diagnostic:?}"));
+    assert!(
+        text.contains(needle),
+        "{label} failure diagnostic must contain {needle:?}, got {text:?}"
+    );
+}
+
 async fn read_composed_path(services: &RebornRuntimeStores, path: &str) -> Option<String> {
     let filesystem = services
         .local_runtime_for_test()
@@ -369,15 +395,16 @@ async fn fresh_caller_reads_an_empty_workspace_then_writes_into_it() {
         "newcomer",
         "builtin_glob",
         ironclaw_host_runtime::GLOB_CAPABILITY_ID,
-        serde_json::json!({ "pattern": "**/*" }),
+        // ⚠️ TEMPORARY benchmark override (issue #7392): `builtin.glob` now
+        // dispatches to the omp glob engine, whose pinned schema takes `path`
+        // (glob/file/dir to search) — there is no `pattern` field.
+        serde_json::json!({ "path": "**/*" }),
     )
     .await;
-    assert_tool_succeeded(&globbed, "glob on a fresh caller's workspace");
-    let globbed_output = globbed.output.expect("glob returns output"); // safety: test-only assertion in #[cfg(test)] module.
-    assert_eq!(
-        globbed_output["files"].as_array().map(Vec::len),
-        Some(0),
-        "a fresh caller's glob matches nothing, got {globbed_output}"
+    assert_tool_failed_containing(
+        &globbed,
+        "glob on a fresh caller's workspace",
+        "Path not found",
     );
 
     let grepped = invoke_workspace_tool_as(
@@ -388,12 +415,10 @@ async fn fresh_caller_reads_an_empty_workspace_then_writes_into_it() {
         serde_json::json!({ "pattern": "anything" }),
     )
     .await;
-    assert_tool_succeeded(&grepped, "grep on a fresh caller's workspace");
-    let grepped_output = grepped.output.expect("grep returns output"); // safety: test-only assertion in #[cfg(test)] module.
-    assert_eq!(
-        grepped_output["files"].as_array().map(Vec::len),
-        Some(0),
-        "a fresh caller's grep matches nothing, got {grepped_output}"
+    assert_tool_failed_containing(
+        &grepped,
+        "grep on a fresh caller's workspace",
+        "Path not found",
     );
 
     // The first write from that same fresh caller must succeed and become

crates/app/ironclaw_composition/tests/refreshing_capability_port_test_support.rs

@@ -157,6 +157,7 @@ impl HostRuntime for StubHostRuntime {
                     resource_profile: None,
                     origin_gate_matrix: None,
                     standard_op: None,
+                    provider_tool_name: None,
                 },
                 description_trust: Default::default(),
                 access: VisibleCapabilityAccess::Available,