open-standards/jouleclaw/jouleclaw-rs/Cargo.toml

[workspace]
resolver = "3"
members = [
    # Phase 1 — foundation
    "crates/jouleclaw-core",
    "crates/jouleclaw-topology",
    "crates/jouleclaw-energy",
    "crates/jouleclaw-fabric",

    # Phase 2 — cascade + format + persistence + wire
    "crates/jouleclaw-cascade",
    "crates/jouleclaw-loader-gguf",
    "crates/jouleclaw-pack",
    "crates/jouleclaw-history",
    "crates/jouleclaw-wire",

    # Phase 3 — backends + runtime
    "crates/jouleclaw-backend-reference",
    "crates/jouleclaw-backend-apple",
    "crates/jouleclaw-runtime",

    # Phase 4 — model tiers
    "crates/jouleclaw-liquid",   # L3 CfC SSM
    "crates/jouleclaw-prism",    # L3 1-bit / ternary BitNet
    "crates/jouleclaw-mrl",      # L2 Matryoshka embeddings
    "crates/jouleclaw-lmm",      # L3 multimodal (vision/text/audio)
    "crates/jouleclaw-ebm",      # L1/L3 energy-based constraint sat
    # gemma4 deferred — depends on joule-l1 + pattern-core (OpenIE IP).
    # Will port with surgery once jouleclaw-l1 ships a thin lawful-tier
    # trait surface in Phase 6.

    # Phase 5 — omni-modal generation (single crate; will split later)
    "crates/jouleclaw-omni",     # diffusion / stable-diffusion / musicgen
                                 # / whisper / gaussian3d / video / fusion
                                 # / 5 modalities / HAL / orchestrator /
                                 # server — ported wholesale from efficient-genai

    # Phase 6 — agentic v6 (plan/execute/diagnose/compose surface)
    "crates/jouleclaw-schema",
    "crates/jouleclaw-plan",
    "crates/jouleclaw-execute",
    "crates/jouleclaw-compose",
    "crates/jouleclaw-deberta",
    "crates/jouleclaw-diagnose",
    "crates/jouleclaw-edge-cli",
    "crates/jouleclaw-edge-client",

    # Phase 6 — net-new (the standard-defining moat)
    "crates/jouleclaw-prov",     # signed receipt per resolution
    "crates/jouleclaw-fresh",    # search-first + provenance envelope
    "crates/jouleclaw-mcp",      # rmcp-compatible + joule-mcp profile
    "crates/jouleclaw-cli",      # jclaw binary (Pi-class minimal harness)
    "crates/jouleclaw-edge",     # end-to-end edge demo + LawfulRegistryTier shim
    "crates/jouleclaw-verify",   # verifier-in-the-loop — AI proposes, verifier disposes
    "crates/jouleclaw-deterministic",  # L1 standard library — 30+ deterministic primitives

    # Pre-cascade resolver — registered, never-evicted lookup table.
    "crates/jouleclaw-lut",

    # L0.5 tool-compute tier — 484 deterministic, zero-hallucination pure-function tools.
    "crates/jouleclaw-tools",

    # L0.25 formula-first tier — structural-contrast relationship resolver.
    "crates/jouleclaw-formula",

    # L0.5 tool-tier — Tier adapter over jouleclaw-tools (registry of 484 deterministic tools).
    "crates/jouleclaw-tool-tier",

    # Regulatory-compliance wedge built on the energy substrate.
    "crates/jouleclaw-compliance",

    # Grammar-constrained decoding for L3/L4 model outputs.
    "crates/jouleclaw-decode",

    # L4.5 proof-solver tier — deterministic CSP at constraint-solver energy.
    "crates/jouleclaw-proof-tier",

    # Typed-signature programs — DSPy-style modules + compiler, pure Rust.
    "crates/jouleclaw-program",

    # L0.75 SSM-router tier — local intent classifier, picks downstream tiers.
    "crates/jouleclaw-ssm-router",

    # L1.25 GraphRAG tier — deterministic entity extraction + KG enrichment.
    "crates/jouleclaw-graph-rag",

    # L1.375 structural-contrast tier — second formula pass with graph context.
    "crates/jouleclaw-struct-contrast",

    # L1.5 SSM-reader tier — local reading-comprehension QA over passages.
    "crates/jouleclaw-ssm-reader",

    # L2 federation tier — multi-provider parallel search + fusion.
    "crates/jouleclaw-federation",

    # L2.5 neural-rerank tier — reranker (BM25 default; ColBERT/SPLADE plug-in).
    "crates/jouleclaw-rerank",

    # L1 local-index tier — BM25-shaped retrieval over an in-process corpus.
    "crates/jouleclaw-local-index",

    # L3 cheap-LLM tier — sync trait surface, EchoBackend default.
    "crates/jouleclaw-llm",

    # L4 cross-model verification tier — parallel dispatch + agreement checker.
    "crates/jouleclaw-verification-tier",

    # L5 learned-routing tier — episode-memory dispatch ordering (meta).
    "crates/jouleclaw-routing",

    # L6 agent tier — multi-step recursive cascade (decompose/dispatch/compose).
    "crates/jouleclaw-agent",

    # L7 reflection — offline meta-cognitive learning, promote/demote lessons.
    "crates/jouleclaw-reflection",

    # L8 self-tuner — five damped control loops over cascade dynamics.
    "crates/jouleclaw-tuner",

    # L9 supervisor — pathology detection (explosion/starvation/oscillation/inversion).
    "crates/jouleclaw-supervisor",

    # L10 governor — rolling joule budget, per-tenant quotas, kill switch.
    "crates/jouleclaw-governor",

    # Full-stack assembler — wires the tier crates into one runnable Runtime + control plane.
    "crates/jouleclaw-stack",

    # Yang→yin promotion — verified model answers become permanent deterministic facts (cost→0 with use).
    "crates/jouleclaw-promote",

    # Skill-compilation — verified resolutions become typed parameterized deterministic skills (a whole query class, no model).
    "crates/jouleclaw-skill",

    # Agent memory layer — CoALA-typed (working/episodic/semantic/procedural), content-addressed, signed-receipt-ready facts.
    "crates/jouleclaw-memory",

    # L1 fact extraction — deterministic regex extractor (hashtags / mentions / quoted / key:value) that composes with jouleclaw-memory.
    "crates/jouleclaw-extract",

    # Composed recall — memory BM25 top-N → jouleclaw-rerank → top-K (the Hindsight pattern, substrate-grade).
    "crates/jouleclaw-recall",

    # Consolidation — CoALA episodic→semantic, scheduled batch. Deterministic tag-clustering reference + trait for LLM abstraction.
    "crates/jouleclaw-consolidate",

    # Writer-critic pattern — fresh-context adversarial gate over (artifact, rubric) with a falsification pass. Builds on jouleclaw-verify.
    "crates/jouleclaw-critic",

    # Persisted run-state — durable typed DAG for multi-step resolutions (linear + branch + join), joule-stamped checkpoints, RunStore trait.
    "crates/jouleclaw-graph",

    # Approval gates — pause a dispatch for review before it runs; energy-shaped (only expensive model calls gated).
    "crates/jouleclaw-approve",

    # Cost-table model-bank dispatcher — route a query to the cheapest capable reasoner slot by measured joules.
    "crates/jouleclaw-dispatch",

    # Session tree — energy-attributed, branchable log of resolutions (Pi-style --fork).
    "crates/jouleclaw-session",

    # AGENTS.md / CLAUDE.md hierarchical discovery, joule-stamped per file read.
    "crates/jouleclaw-agents-md",

    # Progressive-disclosure 3-tier loading (Anthropic Skills-shape); per-tier joule cost is first-class.
    "crates/jouleclaw-disclosure",

    # Eval-driven skill engineering — Executor/Grader/Comparator with energy-as-pass-criterion (EnergyBudgetGrader).
    "crates/jouleclaw-evals",

    # Runtime-enforced control-flow gates over a Run, including EnergyBudgetGate (physics-grounded refusal).
    "crates/jouleclaw-gate",

    # Doctrine traits — BoundedError + FastStrong + Scored. The (ε,δ), fast-path-vs-strong, and score+explanation patterns.
    "crates/jouleclaw-bounded",

    # ai-verify port: Bolero/Kani/MIRI/Loom orchestration; joule-stamped ProofReport.
    "crates/jouleclaw-audit",

    # SonarSource cognitive-complexity reimpl over `syn` AST. Percentile-rank only, never threshold.
    "crates/jouleclaw-cognitive",

    # DDSketch quantile sketches with α-relative-error bounds; HDR opt-in for JVM interop.
    "crates/jouleclaw-quantile",

    # Probabilistic sketches: Count-Min, HyperLogLog++, BinaryFuse8 — all with (ε,δ) introspection.
    "crates/jouleclaw-sketch",

    # Drift detection: Page-Hinkley + DDSketch p99 two-detector. Distinguishes systematic drift from tail noise.
    "crates/jouleclaw-drift",

    # Geometric outlier detection: Tukey fences + Isolation Forest. Score + explanation, never boolean.
    "crates/jouleclaw-outlier",

    # Two-tier integrity: CRC32C (Castagnoli) fast-path + blake3 tamper-evident. Postgres 18 / RocksDB doctrine.
    "crates/jouleclaw-integrity",

    # Determinism-contract layer — wave-5: ai-scientist that delivers deterministically, not stochastically.
    #
    # Pre-registration: lock analysis plan + held-out data hash BEFORE proposer sees test set. OSF Replication Recipe shape.
    "crates/jouleclaw-prereg",
    # Inference pin: (model, weights blake3, kernel versions, seed, batch_invariant). Thinking Machines / SGLang batch-invariant kernels.
    "crates/jouleclaw-pin",
    # Lab backend trait: SiLA 2 + Opentrons + Emerald escape hatch. Submit/poll/fetch over a Protocol enum.
    "crates/jouleclaw-lab",
    # Formalization-faithfulness checker: (informal, formal) pair with typed FaithfulnessEvidence; trait + reference deterministic checker.
    "crates/jouleclaw-formalize",
    # Verification artifact: typed enum {FormalProof | PinnedContainer | LabTrace | ReplayJournal}, RO-Crate v1.0 / PROV-O aligned. ArtifactGate.
    "crates/jouleclaw-artifact",
    # MCP mutation tools for Run-graph traversal: list_nodes / get_node / append_child / mark_replicated / verify_artifact. The first scientific-MCP mutation verbs.
    "crates/jouleclaw-graph-mcp",

    # Wave-6 — sandbox teeth + DB-grade cost-model + transform-graphs + mech-interp.
    #
    # RATS RFC 9334 + EAT RFC 9711 attestation envelope.
    "crates/jouleclaw-attest",
    # OCI image + ORAS referrer content-addressed distribution substrate.
    "crates/jouleclaw-oci",
    # In-toto Statement + SLSA v1.1 Build-track Provenance predicate.
    "crates/jouleclaw-slsa",
    # Runtime claim + CapabilitySet (bwrap/gVisor/Kata/Firecracker/Wasmtime tags). The PinnedContainer sandbox teeth.
    "crates/jouleclaw-sandbox",
    # Cache policy — the 4-vendor 0.1× input-token cache-read convention (Anthropic / Google / OpenAI / DeepSeek).
    "crates/jouleclaw-cache",
    # Transform-graph: Entity / Transform / TransformResult PROV-O-tagged. First cross-tool transform-graph schema in the field.
    "crates/jouleclaw-transform",
    # Mech-interp FeatureActivation tuple + Neuronpedia identifier (Gemma Scope 2 / SAELens / TransformerLens alignment).
    "crates/jouleclaw-mechinterp",

    # Wave-7 — close the honest narrowings from wave-6.
    #
    # Signature verification (Ed25519, JWS, COSE_Sign1) — closes "no signature crypto in v1".
    "crates/jouleclaw-attest-sig",
    # Per-vendor TEE quote parsers (Intel TDX, AMD SEV-SNP, InTotoSlsa) — closes "no per-vendor TEE parsing".
    "crates/jouleclaw-attest-vendor",
    # CoRIM (IETF draft) CBOR reference-value format — closes "no CoMID/CoRIM hard dep".
    "crates/jouleclaw-corim",
    # SandboxEscapeBench harness + EnvironmentProbe trait — closes "no escape-proof claim" by measuring the gap.
    "crates/jouleclaw-sandbox-audit",
    # Maltego TRX XML adapter — closes "PROV-O JSON-LD only".
    "crates/jouleclaw-transform-trx",
    # Safetensors SAE loader for Gemma Scope 2 — closes "no SAE weight loading".
    "crates/jouleclaw-mechinterp-loader",

    # Wave-8 — comprehension positioning + audit-surface gaps (5-lens cross-talk).
    #
    # QueryIntent taxonomy + deterministic-first heuristic classifier with LLM seam.
    # Closes the "Priscilla 67%/2% unmeasurable on a JouleClaw deployment" gap.
    "crates/jouleclaw-intent",
    # Append-only Receipts log + by_agent / by_tool / by_tier / by_window / by_intent
    # queries. Closes the "no aggregated cost ledger" gap flagged by all 5 audit lenses.
    "crates/jouleclaw-ledger",

    # Wave-9 — JCR-1 Receipt Specification reference: canonical det-CBOR signed core
    # (RFC 8949 §4.2.1), COSE_Sign1 envelope (RFC 9052 / EdDSA), 10 conformance vectors,
    # plus the Python + Go independent verifiers and a Rust producer example. Closes
    # the wave-7 honest narrowing "no canonical serialization the spec — not the crate
    # — is the source of truth for."
    "crates/jouleclaw-jcr1",

    # Wave-10 — calibrated escalation gate: Platt-scaled probabilities + split-conformal
    # abstention + EscalationGate trait. Pure arithmetic, trusted-core safe. Closes the
    # 5-lens cross-talk audit's load-bearing correctness gap: "how does a tier know it
    # failed?" — answered with calibration math instead of a hand-rolled threshold.
    "crates/jouleclaw-calibration",

    # Wave-13 — out-of-process deny-by-default policy engine. Companion to the
    # existing escape-probe sandbox harness (which is a test, not a gate) and the
    # L10 governor (per-tenant quotas). Adopts NVIDIA OpenShell's Policy Engine
    # primitive into the JouleClaw open-standards surface: filesystem / network /
    # process granularity at binary/destination/method/path, deny-by-default,
    # live policy updates, full audit trail ready to feed jouleclaw-ledger.
    "crates/jouleclaw-policy",

    # Wave-14 — bridge from jouleclaw-policy AuditEvents to JCR-1-style signed
    # receipts: canonical det-CBOR + COSE_Sign1 envelope (alg=-8, Ed25519)
    # under the same steward identity as the cascade-receipt stream, plus an
    # in-memory and a JSONL sink and an idempotent PolicyShipper. Lifts every
    # policy decision into the same unified auditable log the joules / intent
    # stream already speaks. First-class jouleclaw-ledger integration is the
    # follow-up.
    "crates/jouleclaw-policy-receipt",

    # Wave-20 — persistent structured workspace for long-running L6 agents
    # (proposal #4). Content-addressed entries (BLAKE3), Ed25519-signed
    # manifests, in-memory + file-backed reference backends. Deterministic
    # state primitive — NOT an LLM dependency. NVIDIA-OpenShell "File
    # System" parity inside the JouleClaw open-standards surface.
    "crates/jouleclaw-workspace",

    # Wave-21 — out-of-process transport for the policy engine. Same
    # trait surface as the in-process reference, but the engine runs in
    # its own process (jclaw-policyd) and the agent talks to it over
    # line-delimited JSON on stdin/stdout. Closes the final outstanding
    # follow-up from the policy adoption proposal: a compromised agent
    # process cannot in-process patch the policy decision, because the
    # engine is on the other side of the kernel boundary.
    "crates/jouleclaw-policy-ipc",

    # Wave-22 — Hydra Core Vocabulary emitter. Turns a JouleClaw tool
    # surface into a hydra:ApiDocumentation JSON-LD document so a generic
    # third-generation agent client discovers what an instance exposes at
    # runtime without bespoke integration. Composes with the /vocab/v1
    # JouleClaw vocabulary shipped wave-22 #1.
    "crates/jouleclaw-hydra",

    # Wave-22 #3 — Minimal SHACL Core validator for JouleClaw wire forms.
    # Validates Receipt / PolicyReceipt / WorkspaceManifest / Action /
    # Decision against the v1 shape graph at /vocab/v1.shapes.ttl, before
    # an agent calls a tool. Local validation, no model-side guessing.
    "crates/jouleclaw-shacl",

    # Wave-22 #4 — Generic third-generation Hydra client. Reads any
    # hydra:ApiDocumentation, validates input against the linked SHACL
    # shapes, dispatches via a pluggable Transport, emits a JCR-1
    # ToolTouch per call. Closes the Kerduchi triangle: §13 vocabulary
    # + §14 Hydra discovery + §15 SHACL validation + this crate as the
    # agent-side consumer.
    "crates/jouleclaw-hydra-client",

    # Wave-22 #6 — WASM bindings for jouleclaw-hydra-client. Compiles
    # the generic third-generation agent client to a browser-loadable
    # WebAssembly module so /third-gen runs the REAL Rust client in
    # the browser, not a JavaScript stand-in. Excluded from the
    # native test sweep — wasm-only by definition.
    "crates/jouleclaw-hydra-client-wasm",

    # Wave-24 #1 — Validation contract. Planning artifact that lives
    # independently of code: typed assertions (each with a stable id
    # and a falsifiable check), features that claim them, mechanical
    # coverage matrix at validation time. The load-bearing primitive
    # that lets a multi-day run not drift. Source: Luke Marsden /
    # factory.ai "Missions" talk; same lineage as the Kerduchi
    # Gen-3 wave-22 architecture.
    "crates/jouleclaw-contract",

    # Wave-24 #3 — Three-role mission orchestrator
    # (Orchestrator / Worker / Validator) composing
    # jouleclaw-contract + jouleclaw-graph::Journal +
    # WorkerHandoff. Serial-by-default; opt-in parallel for
    # read-only fan-out.
    "crates/jouleclaw-mission",

    # Wave-25 — Bridge from jouleclaw-contract::ContractVerdict
    # to a JCR-1-shaped signed receipt (sibling schema
    # `verdict-receipt/1`). Same canonical det-CBOR +
    # COSE_Sign1 (alg=-8 EdDSA) envelope the cascade and
    # policy receipt streams use, so verdicts join the
    # unified auditable log. Closes the SPEC.md §16.5 promise
    # that "the verdict is the artifact a receipt links to".
    "crates/jouleclaw-contract-receipt",

    # Wave-25 #3 — Source-as-truth fetcher. Given a PackageSpec
    # (npm / PyPI / crates.io / GitHub / generic URL), fetch
    # the package's actual source into the workspace as a
    # content-addressed L1 entry; record source URL + bundle
    # hash + fetched-at as ClaimProvenance for the receipt
    # stream. Pluggable SourceFetcher trait; in-tree
    # StaticBundleFetcher is the deterministic reference (no
    # network in the trusted core). Implements JouleClaw's
    # "fresh > frozen" doctrine for third-party code.
    "crates/jouleclaw-source",

    # Wave-25 #4 — Scored review-revise loop. Composes (artifact,
    # Reviser, jouleclaw-bounded::Scored, threshold, max_iters)
    # into a bounded loop with a typed RevisionLog. The
    # `/grebloop` shape made into a first-class primitive; no
    # model invocation in the trusted core (Reviser is a trait).
    "crates/jouleclaw-revise",

    # Wave-26 #1 — Stuck-pattern detector over a run journal.
    # Typed StuckSignal { RepeatIntent | ExplicitComplaint |
    # Abandonment | ClusteredFailures | Solved } emitted by a
    # pluggable StuckDetector trait. Solved is the transition
    # marker the experiment layer harvests. Source: Lovable /
    # Benjamin Forsbeck "continuous learning at scale" talk.
    "crates/jouleclaw-stuck",

    # Wave-26 #3 — A/B causal-impact layer for context
    # injection. KnowledgeBank holds candidate entries;
    # inject_or_blank() emits Treatment or Control
    # deterministically per call_id; record_outcome() pairs
    # outcomes with assignments; effect_estimate() returns the
    # Welch's-t lift + 95% CI. prune_underperforming() drops
    # stale entries so context rot is detected and removed.
    "crates/jouleclaw-experiment",

    # Wave-27 #1 — System Use Case spec. The intent-side
    # companion to jouleclaw-contract::ValidationContract.
    # Jacobson-template fields (actor, goal, pre/post conditions,
    # main / alternative / error flows, business rules) as a
    # typed source artifact; to_assertions() mechanically
    # derives the verification rubric. Source: Martinelli
    # AI-unified-process talk.
    "crates/jouleclaw-usecase",

    # Wave-27 #2 — Spec-drift detector across (use_case,
    # test_set, impl_set). UseCaseRef tags + SpecCoverageReport
    # surface unverified postconditions, unverified business
    # rules, unreferenced tests, unreferenced impl. The
    # load-bearing failure mode every long-running AI project
    # eventually hits.
    "crates/jouleclaw-spec-coverage",

    # Wave-27 #3 — Brownfield reverse-engineering of UseCases
    # from existing code or text. UseCaseReverser trait + a
    # deterministic HeuristicReverser reference (Markdown
    # heading scan). The Martinelli brownfield workflow as a
    # first-class primitive; production extractors (LLM-backed
    # or language-aware) live behind the trait.
    "crates/jouleclaw-usecase-reverse",

    # Wave-28 #4 — OpenTelemetry GenAI semconv adapter for every
    # JouleClaw receipt shape (cascade Receipt, PolicyReceipt,
    # ContractVerdict, WorkerHandoffEvent, AgentFeedbackEvent).
    # Pure projection — no opentelemetry runtime dep; transport
    # lives in a follow-on crate. Operators ingest JouleClaw
    # receipts into Datadog/Grafana/Honeycomb via the same
    # pipeline they already run.
    "crates/jouleclaw-otel",

    # Wave-28 #1 — Pinned batch-invariant kernel registry +
    # verification gate. Closes the determinism story at the
    # physics layer: a backend that claims batch_invariant=true
    # MUST commit to a registered kernel set (SGLang
    # deterministic-inference; Thinking Machines reference set;
    # future Rust ports). BatchInvarianceGate refuses pins that
    # drift from the registry.
    "crates/jouleclaw-batch-invariant",

    # Wave-29 — A2A v1.0 protocol surface (Google → Linux
    # Foundation, April 2026). Typed AgentCard (signed JSON-LD
    # with Ed25519 signature stripes), Task / TaskResult call
    # surface, Hydra → AgentCard projection, well-known
    # discovery helper. Reuses jouleclaw-attest::AgentIdentity
    # + jouleclaw-attest-sig for keys; transport stays
    # downstream. Lets JouleClaw publish + consume agents over
    # the open agent-to-agent protocol.
    "crates/jouleclaw-a2a",

    # Wave-30 — Agent Performance Primitives. Speculative
    # branching for the L6 agent: dispatch cheap-tier and
    # expensive-tier in parallel, commit cheap if it verifies,
    # otherwise fall back to expensive (already running). Honest
    # energy accounting records both joules_committed_uj and
    # joules_speculative_lost_uj so operators see the true
    # speculation cost. The biggest single energy win missing
    # from JouleClaw's sequential cascade. Source: NVIDIA NeMo
    # Agent Toolkit APP + "Speculative Actions" paper.
    "crates/jouleclaw-agent-app",

    # Wave-31 — Unfolding-tool primitive. Expose ONE meta-tool
    # `discover_tools(category)` to the agent; reveal specific
    # tool descriptors only when asked. Cuts the fixed
    # prompt-token cost of every agent turn for deployments with
    # large tool catalogs (50-200 MCP tools). Token-budget-aware
    # fan-out with honest dropped-count reporting. Composes on
    # jouleclaw-mcp + jouleclaw-tools; pure types, no model
    # invocation. Source: Embable unfolding-tool + the 2026
    # convergence on meta-tools-with-disclosure.
    "crates/jouleclaw-unfolding",

    # Wave-32 — Perimeter primitive. Outbound-only RPC tunnel
    # for the Anthropic Code-with-Claude pattern: agent on
    # vendor side, tool execution / policy decisions / workspace
    # I/O / receipt writes stay inside the customer perimeter
    # via one signed outbound stream. Energy-aware framing
    # (JWP-shaped) + Ed25519 per-frame signatures + sequence
    # replay protection. Pure types + InMemoryTransport
    # reference; production transports (QUIC / JWP / gRPC) live
    # downstream.
    "crates/jouleclaw-perimeter",

    # Wave-33 — RunMutation channel. Mid-task instruction /
    # permission / budget updates to a live Run without
    # breaking the upstream KV cache. Anthropic Messages May
    # 2026 shape. Typed RunMutation enum split by
    # cache-stability (suffix-appending vs prefix-rewriting);
    # honest accounting of cache invalidations in the audit log.
    "crates/jouleclaw-msgsdk",

    # Wave-34 — A*-search runtime re-planner. Per-step
    # adaptation (vs jouleclaw-plan's one-shot CSP):
    # after every action, search the shortest joule-weighted
    # path of remaining actions. Pluggable PlanState trait;
    # deterministic tie-breaks; expansion-limit fallback.
    # Same shape Embable uses for goal-oriented agents.
    "crates/jouleclaw-replan",

    # Wave-35 — Workspace dep-graph verification. The
    # Spring-Modulith `verify()` pattern for Cargo: each crate
    # may declare an `allowed_in` allowlist of consumers under
    # [package.metadata.jouleclaw.boundaries]; the verifier
    # surfaces boundary violations + cycles. Pure types + TOML
    # parsing — no Cargo subprocess.
    "crates/jouleclaw-boundaries",

    # Wave-36 — Workspace dep-graph visualisation. Mermaid /
    # Graphviz DOT / PlantUML emitters over a
    # jouleclaw-boundaries::WorkspaceGraph + a typed Topology
    # summary (entrypoints, sinks, longest-path layers). CI
    # bakes the diagram into docs so the architecture map
    # stays accurate by construction.
    "crates/jouleclaw-workspace-map",

    # Wave-37 — Architecture Decision Record. The persistent
    # *why* behind a piece of architecture, in a typed form an
    # agent can read on every turn. Different slot from
    # jouleclaw-usecase (intent) and jouleclaw-contract
    # (rubric): an ADR captures why + how-it's-enforced.
    # Typed Enforcement (Lint / Test / Boundary / Manual),
    # path-glob lookup, Markdown round-trip. Source: Mikuel /
    # Spec27 talk on capturing decisions for humans and AI
    # alike.
    "crates/jouleclaw-adr",

    # Wave-38 — Ebbinghaus-style memory decay. Typed
    # DecayPolicy { half_life, max_age, min_observations,
    # frequency_weight, prune_threshold } + per-record
    # DecayedRelevance { score, recency, frequency, age }.
    # Composes with jouleclaw-memory; pure stats, no clock.
    # Microsoft Scout / Werner shape: unused fades, frequently
    # used reinforces. Different from jouleclaw-experiment
    # (A/B causal) and jouleclaw-drift (statistical drift).
    "crates/jouleclaw-memory-decay",

    # Wave-39 — Sandbox lifecycle protocol. Where
    # jouleclaw-sandbox carries CapabilitySet claims (what was
    # enforced), this adds the SandboxRuntime trait
    # (create / start / exec / kill / status / destroy) +
    # typed SandboxSpec + EgressPolicy. Pluggable backends
    # (Docker / K8s / gVisor / Firecracker / OpenSandbox /
    # local-process). Alibaba OpenSandbox shape, CNCF
    # Landscape June 2026; honest in-tree LocalProcessRuntime
    # reference tagged SandboxKind::Unattested.
    "crates/jouleclaw-sandbox-protocol",

    # Wave-40 — Sub-artifact annotation primitive. OpenAI
    # Codex annotations shape (Nov 2026): select a span in a
    # deliverable (TextRange / Cells / SlideRegion /
    # DomSelector / Custom) and ask the agent to explain or
    # edit just that span. PatchSet wire form lets the caller
    # apply edits without re-running the produce-loop.
    # Composes with jouleclaw-revise (scored iteration on
    # annotations) and jouleclaw-mission (annotations as
    # features).
    "crates/jouleclaw-annotate",

    # Wave-41 — Information Conservation Law as a typed claim.
    # The Datum / Spec27 keystone primitive for the
    # information-theory leg of the JouleClaw triangle. A
    # correct output contains AT LEAST the information of its
    # specification AND AT MOST (spec + delta + substrate).
    # Anything beyond that is hallucination — typed,
    # measurable, refusable. Pluggable InformationMeasure;
    # canonical-JSON byte-count reference; deterministic
    # verifier with three findings (BelowSpec, Hallucination,
    # MissingDelta) plus Conforming. The first leg of the
    # triangle, fully realized.
    "crates/jouleclaw-conservation",

    # Wave-42 — The cone. ConeCoord { complexity, novelty } +
    # NoveltyBand dispatch by information-distance to the
    # nearest known arrangement, NOT by heuristic. Pluggable
    # ComplexityEstimator + NoveltyEstimator; generic over
    # tier ids so any cascade adopts it (Datum's lut/
    # formulaic/stochastic + JouleClaw's L0..L4 ship as
    # defaults). The second leg of the triangle.
    "crates/jouleclaw-cone",

    # Wave-43 — The Oracle. Closure-gate Verdict { Pass |
    # Fail(reasons) }. Datum's loop-closer; the third leg of
    # the triangle. Distinct from existing scoring primitives
    # (jouleclaw-calibration, -critic, -verification-tier,
    # -evals): those produce scores, this produces a gate
    # decision. Typed FailReason (Compile / TypeCheck / Test
    # / Lint / Contract / Conservation / Custom);
    # CompositeOracle chains backends with short-circuit-on-
    # first-fail.
    "crates/jouleclaw-oracle",

    # Wave-44 — The Elicitor. Deterministic structured intake
    # at the front door. Walks a free-form RawRequest through
    # a typed list of Slots; emits ElicitationGaps one at a
    # time until every required slot is filled, then yields
    # an IntentDraft. The model — if used at all — lives at
    # the *question* (suggesting slot order), never at the
    # *answer*. Reference SlotWalker is pure data, no model,
    # no entropy; the determinism floor under Datum's G1-G5.
    # The fourth leg of the triangle (conservation + cone +
    # oracle + elicitor) — sets up wave-45's Datum lift.
    "crates/jouleclaw-elicitor",

    # Wave-45 — Datum, lifted into JouleClaw. The
    # demonstration crate: once the four load-bearing
    # primitives (-conservation / -cone / -oracle / -elicitor)
    # ship as standalone JouleClaw crates, Datum reduces to a
    # thin wiring layer. Datum-local types only: TemplateId,
    # Template (with body + typed Slot list), InMemoryStore,
    # lut_resolve (pure substitution), conservation_check
    # (bridges Intent → ConservationClaim → Verifier), and
    # dispatch_one_shot (cone-classify → resolve → conserve
    # → oracle-verify → DatumOutcome). The proof-by-
    # construction that the random-walk AI features (RAG /
    # database / geospatial / world model / agent harness)
    # are one-crate compositions over the triangle.
    "crates/jouleclaw-datum",

    # Wave-46 — context-store. SQLite + FTS5 full-text search
    # over agent / CLI / chat turns (microjoules per query, zero
    # LLM cost) + a typed FrozenSnapshot block with bounded
    # byte budgets whose mutations defer to the next session so
    # the LLM prefix-cache stays warm. Ingested from Hermes
    # Agent's documented memory pattern; the deterministic
    # recall floor between L0 cache and L2 embedding+retrieval.
    "crates/jouleclaw-context-store",

    # Wave-46 — adversarial-fuzz Oracle backend. Implements
    # jouleclaw-oracle::Oracle over a caller-supplied
    # deterministic FuzzProperty; each round seeds ChaCha20 with
    # (seed, round) to produce reproducible inputs; first failure
    # short-circuits with the counterexample carried as
    # FailReason::Custom. Composes via CompositeOracle alongside
    # type-checkers / linters / a Lean-backed Oracle. Ingested
    # from the OSS-maintainer crash-harness pattern (Valkey CVE
    # hunt); the substrate version is the typed harness, not the
    # agent that drives it.
    "crates/jouleclaw-oracle-fuzz",

    # Wave-47 — typed primitives for streaming / continuous-
    # interaction cascades. Tick + TickKind (Audio/Text/Video/
    # Marker including BargeIn) + StreamWindow + StreamSpec +
    # RollingConservationLedger. Ingested from the 2026 multi-
    # stream micro-turn pattern (Thinking Machines Interaction
    # Models May 2026, OpenAI gpt-realtime, Google gemini-live,
    # τ-Voice ICASSP-2026 benchmark): 200 ms ticks as the
    # canonical quantum, < 150 ms barge-in deadline, gate-per-
    # window verification. Pure types — no audio codec, no
    # network, no model.
    "crates/jouleclaw-stream",

    # Wave-47 — gate-per-window Oracle for streaming cascades.
    # StreamOracle trait + WindowVerdict { Pass | Fail | Yield |
    # NeedMore } — Yield is load-bearing for barge-in. Reference
    # backends: AlwaysPassStream, BargeInDetector, PerTickAdapter
    # (lifts a per-request jouleclaw-oracle::Oracle into the
    # streaming surface), CompositeStreamOracle (dominance-rank
    # composition: Fail > Yield > NeedMore > Pass; always runs
    # every backend, unlike the per-request composite that
    # short-circuits).
    "crates/jouleclaw-stream-oracle",

    # Wave-48 — typed UI-output ladder. UiOutput { Static |
    # Declarative | Generative } + ComponentRegistry +
    # CapabilityPolicy + a stable MIME so streaming ticks carry
    # UI outputs without extending the tick schema. Ingested
    # from the 2026 generative-UI convergence: MCP Apps (Jan
    # 2026), AG-UI, A2UI (Google), Open-JSON-UI all settled on
    # the same three rungs with iframe sandboxing for the
    # generative rung. Pure types — no renderer, no sandbox
    # runtime; per-rung Oracles + JCR-1 ui-output/1 receipt live
    # downstream.
    "crates/jouleclaw-ui-output",

    # Wave-48 — per-rung Oracle backends for jouleclaw-ui-output.
    # StaticUiOracle (component_id ∈ registry), DeclarativeUiOracle
    # (descriptor.kind ∈ allow-list), GenerativeUiOracle
    # (CapabilityPolicy + byte budget + deny-substring list). All
    # implement the per-request jouleclaw-oracle::Oracle trait so
    # they compose via CompositeOracle and lift into the streaming
    # cascade via jouleclaw-stream-oracle::PerTickAdapter.
    "crates/jouleclaw-ui-oracle",

    # Wave-49 — typed cross-standards binding for the JouleClaw /
    # Sandbox / Joule-Code triad. CrossStandardBinding records
    # the three reference ids per trace + the verifiable
    # invariants (trace-id equality, joule agreement within
    # tolerance, worst-counter energy provenance ACROSS standards,
    # trusted-stewards set, sandbox grants ⊆ cascade
    # authorisation). Wire-layer composition via JCR-1-shaped
    # canonical JSON + BLAKE3 content addressing; no cross-
    # workspace path deps. The substrate auditors check when
    # proving a trace went through all three standards
    # consistently.
    "crates/jouleclaw-cross-binding",

    # Wave-50 — streaming coding operations. The missing
    # integration between wave-47's streaming substrate and
    # Joule-Code's coding-op cargo. CodingEvent { TypedChar |
    # SuggestionAppeared | SuggestionAccepted | SuggestionRejected
    # | CursorMoved | DiagnosticDelta } sits in tick bytes under
    # canonical MIME `application/x.jouleclaw-coding-event+json`.
    # CodingOpMaterializer accumulates accepted suggestions across
    # windows + materializes them into a content-addressed
    # MaterializedCodingOp matching joule-code-cargo's wire shape;
    # the wave-47 streaming substrate doesn't change.
    "crates/jouleclaw-coding-stream",

    # Wave-54 — event-sourced agent substrate. Append-only event
    # log (BLAKE3-chained, content-addressed) + deterministic
    # replay via content-addressed model+tool cache (ActiveGraph
    # 2026 convention: LLM key = BLAKE3 of (system, user_messages,
    # model_id, tool_defs, output_schema); tool key = (tool_id,
    # args_hash)) + lineage trace. Ingested from ActiveGraph
    # (Nakajima, arxiv 2605.21997, May 2026, v1.0 May 2026), the
    # uncontested 2026 SOTA event-sourced agent runtime. The
    # substrate JouleClaw's receipts + cascade pointed at but
    # didn't name as one typed primitive.
    "crates/jouleclaw-event-log",

    # Wave-55 — Lean-backed Oracle. Implements Oracle over a
    # Lean 4 toolchain; the candidate's source is written to a
    # temp file, lean is invoked, exit code maps to
    # Verdict { Pass | Fail }. Composes with the fuzz Oracle in
    # a CompositeOracle: fuzz finds counterexamples, Lean proves
    # their absence. The Axiom-Math-style code-with-proof gate
    # the verified-code/1 schema's Lean variant has been
    # pointing at.
    "crates/jouleclaw-oracle-lean",

    # Wave-56 — Sandbox runtime as a Tier wrapper. Wraps any
    # jouleclaw-cascade::Tier in a SandboxRuntime so dispatches
    # happen inside a bounded isolation unit with explicit
    # capability grants + a sandbox attestation alongside the
    # cascade Answer. Trait + reference PassthroughRuntime here;
    # real isolation backends (sandbox-rs Wasmtime / Firecracker /
    # TEE) implement the same trait downstream. The Rust-source
    # binding the wave-49 wire-layer composition was deferring.
    "crates/jouleclaw-sandbox-tier",

    # Wave-57 — Typed multimodal-view primitive. The 2026
    # multimodal-lakehouse pattern (Pixeltable computed columns +
    # LanceDB storage) expressed as vendor-neutral types:
    # MultimodalSchema + ColumnType (Image/Video/Audio/Document/
    # Json/Scalar/Vector) + ComputedColumn (declarative
    # transformation, BLAKE3 cache key for incremental
    # evaluation) + MaterializedIndex (vector / FTS, auto-synced
    # to source) + IteratorView (parent → child explosion) +
    # VersionedQuery + BackendStore trait. Reference
    # InMemoryStore.
    "crates/jouleclaw-multimodal-view",

    # Wave-58 — Citation-at-storage-boundary primitive. Typed
    # CitationAllowList of permitted source ids the runtime
    # enforces BEFORE any cited output is written to durable
    # storage. Fabricated citations are dropped at the boundary,
    # not post-hoc filtered. Pairs with the worst-counter
    # provenance rule + JCR-1 receipts. The conservation
    # primitive lifted from Symdue's claim, made vendor-neutral.
    "crates/jouleclaw-citation-whitelist",

    # Wave-59 — RFC 8785 JSON Canonicalization Scheme. JSON
    # track for JCR-1: callers choose CBOR+COSE_Sign1 for
    # binary-efficient interop, or JCS for JSON-native ecosystems
    # (web tooling, OTel exporters, transparency-log APIs that
    # take JSON). Matches the 2026 convergence (Sello, Traceseal,
    # OrgKernel — all use Ed25519 + JCS + SHA-256 or similar).
    "crates/jouleclaw-jcs",

    # Wave-60 — OTel GenAI semantic conventions. Typed gen_ai.*
    # attribute namespace + jouleclaw.* substrate extensions
    # under a separate namespace so they don't collide with the
    # spec. Used by jouleclaw-otel to surface JouleClaw runs in
    # every OTel-compatible backend (Phoenix, Langfuse, Datadog,
    # Honeycomb) without per-vendor adapters. Tracks the OTel
    # GenAI working group spec — the 2026 default substrate for
    # LLM observability.
    "crates/jouleclaw-otel-genai",

    # Wave-61 — OpenInference attribute mapping. Arize's OTel-
    # aligned semantic-convention SUPERSET adds AI-specific
    # attributes the bare gen_ai.* spec doesn't cover: retrieval
    # operations, agent reasoning steps, eval results, tool
    # invocations. JouleClaw runs surface in Arize Phoenix,
    # Langfuse, OpenLIT, and any OpenInference-aware tool.
    "crates/jouleclaw-openinference",

    # Wave-62 — Merkle transparency log. Append-only log of
    # receipt content hashes with RFC 6962-style Merkle tree +
    # inclusion proofs + consistency proofs between tree states.
    # BLAKE3 hash (JouleClaw-native) with RFC 6962 leaf / node
    # domain separators (0x00 / 0x01) preserved. The auditor-
    # grade primitive Sello (Notarized Agents, arxiv 2606.04193)
    # named as the missing tier in JouleClaw's stack: any party
    # proves a receipt was included without trusting the log
    # operator.
    "crates/jouleclaw-transparency-log",

    # Wave-63 — Theorem-prover Elicitor. Wraps 2026 SOTA Lean 4
    # provers (Leanstral, Goedel-Prover-V2, DeepSeek-Prover-V2,
    # Kimina-Prover, Aristotle) as candidate PRODUCERS that
    # jouleclaw-oracle-lean (the gate) then accepts/rejects.
    # Trait-based; per-prover configs are typed; MockProverBackend
    # for tests; ProverEnsemble falls through across multiple
    # producers. The substrate proposes, the type-checker
    # disposes.
    "crates/jouleclaw-prover-adapter",

    # Wave-64 — HPKE (RFC 9180) confidential JCR-1 receipts.
    # X25519-HKDF-SHA256 + HKDF-SHA-256 + ChaCha20-Poly1305.
    # Encrypts a receipt body so only the designated recipient
    # reads it; verifier proves authenticity offline against the
    # outer envelope. The Sello / Notarized-Agents confidential
    # payload pattern.
    "crates/jouleclaw-hpke",

    # Wave-65 — Attestor role typing. SelfAttested |
    # Independent | Quorum. AcceptancePolicy { Any |
    # AtLeastIndependent | Independent | Quorum } checks a
    # receipt's declared role against pinned mediator sets +
    # quorum thresholds. The Notarized Agents doctrine:
    # independent attestation > self-attestation when the
    # receipt is consumed off-host.
    "crates/jouleclaw-attestor",

    # Wave-66 — OpenAI-compatible HTTP-endpoint types. Drop-in
    # /v1/chat/completions + /v1/embeddings + /v1/models. Every
    # OpenAI-SDK-shaped client speaks to JouleClaw with no code
    # changes; cascade dispatches cheapest-tier-first under the
    # hood.
    "crates/jouleclaw-openai-api",

    # Wave-67 — TokenPowerBench-compat energy benchmark surface
    # (AAAI 2026 arxiv 2512.03024). Types + JSON output schema
    # for per-scenario joules_per_token + tokens_per_second +
    # honest worst-counter provenance.
    "crates/jouleclaw-tokenpower-bench",

    # Wave-68 — FrugalGPT (Chen et al., arxiv 2305.05176) three-
    # component primitives. Router (selects backend) +
    # AnswerScorer (rates output) + StopJudger (accept vs
    # escalate). FrugalCascade composes the three into one
    # solve(query) call with full audit trail.
    "crates/jouleclaw-frugalgpt",

    # Wave-69 — Cache-Augmented Generation (CAG). Preloaded KV
    # cache as a typed first-class object: knowledge corpus
    # encoded ONCE into KV cache; queries reuse the cached
    # prefix without retrieval. Trait-based KvCacheBackend so
    # vLLM APC / SGLang RadixAttention / FusionRAG / CacheBlend
    # each conform. The 2026 RAG alternative for fixed-corpus
    # tasks (arxiv 2412.15605).
    "crates/jouleclaw-cag",

    # Wave-70 — Backend determinism probes. Verifies byte-
    # identical outputs across repeat-identical / batch-
    # invariance / seed-diversity checks. Emits a
    # DeterminismReport with the declared mode (vLLM-batch-
    # invariant / SGLang-deterministic / Thinking-Machines
    # batch-invariant / LLM-42 verified speculation / default)
    # so the cascade routes deterministic queries only to
    # backends that pass.
    "crates/jouleclaw-determinism-check",

    # G1 — Categorical typed shapes per Wang & Buehler 2026
    # (arxiv 2606.01444). Schema, Copresheaf I_t: S → Set,
    # Category of Elements, Endofunctor, Left Kan Extension
    # Lan_u I_t. Adds the schema-mutation case the existing
    # event-log + graph (fixed-schema endofunctors) didn't have.
    # Pairs with jouleclaw-revise::information_criteria (MDL,
    # AIC) — those are the gate criterion; this crate is the
    # algebra.
    "crates/jouleclaw-category",

    # G2 — Prime Intellect Verifiers env exporter. Adapter that
    # emits a typed VerifiersEnvManifest a Python harness can
    # publish via `prime env push`. Maps JouleClaw (Oracle,
    # EventLog, Sandbox, JCR-1 receipt) → Verifiers (Rubric,
    # state, harness, signed transcript). Closes Lewis Tunstall's
    # explicit 2026 "no Rust-native receipt-sealed envs" gap.
    "crates/jouleclaw-verifiers-export",

    # R3 — Recursive Self-Aggregation scaffold. 2026 test-time-
    # compute pattern Lewis Tunstall named. Generator (N
    # candidates from a seed) + Scorer + Aggregator (top-K → one)
    # in a bounded loop with accept-threshold + max-rounds.
    # Composes with jouleclaw-revise (Reviser can be a
    # Generator's inner step) and the Scored trait from
    # jouleclaw-bounded.
    "crates/jouleclaw-rsa",

    # R4 — Benchmark shells. Typed shapes + reference graders
    # for AlgoTune (Press et al. NeurIPS 2025, $1-per-task
    # numerical-program speedup; empirically validates the
    # cascade thesis "cheap models with iteration > frontier
    # single-shot") and CodeClash (Press et al. 2026, two
    # agents writing competing code in arenas, multi-round
    # iteration). GeometricSpeedupGrader +
    # RoundWinRatioGrader.
    "crates/jouleclaw-bench-suite",

    # Harness economics — the joint, ungameable metric joules-AND-dollars
    # per VERIFIED fix, with the skill-compilation repeat curve that bends
    # the marginal cost of recurring work toward zero. The honest answer to
    # SWE-bench-%/$-per-task. Reuses cascade + skill; local=energy-priced,
    # remote=call-priced.
    "crates/jouleclaw-harness-econ",

    # Adapter 3 — HF Hub model-weight downloader. Thin wrapper
    # around the upstream hf-hub crate with BLAKE3 content-hash
    # of every downloaded file (for receipts) + a typed
    # DownloadedFile shape. The enabler for jouleclaw-embed-candle
    # and jouleclaw-rerank-candle.
    "crates/jouleclaw-hf-hub",

    # Adapter 4 — Local embedder via Candle. BGE / sentence-bert
    # family through candle_transformers::models::bert::BertModel.
    # Pooling (CLS/Mean/Last) + L2 normalization. Tokenizer via
    # the `tokenizers` crate. The L2 cascade tier's no-API
    # backend.
    "crates/jouleclaw-embed-candle",

    # Adapter 5 — Local cross-encoder reranker via Candle.
    # bge-reranker / ms-marco MiniLM family. BERT base + Linear
    # classification head; tokenises (query, document) pairs;
    # returns [(doc_index, score)] sorted descending. The L2.5
    # cascade tier's no-API backend.
    "crates/jouleclaw-rerank-candle",

    # Paid / hosted embedding-API backends — OpenAI, Voyage,
    # Cohere, Jina hosted. Sibling to jouleclaw-embed-candle
    # (local). L2 cascade tier's any-cloud backends.
    "crates/jouleclaw-embed-api",

    # Paid / hosted rerank-API backends — Cohere Rerank v3,
    # Voyage rerank, Jina hosted reranker. Sibling to
    # jouleclaw-rerank-candle (local). L2.5 cascade tier's any-
    # cloud backends.
    "crates/jouleclaw-rerank-api",

    # Skills-curator loop — an agent rewrites a skill definition
    # from observed session traces. Vincent's OpenClaw dot.skills
    # self-improvement loop as typed Rust. Composes jouleclaw-llm
    # (backend) + the SkillDefinition / SessionTrace shapes.
    "crates/jouleclaw-skill-curator",

    # Coherence / waffling detector — typed score over an agent
    # trace surfacing when the agent is bullshitting (hedge
    # density, vague pronouns, fillers, repeated 6-grams).
    # Distinct from jouleclaw-stuck (pattern-matching for
    # repeat-intent); semantic-quality detector for the
    # supervisor's pathology probe set.
    "crates/jouleclaw-coherence",

    # ActiveGraph (Nakajima 2026, arXiv 2605.21997) ingest —
    # fork + structural-diff over jouleclaw-event-log. Replay
    # determinism JouleClaw already had; fork-at-any-event and
    # typed diff between branched projections is what this crate
    # adds. Composes with the existing event-log + content-
    # addressed cache for full event-sourced agent state.
    "crates/jouleclaw-event-fork",

    # Graphify (safishamsi/graphify, 2026) ingest — corpus →
    # typed graph (GraphBuilder + LexicalCodeBuilder), community
    # detection (CommunityDetector + ConnectedComponents),
    # token-budgeted subgraph query (BudgetedQuery +
    # LexicalBudgetedQuery). Reuses jouleclaw-graph-rag's
    # Entity/Edge/KnowledgeGraph primitives; deterministic-first
    # reference impls (tree-sitter + Leiden wireable as later
    # features).
    "crates/jouleclaw-codegraph",

    # Bitemporal claim primitive — BitemporalClaim<T> with
    # valid_time + transaction_time, supersession + lineage,
    # as_of(reference_time, txn_cutoff) projection. Closes the
    # absent-time gap in the 2026 knowledge-management stack
    # (none of Notion/Obsidian/NotebookLM/Karpathy-wiki/mem0/
    # LangMem/Cognee/GraphRAG carry valid_time; only Zep's
    # Graphiti does). Generic primitive: composes into
    # jouleclaw-memory (Fact gains canonical bitemporal
    # envelope) and jouleclaw-fresh (RetrievedClaim gains
    # valid-window). Reference time lives on the QUERY (recorded
    # on AsOfReceipt), so the resolution is forever stamped
    # with the temporal frame the consumer chose.
    "crates/jouleclaw-bitemporal",

    # Adjudication primitive — typed "who held the ruler, how,
    # at what cost, independent of the seller?" stamp.
    # AdjudicatedClaim<T> + VerificationStamp + Adjudicator +
    # VerificationMethod (Mechanical / Statistical / Human /
    # Crowd / External / SelfClaimed) + VerificationDecision
    # (Pass / Refute / Inconclusive). Load-bearing query:
    # `unbuyable()` — at least one Pass from an adjudicator
    # independent of the seller. The substrate expression of
    # the conversation's "a signal only counts if the bar is
    # adjudicated by someone other than the seller." Distinct
    # from jouleclaw-prov (who CREATED the artifact) and
    # jouleclaw-verify (in-process verification harness).
    "crates/jouleclaw-adjudication",

    # Recombination provenance — typed UpstreamRef +
    # Origin (Original | Recombination { upstream }) +
    # RecombinationStamp + BorrowedAdjudication. Records what
    # fraction of an artifact came from each upstream and how
    # much NOVELTY MASS remains (the fraction needing fresh
    # adjudication). Load-bearing query:
    # `BorrowedAdjudication::unbuyable()` — passes via inherited
    # path (fully covered by upstream unbuyable stamps) OR
    # fresh path (claim has its own independent stamp). Closes
    # the conversation gap: AI coding "works" because it
    # inherits open-source verification, but borrowed stamps
    # don't auto-cover novelty. Resemblance alone never passes.
    "crates/jouleclaw-recombination",

    # RCE ports 1/2/5 — Reason + Currency + Foreman.
    # Port of joulesperbit/crates/rce primitives that JouleClaw
    # lacked: first-class verifiable PURPOSE (Reason), first-
    # class verifiable FRESHNESS (Currency), and the typed
    # ForemanResponse { Resolved | Defer | Reject } escalation
    # envelope + LlmForeman adapter wrapping any LlmBackend.
    "crates/jouleclaw-reason",
    "crates/jouleclaw-currency",
    "crates/jouleclaw-foreman",

    # RCE port 3 — HandlerSpec 10-variant typed interpreter.
    # The load-bearing "compile AI into determinism" primitive:
    # Passthrough / Constant / Project / Validate / Wrap /
    # Pipeline / AlwaysEscalate / AlwaysError / IfHasField /
    # GeneratedRust (the last carries source for audit + a
    # safe fallback the runtime actually executes). HandlerResult
    # { Ok | Escalate | Error } as the three corners every
    # handler resolves to. JSON-described, content-hashable,
    # sealable into JCR-1 receipts. Significantly richer than
    # jouleclaw-skill::Procedure (which has only 3 variants).
    "crates/jouleclaw-handler-spec",

    # RCE port 4 — 9-step typed PromotionStep gate +
    # PromotionRecord + InMemoryPromotionPathStore. Makes the
    # promotion discipline auditable: PrototypeWritten →
    # SchemaValidated → CurrencyChecked → RustGenerated →
    # CompilerPassed → PropertyTested → FormallyVerified →
    # ReasonAttached → Promoted. No skipping, no backtracking,
    # sealed at Promoted. Each gate carries an evidence_hash
    # the substrate can later re-verify. Composes with
    # handler-spec (body being promoted), currency (gate 3),
    # reason (gate 8).
    "crates/jouleclaw-promotion-path",

    # RCE port 5 (originally tagged port 6 in audit) — Hindsight
    # engine. Observation → Insight → Recommendation lifecycle
    # for NODE-LEVEL graph mutation. Four FeedbackKind classes
    # (FixTheCode / AdaptTheGraph / InvalidateReason /
    # ParadigmPressure) classify the correction; six
    # RecommendedAction variants (ReplaceHandler / AddNode /
    # RemoveNode / Reroute / RevalidateReason /
    # RecordParadigmPressure) carry the graph-mutation payload.
    # Distinct from jouleclaw-reflection (cascade-tier scheduling
    # Promote/Demote/KeepAsIs); the two compose — reflection
    # reorders the cascade, hindsight rewrites the graph.
    "crates/jouleclaw-hindsight",

    # Tool-call repair primitive — absorbs Ahmad Awais (Command
    # Code, ~600B tokens/day) insight: open-weight LLMs
    # (DeepSeek V4 Pro, Kimi K2, MiniMax) have specific tool-call
    # mis-shaping variations they REPEAT 50+ times instead of
    # correcting from a returned schema error. The fix is at the
    # HARNESS layer: detect deterministically, repair the call,
    # return the result + a hint so the model learns. Provides
    # DetectPattern (6 variants) + RepairAction (5 variants) +
    # RepairRule + RepairLibrary + a `presets` module with
    # reference rules for the variations Ahmad called out.
    "crates/jouleclaw-toolcall-repair",

    # KL-delta accumulator (Ahmad's TASTE primitive). Records
    # ONLY THE DELTA between what a model would do by default
    # and what the user is observed to prefer. Distinct from
    # jouleclaw-skill-curator (one-shot LLM rewrite) — taste is
    # continuous, deterministic, per-repo. Includes the typed
    # MERGE primitive Ahmad explicitly punted on: conflicts
    # surface as typed MergeConflict shapes for human review or
    # strategy-driven auto-resolution. PR-reviewable markdown
    # emission so the file lives in git, not in a model.
    "crates/jouleclaw-taste",

    # Agentic authorization telemetry — tracks Abdel Fang
    # (Open A2A) OTel semconv proposal (issue 180). Typed
    # AgentIdentity with Ed25519-anchored capability declaration,
    # AuthorizationDecision { Allow | Deny { reason } },
    # AuthorizationSpan with agent.id + agent.public_key +
    # capability + decision path + trust/drift scores.
    # Capability-first allow-list semantics — system prompt as
    # security guardrail is structurally precluded. Closes the
    # gap between jouleclaw-prov (CLAIM provenance) and
    # agent-action authorization.
    "crates/jouleclaw-agent-auth",

    # Typed workflow-vs-agent dispatch decision. Encodes the
    # operational cheat-sheet (high-stakes / well-defined I/O /
    # cost-sensitive → Workflow; reasoning-heavy / high edge-case
    # volume / human-in-loop available → Agent) as deterministic
    # rules. Returns a Recommendation with typed RuleHit
    # rationale (auditable: "why did this query go through the
    # agent?"), detects drift across two ProcessCharacteristics
    # snapshots, and emits Hybrid recommendations when
    # saturation signals (high support count + low unobserved
    # branches) suggest the agent's resolutions are ready to
    # promote to a deterministic workflow.
    "crates/jouleclaw-dispatch-profile",

    # Typed (model, harness-conditions) tuple as substrate
    # identity. Same model behaves differently under different
    # harness conditions: tool-call repair on/off, permission
    # mode, multimodal attachments, coherence supervisor,
    # decoding grammar, system-prompt overlay. Routing /
    # reflection / dispatch crates key on the tuple, not on
    # bare model id. content_hash() is the substrate cache key;
    # wire() emits a compact model@hash[..12] tag for spans.
    "crates/jouleclaw-harness-profile",

    # RCE port — engine-internal CommsFabric. Per-node bounded
    # FIFO mailboxes + tick-driven heartbeat liveness monitor.
    # Distinct from jouleclaw-wire / jouleclaw-mcp /
    # jouleclaw-a2a (external protocol surfaces); this is the
    # runtime's internal fabric for node-to-node messaging +
    # supervisor liveness detection. Substrate-clean: caller
    # supplies tick (no Instant::now).
    "crates/jouleclaw-comms-fabric",

    # RCE port — brownfield onramp. Take an existing codebase
    # corpus + produce typed knowledge: CodebaseMap of modules
    # / functions / external deps, InferredReason with typed
    # ReasonConfidence (Documented / Institutional / Inferred /
    # Lost — never guess), ReverseCompileResult naming the
    # explicit holes (missing reasons, currency gaps). Distinct
    # from jouleclaw-codegraph (which builds a queryable graph
    # for retrieval); brownfield understands existing code at
    # its own level so a deterministic substrate can be
    # retrofitted on top. Substrate-clean: accepts
    # &[(PathBuf, String)]; v0 Rust lexical extractor handles
    # the demonstrator (jouleclaw-rs itself).
    "crates/jouleclaw-brownfield",

    # Agentic-authorization telemetry (OTel semconv proposal:
    # identity + capability + trust/drift score + fine-grained
    # decision path on spans).
    #
    # jouleclaw-trust — per-agent trust + drift scoring ledger fed
    # by typed TrustSignals (policy denies, capability violations,
    # verification failures). Pairs the bounded trust score with
    # jouleclaw-drift's two-detector classification over the score
    # series. A behavioral prior, never a security boundary.
    "crates/jouleclaw-trust",
    # jouleclaw-otel-authz — projects AgentIdentity (did:key +
    # public key), the requested capability, TrustSnapshot scores,
    # and jouleclaw-policy's TracedDecision into a parent authz
    # span + one child span per DecisionStep. Pure projection on
    # top of jouleclaw-otel's SpanData.
    "crates/jouleclaw-otel-authz",
    "crates/jouleclaw-jcp",
    "crates/jouleclaw-corpus",
]

