@crewhaus/ir 0.5.7 → 0.6.0

package/dist/index.d.ts

@@ -86,6 +86,61 @@ export type IrSubAgentDefinition = {
     readonly federation?: {
         readonly url: string;
     };
+    /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+    readonly modelProfile?: string;
+    /**
+     * 0.6.0 §4.2 / §7.7 — the `instructions` overlay of the profile `model`
+     * resolved from, carried RAW (not folded into `instructions`) so the spawner
+     * folds it only for the declared / inherited plans: a Task call that pins one
+     * of `allowedProfiles` runs on THAT option's overlay instead. Every other
+     * serving slot folds its overlay at lower time; the sub-agent is the one slot
+     * whose prompt depends on a per-call choice.
+     */
+    readonly overlay?: string;
+    /** 0.6.0 §7.7 — the child's own request params (spec `thinking` /
+     *  `max_tokens` / `temperature`, or the referenced profile's). */
+    readonly thinking?: IrThinking;
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    /** 0.6.0 §7.7 — per-sub-agent model routing (the agent block's quartet). */
+    readonly modelFallbacks?: readonly string[];
+    readonly circuitBreaker?: IrCircuitBreaker;
+    readonly modelTiers?: IrModelTiers;
+    readonly modelPool?: IrModelPool;
+    /** 0.6.0 §7.7 — fraction of the parent's `budget.usd` this child may spend. */
+    readonly budgetShare?: number;
+    /** 0.6.0 §7.7 — inherit the parent's SERVED arm instead of the declared
+     *  primary (default false keeps today's declared-primary behaviour). */
+    readonly inheritRouting?: boolean;
+    /**
+     * 0.6.0 §7.7 — the `models:` profiles the Task tool's `profile` argument
+     * may name for this child, each RESOLVED at lower time to the model and
+     * request params the child runs on when that profile is chosen (the same
+     * expansion a `model: $<profile>` slot gets). Resolving here — not at
+     * runtime — is what keeps the registry provenance-only downstream of the
+     * compiler: nothing at runtime ever sees a `$` or looks a profile up.
+     */
+    readonly allowedProfiles?: readonly IrSubAgentProfileOption[];
+};
+/**
+ * 0.6.0 §7.7 — one entry of {@link IrSubAgentDefinition.allowedProfiles}: the
+ * profile NAME (the allowlist the model-filled Task `profile` argument is
+ * checked against — it can never name a model outside the spec) plus the
+ * profile's resolved serving slot. When the Task call pins this profile the
+ * child runs single-model on `model` with these params and this failover
+ * chain; its own `model_pool` / `model_tiers` do not route that call. The
+ * profile's `instructions` overlay is carried so the spawner can fold it into
+ * the child's prompt for that call only.
+ */
+export type IrSubAgentProfileOption = {
+    readonly profile: string;
+    readonly model: string;
+    readonly thinking?: IrThinking;
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly overlay?: string;
+    readonly modelFallbacks?: readonly string[];
+    readonly circuitBreaker?: IrCircuitBreaker;
 };
 /**
  * Section 14 — per-tool runtime config carried verbatim from the spec to
@@ -104,6 +159,11 @@ export type IrToolConfigs = Readonly<Record<string, unknown>>;
  */
 export type IrCompaction = {
     readonly model?: string;
+    /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+    readonly modelProfile?: string;
+    /** 0.6.0 §4.2 — the profile's pinned request params (autocompact builds its
+     *  own request). Present only when the profile declares any. */
+    readonly params?: IrModelParams;
     /** Loop contract 0.4 (Batch A) — context-window fill fraction that
      *  triggers autocompaction (spec `compaction.threshold`, 0.5–0.99).
      *  Runtime default applies when absent. */
@@ -165,23 +225,213 @@ export type IrModelTiers = {
         readonly priorToolDensityThreshold?: number;
     };
 };
