@event4u/agent-config 7.0.2 → 7.2.0

package/dist/agent-src/contexts/execution/host-capability-manifest.md

@@ -0,0 +1,68 @@
+# Host-Capability Manifest
+
+Resolved once per session by the **agent** (not a long-running process) and
+cached for the rest of the session. Tells the orchestration layer which
+subagent primitives the current host actually exposes, so auto-dispatch never
+attempts a primitive the host cannot run.
+
+## Schema
+
+A single JSON object, `schema_version: 1`:
+
+```json
+{
+  "schema_version": 1,
+  "subagent_spawn": false,
+  "parallel_spawn": false,
+  "status_polling": false,
+  "separate_quota_pool": false
+}
+```
+
+## Resolution
+
+The agent fills the manifest from two inputs, in order:
+
+1. The agent's own knowledge of the **current host** and its documented
+   subagent primitives.
+2. An **optional** settings override `subagents.host_capabilities` in
+   `.agent-settings.yml`. Any field present there wins for that field; any
+   field omitted falls back to the safe default below.
+
+The manifest is resolved once and cached — the agent does not re-resolve it
+mid-session.
+
+## Safe default — unknown host assumes nothing
+
+```
+SAFE DEFAULT = ALL FIELDS false.
+AN UNKNOWN HOST IS ASSUMED TO HAVE NO SUBAGENT PRIMITIVE.
+A MISSING OR INVALID FIELD IS false, NEVER true.
+```
+
+This is a hard rule. When the host is unrecognized, or a field is absent /
+malformed in the override, the field resolves to `false`. The orchestration
+layer then degrades to in-session execution rather than attempting an
+unsupported primitive.
+
+## Fields
+
+| Field | Type | Gates downstream |
+|---|---|---|
+| `subagent_spawn` | bool | Any delegation at all. `false` → no subagent is ever spawned; everything runs in-session. |
+| `parallel_spawn` | bool | Concurrent dispatch of multiple subagents. `false` → delegation is serial, one subagent at a time. |
+| `status_polling` | bool | Monitoring running subagents (progress / completion checks). `false` → fire-and-collect only, no mid-run polling. |
+| `separate_quota_pool` | bool | Quota-arbitrage bonus (Phase 2) — subagents draw from a distinct quota pool than the session. `false` → assume shared quota. |
+
+A field being `true` is a **precondition**, not a mandate: `parallel_spawn:
+true` permits concurrency but the dispatch cap still applies (see
+`subagents.max_parallel` in subagent-configuration.md).
+
+## Related
+
+- [`subagent-configuration`](../subagent-configuration.md) — the `subagents.*`
+  settings keys and the model / parallelism resolution this manifest sits
+  alongside.
+- [`orchestration-telemetry`](orchestration-telemetry.md) — records what the
+  resolved manifest actually enabled per dispatch.
+  Phase-0 substrate belongs to.

package/dist/agent-src/contexts/execution/orchestration-benchmark-gate.md

