cairn-ai 0.4.0 → 0.4.1

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cairn",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Token-efficient agent harness with tool readiness for Codex, Claude Code, and Antigravity.",
   "author": {
     "name": "WkNam"

package/docs/model-guidance/README.md

@@ -50,7 +50,7 @@ The goal is not to make prompts long by model. The goal is to stabilize the same
 
 ## Model and Reasoning Effort Routing
 
-- The plan decides each task's model from its nature and records `Requested model` and `Effective model`; models are not always inherited. Tiers: fast = read-only exploration, search, inventory, summarization (Claude Code `haiku`); balanced = Light Path implementation and routine verification (`sonnet`); stronger = planning, complexity triage, Heavy Path implementation, review, and final verification/review (`opus`); strongest = Heavy Path design only (`fable`). Antigravity `invoke_subagent` `Model` accepts only a tier enum (fast `flash_lite`, balanced `flash`, stronger `pro`, strongest `pro`; no tier above `pro`) and has no effort option, so Effective reasoning effort is `inherited`. Codex slugs: fast `gpt-6-luna`, balanced `gpt-6.1-terra`, stronger `gpt-6-sol`, strongest `gpt-6-astra`.
+- The plan decides each task's model from its nature and records `Requested model` and `Effective model`; models are not always inherited. Tiers: fast = read-only exploration, search, inventory, summarization (Claude Code `haiku`); balanced = Light Path implementation and routine verification (`sonnet`); stronger = planning, complexity triage, Heavy Path implementation, review, and final verification/review (`opus`); strongest = Heavy Path design only (`fable`), run as a separate `kind: "design"` task dispatched to that tier rather than part of planning. Antigravity `invoke_subagent` `Model` accepts only a tier enum (fast `flash_lite`, balanced `flash`, stronger `pro`, strongest `pro`; no tier above `pro`) and has no effort option, so Effective reasoning effort is `inherited`. Codex slugs: fast `gpt-6-luna`, balanced `gpt-6.1-terra`, stronger `gpt-6-sol`, strongest `gpt-6-astra`.
 - Model Effective: passed and not rejected is that value; not passed is `not-applied: <reason>`; `inherited` only when the host has no model option. If a lower-tier worker fails a gate, re-dispatch that task one tier up (fast, balanced, stronger, strongest) before recording a blocker.
 - Routing is per dispatch only; never change model or global/user config files. `Model routing: inherited` in `MEMORY.md` or the plan disables per-task selection.
 - Light Path planning, implementation, and verification request `medium`.

package/docs/model-guidance/claude.md

@@ -18,7 +18,7 @@ Claude-family models are strong at long-context retention, policy interpretation
 - Do not skip the two verification gates even on Light Path.
 - Do not approve a plan that lacks dry-run or check evidence for external-state-changing work.
 - Do not allow open-ended verification loops. Require a blocker or sub-task split after two failed passes.
-- Choose the model per task (fast `haiku`, balanced `sonnet`, stronger `opus`: planning, triage, Heavy implementation, review, final verification/review; strongest `fable`: Heavy design only) and record `Requested model`/`Effective model`; Effective is the passed value, `not-applied: <reason>`, or `inherited` when the host has no model option. Re-dispatch one tier up (fast, balanced, stronger, strongest) if a lower-tier worker fails a gate. `Model routing: inherited` disables this. `Requested reasoning effort` is Cairn's desired profile; `Effective reasoning effort` is what the dispatch response confirms. Every new task/worker dispatch MUST pass the task's requested effort through the host option together with the chosen model; recording without passing is a defect. Effective is the requested value when the dispatch passed it and the host did not reject it, `not-applied: <reason>` when it was not passed, and `inherited` only when the host exposes no effort option. Infer capability only from the exposed interface or dispatch response, distinguish Cairn non-integration from host non-support, and change no global/user configuration.
+- Choose the model per task (fast `haiku`, balanced `sonnet`, stronger `opus`: planning, triage, Heavy implementation, review, final verification/review; strongest `fable`: Heavy design only, as a separate `kind: "design"` task dispatched to that tier rather than part of planning) and record `Requested model`/`Effective model`; Effective is the passed value, `not-applied: <reason>`, or `inherited` when the host has no model option. Re-dispatch one tier up (fast, balanced, stronger, strongest) if a lower-tier worker fails a gate. `Model routing: inherited` disables this. `Requested reasoning effort` is Cairn's desired profile; `Effective reasoning effort` is what the dispatch response confirms. Every new task/worker dispatch MUST pass the task's requested effort through the host option together with the chosen model; recording without passing is a defect. Effective is the requested value when the dispatch passed it and the host did not reject it, `not-applied: <reason>` when it was not passed, and `inherited` only when the host exposes no effort option. Infer capability only from the exposed interface or dispatch response, distinguish Cairn non-integration from host non-support, and change no global/user configuration.
 - In Claude Code, pass model with the Agent tool `model` parameter (`haiku|sonnet|opus|fable`) and effort with `effort` (`low|medium|high|xhigh|max`, same as Cairn values), for example `{"description": "Implement task-1", "subagent_type": "general-purpose", "model": "sonnet", "effort": "medium", "prompt": "..."}`. `subagent_type: "fork"` ignores `model` and `effort`; never dispatch routed work as a fork.
 - On Heavy Path, check plan gaps before implementation.
 - Review all three complexity records: the provisional request checkpoint, post-exploration planning checkpoint, and code checkpoint after exact file/caller/test inspection immediately before the first edit. Before editing, evidence may change either route. Every change must synchronize the plan artifact, repository goal task roadmap through `goal replan`, and native UI plan, including reviews and required evidence. After editing begins, a new Heavy signal promotes Light Path to Heavy Path: stop further edits, mark affected evidence stale, synchronize all three roadmaps, and repeat the code checkpoint.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cairn-ai",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Token-efficient agent harness with tool readiness for Codex, Claude Code, and Antigravity",
   "license": "MIT",
   "author": {

package/scripts/cairn-goal-cli.mjs

@@ -54,6 +54,7 @@ export async function runGoalCli(args, {
       status: options.status ?? taskAction ?? positional[1],
       blocker: options.reason,
       effortWaiver: options["allow-inherited-effort"],
+      designWaiver: options["allow-no-design-model"],
     });
     emit(JSON.stringify(state));
     return state;
@@ -77,6 +78,10 @@ export async function runGoalCli(args, {
       effortSource: options["effort-source"],
       route: options.route,
       effortWaiver: options["allow-inherited-effort"],
+      kind: options.kind,
+      model: options.model,
+      modelSource: options["model-source"],
+      designWaiver: options["allow-no-design-model"],
     });
     const task = state.tasks.find((item) => item.id === String(options.task ?? positional[0]).trim());
     if (task?.route === "heavy" && task.assignedAgentId && (!task.effort || task.effortSource === "not-applied")) {
@@ -214,10 +219,10 @@ function allowedOptions(command) {
   const byCommand = {
     start: ["goal", "plan", "tasks", "criteria", "requiredEvidence", "session", "evidencePolicy", "evidence-policy"],
     status: [],
-    task: ["task", "status", "reason", "allow-inherited-effort"],
+    task: ["task", "status", "reason", "allow-inherited-effort", "allow-no-design-model"],
     replan: ["tasks"],
     claim: ["session"],
-    assign: ["task", "agent", "effort", "effort-source", "route", "allow-inherited-effort"],
+    assign: ["task", "agent", "effort", "effort-source", "route", "allow-inherited-effort", "kind", "model", "model-source", "allow-no-design-model"],
     receipt: ["task", "kind", "scope", "command", "exitCode", "exit-code", "exit", "timestamp", "goalId", "goal-id", "plan"],
     verify: ["task", "kind", "scope", "watch", "timeout-ms"],
     finish: ["watch", "timeout-ms"],

package/scripts/cairn-goal-operations-evidence.mjs

@@ -182,6 +182,10 @@ export function goalStats(state, root = process.cwd()) {
       effort: task.effort ?? null,
       effortSource: task.effortSource ?? null,
       ...(task.effortWaiver ? { effortWaiver: task.effortWaiver } : {}),
+      ...(task.kind ? { kind: task.kind } : {}),
+      ...(task.model ? { model: task.model } : {}),
+      ...(task.modelSource ? { modelSource: task.modelSource } : {}),
+      ...(task.designWaiver ? { designWaiver: task.designWaiver } : {}),
     })),
   };
 }

package/scripts/cairn-goal-operations.mjs

@@ -5,9 +5,9 @@ import { assertNoSymlinkComponents } from "./cairn-safe-fs.mjs";
 import { goalStatePath, readGoalState, readGoalStateUnlocked, withGoalStateLock, writeGoalStateUnlocked } from "./cairn-goal-state.mjs";
 import {
   GOAL_STATE_VERSION, PLAN_ID_MAX_LENGTH, assertRecoveryReferenceBudget, boundedRequiredText,
-  assertCanBeActive, assertEffortRecord, assertTaskGraph,
+  assertCanBeActive, assertEffortRecord, assertModelRecord, assertTaskGraph,
   defaultGoalEvidence, normalizeCriteria, normalizeTask, optionalText, requiredText,
-  terminalGoalStatuses, timestamp, validEvidencePolicy, validGoalStatus, validTaskRoute, validTaskStatus, validateState,
+  terminalGoalStatuses, timestamp, validEvidencePolicy, validGoalStatus, validTaskKind, validTaskRoute, validTaskStatus, validateState,
 } from "./cairn-goal-state-validation.mjs";
 import {
   advanceGoal, assertGoalMutable, ensureGoalCanComplete, ensureTaskCanComplete,
@@ -119,11 +119,13 @@ function applyGoalTransition(state, nextStatus, blocker, root) {
   return state;
 }
 
-export async function setTaskStatus({ root = process.cwd(), taskId, status, blocker, effortWaiver } = {}) {
+export async function setTaskStatus({ root = process.cwd(), taskId, status, blocker, effortWaiver, designWaiver } = {}) {
   const nextStatus = validTaskStatus(status);
   const normalizedTaskId = requiredText(taskId, "taskId");
   const normalizedWaiver = optionalText(effortWaiver, "effortWaiver");
   if (normalizedWaiver !== null && nextStatus !== "completed") throw new Error("--allow-inherited-effort applies only when completing a task");
+  const normalizedDesignWaiver = optionalText(designWaiver, "designWaiver");
+  if (normalizedDesignWaiver !== null && nextStatus !== "completed") throw new Error("--allow-no-design-model applies only when completing a task");
   return mutateGoal(root, (state) => {
     assertGoalMutable(state);
     const task = taskById(state, normalizedTaskId);
@@ -134,7 +136,9 @@ export async function setTaskStatus({ root = process.cwd(), taskId, status, bloc
     }
     if (nextStatus === "completed") {
       if (normalizedWaiver !== null) task.effortWaiver = normalizedWaiver;
+      if (normalizedDesignWaiver !== null) task.designWaiver = normalizedDesignWaiver;
       ensureHeavyEffortApplied(task);
+      ensureHeavyDesignRecorded(state, task);
       ensureTaskCanComplete(state, task, root);
     }
     if (nextStatus === "blocked") task.blocker = requiredText(blocker, "blocker");
@@ -201,10 +205,24 @@ function ensureHeavyEffortApplied(task) {
   throw new Error(`Heavy task ${task.id} assigned to ${task.assignedAgentId} has no applied effort (effort ${task.effort ?? "none"}, source ${source ?? "none"}); record goal assign ${task.id} --effort <low|medium|high|xhigh|max> --effort-source host-option, or complete with --allow-inherited-effort <reason>`);
 }
 
+// A kind "design" task must record the strongest-tier model it was dispatched with (host-option). Any other assigned
+// Heavy task needs a completed design task in the goal. A designWaiver reason bypasses both; Light and unassigned
+// tasks are not checked.
+function ensureHeavyDesignRecorded(state, task) {
+  if (task.designWaiver) return;
+  if (task.kind === "design") {
+    if (task.model && task.modelSource === "host-option") return;
+    throw new Error(`Design task ${task.id} has no recorded design model (model ${task.model ?? "none"}, source ${task.modelSource ?? "none"}); dispatch it to the strongest tier and record goal assign ${task.id} --model <value> --model-source host-option, or complete with --allow-no-design-model <reason>`);
+  }
+  if (task.route !== "heavy" || !task.assignedAgentId) return;
+  if (state.tasks.some((item) => item.kind === "design" && item.status === "completed")) return;
+  throw new Error(`Heavy task ${task.id} assigned to ${task.assignedAgentId} has no completed design task; add a kind "design" task with goal replan, complete it with goal assign <design-task> --model <value> --model-source host-option, or complete with --allow-no-design-model <reason>`);
+}
+
 // Omitted effort/route/waiver options keep stored values, so a reassignment can change only the agent. When effort
 // or effortSource is given, both are replaced together; an omitted source is inferred from the effort.
 export async function assignTask({
-  root = process.cwd(), taskId, agentId = null, effort, effortSource, route, effortWaiver,
+  root = process.cwd(), taskId, agentId = null, effort, effortSource, route, effortWaiver, kind, model, modelSource, designWaiver,
 } = {}) {
   const normalizedTaskId = requiredText(taskId, "taskId");
   const normalizedAgentId = agentId === null ? null : requiredText(agentId, "agentId");
@@ -215,6 +233,12 @@ export async function assignTask({
     if (normalizedEffort === null && normalizedSource !== "not-applied") throw new Error("--effort-source requires --effort unless it is not-applied");
     assertEffortRecord(normalizedEffort, normalizedSource, "assign");
   }
+  const modelGiven = model !== undefined || modelSource !== undefined;
+  const normalizedModel = model === undefined || model === null ? null : requiredText(model, "model");
+  const normalizedModelSource = modelSource ?? (normalizedModel === null ? null : normalizedModel === "inherited" ? "inherited" : "host-option");
+  if (modelGiven) assertModelRecord(normalizedModel, normalizedModelSource, "assign");
+  const normalizedKind = kind === undefined ? undefined : validTaskKind(kind);
+  const normalizedDesignWaiver = designWaiver === undefined ? undefined : requiredText(designWaiver, "designWaiver");
   const normalizedRoute = route === undefined ? undefined : validTaskRoute(route);
   const normalizedWaiver = effortWaiver === undefined ? undefined : requiredText(effortWaiver, "effortWaiver");
   return mutateGoal(root, (state) => {
@@ -225,6 +249,12 @@ export async function assignTask({
       task.effort = normalizedEffort;
       task.effortSource = normalizedSource;
     }
+    if (modelGiven) {
+      task.model = normalizedModel;
+      task.modelSource = normalizedModelSource;
+    }
+    if (normalizedKind !== undefined) task.kind = normalizedKind;
+    if (normalizedDesignWaiver !== undefined) task.designWaiver = normalizedDesignWaiver;
     if (normalizedRoute !== undefined) task.route = normalizedRoute;
     if (normalizedWaiver !== undefined) task.effortWaiver = normalizedWaiver;
     task.updatedAt = timestamp();

package/scripts/cairn-goal-state-validation.mjs

@@ -25,6 +25,7 @@ export const TASK_ROUTES = new Set(["light", "heavy"]);
 export const CONCRETE_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
 export const TASK_EFFORTS = new Set([...CONCRETE_EFFORTS, "inherited"]);
 export const EFFORT_SOURCES = new Set(["host-option", "inherited", "not-applied"]);
+export const TASK_KINDS = new Set(["design"]);
 
 export function validateState(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Cairn goal state must be an object");
@@ -66,6 +67,9 @@ export function validateState(value) {
     if (task.route !== null && task.route !== undefined) validTaskRoute(task.route, `task ${task.id} route`);
     assertEffortRecord(task.effort ?? null, task.effortSource ?? null, `task ${task.id}`);
     if (task.effortWaiver !== null && task.effortWaiver !== undefined) requiredText(task.effortWaiver, `task ${task.id} effortWaiver`);
+    if (task.kind !== null && task.kind !== undefined) validTaskKind(task.kind, `task ${task.id} kind`);
+    assertModelRecord(task.model ?? null, task.modelSource ?? null, `task ${task.id}`);
+    if (task.designWaiver !== null && task.designWaiver !== undefined) requiredText(task.designWaiver, `task ${task.id} designWaiver`);
     validTimestamp(task.createdAt);
     validTimestamp(task.updatedAt);
   }
@@ -120,6 +124,10 @@ export function normalizeTask(task, index, defaultStatus, previousTaskId = null)
     effort: null,
     effortSource: null,
     effortWaiver: null,
+    kind: source.kind === undefined || source.kind === null ? null : validTaskKind(source.kind, `tasks[${index}].kind`),
+    model: null,
+    modelSource: null,
+    designWaiver: null,
     blocker: null,
     createdAt: timestamp(),
     updatedAt: timestamp(),
@@ -131,6 +139,20 @@ export function validTaskRoute(value, label = "route") {
   return value;
 }
 
+export function validTaskKind(value, label = "kind") {
+  if (!TASK_KINDS.has(value)) throw new Error(`${label} must be one of: ${[...TASK_KINDS].join(", ")}`);
+  return value;
+}
+
+// A model is a non-empty host-specific string; source "host-option" needs a model, and a model needs a source.
+export function assertModelRecord(model, source, label = "task") {
+  if (model !== null) requiredText(model, `${label} model`);
+  if (source !== null && !EFFORT_SOURCES.has(source)) throw new Error(`${label} modelSource must be one of: ${[...EFFORT_SOURCES].join(", ")}`);
+  if (source === "host-option" && model === null) throw new Error(`${label} modelSource host-option requires a model`);
+  if (source === "inherited" && model === null) throw new Error(`${label} modelSource inherited requires a model`);
+  if (model !== null && source === null) throw new Error(`${label} model requires a modelSource`);
+}
+
 // effort "inherited" pairs only with source "inherited"; source "host-option" needs a concrete level; a source
 // without an effort is only meaningful as "not-applied".
 export function assertEffortRecord(effort, source, label = "task") {

package/skills/cairn-plan/delegation.md

@@ -58,5 +58,5 @@ This skill explicitly instructs the effort level for delegated work. It also ins
 | Antigravity | `invoke_subagent` `Model` takes only a tier enum: fast `flash_lite`, balanced `flash`, stronger `pro`, strongest `pro` (no tier above `pro`); `inherit` is not used for routed work. No effort option. | model: passed value; effort: `inherited` |
 | Host without an option | None. | `inherited` |
 
-- After each dispatch, record state with `goal assign --task <id> --agent <id> --effort <value> --effort-source <host-option|inherited|not-applied>`. Mark Heavy tasks with `route: "heavy"` (tasks JSON field or `goal assign --route heavy`). A Heavy task with no effort, `not-applied`, or `inherited` fails `goal task --status completed` unless `--allow-inherited-effort <reason>` records why.
+- After each dispatch, record state with `goal assign --task <id> --agent <id> --effort <value> --effort-source <host-option|inherited|not-applied>`; for a `kind: "design"` task also `--model <value> --model-source host-option`. Mark Heavy tasks with `route: "heavy"` (tasks JSON field or `goal assign --route heavy`). A Heavy task with no effort, `not-applied`, or `inherited` fails `goal task --status completed` unless `--allow-inherited-effort <reason>` records why.
 - On every route change, synchronize the plan artifact, repository goal task roadmap through `goal replan`, native UI plan, and reasoning effort profile before mutation. Completed task profiles are preserved as audit history; incomplete task profiles are recalculated for the new path.

package/skills/cairn-plan/heavy-path.md

@@ -4,8 +4,9 @@ Reference for `cairn-plan`. Read only when a Heavy Path signal is present or a r
 
 ## Heavy Path Flow
 
-Heavy Path flow: plan -> pre-implementation review -> bounded `worker` implementation -> verification worker or read-only review.
+Heavy Path flow: plan -> Heavy design task -> pre-implementation review -> bounded `worker` implementation -> verification worker or read-only review.
 
+- On a Heavy route, `goal replan` adds a `kind: "design"` task (`heavy-design`, `route: "heavy"`, `requiredEvidence: ["designRecord"]`) after `triage-plan`, and implementation tasks depend on it. The main agent never does this design inline: dispatch it read-only to the strongest tier (Claude Code Agent `model: "fable"`, `effort: "high"`, never `fork`), record `goal assign heavy-design --model <value> --model-source host-option`, merge the result into the plan's `## Heavy Design`, and bind that plan with `goal verify --kind designRecord`. `--allow-no-design-model <reason>` is the only bypass.
 - Record the pre-implementation decisions that review must resolve before any mutation.
 - Every Heavy Path task includes an explicit automated test command and a `Tests:` evidence line; completion cannot rely on generic verification wording without test evidence.
 - Planning, review, and implementation request `high` reasoning effort; final verification and review request `xhigh` (see `cairn://skills/cairn-plan/delegation.md`).

package/skills/cairn-work/delegation.md

@@ -58,5 +58,5 @@ This skill explicitly instructs the effort level for delegated work. It also ins
 | Antigravity | `invoke_subagent` `Model` takes only a tier enum: fast `flash_lite`, balanced `flash`, stronger `pro`, strongest `pro` (no tier above `pro`); `inherit` is not used for routed work. No effort option. | model: passed value; effort: `inherited` |
 | Host without an option | None. | `inherited` |
 
-- After each dispatch, record state with `goal assign --task <id> --agent <id> --effort <value> --effort-source <host-option|inherited|not-applied>`. Mark Heavy tasks with `route: "heavy"` (tasks JSON field or `goal assign --route heavy`). A Heavy task with no effort, `not-applied`, or `inherited` fails `goal task --status completed` unless `--allow-inherited-effort <reason>` records why.
+- After each dispatch, record state with `goal assign --task <id> --agent <id> --effort <value> --effort-source <host-option|inherited|not-applied>`; for a `kind: "design"` task also `--model <value> --model-source host-option`. Mark Heavy tasks with `route: "heavy"` (tasks JSON field or `goal assign --route heavy`). A Heavy task with no effort, `not-applied`, or `inherited` fails `goal task --status completed` unless `--allow-inherited-effort <reason>` records why.
 - On every route change, synchronize the plan artifact, repository goal task roadmap through `goal replan`, native UI plan, and reasoning effort profile before edits resume. Completed task profiles are preserved as audit history; incomplete task profiles are recalculated for the new path.

package/skills/cairn-work/heavy-path.md

@@ -5,6 +5,7 @@ Reference for `cairn-work`. Read only when the recorded route is Heavy Path, a n
 ## Heavy Path Execution
 
 - Follow the full planning and review pipeline recorded in the plan without role-mapping shortcuts: pre-implementation review before mutation, bounded `worker` implementation, then verification worker or read-only review after evidence exists.
+- Heavy implementation cannot complete until a completed `kind: "design"` task exists (`--allow-no-design-model <reason>` is the only bypass).
 - Run the recorded automated test command and record explicit `Tests:` evidence in the plan before claiming completion. This is required even when module acceptance uses a broader check command.
 - Planning, review, and implementation request `high` reasoning effort; final verification and review request `xhigh`.
 

package/templates/work-plan.md

@@ -41,7 +41,7 @@ Describe the observable result.
 
 ## Reasoning Effort Profile
 
-- Model: decided per task (fast `haiku` for read-only exploration/search/summarization; balanced `sonnet` for Light implementation and routine verification; stronger `opus` for planning, complexity triage, Heavy implementation, review, and final verification/review; strongest `fable` for Heavy design only). Pass it through the host option on every dispatch (Claude Code: Agent `model`, never `fork`); re-dispatch one tier up (fast, balanced, stronger, strongest) if a lower-tier worker fails a gate; `Model routing: inherited` disables this. Never change model/global config.
+- Model: decided per task (fast `haiku` for read-only exploration/search/summarization; balanced `sonnet` for Light implementation and routine verification; stronger `opus` for planning, complexity triage, Heavy implementation, review, and final verification/review; strongest `fable` for Heavy design only, as a separate `kind: "design"` task dispatched to that tier rather than part of planning). Pass it through the host option on every dispatch (Claude Code: Agent `model`, never `fork`); re-dispatch one tier up (fast, balanced, stronger, strongest) if a lower-tier worker fails a gate; `Model routing: inherited` disables this. Never change model/global config.
 - Light Path: planning=`medium`, implementation=`medium`, verification=`medium`.
 - Heavy Path: planning/review=`high`, implementation=`high`, final verification/review=`xhigh`.
 - Host boundary: every new task/worker dispatch MUST pass the task's requested effort through the host option (Claude Code: Agent `effort`, never `fork`; Codex: host-native option). Recording without passing is a defect. Use `inherited` only when the host has no option.