chore(tasks): model-router W1-B split — floor + wiring contracts/plans, skills-dir loading decision, journal

.claude/tasks/plans/2026-10-08-model-router-floor-1835.md

@@ -0,0 +1,108 @@
+# PLAN — model-router wave 1-B1: user effort floor for the turn (dispatch-ready)
+Contract: .claude/tasks/contracts/2026-10-08-model-router-floor-1835.md
+Code: mods/model-router/hooks/register.ts (read it in full first) and
+register.test.ts. API truth: the engine-laid declarations under
+mods/model-router/.claude-plugin/types/ (claude-code/index.d.ts,
+claude-code-tools/index.d.ts).
+
+## Why
+Today the prompt rule (`ultrathink` → escalate) and a typed `/effort-<l>`
+share ONE slot (`turnMain`) with the model's `route` calls and the
+`Skill(effort-*)` bridge: last writer wins, and a later skill load resets
+the slot to the session default. A user's explicit level is therefore lost
+mid-turn. The user chose FLOOR semantics: their level is a minimum for the
+whole main turn; derived routes may go above it, never below; it also
+lifts a lower sticky `/route`.
+
+## Precedence after the change (main loop only)
+- model axis (unchanged order, floor last): `userMain ?? turnMain ?? turnFloor`
+  route's `model`, applied only with `mainModelSwitch` and the window guard.
+- effort axis: `base = (userMain ?? turnMain)?.route.effort ?? e.effort`;
+  `effort = floored(base, turnFloor?.route.effort)`.
+- `floored(effort, floor)`: no floor → `effort`; `effort` is a Level whose
+  LEVELS index ≥ the floor's → `effort`; otherwise (lower Level, a number,
+  or undefined) → `floor`.
+- The haiku omission (`effort: undefined` when the model sent starts with
+  `claude-haiku`) still runs AFTER flooring.
+- Sub-agent steps (`e.agentId` set) never read `turnFloor`.
+
+## Changes in register.ts (names as in the current file)
+1. `State`: add `turnFloor: Routed | null` with the comment `user-explicit
+   level for this turn (prompt rule, typed /effort-<l>): a floor, main loop
+   only`; reword the `turnMain` comment to `model route tool, skill table
+   row, Skill(effort-*) bridge; dropped at turn end`. `newState`:
+   `turnFloor: null`.
+2. Helpers (new, small): `const rank = (l: Level): number => LEVELS.indexOf(l)`;
+   `function floored(effort: StepIn['effort'], floor: Level | undefined)`
+   per the rule above. A helper `floorLevel(st)` returning
+   `st.turnFloor?.route.effort` is allowed if it keeps call sites short.
+3. `mainPlan`: compute `base` and `effort = floored(base, floorLevel(st))`;
+   `wanted = set?.route.model ?? st.turnFloor?.route.model`; the rest
+   (switch, window guard) unchanged.
+4. `registerPrompt` / `prompt.submit`: the non-queued branch writes
+   `st.turnFloor = routed` (instead of `st.turnMain`); the queued branch
+   (`e.turnId !== undefined && e.wait`) keeps writing `st.pendingPrompt`.
+5. `slashEffort`: write `st.turnFloor = { phase: skill, route: { effort:
+   level }, source: 'slash' }`; returned text line becomes `Effort floor
+   <level> set by model-router for this turn: nothing below it runs.`
+   followed by `\n` + the original text (prepend, never replace).
+6. `onSkillLoad` (main branch): `st.turnMain = null` unconditionally (the
+   slot no longer holds prompt or slash routes), then the table row as now.
+   `turnFloor` is never touched there.
+7. `clearRoutes` (`/route clear`): also `st.turnFloor = null`.
+   `clearLoop` (model `route({clear})`, main branch): `turnMain` only, as now.
+8. `endMainTurn`: `st.turnFloor = st.pendingPrompt; st.pendingPrompt =
+   null; st.turnMain = null;` then the existing resets.
+9. Truthful answers (main branch only; agent branches unchanged):
+   - `effortBridge`: keep the sticky sentence when `st.userMain` is set;
+     else when the floor ranks above `level`: `model-router: <skill>
+     recorded, but the user's floor <f> for this turn keeps main at <f>;
+     the <skill> skill text was not loaded.`; else the current sentence.
+   - `routedText`: keep the sticky branch; else when `p.route.effort` is
+     set and the floor ranks above it, print the effort as `<f> (user
+     floor; asked <asked>)`.
+10. Display: `mainText` appends ` · floor <f> (<phase>)` when `turnFloor` is
+    set (also after `main: session defaults`); `statusLine` appends
+    ` · floor <f>`.
+
+## Tests in register.test.ts (keep every existing test; adapt only what
+the new slot changes, e.g. the `ultrathink` test now expects the floor on
+the `main:` line). Add at least six tests whose names contain `floor`,
+using the existing boot helper, full typed inputs and bottom hooks, and
+asserting on the `main:` line or on what the bottom `turn.step` hook
+receives (drain the stream with `for await`, then `.result`):
+- `floor: ultrathink survives a model route` — prompt `ultrathink`
+  (composer, `wait: false`, no `turnId`) then route tool `orchestrate` →
+  a main step with engine effort `high` reaches the bottom at `max`.
+- `floor: a typed /effort-medium floors a lower route and allows a higher
+  one` — `$.skill.prompt({ skill: 'effort-medium', text: 'x' })` (no Skill
+  call in flight) → route tool `mechanical` → main step at `medium`;
+  then route tool `escalate` → main step at `max`.
+- `floor: survives a skill load` — ultrathink, route tool `orchestrate`,
+  then a non-effort `Skill` call (bottom `tool.call` hook registered) →
+  main step at `max`, and `main:` line no longer names `orchestrate`.
+- `floor: lifts a lower sticky route, then ends with the turn` — `/route
+  effort=low` then ultrathink → main step at `max`; fire a main
+  `turn.complete` → next main step at `low`.
+- `floor: main only` — ultrathink, spawn `Explore` (bottom `agent.spawn`
+  hook returning an `agentId`), then a step for that `agentId` → reaches
+  the bottom at `medium`, not `max`.
+- `floor: /route clear removes it` — ultrathink, `/route clear` → main
+  step keeps the engine effort.
+Optional seventh: the bridge context line names the floor when it wins.
+
+## Constraints
+- Style: ≤ 25 logic lines per function, 80 chars per line, no `any`, no
+  module-level mutable state, doc comments state intent.
+- Do not touch: the agent axis, the spawn table, config loading, the
+  hardening (caps, warnOnce, safely), the route tool schema.
+- Verify (paste outputs): `claude plugin validate .`, the contract's tsc
+  command, `claude plugin test .`, then from the repo root
+  `bash ~/.claude/lib/gates.sh run .claude/tasks/contracts/2026-10-08-model-router-floor-1835.md`.
+
+## Disposition
+- honors BDR-115 (one writer per axis, calling-loop writes, truthful
+  answers) and the wave plan's routing rule (explicit user choice beats the
+  derived phase); supersedes the 1-A contract's one-slot precedence for
+  prompt and slash sources.
+- LRN-206 (kit facts) applies to every new test.