@@ -0,0 +1,62 @@
+# Orchestration Benchmark & Default-Flip Gate (Phase 6)
+
+The falsification gate the whole auto-orchestration roadmap is built around.
+Reaching the user's "default `on`" is a **measured milestone**, not an
+assumption: the shipped default for `subagents.auto` flips toward `on` only
+when a real benchmark proves a net win at held quality.
+
+## Measurement — pin the method
+
+Measure orchestrated vs. single-agent on a representative delegable-task set
+using the existing `bench:ab` value harness. Pin the comparison method:
+
+- **Paired** — the same task set runs both arms (single-agent, auto-orchestrated).
+- **Activation-aware** — the orchestration layer is toggled per arm via
+  `subagents.enabled` / `subagents.auto`, not a global confound.
+- **Metrics** — token delta, wall-clock, and an outcome-quality score (held at
+  or above the single-agent baseline).
+
+The measurement is an **empirical run with live API spend on a task corpus** —
+it is authorised and run out of band, not produced by this package's code. This
+context defines the gate; it does not fake the result.
+
+## Pass gate (defined up front)
+
+```
+GATE PASSES  ⇔  net token-OR-time win on the delegable-task subset
+              AND output quality held at/above the single-agent baseline.
+HONEST-NULL EXIT: no win, or quality regressed → KEEP the conservative default.
+```
+
+`gateVerdict()` encodes pass = `net_win && quality_held`.
+
+## Default flip — one line, host-gated
+
+On a **passing** gate, the shipped default for `subagents.auto` becomes `on`
+**only** on hosts whose capability manifest reports `subagent_spawn: true`
+(`off` elsewhere). `resolveShippedDefault()` encodes this. The flip itself is a
+one-line edit to the `subagents.auto` default in
+`src/config/agent-settings.template.yml` — no code change, host-gated by the
+manifest at runtime.
+
+Until the gate passes, the shipped default stays `ask` (conservative). This is
+the reconciliation of the user's "default on" goal with the council's
+"prove-first": `on` is the destination, reached by evidence, not assumed.
+
+## Reproducibility
+
+The benchmark report (arms, task set, metrics, verdict) is reproducible from
+the pinned `bench:ab` scenario + the gate helper, so the default-flip decision
+is auditable rather than asserted.
+
+## Reference implementation
+
+[`src/scripts/_lib/orchestration_gate.ts`](../../../../src/scripts/_lib/orchestration_gate.ts)
+(`gateVerdict`, `resolveShippedDefault`), covered by
+[`tests/scripts/_lib_orchestration_gate.test.ts`](../../../../tests/scripts/_lib_orchestration_gate.test.ts).
+
+## Related
+
+- [`auto-orchestration-activation`](auto-orchestration-activation.md) — the `subagents.auto` key this gate sets the default for.
+- [`host-capability-manifest`](host-capability-manifest.md) — `subagent_spawn` gates the flip.
+- [`orchestration-telemetry`](orchestration-telemetry.md) — the per-dispatch metrics the benchmark aggregates.

package/dist/agent-src/contexts/execution/orchestration-telemetry.md

@@ -0,0 +1,59 @@
+# Orchestration Telemetry
+
+Per-dispatch orchestration metrics, recorded for every auto-dispatch the
+orchestration layer performs. These ride as an **optional** `orchestration`
+sub-object on the existing audit-log-v1 JSONL line — additive and
+non-breaking. A line without an `orchestration` object is still a valid
+audit-log-v1 line; readers that do not understand the field ignore it (per the
+v1 forward-compat rule on unknown fields).
+
+## Shape
+
+```json
+{
+  "task_size_estimate": 0,
+  "spawn_count": 0,
+  "tiers": [],
+  "token_delta": 0,
+  "wall_clock_ms": 0,
+  "outcome": "DONE",
+  "verify_mode": "deterministic"
+}
+```
+
+## Field semantics
+
+| Field | Type | Meaning |
+|---|---|---|
+| `task_size_estimate` | int | Pre-dispatch estimate of the task's size (the orchestrator's sizing heuristic). Counts only, no body. |
+| `spawn_count` | int | Number of subagents dispatched for this task. `0` → handled in-session. |
+| `tiers` | string[] | Model tiers dispatched to, one entry per spawn class (e.g. `["sonnet","opus"]`). Tier names only, no prompts. |
+| `token_delta` | int | Net token cost of the dispatch versus the in-session baseline. Counts only. |
+| `wall_clock_ms` | int | Wall-clock duration of the dispatch, milliseconds. |
+| `outcome` | enum | One of `DONE` · `DONE_WITH_CONCERNS` · `NEEDS_CONTEXT` · `BLOCKED` · `killed`. |
+| `verify_mode` | enum | How the dispatch's output was verified: `deterministic` · `judge` · `none`. |
+
+## Privacy floor
+
+Counts and ids only — **no bodies**. This preserves the audit-log-v1 privacy
+floor: no prompts, no conversation snippets, no subagent output, no secrets.
+`tiers` carries tier names, never model prompts or completions.
+
+## Example line
+
+One JSON object per line, UTF-8, no trailing whitespace. The `orchestration`
+object is an additive extension on an otherwise standard audit-log-v1 line:
+
+```json
+{"schema_version":1,"id":"01HXY...","ts":"2026-06-23T12:34:56Z","work_id":"PROJ-7-2026-06-23T12-30-00Z","phase":"implement","outcome":"success","confidence_band":"high","risk_class":"low","memory":{"asks":2,"hits":1},"verify":{"claims":1,"first_try_passes":1},"rules_applied":["verify-before-complete"],"persona":"backend","input_kind":"orchestration","type":"phase","orchestration":{"task_size_estimate":3,"spawn_count":2,"tiers":["sonnet","opus"],"token_delta":4200,"wall_clock_ms":18500,"outcome":"DONE","verify_mode":"deterministic"}}
+```
+
+## Related
+
+- [`audit-log-v1`](../../../../docs/contracts/audit-log-v1.md) — the frozen
+  JSONL contract this object rides on; the `orchestration` field is optional
+  and additive, schema_version unchanged.
+- [`host-capability-manifest`](host-capability-manifest.md) — the manifest that
+  decides whether a dispatch is even attempted; `spawn_count` and `tiers`
+  reflect what it enabled.
+  Phase-0 instrumentation belongs to.