[workspace.package]
version = "0.1.0"
edition = "2024"
license = "Apache-2.0"
repository = "https://github.com/Transaction-Science/open-standards"
authors = ["JouleClaw Contributors"]
description = "JouleClaw — energy-optimised AI runtime. Apache-2.0 Rust reference implementation."

[workspace.dependencies]
# Core
serde = { version = "1", features = ["derive"] }
serde_json = "1"
serde_cbor = "0.11"
# Held at 0.0.12: 0.0.13 parses with noyalib 0.0.5, which carries RUSTSEC-2026-0333.
serde_yml = "0.0.12"
toml = "1.2"
thiserror = "2"
blake3 = "1"
sha2 = "0.11"
base64 = "0.23"

# Wave-7 — close-the-gaps deps
ciborium      = "0.2"        # CBOR for EAT-CWT + CoRIM (IETF RATS WG canonical CBOR codec)
ed25519-dalek = { version = "3", features = ["alloc"] }          # Ed25519 signing — rustcrypto, widely audited
# Held at 0.41: 0.42 reworks name/text/entity decoding to str; the GGUF/OpenVINO and TRX readers need re-proving, not recompiling.
quick-xml     = "0.41"       # Maltego TRX XML round-trip (serde-feature)
safetensors   = "0.8"        # HuggingFace SAE weight loader (Gemma Scope 2 alignment)

