@dzhechkov/keysarium 1.5.21 → 1.5.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/keysarium",
-  "version": "1.5.21",
+  "version": "1.5.25",
   "description": "AI Case Research Toolkit for Claude Code — full 7-phase pipeline with feature-adr, dream cycles, background workers, multi-platform support, reward learning, and Cloud.ru AI Factory mapping (--ai-factory flag)",
   "main": "src/cli.js",
   "bin": {

package/templates/.claude/skills/feature-adr/SKILL.md

@@ -366,7 +366,7 @@ to Codex — always ASKING first, always with a Claude fallback (never blocks):
 - **Model choice** → `args.codexModel` (`auto` default (Codex self-selects) · or an id your account exposes (e.g. `gpt-5.5`)).
 
 *Scenario:* an L/XL run hits the session limit during coding → with `coder: 'codex-fallback'` feature-adr
-logs *"Claude unavailable (limit?) — falling back to Codex auto"* and finishes on Codex, no restart.
+logs *"Claude unavailable (limit?) — falling back to Codex auto"* and finishes on Codex, no restart. Codex writes out-of-band, so feature-adr confirms the edits LANDED (`git status`, ~30s poll) before QE — no false "Step 7 never ran" grade.
 
 *Example:* `Workflow({ scriptPath: '.claude/workflows/feature-adr.js', args: { slug, description, tier:
 'M', planner: 'codex', coder: 'codex-fallback', qeReviewer: 'codex-fallback', codexModel: 'auto' } })  // 'auto' = Codex picks top; or pin e.g. 'gpt-5.5'`.
@@ -375,6 +375,45 @@ Pre-flight, if Codex is `ready` (`codex-companion setup --json`), the orchestrat
 before launching; plain `/feature-adr` offers the same at the planning checkpoint. Omit the Codex knobs
 for today's all-Claude behavior. See `.claude/rules/feature-adr-ultracode.md`.
 
+**Per-stage model routing — `args.models` (one dial, 11 stages).** `args.models` is an optional map that
+routes each pipeline stage to an optimal model. Keys: `{router, requirements, research, adr, ideation,
+ddd, architecture, plan, code, qe, fleet}`. Each value is a **spec**:
+
+- **Claude** — `'fable' | 'opus' | 'sonnet' | 'haiku'` → adds `model` to that stage's `agent()` call
+  (any role `agentType` like `qe-code-reviewer` is PRESERVED).
+- **Codex** — `'codex'` / `'codex:<id>'` / `'codex:<id>:<reasoning>'` (e.g. `'codex:gpt-5.6:xhigh'`;
+  `reasoning ∈ low|medium|high|xhigh`; ids incl. `gpt-5.5`, `gpt-5.6`) → routes the stage to the
+  `codex:codex-rescue` runtime with that `codexModel` + reasoning hint.
+
+**Recommended DEFAULT TABLE** (applied only when you opt into routing — any one `args.models` key or any
+Codex knob flips it on; otherwise every stage stays session-inherited, byte-identical to today):
+
+| Stage | Default | | Stage | Default |
+|---|---|---|---|---|
+| router | `fable` | | architecture | `opus` |
+| requirements | `sonnet` | | plan | `sonnet` |
+| research | `sonnet` (folds into requirements) | | code | *the coder knob* (default Claude `opus`) |
+| adr | `opus` | | qe | *CROSS-MODEL of the coder* (see below) |
+| ideation | `sonnet` | | fleet | `sonnet` |
+| ddd | `opus` (folds into architecture) | | | |
+
+**Cross-model QE default (load-bearing).** When `args.models.qe` is UNSET, QE is auto-routed to the
+**other model family than the coder** — a model that WRITES code must not also SELF-QE; independent
+cross-model review catches what self-review misses. coder=Codex ⇒ QE=Claude (`opus`); coder=Claude ⇒
+QE=Codex (`codex:<top>:high`), or a Claude reviewer if Codex is unavailable (**never blocks**).
+
+**Precedence.** `args.models[stage]` is the general mechanism and WINS on conflict; the legacy
+`planner`/`coder`/`qeReviewer`/`codexModel` knobs are shortcuts that fill a stage only when `args.models`
+does not. `codexModel` sets the default id for a bare `'codex'` spec. Codex-fallback (Claude-first, then
+Codex on limit-exhaustion) stays a knob-only behavior; a direct `models.code='codex'` means codex-first.
+
+**gpt-5.6-ready** — a new Codex id is a DATA-ONLY addition to the `KNOWN_CODEX` allowlist (no control flow).
+**Reporting** — the run result includes `modelsUsed` (the resolved per-stage model) so you see who did what.
+
+*Example:* `Workflow({ scriptPath: '.claude/workflows/feature-adr.js', args: { slug, description, tier:
+'L', models: { code: 'opus', qe: 'codex:gpt-5.6:high', architecture: 'opus', router: 'fable' } } })` —
+Claude writes the code, Codex independently QEs it.
+
 ### Pattern memory loop (self-learning — runs in ALL modes)
 
 **Self-learning is MANDATORY on EVERY `/feature-adr` run — including plain `/feature-adr` without any
@@ -408,6 +447,15 @@ non-blocking — an error or empty result never stalls the pipeline. This layer
 **distinct from the Keysarium reward layer** installed by `--with-learning`: it uses agentic-qe MCP
 memory + the dz store, is UNCONDITIONAL for the dz half (recall/teach/fa-record run in every mode) and Direct-mode-only for the aqe-MCP half, and never touches `.keysarium/memory/`.
 
+**Canonical brain store — `args.brain` (never fragment the loop).** The dz durable loop only compounds if
+Step-0 recall and Step-8 teach hit the SAME store. The workflow pins both to a canonical **brain** —
+`args.brain`, default = the workspace root — via `cd <brain> && dz recall/teach … --project <brain>`, so a
+Step-8 teach issued from a coder that `cd`'d into a target repo still lands in the brain, not that repo's
+`.dz`. Omitting `args.brain` is behaviorally inert for a workspace-CWD run (`brain === repo`). **Share** a
+brain: `dz recall --all --json > patterns.json` → `dz teach --from-json patterns.json --project <brain>`
+(exact-text dedup, idempotent). **Recover** a fragmented store: `cd <stray-repo> && dz recall --all --json >
+/tmp/stray.json` → `dz teach --from-json /tmp/stray.json --project <brain>` to merge it back into the brain.
+
 **Live learning panel (`dz statusline`).** The pipeline **drives** the panel: at each pattern-memory-loop
 step above it records its live state via `dz statusline --fa-record …`, so `dz statusline` can surface
 per-run learning (which feature, which step, how many patterns recalled vs. newly stored). Each of the