package/dist/agent-src/contexts/execution/roadmap-process-loop.md

@@ -259,9 +259,14 @@ Loop MUST:
    On picks 3 / 4 / 5 → apply change, re-evaluate decision table,
    archive when gate clears.
 
-`count_deferred == 0` → archive proceeds via
-[`roadmap-management`](../../skills/roadmap-management/SKILL.md) skill
-(`git mv`, regen).
+`count_deferred == 0` → archive. **Primary:** `archive_completed_roadmaps --all`
+— untracked-safe (`git mv`, or plain `mv` in a pre-first-commit / untracked
+consumer), rewrites inbound refs (index when tracked, filesystem when not),
+regens dashboard; PR-independent (gap B). **Fallback (script not vendored):**
+emit a one-line vendor instruction (`agents:init`), then the manual procedure in
+[`roadmap-management`](../../skills/roadmap-management/SKILL.md) (mkdir
+`archive/`, `mv`, ref-rewrite, regen). NEVER silently `git mv` (fails on
+untracked, leaves a completed roadmap rotting).
 
 ## Scope deltas — what each wrapper binds
 

package/dist/agent-src/contexts/execution/subagent-response-contract.md

@@ -0,0 +1,56 @@
+# Subagent Response Contract (Phase 3 / A3)
+
+The structured body a subagent returns inside the 4-status envelope. The status
+([`subagent-steering`](subagent-steering.md): `DONE` / `DONE_WITH_CONCERNS` /
+`NEEDS_CONTEXT` / `BLOCKED`) stays the envelope; this is the **body** the
+orchestrator synthesises and re-verifies.
+
+## Shape
+
+```json
+{
+  "summary": "",
+  "findings": [{ "title": "", "evidence_refs": ["file:line | id | path"], "mutating": false }],
+  "risks": [],
+  "confidence": "low | medium | high",
+  "handoff": ""
+}
+```
+
+- **Refs, not bodies.** `evidence_refs` are ref tokens (`file:line`, ids, paths),
+  never inline content — same minimal-slice / privacy floor as the spawn contract.
+- `mutating` marks a finding whose action changes files/state (feeds the verify link).
+
+## Orchestrator synthesis duties
+
+```
+NEVER ADOPT A SUBAGENT RETURN UNVERIFIED.
+```
+
+On collecting returns, the orchestrator MUST:
+
+1. **Dedupe** findings across subagents.
+2. **Mark contradictions** between returns (do not silently pick one).
+3. **Re-check evidence gaps** — a finding with no `evidence_refs` is an unbacked
+   claim; resolve it with a real tool before adopting (`synthesisGaps`).
+4. **Downgrade or reject** risky findings; the final decision is the orchestrator's.
+
+## Confidence → verify-budget link
+
+A **mutating** finding returned at **`low`** confidence forces the full
+cross-model judge path — no deterministic-only pass — per
+[`verify-budget`](verify-budget.md) (`forcesJudge`). High-confidence trivial
+findings may still take the deterministic path. The chosen `verify_mode` is
+recorded in [`orchestration-telemetry`](orchestration-telemetry.md).
+
+## Reference implementation
+
+[`src/scripts/_lib/subagent_response.ts`](../../../../src/scripts/_lib/subagent_response.ts)
+(`validateResponse`, `synthesisGaps`, `forcesJudge`), covered by
+[`tests/scripts/_lib_subagent_response.test.ts`](../../../../tests/scripts/_lib_subagent_response.test.ts).
+
+## Related
+
+- [`subagent-steering`](subagent-steering.md) — the 4-status envelope + lifecycle this body rides in.
+- [`verify-budget`](verify-budget.md) — the deterministic-vs-judge budget the confidence link feeds.
+- [`verify-before-complete`](../../rules/verify-before-complete.md) — the Iron Law behind "never adopt unverified".

