apomesh-vertical-deep-research-projection

apomesh-vertical-deep-research-projection is the dependency-light sibling of the Deep-Research vertical. It carries deep research’s tier-4 open-vocabulary consumer surfaces — the pieces that project and verify deep research’s io.descoped.deep-research extension signals — without any of the strategy, skills, or two-mode verification machinery that lives in the heavy crate. It exists so a dependency-light consumer (the Tauri console, the worker) can register those surfaces without pulling the whole deep-research runtime into its build. Touch it when you add or change how deep research’s coverage signals are rendered or gated.

Position in the workspace

• Layer: vertical (a substrate-coupled use-case’s projection sibling). See Agent configuration for the tier-4 open-vocabulary / reproducibility plane these surfaces feed.
• Split rationale (#851 D2/D5): the console depends only on the substrate-types core, never the heavy apomesh-substrate / apomesh-orchestrator trees, so the desktop build stays small. The deep-research runtime crate pulls those heavy trees, so it cannot enter the console — but the enrichment handler must register in both projection composition roots (the orchestrator daemon and the console). The handler is pure projection (fn(&ExtensionEnvelope) -> ProjectedView) with no runtime dependency, so it lives here, in a crate that depends only on the light type core — mirroring the substrate / substrate-types split itself.
• Depends on: apomesh-substrate-types (the ExtensionHandler trait + ProjectedView, the Tool + registry types) and apomesh-protocol (ExtensionEnvelope), plus serde_json, async-trait, tokio-util. It depends on none of the heavy vertical runtime by design.
• Consumed by: ui/control-plane (registers the handler at console boot), apomesh-worker (registers the verification unit at worker boot), and apomesh-orchestrator (declares it; the orchestrator-bin root registers the handler through the heavy crate’s re-export). The heavy apomesh-vertical-deep-research re-exports every item verbatim, so its public API is unchanged.

What it owns

• The coverage-audit enrichment handler — CoverageAuditHandler, a pure ExtensionHandler that turns the (io.descoped.deep-research, coverage.audit) event the deep-research post-verify hook emits into an honest one-line summary plus decoded detail. Pure (no IO / clock / randomness); a malformed payload degrades to a structural fallback, never a panic.
• The coverage-schema verification unit — CoverageSchemaCheckUnit, a sandboxed Tool the substrate’s predicate evaluator dispatches so a bespoke agent can gate a session on a version-pinned Predicate::Extension. It reads only the explicit predicate args (no session reach-through), emits the substrate-decoded { pass, score, feedback } verdict, and fails closed on a malformed shape — never a coerced pass.
• The two per-vertical registrars — register_deep_research_extension_handlers (called at both projection roots) and register_deep_research_verification_units (called at the worker root, where the predicate evaluator lives). A new deep-research handler or unit joins one registrar and every consumer sees it for free.
• The open-vocabulary identifiers — DEEP_RESEARCH_VENDOR_ID (the reverse-DNS vendor namespace) and the COVERAGE_AUDIT_VARIANT / COVERAGE_SCHEMA_VARIANT variant ids.

It does not own the deep-research strategy, the tier-keyed skills, or the mechanical / LLM-judge verification logic — all of that lives in the heavy apomesh-vertical-deep-research crate.

Public surface

Verified against HEAD. A curated map, not the full rustdoc.

• CoverageAuditHandler — the pure coverage-audit ExtensionHandler; project(&ExtensionEnvelope) renders summary + detail with a structural fallback.
• register_deep_research_extension_handlers — register every deep-research handler into an ExtensionHandlerRegistry; called at both projection roots.
• CoverageSchemaCheckUnit — the sandboxed coverage-schema evaluation unit (a Tool); checks a supplied output object carries every required_keys field.
• register_deep_research_verification_units — register every deep-research unit into an ExtensionPredicateRegistry; called at the worker root, fail-closed on the [[extension_vendors]] allowlist.
• DEEP_RESEARCH_VENDOR_ID — the reverse-DNS vendor namespace (io.descoped.deep-research).
• COVERAGE_AUDIT_VARIANT / COVERAGE_SCHEMA_VARIANT — the two variant ids the handler and the unit key on.

Usage

Both surfaces register at boot in their composition root — neither is called directly by agent code. A projection root (the console, the orchestrator daemon) registers the handler; the worker registers the verification unit:

use apomesh_substrate_types::extension::ExtensionHandlerRegistry;
use apomesh_substrate_types::predicate::ExtensionPredicateRegistry;
use apomesh_vertical_deep_research_projection::{
    register_deep_research_extension_handlers, register_deep_research_verification_units,
};

// At a projection root (console / orchestrator daemon): enrich the
// deep-research coverage-audit event beside the first-party handlers.
let handlers = ExtensionHandlerRegistry::new();
register_deep_research_extension_handlers(&handlers)?;

// At the worker root: land the coverage-schema unit so a
// `Predicate::Extension` resolves to a real, sandboxed evaluation unit.
let units = ExtensionPredicateRegistry::new();
register_deep_research_verification_units(&units)?;
# Ok::<(), apomesh_substrate_types::extension::ExtensionError>(())

To launch a deep-research session that emits these signals against a running stack, see Deep research.

Related

• Reference: apomesh-vertical-deep-research (the heavy sibling that owns the strategy + skills and re-exports this crate), apomesh-substrate-types (the ExtensionHandler / Tool / registry homes), apomesh-protocol (ExtensionEnvelope).
• Build: Deep research — launch a session and read its verified report.
• Concepts: Agent configuration — the tier-4 open-vocabulary / reproducibility plane these surfaces feed.