@warble/ir-spec 0.7.0 → 0.8.0

package/index.d.ts

@@ -3,7 +3,7 @@
  * `docs/spec/ir-schema.md` (bundled here as `ir-schema.md`) for why this is exported without being
  * meant to be imported by a dispatcher.
  */
-export declare const IR_VERSION: "0.7";
+export declare const IR_VERSION: "0.8";
 
-declare const _default: { IR_VERSION: "0.7" };
+declare const _default: { IR_VERSION: "0.8" };
 export default _default;

package/index.js

@@ -8,6 +8,6 @@
  * exported for tooling that wants the value without re-parsing `package.json` (e.g. a script
  * checking a dispatcher's declared peer range against the spec it names).
  */
-export const IR_VERSION = "0.7";
+export const IR_VERSION = "0.8";
 
 export default { IR_VERSION };

package/ir-schema.md

@@ -1,4 +1,4 @@
-# Warble IR — the compile contract (`warble_ir_version: 0.7`)
+# Warble IR — the compile contract (`warble_ir_version: 0.8`)
 
 The IR is the **language-neutral seam** between the Warble front-end (`warble compile`) and any
 back-end. The v1 reference back-end is the Claude Code CLI target (`warble dispatch`, Rust); other
@@ -6,26 +6,33 @@ runtimes are other thin back-ends. Both sides depend only on this document — n
 internals.
 
 `warble compile <project-dir> -o ir.json` reads a Warble project (profile + components +
-context binding) and emits **one** IR JSON document with `"warble_ir_version": "0.7"` — the
+context binding) and emits **one** IR JSON document with `"warble_ir_version": "0.8"` — the
 current, live contract the compiler emits today. (Earlier drafts of this doc kept the per-step-tier
 shape in a separate "v0.2 (proposed)" section; that has been folded into the contract below now
 that it is implemented and wired into the built core/dispatcher.) The shape below is what the
 dispatcher consumes.
 
+> **Composition boundary:** v0.8 adds the resolved `components[].entrypoint` and optional
+> `llm_calls[].component_calls` facets specified by
+> [`component-composition.md`](./component-composition.md). Every shipped reader retains them. The
+> Agent SDK and composed Codex local orchestrate targets realize narrow slices with dispatcher-owned
+> isolated child runs and their documented runtime budgets; unsupported shapes and other targets preflight wall-hit instead of
+> dropping or inlining an edge.
+
 > Scope note (v0.3+): context binding is **fine-grained**. The host injects a `ContextLoader`
 > selected for the binding kind, and the compiler **evaluates** every `context_precondition`
 > against that bound context — not merely validates vocabulary membership. The IR records passing