package/dist/agent-src/contexts/execution/subagent-routing.md

@@ -0,0 +1,57 @@
+# Subagent Routing (Phase 2 — downshift + quota arbitrage)
+
+How a delegated sub-task's model is chosen. The orchestrator stays on the
+session / high tier and routes each sub-task to the **lowest-capable** tier it
+declares (cost + speed via model downshift). Quota arbitrage is an optional
+bonus layered on top. Vendor-neutral throughout — no `.md` here names a
+provider's model or billing rule.
+
+## Inputs
+
+- The sub-task's declared `model_tier` (`lite | medium | high | inherit`,
+  per [`model-recommendations`](../model-recommendations.md)).
+- `subagents.downshift`, `subagents.quota_arbitrage`, `subagents.model_map`
+  (see [`auto-orchestration-activation`](auto-orchestration-activation.md)).
+- The host-capability manifest's `separate_quota_pool`
+  ([`host-capability-manifest`](host-capability-manifest.md)).
+
+## Policy
+
+```
+ORCHESTRATOR STAYS ON THE SESSION / HIGH TIER.
+A SUB-TASK RUNS ON THE LOWEST-CAPABLE TIER IT DECLARES (downshift on).
+QUOTA ARBITRAGE IS A BONUS, NEVER LOAD-BEARING — REMOVE IT AND ROUTING IS
+THE SAME MINUS THE QUOTA WIN.
+```
+
+1. **Downshift off** (`downshift: false`) → every sub-task runs on the session
+   tier. No routing change.
+2. **Downshift on** → a sub-task runs on its declared tier; an `inherit` task
+   runs on the session tier. The tier resolves to a model alias via
+   `model_map`; an empty entry means "use the tier's runtime default" — never a
+   baked-in provider model name.
+3. **Quota arbitrage** → prefer the **separate** quota pool for the sub-task
+   **only when** `subagents.quota_arbitrage == true` **and**
+   `manifest.separate_quota_pool == true`. Otherwise the shared pool is used and
+   the tier/model choice is unchanged. This is the only place the
+   "Sonnet-has-its-own-allowance" idea lives, and it lives as a runtime-detected
+   flag, never as portable prose.
+
+## Why vendor-neutral
+
+A separate-quota-pool is a billing quirk of one host at one time. Encoding it
+as `manifest.separate_quota_pool` (resolved per host) keeps the package
+portable: hosts without it route identically, just without the bonus. No skill,
+rule, or context asserts "model X is free".
+
+## Reference implementation
+
+[`src/scripts/_lib/subagent_routing.ts`](../../../../src/scripts/_lib/subagent_routing.ts)
+(`resolveSubagentRouting`), covered by
+[`tests/scripts/_lib_subagent_routing.test.ts`](../../../../tests/scripts/_lib_subagent_routing.test.ts).
+
+## Related
+
+- [`subagent-configuration`](../subagent-configuration.md) — implementer/judge model + parallelism.
+- [`auto-orchestration-activation`](auto-orchestration-activation.md) — the enable/auto gate that runs first.
+- [`host-capability-manifest`](host-capability-manifest.md) — source of `separate_quota_pool`.

package/dist/agent-src/contexts/execution/subagent-spawn-contract.md