# DB-grade verification + error tracking primitives (wave-4 ingest)
crc32c = "0.6"                                    # Castagnoli CRC32C — Postgres 18 / RocksDB default
sketches-ddsketch = "0.4"                         # α-relative-error quantile sketches (Masson 2019)
hdrhistogram = "7"                                # JVM-interop opt-in (Gil Tene)
cardinality-estimator = "1"                       # HLL++ with sparse representation
probabilistic-collections = "0.7"                 # Count-Min Sketch reference
xorf = "0.13"                                     # BinaryFuse{8,16,32} static membership
syn = { version = "3", features = ["full", "visit"] }  # AST walk for cognitive complexity
regex = "1"
chrono = { version = "0.4", default-features = false, features = ["clock", "serde", "std", "wasmbind"] }
uuid = { version = "1", features = ["v4", "v5", "v7", "serde", "js"] }

# Optional HTTP (feature-gated in jouleclaw-tools)
reqwest = { version = "0.13", default-features = false, features = ["rustls", "json"] }

# Numerics + tensors
half = "2"
bytemuck = { version = "1", features = ["derive"] }

# Async runtime
tokio = { version = "1", features = ["rt-multi-thread", "macros", "sync", "fs"] }
async-trait = "0.1"

# Telemetry
tracing = "0.1"

# Hardware energy telemetry — pinned where production-ready (from wave-1 research)
nvml-wrapper = "0.13"  # NVIDIA discrete GPU, production-ready

# Testing
proptest = "1"
insta = "1"
tempfile = "3"

[profile.release]
opt-level = 3
lto = "fat"
codegen-units = 1
panic = "abort"
strip = "symbols"

[profile.release-with-debug]
inherits = "release"
debug = true
strip = "none"