-> checks in `precondition_result.checks`; a Wren-project adapter also fills
-> `context_binding.resolved` with metrics/dimensions/grains and lineage, while a raw-source adapter
-> answers the constitutive probes and an external adapter emits no resolved block. A precondition
-> that is answerable-and-false, or that the adapter **cannot answer** at all, is a
+> checks in `precondition_result.checks`; a `prepared` binding also fills
+> `context_binding.resolved` with metrics/dimensions/grains and lineage, while a raw-source binding
+> answers the constitutive probes and an external one emits no resolved block. A precondition
+> that is answerable-and-false, or that the loader **cannot answer** at all, is a
 > loud compile-time fail — so an emitted IR only ever contains passing checks. See
 > [`context_precondition`](#context_precondition-closed-predicate-vocabulary) and the
 > [v0.3 binding](#v03--fine-grained-context-binding) section below.
 >
-> The coarse `context_binding.project` locator is **retained**: Wren-project back-ends use it to run
-> `wren`, while other binding kinds give it adapter-specific meaning. Fine-grained binding is
-> additive, not a replacement.
+> The coarse `context_binding.project` locator is **retained**: a back-end uses it to name the layer
+> it queries, and each binding kind gives it its own meaning. Fine-grained binding is additive, not a
+> replacement.
 
 ---
 
@@ -41,11 +48,11 @@ version on anything else — there is no best-effort or partial parse of an unre
 
 | Consumer | Accepted `warble_ir_version` | Where the accepted version is declared |
 | --- | --- | --- |
-| `core` (`warble compile`) | emits `0.7` | the `"warble_ir_version"` literal in `core/src/compile.rs` |
-| `dispatcher/claude-code-cli` | `0.7` | `SUPPORTED_IR_VERSION` in `dispatcher/claude-code-cli/src/ir.rs` |
-| `dispatcher/vercel` | `0.7` | `SUPPORTED_IR_VERSION` in `dispatcher/vercel/src/emit.rs` |
-| `dispatcher/claude-agent-sdk` | `0.7` | `SUPPORTED_IR_VERSIONS` in `dispatcher/claude-agent-sdk/src/ir.ts` |
-| `dispatcher/codex-local` | `0.7` | `SUPPORTED_IR_VERSION` in `dispatcher/codex-local/src/ir.ts` |
+| `core` (`warble compile`) | emits `0.8` | the `"warble_ir_version"` literal in `core/src/compile.rs` |
+| `dispatcher/claude-code-cli` | `0.8` | `SUPPORTED_IR_VERSION` in `dispatcher/claude-code-cli/src/ir.rs` |
+| `dispatcher/vercel` | `0.8` | `SUPPORTED_IR_VERSION` in `dispatcher/vercel/src/emit.rs` |
+| `dispatcher/claude-agent-sdk` | `0.8` | `SUPPORTED_IR_VERSIONS` in `dispatcher/claude-agent-sdk/src/ir.ts` |
+| `dispatcher/codex-local` | `0.8` | `SUPPORTED_IR_VERSION` in `dispatcher/codex-local/src/ir.ts` |
 
 Each back-end copies this value rather than importing it from `core` or from another back-end: a
 back-end shouldn't need a Rust dependency edge just to know a version string, and independent copies
@@ -62,7 +69,7 @@ is informational, not itself an input enforcement check.
 `@warble/claude-agent-sdk` and `@warble/codex-local` additionally each declare a `peerDependencies`
 entry on [`@warble/ir-spec`](../../packages/ir-spec) — a dedicated npm package whose own version *is*
 the IR version (see [IR version to npm version mapping](#ir-version-to-npm-version-mapping) below) —
-plus an advisory `"warble": { "irVersion": "0.7" }` field in the same `package.json`. This makes the
+plus an advisory `"warble": { "irVersion": "0.8" }` field in the same `package.json`. This makes the
 IR version a dispatcher speaks visible in the npm dependency graph without opening the package.
 **Neither dispatcher imports `@warble/ir-spec`** — the peer is a declaration, not a dependency edge,
 and each dispatcher keeps enforcing its own copy of `SUPPORTED_IR_VERSION`(S) above. `@warble/ir-spec`
@@ -92,7 +99,7 @@ spec title, there are **eighteen** locations that must agree:
 | 7 | `dispatcher/vercel/src/emit.rs` `MAX_SUPPORTED_IR_VERSION` | Advisory | `core/tests/ir_version_lockstep_tests.rs` |
 | 8 | `dispatcher/claude-agent-sdk/src/manifest.ts` `MIN_SUPPORTED_IR_VERSION` | Advisory | `core/tests/ir_version_lockstep_tests.rs` |
 | 9 | `dispatcher/claude-agent-sdk/src/manifest.ts` `MAX_SUPPORTED_IR_VERSION` | Advisory | `core/tests/ir_version_lockstep_tests.rs` |
-| 10 | This document's title (`warble_ir_version: 0.7`) | Spec | `core/tests/ir_version_lockstep_tests.rs` |
+| 10 | This document's title (`warble_ir_version: 0.8`) | Spec | `core/tests/ir_version_lockstep_tests.rs` |
 | 11 | `packages/ir-spec/package.json` `"version"` (mapped `x.y` -> `x.y.0`) | Producer (npm) | `core/tests/ir_version_lockstep_tests.rs` |
 | 12 | `packages/ir-spec/index.js` `IR_VERSION` | Advisory | `core/tests/ir_version_lockstep_tests.rs` |
 | 13 | `dispatcher/claude-agent-sdk/package.json` `peerDependencies["@warble/ir-spec"]` (mapped `x.y` -> `x.y.x`) | Declaration | `core/tests/ir_version_lockstep_tests.rs` |
@@ -169,7 +176,7 @@ back-end accepts, and must be regenerated rather than merely re-read.
 
 ```jsonc
 {
-  "warble_ir_version": "0.7",
+  "warble_ir_version": "0.8",
   "profile": "orders-analytics",          // profile.yml `profile:`
   "context_binding": {                    // resolved from profile `context:` + context/binding.yml
     "project": "examples/jaffle-wren",    // coarse path to a wren project (retained for back-ends)
@@ -183,7 +190,7 @@ back-end accepts, and must be regenerated rather than merely re-read.
       "dimensions": [ { "name": "status", "temporal": false }, { "name": "order_date", "temporal": true } ],
       "time_dimensions": ["order_date"],
       "models": ["customers", "orders", /* … */],
-      "lineage": { "nodes": 15, "edges": 12, "resolvable": true }   // summary only; full DAG stays in the adapter
+      "lineage": { "nodes": 15, "edges": 12, "resolvable": true }   // summary only; the full DAG stays in the bound document
       // when the project carries consumer artifacts, `lineage` additionally reports
       //   "consumers": { "queries": 2, "dashboards": 1 }            // query:/dashboard: node counts
       // and, when construction had to degrade (e.g. a consumer's SQL didn't parse),
@@ -256,6 +263,7 @@ narrower capability must list it explicitly alongside (or instead of) the broade
 ```jsonc
 {
   "id": "generate_dashboard",
+  "entrypoint": true,                    // resolved mount eligibility; defaults true in authoring
   "verb": "generate_dashboard",
   "type": "analytical",                   // analytical | assertive | mutating | constitutive | orchestrating
   "realization_kind": "skill",            // required in component.yml; a profile mount may replace it
@@ -266,26 +274,16 @@ narrower capability must list it explicitly alongside (or instead of) the broade
   "context_requirements": [               // human-readable shape strings — always emitted, may be []
     "a wren project (semantic layer) to build dashboards over"
   ],
-  "context_precondition": [               // structured predicates — always emitted, may be []
-    { "predicate": "has_metric" },
-    { "predicate": "has_groupable_dimension" }
-    // "args" is optional per entry, e.g. { "predicate": "has_metric", "args": { "name": "revenue" } }
-    // predicate must be from the closed vocabulary — see below. Compile validates membership AND
-    // evaluates each predicate against the bound context via the injected ContextLoader.
-  ],
+  "context_precondition": [],              // dashboard delegates panel data-shape checks to answer_query
   "params": [                             // always emitted, may be []
-    { "name": "topic_default", "bind": "optional", "default": "overview" },  // profile-bound (bind)
-    { "name": "connection", "source": "runtime-injected" }                    // runtime-injected, not in git
+    { "name": "topic_default", "bind": "optional", "default": "overview" }   // profile-bound (bind)
   ],
   "binds": {                              // additive; present only when >=1 bind-family param has a value
     "topic_default": "overview"           // mount didn't supply one, so this is the declared default
   },
   "precondition_result": {                // per-predicate evaluation outcome (v0.3, see §checks)
     "status": "pass",                     // always "pass" in emitted IR — a failing predicate loud-fails
-    "checks": [                           // one entry per declared context_precondition, in order
-      { "predicate": "has_metric", "outcome": "pass" },
-      { "predicate": "has_groupable_dimension", "outcome": "pass" }
-    ]
+    "checks": []                          // one entry per declared context_precondition, in order
   },
   "brief": "…shared framing for every step, placeholders substituted…",  // additive; present only when authored — see below
   "slots": [                              // additive; present only when the component declares slots — see below
@@ -298,10 +296,11 @@ narrower capability must list it explicitly alongside (or instead of) the broade
   "prompt_fragment": "…rendered skill instructions…",  // see §prompt rendering
   "llm_calls": [                          // per-step tier, order preserved from component llm_steps
     { "name": "plan_dashboard", "tier": "strong", "conditional": false, "when": null,
-      "consumes": [], "produces": "query_plan",
+      "consumes": [], "produces": "dashboard_plan",
       "prompt": "<plan_dashboard.md rendered, placeholders substituted, no ## header>" },
     { "name": "compose_layout", "tier": "cheap", "conditional": false, "when": null,
-      "consumes": ["query_plan"], "produces": "dashboard_summary",
+      "consumes": ["dashboard_plan"], "produces": "dashboard",
+      "component_calls": [{ "alias": "answer", "component": "answer_query" }],
       "prompt": "<compose_layout.md rendered>" }
     // a conditional step instead carries e.g. "conditional": true, "when": { "guard": "on_failure", "target": "generate_sql" }
     // — see `llm_calls[].when` below
@@ -311,13 +310,13 @@ narrower capability must list it explicitly alongside (or instead of) the broade
     // `llm_calls[].produces_exclusive` below
   ],
   "guardrails": [                         // resolved; `locked` is the normalized lock-state
-    { "name": "read_only_execution", "locked": true }
-    // `scope`/`threshold` appear only when authored; their meaning is guardrail/target-specific,
-    // e.g. another component may emit { "name": "artifact_write", "locked": true, "scope": "." }
+    { "name": "read_only_execution", "locked": true },
+    { "name": "artifact_write", "locked": true, "scope": "." }
   ],
   "trigger": { "kind": "one_shot" },      // one_shot | scheduled | event
-  "required_capabilities": [              // union of component declarations
-    "sql_execution:read_only", "genbi_build", "llm:strong", "llm:cheap"
+  "required_capabilities": [              // declarations plus shape-implied requirements
+    "render_contract", "artifact_write", "llm:per_step_tier", "llm:strong", "llm:cheap",
+    "component_invocation"
   ],
   "borrowed_actions": [],
   "eval_ref": "generate_dashboard.eval",  // legacy reference string; retained for back-compat
@@ -327,7 +326,10 @@ narrower capability must list it explicitly alongside (or instead of) the broade
   },
   "effect": {
     "render_blocks": [
-      { "type": "chart", "fields": {} }, { "type": "table", "fields": {} }, { "type": "kpi_card", "fields": {} }
+      { "type": "kpi_card", "fields": { "label": "string", "value": "number|string", "unit": "string?", "delta": "number?" } },
+      { "type": "table", "fields": { "columns": "string[]", "rows": "row[]" } },
+      { "type": "chart", "fields": { "chart_type": "bar|line|pie|area|scatter", "x": "string", "series": "string[]", "rows": "row[]" } },
+      { "type": "definition", "fields": { "sql": "string", "source_tables": "string[]", "filters": "string[]" } }
     ],
     "outcome": {
       "kind": "none"                      // none | assertion | mutation | dispatch — stays this 4-value union
@@ -533,6 +535,36 @@ scopes a step's own call at the back-end.
   "prompt": "…" }
 ```
 
+#### `entrypoint` and `llm_calls[].component_calls` (since v0.8)
+
+The composition contract adds two protocol fields:
+
+```jsonc
+{
+  "id": "answer_query",
+  "entrypoint": false,
+  "llm_calls": [
+    {
+      "name": "compose_dashboard",
+      "component_calls": [
+        { "alias": "answer", "component": "answer_query" }
+      ]
+    }
+  ]
+}
+```
+
+`entrypoint` is a required resolved mount property, defaulting to `true` at the authoring boundary
+for profiles written before it existed. `component_calls` is omitted when empty and otherwise is a
+step-local static allowlist; its aliases resolve to unique mounted component identities after
+overlays. A non-empty list also adds the required runtime-provided `component_invocation`
+capability to the component and the declaring step's effective requirements.
+
+The compiler rejects duplicate mounted identities, invalid or duplicate aliases, missing targets,
+self-calls, and cycles before emitting the IR. See
+[`component-composition.md`](./component-composition.md) for the authoritative validation,
+preparation, runtime, envelope, and compatibility rules.
+
 #### `guardrails[].scope` / `threshold` and the `locked`/`overridable` normalization
 
 `scope` and `threshold` are passthrough fields — each is present in the resolved IR **only when
@@ -679,6 +711,57 @@ does not hold, the slot is removed rather than filled with any variant: an instr
 withheld capability is worse than no instruction. Evaluating it is the host's job; compile only
 carries it.
 
+**Who resolves a slot.** Compile never picks a variant — every one travels in the IR — so a consumer
+must substitute before a prompt is sent. Two back-ends do: the Agent SDK back-end takes the host's
+table through its dispatch input, and the `warble` CLI resolves the IR document once, before any
+target-specific type deserializes it, from repeated `--slot NAME=VARIANT` flags (`--slot NAME=`
+removes a slot whose condition does not hold). A back-end that cannot yet resolve refuses an IR
+declaring slots rather than emitting the placeholder.
+
+**A slot nobody answers takes its `default` — with one exception.** A slot carrying `present_when`
+and no answer is a loud failure, not a default: `default` covers "no opinion on the wording", and it
+cannot cover "no opinion on whether this exists at all". Defaulting there is precisely the failure
+the field exists to prevent.
+
+**A consumer that records an IR hash to identify a run now records something narrower than it
+looks.** Before slots, compile finished every string, so an IR hash fixed the prompt as well. Now
+two runs can share one and have sent different prompts, so anything that needs to identify what a
+model was told has to fingerprint the assembled prompts instead — and each back-end has to produce
+it, since only dispatch knows the answer.
+
+The contract is: **a digest per named prompt surface, plus a total over all of them**, taken as late
+as possible — over the text that actually reaches the runtime, not over the plan a host may then
+rebuild. The question is excluded (it is the caller's text and varies per turn by design, so
+including it would make every turn unique and answer nothing). Per-turn content supply is excluded
+too, and deliberately: it is not an IR construct, and when it lands it needs its own decision about
+whether it joins the digest.
+
+The surfaces, per back-end:
+
+| Back-end | Surfaces |
+| --- | --- |
+| Agent SDK, from a plan | the driver's `systemPrompt` and each named subagent's prompt — what the single and split paths send as built. On the single-tier collapse path a component's `prompt_fragment` is folded into `systemPrompt` and `llm_calls[].prompt` is not read, so a one-step component's text is covered through the driver surface. |
+| Agent SDK, per turn at run time | the `systemPrompt` and subagent prompts of every turn the runtime sends, reported one fingerprint per turn, plus — for a step bound to a local OpenAI-compatible endpoint — the role/content messages it posts, keyed by position and role, since such a step builds no SDK options at all. This is the only truthful source for the staged and hybrid-tool paths: a staged step's options carry a runtime preamble ahead of the step prompt, and the hybrid-tool driver composes a prompt from the step list that appears in no plan field. A plan-derived digest **must not** claim those. |
+| Claude Code CLI | not yet produced — filed as a follow-up |
+| vercel | not yet produced — filed as a follow-up |
+| codex-local | not yet produced — filed as a follow-up |
+
+**Take it from a plan only when the host sends that plan's options as built.** Otherwise take it at
+the point of send. A host that rebuilds its options — replacing the system prompt, say — and then
+records a plan-derived digest has recorded a prompt nobody received, which is worse than recording
+nothing: it reads as evidence.
+
+A back-end that grows a new prompt-carrying surface and does not add it to its digest narrows the
+fingerprint silently. That is the same shape as an unresolved slot placeholder, one layer out, which
+is why the surfaces are listed here rather than left implicit in each implementation.
+
+**Display paths differ, and the two manifests differ from each other.** The rule above protects a
+model; a reader is not one, so a display renders an unanswered condition's default rather than
+refusing — what it shows is what the default binding would say, never a promise about what will be
+sent. Whether a display needs resolving at all depends on its schema: the `warble manifest` output
+omits prompt text structurally and so needs none, while the Agent SDK back-end's own manifest
+carries each step's prompt and therefore resolves like any other consumer of that text.
+
 #### `assets` (additive since v0.7)
 
 `object[]` — **omitted entirely (not present as a key, not `[]`) unless the component declares
@@ -696,6 +779,28 @@ file's bytes and `bytes` its length; **both are computed at compile and neither
 could only rot, and silently replacing one would leave the author trusting a field that means
 nothing.
 
+**An IR's assets travel beside it.** Because content is not carried (below) and no consumer can
+re-read a component directory — there is none at dispatch, and a Hub component was resolved over the
+network at compile — `warble compile` writes each component's asset content into a sibling directory
+of the IR it emits: for `<dir>/ir.json`, into `<dir>/ir.assets/<component-id>/<authored path>`.
+Nothing is created for a project that declares no assets.
+
+Dispatch lands them at the authored relative path inside the agent's working directory and verifies
+every file against its `hash`. **A manifest path is re-validated on the way in, twice.** Absolute
+paths and `..` segments are refused as text; then the resolved location is checked against the
+canonicalized root, so a syntactically clean path that reaches outside through a symlinked directory
+is refused too — on the write side and on the read side. Compile checks what an author wrote against
+the component directory, but an IR is a document that can arrive from anywhere, and the working
+directory it lands in may be a real project somebody else has written to. Without both checks a
+manifest is an arbitrary file write. **Both failure modes are loud**: a manifest entry with no file in the
+travelling directory, and one whose content no longer hashes to the recorded value, each stop the
+dispatch, and nothing is landed at all rather than part of a component's set. Silence there is the
+defect this closes — a component that declared its files and received none.
+
+The consequence to know: **the artifact that travels is the IR plus that directory.** Copying an
+`ir.json` on its own and dispatching it fails loudly rather than running without the files, which is
+the right direction but is a new failure to recognise.
+
 **Content is not carried.** This is the deliberate contrast with [`slots`](#slots-additive-since-v07)
 above, and the two together define the line: a slot variant is prompt text, so its content is read
 into the IR and composed into a prompt; an asset is a file that must be present on disk when the
@@ -870,7 +975,7 @@ Warble differentiator.
 `warble compile ./examples/demo-agent -o ir.json` against the demo project in this repo must produce an
 IR equal to `examples/demo-agent/ir.golden.json` (committed alongside, used as the core's fixture test).
 `warble compile ./examples/render-demo -o ir.json` similarly must equal
-`examples/render-demo/ir.golden.json`. Both goldens use the current v0.7 contract:
+`examples/render-demo/ir.golden.json`. Both goldens use the current v0.8 contract:
 `context_requirements`, `context_precondition`, and `params` are always present (possibly `[]`, as
 on `dashboard`), while `eval` appears only on `generate_dashboard` and `scope: "."` appears only on
 render-demo's authored `artifact_write` guardrail.
@@ -881,8 +986,9 @@ render-demo's authored `artifact_write` guardrail.
 
 Where v0.2 carried a coarse project path and *declared* preconditions, v0.3 made the front-end
 **probe the bound context**. A host injects a `ContextLoader` (the trait lives in core, sans-IO).
-The same binding crate now supplies `MdlContext` for Wren projects and `RawSourceContext` for raw
-constitutive input; hosts may supply other adapters.
+Warble ships `PreparedContext` — which reads a projection the layer's own owner wrote, so any
+semantic format binds without Warble speaking it — plus `RawSourceContext` for raw constitutive
+input and `ExternalContext` for a layer held elsewhere; a host may supply its own loader.
 
 ## What lands in the IR
 - For a Wren project, `context_binding.resolved` carries the compiler's introspection result: `metrics`
@@ -905,13 +1011,14 @@ answerable only over a declared metric (see the `context_precondition` section a
 source through `RawSourceContext`; an MDL-only adapter returns unanswerable for both.
 
 ## `blast_radius` (read path)
-The adapter self-builds a lineage DAG (`model → relationship / cube → metric / dimension`, plus view
-references), and core computes `LineageGraph::blast_radius(node)` = the transitive downstream closure
-+ worst `Severity` (`Semantic > Structural > Compatibility > None`). This is exposed as read-only
-analysis on the read path, and the same query also serves as an enforcement gate for *mutating*
-applies. This is the one `provided_by: warble`
-capability — see `capability-model.md` §6/§7.1, whose coarse-binding loud-fail is now lifted because
-fine-grained binding exists.
+The bound layer's owner builds the lineage DAG (`model → relationship / cube → metric / dimension`,
+plus view references) **and** computes each node's downstream closure with a severity **rank** on its
+own scale, supplying both in the prepared-context document. Warble computes neither: it compares a
+supplied rank against an authored ceiling and decides `allow` / `escalate` / `block`, refusing
+outright when no analysis was supplied. That gate is exposed as read-only analysis on the read path
+and as the enforcement gate for *mutating* applies. It remains the one `provided_by: warble`
+capability, on those grounds rather than on computing the closure — see `capability-model.md` §6/§7.1
+and `blast-radius.md`.
 
 ---
 
@@ -985,6 +1092,15 @@ instead of trusting the prose alone:
 Both are additive optional fields on the existing envelope/block shapes above, not a new block type;
 a renderer or consumer that doesn't recognize them ignores them.
 
+When a render envelope crosses a future same-profile component-call boundary, it is wrapped as the
+`kind: render` success variant and validated against the **callee's** block contract. A
+non-rendering terminal JSON value (including the current tabular
+`{columns, rows, summary, verified, definition}` shape) is wrapped as `kind: value`. The child does
+not render or persist either form; only the root invocation owns those effects. The normalized
+wrapper and failure vocabulary are specified in
+[`component-composition.md`](./component-composition.md#6-target-neutral-request-and-result-envelopes),
+and are not part of the resolved v0.8 IR.
+
 ## 3. Renderer registry — `render(target, blocks[]) → artifact`
 Warble owns the **contract + a reference renderer (HTML)**; runtimes register/override per target.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warble/ir-spec",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "license": "Apache-2.0",
   "type": "module",
   "description": "The Warble IR (warble_ir_version) as a resolvable npm package: a version constant plus the compile-contract schema document. Not a runtime dependency — its version IS the contract.",