@@ -0,0 +1,54 @@
+# Subagent Spawn Contract (Phase 3 — task-optimal configuration)
+
+How a delegated subagent is configured for its task. Composes the package's
+existing config seams — role-mode + profile + persona + a **minimal** knowledge
+slice — into a single spawn brief, so each subagent reacts optimally to its
+task without re-inventing any taxonomy.
+
+## The brief
+
+```json
+{
+  "task": "<the sub-task>",
+  "role_mode": "developer|reviewer|tester|po|incident|planner|null",
+  "profile": "<active profile id or null>",
+  "personas": ["<persona id>", "..."],
+  "knowledge_refs": ["<id-or-path>", "..."]
+}
+```
+
+## Selection — reuse existing seams, no new taxonomy
+
+| Element | Source |
+|---|---|
+| `role_mode` | The six contracts in [`role-contracts`](../../../docs/guidelines/agent-infra/role-contracts.md). A review sub-task → `reviewer`; a planning sub-task → `planner`; default → null (no contract). |
+| `profile` | The active profile (`profile.id` in `.agent-settings.yml`); inherited from the session unless the sub-task is a different domain. |
+| `personas` | The persona ids already cited in the task's skill frontmatter (review lenses). Capped at 2 (`MAX_PERSONAS`). |
+| `knowledge_refs` | A SMALL set of knowledge references (ingest ids / file paths) relevant to the sub-task. Capped at 5 (`MAX_KNOWLEDGE_REFS`). |
+
+Nothing here defines a new role / persona / profile — it selects from what the
+package already ships.
+
+## Minimal-slice — hard invariant
+
+```
+KNOWLEDGE IS PASSED AS A FEW REFERENCES, NEVER AS INLINE BODIES.
+NEVER BULK-DUMP CONTEXT INTO A SUBAGENT.
+```
+
+Per [`lethal-trifecta-guard`](../../rules/lethal-trifecta-guard.md), the
+private-data leg stays narrow: the composer rejects inline bodies (multi-line /
+oversized entries), accepts only ref-like tokens, and caps the count. Anything
+dropped is recorded in `warnings` and surfaced — never silently widened.
+
+## Reference implementation
+
+[`src/scripts/_lib/subagent_spawn.ts`](../../../../src/scripts/_lib/subagent_spawn.ts)
+(`composeSpawnBrief`), covered by
+[`tests/scripts/_lib_subagent_spawn.test.ts`](../../../../tests/scripts/_lib_subagent_spawn.test.ts).
+
+## Related
+
+- [`auto-orchestration-activation`](auto-orchestration-activation.md) — runs before this; decides IF a subagent spawns.
+- [`subagent-routing`](subagent-routing.md) — decides WHICH model the subagent runs on.
+- [`role-mode-adherence`](../../rules/role-mode-adherence.md) — the role contract a spawned `role_mode` must honour.

package/dist/agent-src/contexts/execution/subagent-steering.md

@@ -0,0 +1,71 @@
+# Subagent Steering & Guardrails (Phase 5)
+
+First-class lifecycle for auto-dispatched subagents, plus the guardrails that
+keep "auto-dispatch by default" from becoming a token sink.
+
+## Lifecycle
+
+```
+dispatch → monitor → status → escalate / kill
+```
+
+- **dispatch** — spawn per the [`spawn contract`](subagent-spawn-contract.md),
+  routed per [`subagent-routing`](subagent-routing.md).
+- **monitor** — where the host manifest reports `status_polling: true`, check
+  progress; otherwise fire-and-collect.
+- **status** — every return uses the fixed 4-status envelope from
+  [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md):
+  `DONE` · `DONE_WITH_CONCERNS` · `NEEDS_CONTEXT` · `BLOCKED`.
+- **escalate / kill** — the orchestrator may kill a runaway subagent and
+  escalate to the user. **The orchestrator never merges autonomously** —
+  integration is the orchestrator's call after verification, never the
+  subagent's.
+
+## Budget + parallel cap
+
+- The N=3 autonomous budget (`autonomous-execution`) binds **per validation
+  target**: three consecutive failed attempts on the same target halts the run
+  and surfaces the three attempts. `budgetHalt()` is the deterministic counter.
+- `subagents.max_parallel` caps concurrent dispatch. No speculative fan-out:
+  a subagent is spawned only for a classified-delegable target, never on spec.
+
+## Rollback guardrails — surfaced, not auto-disabled
+
+```
+A CONFIG PACKAGE RUNS NO DAEMON. THERE IS NO AUTOMATIC COHORT-DISABLE.
+BREACHES ARE SURFACED FROM THE AUDIT LOG FOR THE MAINTAINER / USER TO ACT ON.
+THE ONLY AUTOMATIC STOP IS THE PER-TARGET N=3 BUDGET.
+```
+
+The guardrail thresholds (`breachedGuardrails()`), read off the
+[`orchestration-telemetry`](orchestration-telemetry.md) audit signals:
+
+| Signal | Threshold | Meaning when breached |
+|---|---|---|
+| `token_blowup` | spend > 2× single-agent baseline | the layer is costing more than it saves |
+| `spawn_failure` | > 10% of spawns fail | host/primitive instability — degrade to single-agent |
+| `verify_skip` | > 1% complete without required verification | safety gap — investigate immediately |
+| `user_override` | > 30% of users set the layer off | the default is wrong for this population |
+
+A breach is a maintainer/user signal, surfaced — never an automatic flip.
+
+## Kill-switch
+
+```
+subagents.enabled: false   (or  subagents.auto: off)
+```
+
+A single, no-deploy settings flip fully disables the layer (`isLayerDisabled()`).
+This is the canonical disable — no code change, effective on the next run.
+
+## Reference implementation
+
+[`src/scripts/_lib/subagent_steering.ts`](../../../../src/scripts/_lib/subagent_steering.ts)
+(`isLayerDisabled`, `budgetHalt`, `breachedGuardrails`), covered by
+[`tests/scripts/_lib_subagent_steering.test.ts`](../../../../tests/scripts/_lib_subagent_steering.test.ts).
+
+## Related
+
+- [`autonomous-execution`](../../rules/autonomous-execution.md) — the N=3 budget.
+- [`auto-orchestration-activation`](auto-orchestration-activation.md) — `enabled`/`auto` keys.
+- [`orchestration-telemetry`](orchestration-telemetry.md) — the audit signals the guardrails read.