-/** One declared candidate in a `model_pool`. */
-export type IrModelPoolCandidate = {
+/**
+ * 0.6.0 §4.2 — the per-model request parameters a `models:` profile can pin
+ * on an AUXILIARY slot (judge / compaction / degrade / security / watchme),
+ * where the consumer builds its own provider request. Carried ONLY when the
+ * slot resolved through a profile that declares them; absent otherwise.
+ */
+export type IrModelParams = {
+    readonly thinking?: IrThinking;
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+};
+/**
+ * 0.6.0 §5.4 — the RESTRICTED per-profile permission schema: `deny` and
+ * `ask` ONLY. A profile can narrow the shape's permissions (decision-level
+ * meet: deny < ask < allow), never widen them — the spec rejects
+ * `alwaysAllow` / `mode` / `ask_mode`, and `modelPlanIntegrity` re-pins the
+ * shape for direct-IR builders.
+ */
+export type IrProfilePermissions = {
+    readonly deny?: readonly string[];
+    readonly ask?: readonly string[];
+};
+/**
+ * 0.6.0 §7.11 (N1) — what a profile REQUIRES of its own model. The four
+ * feature flags mirror `ProviderFeatures`; the two size floors are spelled
+ * as floors (`…Gte`). Structurally `@crewhaus/cost-tracker`'s
+ * `CapabilityRequirement` and `@crewhaus/model-plan`'s `FeatureRequirement`,
+ * so one value serves the compile-time twin and the runtime gate.
+ */
+export type IrModelRequires = {
+    readonly tool_use?: boolean;
+    readonly vision?: boolean;
+    readonly thinking?: boolean;
+    readonly web_search?: boolean;
+    readonly contextWindowGte?: number;
+    readonly maxOutputTokensGte?: number;
+};
+/**
+ * 0.6.0 §4.1 — a DECLARED capability override for a model the offline
+ * capability table does not know (local / azure / named hosts). Flat, every
+ * field optional: an unknown fact never satisfies a requirement on it.
+ */
+export type IrModelCapabilities = {
+    readonly tool_use?: boolean;
+    readonly vision?: boolean;
+    readonly thinking?: boolean;
+    readonly web_search?: boolean;
+    readonly caching?: "explicit" | "automatic" | false;
+    readonly contextWindow?: number;
+    readonly maxOutputTokens?: number;
+};
+/**
+ * 0.6.0 §4.2 — one resolved model profile: the lower-time expansion of a
+ * `models:` entry, and the settings a `model_pool` candidate carries inline.
+ * Every field but `model` is optional, and a profile-less candidate is a bare
+ * `{ model, tags }` with every key here absent — which is exactly why
+ * existing pools lower and emit byte-identically. `profile` is the registry
+ * name (provenance AND the scoreboard arm identity, §7.9); `overlay` is the
+ * per-model instructions overlay appended in the volatile prompt region when
+ * this candidate serves; `tools` is SUBSET-ONLY (builtin keys as the spec
+ * spells them, `mcp__<server>__*` globs, `Consult` / `Escalate`; `[]` means
+ * zero shape tools); `costCapUsdMicros` is the per-profile cap inside a run.
+ * `$` never appears in an IR model string — references are resolved here.
+ */
+export type IrModelProfile = {
+    readonly profile?: string;
     readonly model: string;
+    readonly tags?: readonly string[];
+    readonly thinking?: IrThinking;
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly modelCallTimeoutMs?: number;
+    readonly overlay?: string;
+    readonly tools?: readonly string[];
+    readonly toolConfigs?: IrToolConfigs;
+    readonly permissions?: IrProfilePermissions;
+    readonly rateLimits?: IrRateLimits;
+    readonly caching?: "prefer" | "off";
+    readonly costCapUsdMicros?: number;
+    readonly requires?: IrModelRequires;
+    readonly capabilities?: IrModelCapabilities;
+    readonly fallbacks?: readonly string[];
+    readonly circuitBreaker?: IrCircuitBreaker;
+};
+/**
+ * 0.6.0 §4.2 — the `models:` registry as lowered: profile name → resolved
+ * profile (sentinels resolved by price rank, every snake_case key renamed).
+ * Present on a variant ONLY when the spec declares `models:`; emitters never
+ * read it (README / loop projection / `models explain` do), so an absent
+ * registry keeps every bundle byte-identical.
+ */
+export type IrModelProfiles = Readonly<Record<string, IrModelProfile>>;
+/**
+ * One declared candidate in a `model_pool`. 0.6.0 §4.2: a profile plus the
+ * routing identity `tags` (always present — the spec defaults them; a
+ * `$profile` candidate inherits the profile's tags when it declares none)
+ * and `enabled: false`, which withdraws the candidate from routing without
+ * deleting its learned history. The lowering inserts `model` then `tags`
+ * FIRST and spreads every 0.6.0 key after them, so `JSON.stringify` of a
+ * plain candidate is byte-identical to 0.5.x (the key-order guard).
+ */
+export type IrModelPoolCandidate = IrModelProfile & {
     readonly tags: readonly string[];
+    readonly enabled?: false;
+};
+/** 0.6.0 §7.2.2 — the `when:` clause of a route rule (spec keys verbatim — the
+ *  runtime's `evaluateRules` in `@crewhaus/model-plan` reads this shape). */
+export type IrModelPoolRuleWhen = {
+    readonly has_images?: boolean;
+    readonly message_matches?: string;
+    readonly user_text_chars_gt?: number;
+    readonly context_tokens_gt?: number;
+    readonly tool_in_play?: boolean;
+    readonly channel?: string;
+    readonly budget_spent_ratio_gt?: number;
+    readonly turn_index_lt?: number;
+};
+/**
+ * 0.6.0 §7.2.2 — one rule-directed routing rule, evaluated first-match in
+ * `preRoute` before the policy. `use` names a candidate tag, a roster arm id
+ * (a `$profile` reference lowers to its profile name — the arm identity), or
+ * a capability requirement the turn's candidates must satisfy.
+ */
+export type IrModelPoolRule = {
+    readonly id: string;
+    readonly when: IrModelPoolRuleWhen;
+    readonly use: string | {
+        readonly requires: IrModelRequires;
+    };
+    readonly enabled?: boolean;
+};
+/** 0.6.0 §7.2.3 — `policy: classifier`: a forced-tool single call whose
+ *  verdict is constrained to the roster's tags. */
+export type IrModelPoolClassifier = {
+    readonly model: string;
+    readonly modelProfile?: string;
+    readonly labels: Readonly<Record<string, string>>;
+    readonly maxTokens?: number;
+};
+/**
+ * 0.6.0 §7.3–§7.8 — the hybrid strategy block. Role slots (`draft`,
+ * `escalateTo`, `members`, `escalateOnDisagreement`) name a candidate tag or
+ * a roster arm id; model slots (`guide.model`, `shadow.candidate`,
+ * `shadow.gradeWith`, `committee.judge`) are resolved model strings with
+ * their profile provenance beside them.
+ */
+export type IrModelPoolStrategy = {
+    readonly cascade?: {
+        readonly draft: string;
+        readonly escalateTo: string;
+        readonly cleanPrompt?: boolean;
+    };
+    readonly guide?: {
+        readonly model: string;
+        readonly modelProfile?: string;
+        readonly every?: "first_turn" | "turn";
+        readonly maxTokens?: number;
+        readonly budgetUsd?: number;
+    };
+    readonly shadow?: {
+        readonly candidate: string;
+        readonly candidateProfile?: string;
+        readonly sampleRate?: number;
+        readonly gradeWith?: string;
+        readonly gradeWithProfile?: string;
+    };
+    readonly committee?: {
+        readonly members: readonly string[];
+        readonly judge?: string;
+        readonly judgeProfile?: string;
+        readonly escalateOnDisagreement?: string;
+    };
+    readonly modelDirected?: boolean;
+    readonly maxEscalations?: number;
+};
+/** 0.6.0 §6.3, §7.10 — the reward block (a sibling of `learning`; nothing
+ *  here is optimizer-tunable). */
+export type IrModelPoolReward = {
+    readonly qualitySource?: "none" | "in_loop" | "shadow" | "promoted";
+    readonly priors?: "none" | "eval";
+    readonly floor?: {
+        readonly arm?: string;
+        readonly confidence?: number;
+        readonly tolerance?: number;
+    };
+    readonly resetOnProfileChange?: boolean;
 };
 /**
  * Adaptive model routing — the N-candidate `model_pool` with a per-turn
- * selection `policy` (`static` | `heuristic` | `learned`). Carried on the
- * agent blocks of the routing-capable shapes (cli, channel, managed), mutually
- * exclusive with `modelTiers`/`modelFallbacks` (enforced in the spec). Absent
- * when the spec omits `model_pool` — codegen gates on presence so an unset
- * block leaves bundles byte-identical. `policy` and each candidate's `tags` are
- * always present (spec defaults them); every other knob is carried verbatim.
+ * selection `policy` (`static` | `heuristic` | `learned` | `classifier`).
+ * Carried on the agent blocks of the routing-capable shapes (cli, channel,
+ * managed), on workflow steps, graph nodes (0.6.0), crew roles and
+ * sub-agents (0.6.0), mutually exclusive with `modelTiers`/`modelFallbacks`
+ * (enforced in the spec). Absent when the spec omits `model_pool` — codegen
+ * gates on presence so an unset block leaves bundles byte-identical. `policy`
+ * and each candidate's `tags` are always present (spec defaults them); every
+ * other knob is carried verbatim.
+ *
+ * 0.6.0 §7.1 — the pool IS the hybrid container: `rules` / `directives` /
+ * `classifier` / `strategy` / `reward` / `scope` are siblings of `routing`
+ * and `learning`, each present only when declared. The whole block travels
+ * to runtime inside the one `JSON.stringify(modelPool)` every emitter
+ * already writes, so every new key rides that blob without an emitter edit.
  */
 export type IrModelPool = {
     readonly candidates: readonly IrModelPoolCandidate[];
-    readonly policy: "static" | "heuristic" | "learned";
+    readonly policy: "static" | "heuristic" | "learned" | "classifier";
     readonly objective?: {
         readonly quality?: number;
         readonly cost?: number;
@@ -203,6 +453,18 @@ export type IrModelPool = {
         readonly seed?: string;
         readonly bandit?: "epsilon-greedy" | "thompson";
     };
+    /** 0.6.0 §7.2.1 — per-message `/model` steering (default off everywhere). */
+    readonly directives?: boolean;
+    readonly rules?: readonly IrModelPoolRule[];
+    readonly classifier?: IrModelPoolClassifier;
+    readonly strategy?: IrModelPoolStrategy;
+    readonly reward?: IrModelPoolReward;
+    /** 0.6.0 §7.9 — scoped routeKey prefix, carried verbatim when declared.
+     *  Never stamped at lower time (that would change every pre-0.6.0 pooled
+     *  step/role blob); the host that knows the scope defaults it at runtime —
+     *  the crew orchestrator to the role name (PR 7b), the composition root to
+     *  the caller's toolset scope (PR 10). */
+    readonly scope?: string;
 };
 /**
  * Loop contract 0.4 (Batch A) — extended-thinking selector, lowered from
@@ -325,9 +587,21 @@ export type IrFailureTaxonomy = readonly IrFailureTaxonomyEntry[];
  * spec's `budget` block. `usdMicros` is the dollar ceiling in USD-micros
  * (1 USD = 1_000_000) — the unit the runtime meters in. `onExceed` decides
  * the behaviour when accrued spend reaches the cap: `stop` ends the run
- * before the next turn; `degrade` re-resolves the primary model to `model`
- * (one cheaper rung) and continues. Carried on the interactive shapes that
- * loop (cli, channel, managed); absent when the spec omits the block.
+ * (0.6.0 §7.12: checked before every model call, tool iterations included);
+ * `degrade` re-resolves the primary model to `model` (one cheaper rung) and
+ * continues — the rung serves the rest of the turn the degrade fired in and
+ * the run ends at the next turn boundary; under a `modelPool` the rung is
+ * the forced candidate rather than an adapter swap. `scope` (0.6.0) is
+ * carried ONLY when the spec
+ * declares it (absent ⇒ the runtime's `run` default, byte-identical for
+ * older specs): `session` seeds the meter on resume from the session log's
+ * persisted `cost_accrual` lines so the cap bounds the conversation.
+ * `judgeShare` (0.6.0 §6.2, spec `judge_share`) is likewise carried only
+ * when declared (absent ⇒ the runtime's 0.3 default): the fraction of
+ * `usdMicros` the auxiliary roles (judge, compaction, guide, classifier,
+ * consult, committee, shadow) may spend before the runtime raises the
+ * `judge_share_exhausted` signal. Carried on the shapes that run the shared
+ * loop; absent when the spec omits the block.
  */
 export type IrBudget = {
     readonly usdMicros: number;
@@ -336,7 +610,12 @@ export type IrBudget = {
     } | {
         readonly kind: "degrade";
         readonly model: string;
+        /** 0.6.0 §4.2 — provenance + the degrade profile's request params. */
+        readonly modelProfile?: string;
+        readonly params?: IrModelParams;
     };
+    readonly scope?: "run" | "session";
+    readonly judgeShare?: number;
 };
 /**
  * Loop contract 0.4 (Batch B, G02) — the grader selector inside
@@ -346,7 +625,8 @@ export type IrBudget = {
  *     `criteria`. `model` is the judge model id; when ABSENT the runtime
  *     uses the shape's primary model (the `cheapest` sentinel was already
  *     resolved at lower time, like `compaction.model`). Judge calls are
- *     METERED into the run budget.
+ *     METERED into the run budget (0.6.0: on the run bus with
+ *     `role: "judge"`, bounded by `IrBudget.judgeShare`).
  *   - `contains` / `regex` — deterministic pass/fail text checks (score 1
  *     on pass, 0 on fail; no model spend).
  */
@@ -354,6 +634,18 @@ export type IrEvaluationGrader = {
     readonly type: "llm_judge";
     readonly criteria: string;
     readonly model?: string;
+    /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+    readonly modelProfile?: string;
+    /** 0.6.0 §6.2 — a judge PANEL (resolved model strings); exclusive with `model`. */
+    readonly judges?: readonly string[];
+    /** 0.6.0 §6.2 — repeat verdicts per judge, folded by median. */
+    readonly repeats?: number;
+    /** 0.6.0 §6.2 — pinned judge sampling temperature. */
+    readonly temperature?: number;
+    /** 0.6.0 §6.2 — what the judge grades. */
+    readonly target?: "output" | "transcript";
+    /** 0.6.0 §4.2 — the judge profile's other pinned params (thinking / maxTokens). */
+    readonly params?: IrModelParams;
 } | {
     readonly type: "contains";
     readonly value: string;
@@ -384,10 +676,25 @@ export type IrEvaluation = {
     readonly grader: IrEvaluationGrader;
     /** Present iff `grader.type === "llm_judge"` (resolved default 0.7). */
     readonly threshold?: number;
-    /** Resolved below-threshold behaviour (spec `on_fail`, default "retry"). */
-    readonly onFail: "retry" | "halt" | "note";
+    /** Resolved below-threshold behaviour (spec `on_fail`, default "retry").
+     *  0.6.0 §7.3 adds `escalate`: re-run the turn on the pool's
+     *  `strategy.cascade.escalateTo` candidate (else the strongest). */
+    readonly onFail: "retry" | "halt" | "note" | "escalate";
     /** Resolved retry hard-cap (spec `max_retries`, default 1). */
     readonly maxRetries: number;
+    /**
+     * 0.6.0 §7.3 — present iff `onFail === "escalate"`: the roster arm the
+     * failing turn is re-run on, RESOLVED at lower time from
+     * `model_pool.strategy.cascade.escalate_to` (a candidate tag, or a
+     * `$profile` lowered to its arm id), else the pool's strongest candidate —
+     * its `routing.strongTag` (default `strong`) when a candidate carries it,
+     * else the last declared candidate's arm id (the router's `escalation()`
+     * convention). The runtime resolves it against the booted roster; it never
+     * names a model outside the spec.
+     */
+    readonly escalateTo?: string;
+    /** 0.6.0 §4.3 — the judge-independence lint waiver; carried only when true. */
+    readonly allowSelfJudge?: true;
 };
 /**
  * Loop contract 0.4 (Batch B, G02) — the judge gate carried by
@@ -416,6 +723,22 @@ export type IrJudge = {
     readonly onFail: "retry_previous" | "halt" | "continue";
     /** Resolved re-run hard-cap (spec `max_retries`, default 1). */
     readonly maxRetries: number;
+    /** 0.6.0 §4.2 — provenance of the judge model folded into the step's/node's
+     *  `model` slot, when it resolved through a `models:` profile. */
+    readonly modelProfile?: string;
+    /** 0.6.0 §6.2 — a judge PANEL (resolved model strings); exclusive with the
+     *  single judge model. */
+    readonly judges?: readonly string[];
+    /** 0.6.0 §6.2 — repeat verdicts per judge, folded by median. */
+    readonly repeats?: number;
+    /** 0.6.0 §6.2 — pinned judge sampling temperature. */
+    readonly temperature?: number;
+    /** 0.6.0 §6.2 — what the judge grades. */
+    readonly target?: "output" | "transcript";
+    /** 0.6.0 §7.3 — the pool tag / arm id a `retry_previous` re-run is forced onto. */
+    readonly escalateTo?: string;
+    /** 0.6.0 §4.2 — the judge profile's other pinned params (thinking / maxTokens). */
+    readonly params?: IrModelParams;
 };
 /**
  * Pillar 3 (FR-004) — per-target security fabric configuration the
@@ -436,6 +759,9 @@ export type IrSecurity = {
     readonly justification?: {
         readonly judge: "rule-based" | "claude";
         readonly model?: string;
+        /** 0.6.0 §4.2 — provenance + the judge profile's request params. */
+        readonly modelProfile?: string;
+        readonly params?: IrModelParams;
     };
     /**
      * Pillar 3 sink-side fabric (FR-006) — the egress-matching strategy.
@@ -780,6 +1106,12 @@ export type IrSlo = {
     readonly ttftMs?: number;
     readonly costPerHourUsd?: number;
     readonly egressBlockRate?: number;
+    /** Escalations per turn (spec `escalation_rate`). */
+    readonly escalationRate?: number;
+    /** Failing in-loop grades + judge-gate verdicts over all of them (spec `judge_fail_rate`). */
+    readonly judgeFailRate?: number;
+    /** Route decisions the quality floor forced onto the floor arm, over all decisions (spec `floor_block_rate`). */
+    readonly floorBlockRate?: number;
     readonly windowMs?: number;
     readonly mitigation: ReadonlyArray<IrSloMitigation>;
 };