package/dist/agent-src/contexts/execution/verify-budget.md

@@ -0,0 +1,50 @@
+# Verification Budget (Phase 4)
+
+How auto-delegated work is verified without double-costing every trivial
+delegation. Preserves `verify-before-complete` and the cross-model judge Iron
+Law of [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md),
+while letting trivial sub-tasks skip a full LLM judge pass.
+
+## The budget
+
+```
+TRIVIAL (below the change-size floor, read-only / no file writes)
+  → DETERMINISTIC verification: diff + dry-run + structural checks. No LLM judge.
+OTHERWISE
+  → FULL CROSS-MODEL JUDGE (judge on a different model than the implementer).
+A REQUIRED VERIFICATION THAT DID NOT RUN IS A SURFACED SAFETY GAP — NEVER A
+SILENT PASS.
+```
+
+The change-size floor (`TRIVIAL_CHANGE_FLOOR`) is the line at which the cost of
+a judge pass exceeds its benefit. Read-only sub-tasks (queries, analysis with no
+mutation) always verify deterministically — there is nothing to mis-write.
+
+## Recording + the gap check
+
+Every dispatch records its `verify_mode` (`deterministic` | `judge` | `none`)
+in the [`orchestration-telemetry`](orchestration-telemetry.md) object on the
+audit-log line. After a dispatch, the orchestrator compares the **required**
+mode (from the change shape) against the **recorded** mode; a required
+verification recorded as `none`, or a non-trivial change verified only
+deterministically, is a **gap** that is surfaced to the user — it never passes
+silently. This is the audit-visible enforcement of the Iron Law.
+
+## Why this does not weaken the floor
+
+`deterministic` is still verification — a real diff + dry-run + structural
+check, not "skip it". The judge Iron Law still fires on every non-trivial,
+mutating change. The budget only removes a redundant LLM pass on changes too
+small to carry risk, where the deterministic check is sufficient evidence.
+
+## Reference implementation
+
+[`src/scripts/_lib/verify_budget.ts`](../../../../src/scripts/_lib/verify_budget.ts)
+(`selectVerifyMode`, `verificationGap`), covered by
+[`tests/scripts/_lib_verify_budget.test.ts`](../../../../tests/scripts/_lib_verify_budget.test.ts).
+
+## Related
+
+- [`verify-before-complete`](../../rules/verify-before-complete.md) — the Iron Law this preserves.
+- [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md) — the cross-model judge law.
+- [`orchestration-telemetry`](orchestration-telemetry.md) — where `verify_mode` is recorded.

package/dist/agent-src/rules/brand-source-of-truth.md

@@ -51,7 +51,17 @@ corpus from quietly replacing a value the brand already defines.
   marked as corpus-sourced, until `brand-identity` defines real tokens.
 - Non-brand surfaces.
 
+## Design register note
+
+When a consumer brand profile is present, the brand register ("the impression IS
+the product") is active — use `brand-identity`, `iconography`, and
+`design-intelligence` as the primary skill cluster. For product/dashboard/admin
+surfaces within the same brand, the product register ("design serves the task")
+may apply per-surface. See [`docs/guidelines/design-modes.md`](../docs/guidelines/design-modes.md)
+for the full Brand-mode vs Product-mode discriminator.
+
 ## See also
 
 - [`brand-consistency`](brand-consistency.md) — validates emitted artifacts against the authoritative brand profile this rule establishes.
 - [`brand`](../skills/brand/SKILL.md) — the gap-fill corpus this rule subordinates to consumer brand.
+- [`docs/guidelines/design-modes.md`](../docs/guidelines/design-modes.md) — brand vs product register discriminator and routing.

package/dist/agent-src/rules/delegation-policy.md

@@ -0,0 +1,85 @@
+---
+type: "auto"
+tier: "2b"
+alwaysApply: false
+source: "package"
+description: "Delegable multi-part work + auto-orchestration enabled — decompose, tier-size each slice, dispatch to subagents instead of doing it all in-session"
+triggers:
+  - keyword: "delegate"
+  - keyword: "orchestrate"
+  - keyword: "subagent"
+  - keyword: "parallel"
+  - phrase: "review these"
+  - phrase: "analyze the codebase"
+  - phrase: "for each"
+load_context:
+  - "../contexts/execution/auto-orchestration-activation.md"
+  - "../contexts/execution/auto-dispatch-classification.md"
+routes_to:
+  - "skill:subagent-orchestration"
+workspaces:
+  - engineering
+packs:
+  - engineering-base
+---
+
+# Delegation Policy
+
+The loadable auto-trigger for the automatic subagent-orchestration layer. It is
+the single source of the "delegate by default" behaviour — the
+`subagent-orchestration` skill and `reasoning-orchestrator` point here rather
+than restating the trigger.
+
+## The Iron Law
+
+```
+WHEN THE ACTIVATION GATE CLEARS, DECOMPOSE THE TASK, TIER-SIZE EACH SLICE,
+AND DISPATCH TO SUBAGENTS — DO NOT DO ALL THE WORK IN-SESSION.
+AMBIGUITY DEFAULTS TO ask / no-op — NEVER SPECULATIVE SPAWN.
+THE ORCHESTRATOR NEVER ADOPTS A SUBAGENT RETURN UNVERIFIED.
+```
+
+## When it fires
+
+Only when the activation gate from
+[`auto-orchestration-activation`](../contexts/execution/auto-orchestration-activation.md)
+clears — all of:
+
+- `subagents.enabled` **and** `subagents.auto != off`,
+- the host-capability manifest reports `subagent_spawn: true`,
+- the task is classified **delegable** per
+  [`auto-dispatch-classification`](../contexts/execution/auto-dispatch-classification.md)
+  (≥1 independent, well-specified slice above the size floor).
+
+`subagents.auto: ask` → ask once before dispatching (per
+[`user-interaction`](user-interaction.md)); `auto: on` → surface the chosen mode
++ per-subtask tiers in one line. Any gate failing, or `auto: off`, or no host
+primitive → run in-session (clean no-op).
+
+## What it makes binding
+
+1. **Decompose** the task into independent / ordered slices.
+2. **Tier-size** each slice (`lite|medium|high`) per the classification context —
+   never the orchestrator's own session tier (the cost win is the per-call
+   downsize; see [`subagent-routing`](../contexts/execution/subagent-routing.md)).
+3. **Dispatch** via the matching `subagent-orchestration` mode (independent →
+   do-in-parallel; ordered → do-in-steps; risk/correctness → + judge).
+4. **Verify** every return per
+   [`verify-budget`](../contexts/execution/verify-budget.md); the cross-model
+   judge Iron Law and the N=3 budget ([`autonomous-execution`](autonomous-execution.md))
+   are never lifted.
+
+## Scope — does NOT
+
+- Make the orchestrator switch its **own** model (the user owns `/model`).
+- Fire on trivial / single-step / fully-in-head work.
+- Spawn on an unclassifiable task — that is ask/no-op, not a speculative spawn.
+- Lift any safety floor or delegate a Hard-Floor action
+  ([`non-destructive-by-default`](non-destructive-by-default.md)).
+
+## See also
+
+- [`subagent-orchestration`](../skills/subagent-orchestration/SKILL.md) — the 7 modes this selects.
+- [`subagent-boundary`](../docs/contracts/subagent-boundary.md) — what a subagent owns vs never owns (task-meaning, memory, pack-surface, safety-floor bypass).
+- [`auto-orchestration-activation`](../contexts/execution/auto-orchestration-activation.md) — the gate.
+- [`reasoning-orchestrator`](../skills/reasoning-orchestrator/SKILL.md) — RDP dispatch, now gated here.