@@ -845,6 +1177,9 @@ export type IrWatchme = {
     readonly capture: "full" | "mirrors";
     /** Phase-2 judge model — default resolved at lower time. */
     readonly judgeModel: string;
+    /** 0.6.0 §4.2 — provenance + the judge profile's request params. */
+    readonly judgeProfile?: string;
+    readonly judgeParams?: IrModelParams;
     readonly judgeSampleRate: number;
     readonly judgeBudgetUsd: number;
     readonly scope: "harness" | "user";
@@ -896,6 +1231,9 @@ export type IrV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "cli";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
@@ -922,6 +1260,13 @@ export type IrV0 = {
         readonly modelTiers?: IrModelTiers;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     readonly tools: readonly string[];
     readonly toolConfigs: IrToolConfigs;
@@ -1018,6 +1363,11 @@ export type IrWorkflowStep = {
      *  PolicyRouter decides per step against the shared routing-store
      *  scoreboard). Absent → single-model. */
     readonly modelPool?: IrModelPool;
+    /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+    readonly modelProfile?: string;
+    /** 0.6.0 §4.1 — sampling temperature (spec `steps[].temperature`, or the
+     *  referenced profile's). Exclusive with `thinking`. */
+    readonly temperature?: number;
     /** Loop contract 0.4 (Batch B, G02) — `"judge"` marks a gate step over
      *  the previous step's output. ABSENT on regular agent steps. */
     readonly kind?: "judge";
@@ -1033,6 +1383,9 @@ export type IrWorkflowV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "workflow";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly steps: readonly IrWorkflowStep[];
     readonly mcp_servers: IrMcpServers;
     readonly permissions: IrPermissions;
@@ -1278,6 +1631,9 @@ export type IrChannelV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "channel";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
@@ -1298,6 +1654,13 @@ export type IrChannelV0 = {
         readonly modelTiers?: IrModelTiers;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     readonly tools: readonly string[];
     readonly toolConfigs: IrToolConfigs;
@@ -1377,6 +1740,9 @@ export type IrManagedV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "managed";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
@@ -1397,6 +1763,13 @@ export type IrManagedV0 = {
         readonly modelTiers?: IrModelTiers;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     readonly tenants: readonly IrManagedTenant[];
     /** Loop contract 0.4 (Batch F, G81) — tool catalog for the managed daemon.
@@ -1473,6 +1846,19 @@ export type IrGraphNode = {
     readonly thinking?: IrThinking;
     readonly tools: readonly string[];
     readonly toolConfigs: IrToolConfigs;
+    /** 0.6.0 §7.7 — per-node model routing (graph nodes carried NONE before
+     *  0.6.0): the agent block's quartet, lowered by the same
+     *  `lowerModelFailover` and rendered onto the node's `runChatLoop` call
+     *  exactly like a workflow step. Absent → the node's single resolved model. */
+    readonly modelFallbacks?: readonly string[];
+    readonly circuitBreaker?: IrCircuitBreaker;
+    readonly modelTiers?: IrModelTiers;
+    readonly modelPool?: IrModelPool;
+    /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+    readonly modelProfile?: string;
+    /** 0.6.0 §4.1 — sampling temperature (spec `nodes.<n>.temperature`, or the
+     *  referenced profile's). Exclusive with `thinking`. */
+    readonly temperature?: number;
     /**
      * When set, the node calls `ctx.requestApproval(prompt)` BEFORE its LLM
      * turn and pauses the graph until `resume(checkpointId, decision)`. The
@@ -1521,6 +1907,9 @@ export type IrGraphV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "graph";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly entry: string;
     readonly nodes: readonly IrGraphNode[];
     readonly edges: readonly IrGraphEdge[];
@@ -1573,11 +1962,21 @@ export type IrPipelineV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "pipeline";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     readonly retrieve: {
         readonly embedderModel: string;
@@ -1639,8 +2038,19 @@ export type IrCrewRole = {
     readonly modelTiers?: IrModelTiers;
     /** Item 9 (G37) — per-role N-candidate pool with a selection policy (a
      *  PolicyRouter decides per role against the shared routing-store
-     *  scoreboard). Absent → single-model. */
+     *  scoreboard). Absent → single-model. 0.6.0 §7.7 (PR 7b): the WIDENED
+     *  pool — each candidate carries its per-candidate profile settings
+     *  (`IrModelPoolCandidate`) — is emitted verbatim onto the role literal and
+     *  forwarded intact by `@crewhaus/crew-orchestrator` into the role's turns,
+     *  which stamp `scope` with the role name when the spec pinned none (the
+     *  compiler leaves `scope` unstamped so pre-0.6.0 pooled roles stay
+     *  byte-identical). */
     readonly modelPool?: IrModelPool;
+    /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+    readonly modelProfile?: string;
+    /** 0.6.0 §4.1 — sampling temperature (spec `roles.<r>.temperature`, or the
+     *  referenced profile's). Exclusive with `thinking`. */
+    readonly temperature?: number;
     /** 0.5.0 — this role's RESOLVED Thredz config: the crew-wide defaults with
      *  the role's own `thredz.roles.<name>` overrides merged in, shorthands
      *  expanded and the credential lowered. Absent → this role has no hosted
@@ -1666,11 +2076,21 @@ export type IrCrewRouting = {
         readonly contains: string;
         readonly to: string;
     }>>>;
+    /**
+     * 0.6.0 §7.7 — the model the `kind: "llm"` router runs on (resolved; a
+     * `$profile` reference lowers here with its provenance beside it). Absent →
+     * the emitter keeps today's default, the entry role's model.
+     */
+    readonly model?: string;
+    readonly modelProfile?: string;
 };
 export type IrCrewV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "crew";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly entry: string;
     readonly roles: readonly IrCrewRole[];
     readonly routing?: IrCrewRouting;
@@ -1726,6 +2146,9 @@ export type IrResearchV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "research";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
@@ -1734,6 +2157,13 @@ export type IrResearchV0 = {
         readonly maxTokens?: number;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     /** Default research goal. The daemon's `--goal "..."` flag overrides. */
     readonly goal: string;
@@ -1792,6 +2222,9 @@ export type IrBatchV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "batch";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
@@ -1800,6 +2233,13 @@ export type IrBatchV0 = {
         readonly maxTokens?: number;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     readonly queue: {
         readonly adapter: IrBatchQueueAdapter;
@@ -1852,9 +2292,15 @@ export type IrVoiceV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "voice";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from
+         *  (profile → model only on this shape; every other field is warned). */
+        readonly modelProfile?: string;
     };
     readonly voice: {
         readonly provider: IrVoiceProvider;
@@ -1893,6 +2339,9 @@ export type IrBrowserV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "browser";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
@@ -1901,6 +2350,13 @@ export type IrBrowserV0 = {
         readonly maxTokens?: number;
         /** Adaptive model routing — N-candidate pool. Absent → single-model. */
         readonly modelPool?: IrModelPool;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from.
+         *  Absent unless the slot was declared as a `$profile` reference. */
+        readonly modelProfile?: string;
+        /** 0.6.0 §4.1 — sampling temperature (spec `temperature`, or the
+         *  referenced profile's). Exclusive with `thinking`. Absent when neither
+         *  declares it. */
+        readonly temperature?: number;
     };
     readonly driver: {
         readonly backend: IrBrowserBackend;
@@ -1921,6 +2377,11 @@ export type IrBrowserV0 = {
     };
     /** Vision-grounding model. Defaults at lower-time to agent.model. */
     readonly groundingModel: string;
+    /** 0.6.0 §4.2 — provenance when `groundingModel` resolved through a profile. */
+    readonly groundingModelProfile?: string;
+    /** 0.6.0 §4.2 — the grounding profile's pinned request params, honoured by
+     *  `@crewhaus/tool-vision-grounding`'s `FindElement` call. */
+    readonly groundingParams?: IrModelParams;
     readonly tools: readonly string[];
     readonly toolConfigs: IrToolConfigs;
     readonly mcp_servers: IrMcpServers;
@@ -1949,10 +2410,15 @@ export type IrEvalV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "eval";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
         readonly tools: readonly string[];
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+        readonly modelProfile?: string;
     };
     readonly dataset: {
         readonly name: string;
@@ -2012,9 +2478,14 @@ export type IrChainV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "onchain";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+        readonly modelProfile?: string;
     };
     readonly chains: readonly IrChainBinding[];
     readonly wallets: readonly IrWalletBinding[];
@@ -2046,9 +2517,14 @@ export type IrChainGameV0 = {
     readonly version: 0;
     readonly name: string;
     readonly target: "onchain-game";
+    /** 0.6.0 §4.2 — the lowered `models:` registry. Present only when the spec
+     *  declares one; emitters never read it. */
+    readonly models?: IrModelProfiles;
     readonly agent: {
         readonly model: string;
         readonly instructions: string;
+        /** 0.6.0 §4.2 — provenance: the `models:` profile `model` resolved from. */
+        readonly modelProfile?: string;
     };
     /** Games are bound to one chain at a time; multi-chain games are rare. */
     readonly chain: IrChainBinding;

package/dist/loop.js

@@ -73,6 +73,12 @@ function describeJudge(j) {
 function describeModelPool(pool) {
     return `adaptive model pool (${pool.candidates.length} candidates, policy: ${pool.policy})`;
 }
+/** 0.6.0 §4.3 — "2 model profiles (fast, strong) · primary profile: fast". */
+function describeModelProfiles(models, primaryProfile) {
+    const names = Object.keys(models);
+    const summary = countList(names.length, "model profile", names);
+    return primaryProfile !== undefined ? `${summary} · primary profile: ${primaryProfile}` : summary;
+}
 function ringSegmentsFromView(view) {
     const tools = view.tools ?? [];
     const toolsKey = view.toolsKey ?? "tools";
@@ -106,6 +112,14 @@ function ringSegmentsFromView(view) {
         reasonKeys.push("agent.model_pool");
         reasonParts.push(describeModelPool(view.modelPool));
     }
+    // 0.6.0 §4.3 — the `models:` registry surfaces as `models.<name>` keys (the
+    // YAML the operator jumps to), and the primary's profile provenance names
+    // the profile it resolved from.
+    if (view.models !== undefined) {
+        for (const name of Object.keys(view.models))
+            reasonKeys.push(`models.${name}`);
+        reasonParts.push(describeModelProfiles(view.models, view.modelProfile));
+    }
     const reason = segment("reason", reasonKeys, `${reasonParts.join(" · ")} on ${view.model}`, `single fixed model (${view.model}) — no thinking, tiers, or pool`);
     // act ← tools / mcp_servers / sub_agents.
     const actKeys = [];
@@ -176,9 +190,12 @@ function ringSegmentsFromView(view) {
         stopKeys.push("budget");
         const usd = view.budget.usdMicros / 1_000_000;
         const onExceed = view.budget.onExceed.kind === "degrade"
-            ? ` (on exceed: degrade → ${view.budget.onExceed.model})`
-            : " (on exceed: stop)";
-        stopParts.push(`budget $${usd}${onExceed}`);
+            ? `on exceed: degrade → ${view.budget.onExceed.model}`
+            : "on exceed: stop";
+        // 0.6.0 — `scope` is only carried when declared, so the rendered summary
+        // is byte-identical for every pre-0.6.0 IR.
+        const scope = view.budget.scope !== undefined ? `; scope: ${view.budget.scope}` : "";
+        stopParts.push(`budget $${usd} (${onExceed}${scope})`);
     }
     if (view.limits !== undefined) {
         stopKeys.push("limits");
@@ -228,6 +245,10 @@ function miniSegments(view) {
         reasonKeys.push("model");
         reasonParts.push(`model: ${view.model}`);
     }
+    if (view.modelProfile !== undefined) {
+        reasonKeys.push(`models.${view.modelProfile}`);
+        reasonParts.push(`profile: ${view.modelProfile}`);
+    }
     if (view.thinking !== undefined) {
         reasonKeys.push("thinking");
         reasonParts.push("extended thinking");
@@ -283,6 +304,7 @@ function workflowCanvas(ir, warnings) {
             ? { model: step.model, ...(step.judge !== undefined ? { judge: step.judge } : {}) }
             : {
                 model: step.model,
+                ...(step.modelProfile !== undefined ? { modelProfile: step.modelProfile } : {}),
                 ...(step.thinking !== undefined ? { thinking: step.thinking } : {}),
                 // Item 9 (G37) — per-step model pool surfaces in the reason segment.
                 ...(step.modelPool !== undefined ? { modelPool: step.modelPool } : {}),
@@ -337,7 +359,10 @@ function graphCanvas(ir, warnings) {
             ? { model: node.model, ...(node.judge !== undefined ? { judge: node.judge } : {}) }
             : {
                 model: node.model,
+                ...(node.modelProfile !== undefined ? { modelProfile: node.modelProfile } : {}),
                 ...(node.thinking !== undefined ? { thinking: node.thinking } : {}),
+                // 0.6.0 §7.7 — per-node model pool surfaces in the reason segment.
+                ...(node.modelPool !== undefined ? { modelPool: node.modelPool } : {}),
                 tools: node.tools,
                 ...(node.hitlPrompt !== undefined ? { hitlPrompt: node.hitlPrompt } : {}),
             }),
@@ -380,6 +405,7 @@ function crewCanvas(ir, warnings) {
         kind: "role",
         mini: miniSegments({
             model: role.model,
+            ...(role.modelProfile !== undefined ? { modelProfile: role.modelProfile } : {}),
             ...(role.thinking !== undefined ? { thinking: role.thinking } : {}),
             // Item 9 (G37) — per-role model pool surfaces in the reason segment.
             ...(role.modelPool !== undefined ? { modelPool: role.modelPool } : {}),
@@ -496,6 +522,8 @@ function cliRingView(ir) {
         ...(ir.agent.thinking !== undefined ? { thinking: ir.agent.thinking } : {}),
         ...(ir.agent.modelTiers !== undefined ? { modelTiers: ir.agent.modelTiers } : {}),
         ...(ir.agent.modelPool !== undefined ? { modelPool: ir.agent.modelPool } : {}),
+        ...(ir.models !== undefined ? { models: ir.models } : {}),
+        ...(ir.agent.modelProfile !== undefined ? { modelProfile: ir.agent.modelProfile } : {}),
         ...(ir.evaluation !== undefined ? { evaluation: ir.evaluation } : {}),
         ...(ir.learning !== undefined ? { learning: ir.learning } : {}),
         ...(ir.security !== undefined ? { security: ir.security } : {}),
@@ -524,6 +552,8 @@ function channelRingView(ir) {
         ...(ir.agent.thinking !== undefined ? { thinking: ir.agent.thinking } : {}),
         ...(ir.agent.modelTiers !== undefined ? { modelTiers: ir.agent.modelTiers } : {}),
         ...(ir.agent.modelPool !== undefined ? { modelPool: ir.agent.modelPool } : {}),
+        ...(ir.models !== undefined ? { models: ir.models } : {}),
+        ...(ir.agent.modelProfile !== undefined ? { modelProfile: ir.agent.modelProfile } : {}),
         ...(ir.evaluation !== undefined ? { evaluation: ir.evaluation } : {}),
         ...(ir.learning !== undefined ? { learning: ir.learning } : {}),
         ...(ir.memory !== undefined ? { memory: ir.memory } : {}),
@@ -544,6 +574,8 @@ function managedRingView(ir) {
         ...(ir.agent.thinking !== undefined ? { thinking: ir.agent.thinking } : {}),
         ...(ir.agent.modelTiers !== undefined ? { modelTiers: ir.agent.modelTiers } : {}),
         ...(ir.agent.modelPool !== undefined ? { modelPool: ir.agent.modelPool } : {}),
+        ...(ir.models !== undefined ? { models: ir.models } : {}),
+        ...(ir.agent.modelProfile !== undefined ? { modelProfile: ir.agent.modelProfile } : {}),
         ...(ir.evaluation !== undefined ? { evaluation: ir.evaluation } : {}),
         ...(ir.learning !== undefined ? { learning: ir.learning } : {}),
         ...(ir.memory !== undefined ? { memory: ir.memory } : {}),

package/dist/readme.js

@@ -179,18 +179,101 @@ function collectConfiguredToolNames(ir) {
     visit(ir);
     return configured;
 }
-/** Deduped models across variant shapes (agent / steps / nodes / roles). */
+/**
+ * Deduped models across variant shapes (agent / steps / nodes / roles), in
+ * declaration order: the primary slot(s) first, then — 0.6.0 §4.3 — every
+ * other model a run can route a call to: pool candidates, the two tiers,
+ * failover chains, and the auxiliary slots (compaction, the in-loop judge or
+ * judge panel, the budget degrade rung, the security judge, the watchme
+ * judge). The README used to list only the primary slot(s), so a pooled or
+ * judged harness under-reported the credentials it needs. A registry
+ * profile's model appears once like any other string; the profile names
+ * themselves render in the "Model profiles" section.
+ */
 function collectModels(ir) {
+    const out = [];
+    const add = (model) => {
+        if (model !== undefined && model.length > 0 && !out.includes(model))
+            out.push(model);
+    };
+    const addRouted = (block) => {
+        add(block.model);
+        for (const c of block.modelPool?.candidates ?? []) {
+            add(c.model);
+            for (const f of c.fallbacks ?? [])
+                add(f);
+        }
+        if (block.modelTiers !== undefined) {
+            add(block.modelTiers.fast);
+            add(block.modelTiers.default);
+        }
+        for (const f of block.modelFallbacks ?? [])
+            add(f);
+    };
     switch (ir.target) {
         case "workflow":
-            return [...new Set(ir.steps.map((s) => s.model))];
+            for (const s of ir.steps) {
+                addRouted(s);
+                for (const j of s.judge?.judges ?? [])
+                    add(j);
+            }
+            break;
         case "graph":
-            return [...new Set(ir.nodes.map((n) => n.model))];
+            for (const n of ir.nodes) {
+                addRouted(n);
+                for (const j of n.judge?.judges ?? [])
+                    add(j);
+            }
+            break;
         case "crew":
-            return [...new Set(ir.roles.map((r) => r.model))];
+            for (const r of ir.roles) {
+                addRouted(r);
+                for (const sa of r.subAgents)
+                    if (sa.model !== undefined)
+                        addRouted({ ...sa, model: sa.model });
+            }
+            add(ir.routing?.model);
+            break;
         default:
-            return [ir.agent.model];
+            addRouted(ir.agent);
+            break;
+    }
+    const aux = ir;
+    for (const sa of aux.subAgents ?? []) {
+        if (sa.model !== undefined)
+            addRouted({ ...sa, model: sa.model });
     }
+    add(aux.compaction?.model);
+    add(aux.evaluation?.grader.model);
+    for (const j of aux.evaluation?.grader.judges ?? [])
+        add(j);
+    add(aux.budget?.onExceed.model);
+    add(aux.security?.justification?.model);
+    add(aux.watchme?.judgeModel);
+    add(aux.groundingModel);
+    return out;
+}
+/**
+ * 0.6.0 §4.3 — the "Model profiles" section: one row per `models:` profile
+ * with its model, tags and the settings it pins. Rendered only when the IR
+ * carries a registry, so profile-less bundles keep the same README.
+ */
+function renderModelProfilesSection(ir) {
+    const registry = ir.models;
+    if (registry === undefined)
+        return undefined;
+    const names = Object.keys(registry).sort();
+    if (names.length === 0)
+        return undefined;
+    const rows = names.map((name) => {
+        const profile = registry[name];
+        const tags = (profile.tags ?? []).map((t) => `\`${escapeCell(t)}\``).join(", ") || "—";
+        const pinned = Object.keys(profile)
+            .filter((k) => k !== "profile" && k !== "model" && k !== "tags")
+            .sort();
+        return `| \`${escapeCell(name)}\` | \`${escapeCell(profile.model)}\` | ${tags} | ${pinned.length > 0 ? pinned.map((k) => `\`${k}\``).join(", ") : "—"} |`;
+    });
+    return ["| Profile | Model | Tags | Pins |", "| --- | --- | --- | --- |", ...rows].join("\n");
 }
 /**
  * Adversarial-review F5 — escape an interpolated value for a GFM table
@@ -375,6 +458,10 @@ export function renderBundleReadme(ir, opts = {}) {
             .join(", ")} |`,
     ].join("\n");
     const sections = [{ heading: "Harness", body: harnessRows }];
+    // 0.6.0 §4.3 — the `models:` registry, when the spec declared one.
+    const profiles = renderModelProfilesSection(ir);
+    if (profiles !== undefined)
+        sections.push({ heading: "Model profiles", body: profiles });
     const tools = renderToolsSection(ir);
     if (tools !== undefined)
         sections.push({ heading: "Tools", body: tools });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/ir",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "type": "module",
   "description": "Canonical typed intermediate representation",
   "main": "dist/index.js",