@dzhechkov/skills-feature-adr 1.3.26 → 1.3.30

package/README.md

@@ -106,6 +106,41 @@ ARCHITECTURE → IMPLEMENTATION →  CODE   →   QE    →  FLEET QE
 # Full protocols + 6 extra skills, up to 7 fleet QE agents
 ```
 
+### Codex model routing (optional)
+
+If [Codex](https://developers.openai.com/codex) is installed + logged in, the pipeline can route work to
+Codex — **always asking first, always with a Claude fallback** (it never blocks on Codex). Three opt-in
+knobs (via the workflow `args`, or offered interactively at the planning checkpoint):
+
+| Knob | Step | What it does |
+|---|---|---|
+| `planner: 'codex'` | 6 Plan | plan on Codex's top model (Claude fallback) |
+| `coder: 'codex-fallback'` | 7 Code | Claude first; **if the Claude Code limit is exhausted mid-run → retry on Codex** |
+| `qeReviewer: 'codex-fallback'` | 8 QE/tests | same fallback for the review/testing stage |
+| `codexModel: 'auto'` | — | which Codex model (`auto` default (Codex self-selects) · or an id your account exposes (e.g. `gpt-5.5`)) |
+
+**Scenario — never stall on a rate limit:** a long L/XL feature hits the Claude Code session limit while
+writing code. Without this the run stalls; with `coder: 'codex-fallback'` the pipeline logs *"Claude
+unavailable (limit?) — falling back to Codex auto"* and finishes the code + tests on Codex, no
+restart and no lost work.
+
+```bash
+# Headless login on a VPS (no browser):
+codex login --device-auth                       # prints a code + URL you approve on another device
+# — or —
+printenv OPENAI_API_KEY | codex login --with-api-key
+```
+
+```js
+// ultracode (the deterministic workflow form): plan on Codex, code+QE fall back to Codex on Claude-limit:
+Workflow({ scriptPath: '.claude/workflows/feature-adr.js',
+  args: { slug: 'add-oauth', description: '…', tier: 'M',
+          planner: 'codex', coder: 'codex-fallback', qeReviewer: 'codex-fallback', codexModel: 'auto' } })  // 'auto' = Codex picks top; or pin e.g. 'gpt-5.5'
+```
+
+Omit the Codex knobs entirely for today's all-Claude behavior. The run result reports
+`plannerUsed` / `coderUsed` / `qeReviewerUsed` / `codexModel` so you can see who did what.
+
 ---
 
 ## Spec-Driven Development (SDD)

package/docs/team-onboarding.md

@@ -170,6 +170,27 @@ for load-bearing judgment). Models are **overridable defaults**.
 > steps and compare reward patterns / rework counts vs your `sonnet` baseline. This table is a
 > starting heuristic, not a benchmark — tune per project.
 
+### Codex routing (optional — cross-model + limit resilience)
+
+In the **ultracode workflow form**, feature-adr can hand steps to [Codex](https://developers.openai.com/codex)
+— opt-in, always with a Claude fallback (never blocks). Two reasons teams turn it on:
+
+1. **Cross-model planning** — plan Step 6 on Codex's top model: `planner: 'codex'`.
+2. **Never stall on a rate limit** — the killer feature: `coder: 'codex-fallback'` +
+   `qeReviewer: 'codex-fallback'`. Claude writes the code/tests as usual; but if a long L/XL run hits
+   the **Claude Code session limit mid-Step-7/8**, the pipeline auto-retries that step on Codex
+   (`auto` by default) instead of stalling — no restart, no lost work.
+
+```bash
+# one-time headless login (VPS, no browser):
+codex login --device-auth        # approve the printed code+URL on your phone/laptop
+
+# then, when launching a run, pass the knobs (or accept the interactive pre-flight offer):
+#   planner: 'codex' | coder: 'codex-fallback' | qeReviewer: 'codex-fallback' | codexModel: 'auto'
+```
+
+Omit the knobs for the all-Claude default. Full reference: `.claude/rules/feature-adr-ultracode.md`.
+
 ---
 
 ## 7. QE modes cheat-sheet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.26",
+  "version": "1.3.30",
   "description": "Adaptive Feature Development skill pack for Claude Code — 11-step pipeline with Complexity Router (S/M/L/XL), ADR-driven architecture, 15 agentic-qe skills, multi-agent fleet QE. Supports --full-qe, --full-qe-extended, --with-learning, and --knowledge-extractor modes.",
   "bin": {
     "skills-feature-adr": "./bin/cli.js"

package/templates/.claude/rules/feature-adr-ultracode.md

@@ -25,22 +25,54 @@ The pipeline ALWAYS runs the feature-adr Pattern memory loop **in-process** —
 - **Step 0** recalls learned patterns (`dz recall`) → folds the top ones into requirements/ADR as `{LEARNED_PATTERNS}` + records the recalled count in the live panel (`dz statusline --fa-record`).
 - **Step 8** teaches the durable lessons back (`dz teach`) + records the stored count. The loop pays off (recall) and grows (teach) every run.
 
-## Optional Codex planner (opt-in, pre-flight ASK)
+## Optional Codex routing (opt-in, pre-flight ASK)
 
-feature-adr can route the **planning step (Step 6)** to Codex's top model instead of Claude. It is
-**opt-in and graceful**: absent/declined/failed → the default Claude planner runs (the pipeline never
-blocks on Codex).
+feature-adr can route work to Codex's models. **All of it is opt-in and graceful** — absent / declined /
+Codex-unavailable → the default Claude agent runs; the pipeline NEVER blocks on Codex. Three knobs, all
+overridable via `args`:
 
-Pre-flight, BEFORE launching a feature-adr run, detect Codex readiness:
+| Knob (`args.*`) | Step | Values | Effect |
+|---|---|---|---|
+| `planner` | 6 (Plan) | `claude` (default) · `codex` | `codex` → Step-6 plans on Codex, Claude fallback |
+| `coder` | 7 (Code) | `claude` (default) · `codex` · `codex-fallback` | `codex-fallback` → Claude first, **on limit-exhaustion (null) → Codex** |
+| `qeReviewer` | 8 (QE/tests) | `claude` (default) · `codex` · `codex-fallback` | same fallback, for the QE/testing stage |
+| `codexModel` | — | `auto` (default — Codex self-selects the top available) · or a specific id your account exposes (e.g. `gpt-5.5`, `gpt-5.4`) | which Codex model to use |
+
+The result reports `plannerUsed` / `coderUsed` / `qeReviewerUsed` / `codexModel` so you can see who did what.
+
+**Pre-flight — detect + ASK (do this BEFORE launching a run):**
+```bash
+node "<codex-plugin>/scripts/codex-companion.mjs" setup --json   # → { "ready": true }
 ```
-node "<codex-plugin>/scripts/codex-companion.mjs" setup --json   → { ready: true }
+If `ready`, ASK the user once (skip all of this if not ready — Claude does everything):
+1. *"Plan (Step 6) on the top Codex model?"* → set `planner: 'codex'`.
+2. *"Fall back to Codex for code + tests/QE (Step 7/8) if the Claude Code limit is exhausted?"* →
+   set `coder: 'codex-fallback'`, `qeReviewer: 'codex-fallback'`.
+3. *"Which Codex model?"* (`auto` — Codex self-selects — or a specific id your account exposes; model ids are account/version-specific, so verify via the runtime rather than assuming) → **write it into codex config so the
+   `codex:codex-rescue` runtime picks it up**, then pass `codexModel`:
+   ```bash
+   printf '\nmodel = "gpt-5.5"\n' >> ~/.codex/config.toml   # pin a REAL id your account has (auto = default; verify: ask the codex runtime what -m ids it accepts)
+   ```
+For the interactive SKILL (plain `/feature-adr`), make the same three offers at the planning checkpoint.
+
+**Scenario (the reason this exists):** a long L/XL run hits the Claude Code session limit mid-Step-7.
+Without this, the Code agent returns null and the run stalls. With `coder: 'codex-fallback'`, feature-adr
+detects the null, logs *"Claude unavailable (limit?) — falling back to Codex auto"*, and finishes
+the code + tests on Codex — no restart, no lost work.
+
+**Example invocations:**
+```js
+// Plan on Codex, code+QE fall back to Codex only if Claude runs out, auto:
+Workflow({ scriptPath: '.claude/workflows/feature-adr.js',
+  args: { slug: 'add-x', description: '…', tier: 'M',
+          planner: 'codex', coder: 'codex-fallback', qeReviewer: 'codex-fallback', codexModel: 'auto' } })  // 'auto' = Codex picks top; or pin e.g. 'gpt-5.5'
+
+// All-Claude (the default — omit the Codex knobs entirely):
+Workflow({ scriptPath: '.claude/workflows/feature-adr.js', args: { slug: 'add-x', description: '…', tier: 'M' } })
 ```
-If `ready`, **ASK the user once**: *"Use the top Codex model for the planning step?"* On yes, pass
-`args.planner: 'codex'` (the workflow routes Step 6 to the `codex:codex-rescue` agentType, with a
-Claude fallback and `plannerUsed` in the result). On no / not-ready, omit `planner` (Claude plans).
-For the interactive SKILL (plain `/feature-adr`), make the same offer at the planning checkpoint.
-Codex needs a headless login on a VPS: `codex login --device-auth` (code + URL) or
-`printenv OPENAI_API_KEY | codex login --with-api-key`.
+
+**Headless Codex login on a VPS (no browser):** `codex login --device-auth` (prints a code + URL you
+approve on another device) or `printenv OPENAI_API_KEY | codex login --with-api-key`.
 
 ## Hybrid checkpoints (router decides)
 

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

@@ -355,11 +355,25 @@ Step 0 (Complexity Router) checks:
   description, code, tier, stopAfter, repo, dzBin } })`. Hybrid checkpoints: S/M autonomous; L/XL return
   after the Plan phase for your steer. See `.claude/rules/feature-adr-ultracode.md`.
 
-**Optional Codex planner (opt-in).** When Codex is installed + logged in (`codex login --device-auth`
-on a headless VPS, or `printenv OPENAI_API_KEY | codex login --with-api-key`), the pipeline can route the
-**planning step to Codex's top model**. It ALWAYS asks first — a pre-flight *"Use the top Codex model for
-planning?"* — and falls back to Claude if you decline or Codex is unavailable (never blocks). ultracode:
-pass `args.planner: 'codex'`. Plain `/feature-adr`: the same offer appears at the planning checkpoint.
+**Optional Codex routing (opt-in).** When Codex is installed + logged in (`codex login --device-auth`
+on a headless VPS, or `printenv OPENAI_API_KEY | codex login --with-api-key`), the pipeline can route work
+to Codex — always ASKING first, always with a Claude fallback (never blocks):
+
+- **Planning (Step 6)** on Codex's top model → `args.planner: 'codex'`.
+- **Code (Step 7) + tests/QE (Step 8) FALLBACK** → `args.coder: 'codex-fallback'`, `args.qeReviewer:
+  'codex-fallback'`: Claude runs first, and only if the **Claude Code limit is exhausted mid-run** (the
+  agent returns null) does the SAME task retry on Codex — so a long build never stalls on a rate limit.
+- **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.
+
+*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'`.
+
+Pre-flight, if Codex is `ready` (`codex-companion setup --json`), the orchestrator asks these three
+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`.
 
 ### Pattern memory loop (self-learning — runs in ALL modes)
 

package/templates/.claude/workflows/feature-adr.js

@@ -1,7 +1,7 @@
 export const meta = {
   name: 'feature-adr',
-  description: 'Canonical /feature-adr --full-qe-extended pipeline as a reusable workflow: router+RECALL then design(ADR, applies learned patterns) then plan then code then agentic-qe QE+TEACH, producing features/<slug>/00-09 artifacts. MANDATORY in-process self-learning loop (Step-0 recall, apply, Step-8 teach). OPTIONAL Codex planner (args.planner=codex → Step-6 routed to codex:codex-rescue top model, graceful fallback to Claude). Hybrid checkpoints (S/M autonomous; L/XL stop-after-plan).',
-  whenToUse: 'ultracode + a feature implementation. Invoke via Workflow({scriptPath:".claude/workflows/feature-adr.js", args:{slug, description, code, tier, stopAfter, planner}}) instead of an ad-hoc orchestration, so every feature ships with an ADR + inline agentic-qe QE + self-learning.',
+  description: 'Canonical /feature-adr --full-qe-extended pipeline as a reusable workflow: router+RECALL then design(ADR, applies learned patterns) then plan then code then agentic-qe QE+TEACH, producing features/<slug>/00-09 artifacts. MANDATORY in-process self-learning loop (Step-0 recall, apply, Step-8 teach). OPTIONAL Codex routing: args.planner=codex (Step-6), args.coder/qeReviewer='codex-fallback' (Step-7/8 fall back to Codex when Claude limits exhaust; args.codexModel default 'auto' (Codex self-selects top; account-specific)). Hybrid checkpoints (S/M autonomous; L/XL stop-after-plan).',
+  whenToUse: 'ultracode + a feature implementation. Invoke via Workflow({scriptPath:".claude/workflows/feature-adr.js", args:{slug, description, code, tier, stopAfter, planner, coder, qeReviewer, codexModel}}) instead of an ad-hoc orchestration, so every feature ships with an ADR + inline agentic-qe QE + self-learning.',
   phases: [
     { title: 'Router', detail: 'Step 0 - classify + self-learning recall' },
     { title: 'Design', detail: 'Steps 1-5 - requirements, ADR, QCSD, architecture (tier-gated)' },
@@ -86,14 +86,47 @@ if (stopHere) {
   return { tier: tier, phase: 'checkpoint-after-plan', artifactsDir: FDIR, planner: (plan ? plan.planner : null), plan: (plan ? plan.summary : null), note: 'L/XL checkpoint - review the ADR + plan, then re-invoke with args.stopAfter="none" to implement + QE.' }
 }
 
-// Step 7: Code
+// Codex fallback config (opt-in). CODER/QE_REVIEWER ∈ 'claude'|'codex'|'codex-fallback'. On
+// 'codex-fallback' the Claude agent runs FIRST; if it returns null (e.g. the Claude Code session limit
+// is exhausted mid-code/mid-QE — exactly the failure we hit before), the SAME task is retried on the
+// codex:codex-rescue runtime. args.codexModel is DEFAULT 'auto' (Codex self-selects the top model
+// available to the account — model ids are account/version-specific and move ahead of any static
+// default, so 'auto' is the portable choice). To hard-pin a specific id (e.g. this account's top is
+// gpt-5.5), the orchestrator writes it into ~/.codex/config.toml at pre-flight; the hint below only nudges.
+const CODEX_MODEL = A.codexModel || 'auto'
+const CODEX_HINT = ' (If you are the Codex runtime, prefer the ' + CODEX_MODEL + ' model.)'
+const CODER = (A.coder === 'codex' || A.coder === 'codex-fallback') ? A.coder : 'claude'
+const QE_REVIEWER = (A.qeReviewer === 'codex' || A.qeReviewer === 'codex-fallback') ? A.qeReviewer : 'claude'
+
+// Step 7: Code (optional Codex fallback on Claude-limit exhaustion)
 phase('Code')
-const code = await agent('Step 7 (Code) of /feature-adr for "' + DESC + '" (' + SLUG + '). Implement the feature per the plan + ADR + architecture in ' + FDIR + '. Write the ACTUAL production code + its tests (mirror the closest existing implementation named in research/architecture). Follow repo conventions; build must pass. Write a change manifest ' + FDIR + '/07_code_changes/change_manifest.md listing every file touched. Return wrote[] (incl. real source files) + summary.', { label: 'code', phase: 'Code', schema: ARTIFACT, effort: 'high' })
+const codePrompt = 'Step 7 (Code) of /feature-adr for "' + DESC + '" (' + SLUG + '). Implement the feature per the plan + ADR + architecture in ' + FDIR + '. Write the ACTUAL production code + its tests (mirror the closest existing implementation named in research/architecture). Follow repo conventions; build must pass. Write a change manifest ' + FDIR + '/07_code_changes/change_manifest.md listing every file touched. Return wrote[] (incl. real source files) + summary.'
+let code = null
+let coderUsed = 'claude'
+if (CODER !== 'codex') {
+  code = await agent(codePrompt, { label: 'code', phase: 'Code', schema: ARTIFACT, effort: 'high' })
+  if (code) coderUsed = 'claude'
+}
+if (code === null && (CODER === 'codex' || CODER === 'codex-fallback')) {
+  if (CODER === 'codex-fallback') log('Code: Claude unavailable (limit?) — falling back to Codex ' + CODEX_MODEL)
+  const codexCode = await agent(codePrompt + CODEX_HINT, { label: 'code:codex', phase: 'Code', agentType: 'codex:codex-rescue' })
+  if (codexCode) { code = { wrote: [FDIR + '/07_code_changes/change_manifest.md'], summary: String(codexCode).slice(0, 500) }; coderUsed = CODER === 'codex' ? 'codex' : 'codex-fallback' }
+}
 
 // Step 8: QE (brutal-honesty, agentic-qe) + MANDATORY teach
 phase('QE')
 const qePrompt = 'Step 8 (QE - brutal-honesty review, agentic-qe) of /feature-adr for "' + DESC + '" (' + SLUG + '). Adversarially review the SHIPPED code (read it): correctness, edge cases, error handling, and the LOAD-BEARING property the ADR named (ASSERT it has a test - the recurring lesson). Grade A/B/C/D honestly. Assess code-test adequacy + doc-test presence. List CONFIRMED gaps with severity. Write ' + FDIR + '/08_qe_report.md. MANDATORY SELF-LEARNING STORE (close the loop, never skip): via Bash run `dz teach "<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>" --reward <0.7-0.95> --domain <area>` for each genuine lesson (1-3 max, high-signal), then run `' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 8 QE" --recalled 3 --stored <count taught> --mode ' + MODE + ' --project ' + REPO + '` (run it verbatim via Bash, do not skip). Do NOT teach trivia or invent gaps. Return {grade, gaps, codeTestsAdequate, docTestsPresent}.'
-const qe = await agent(qePrompt, { label: 'qe:brutal', phase: 'QE', agentType: 'qe-code-reviewer', schema: QE })
+let qe = null
+let qeReviewerUsed = 'claude'
+if (QE_REVIEWER !== 'codex') {
+  qe = await agent(qePrompt, { label: 'qe:brutal', phase: 'QE', agentType: 'qe-code-reviewer', schema: QE })
+  if (qe) qeReviewerUsed = 'claude'
+}
+if (qe === null && (QE_REVIEWER === 'codex' || QE_REVIEWER === 'codex-fallback')) {
+  if (QE_REVIEWER === 'codex-fallback') log('QE: Claude unavailable (limit?) — falling back to Codex ' + CODEX_MODEL)
+  const codexQe = await agent(qePrompt + CODEX_HINT, { label: 'qe:codex', phase: 'QE', agentType: 'codex:codex-rescue' })
+  if (codexQe) { qe = { grade: 'codex-review', gaps: [], codeTestsAdequate: null, docTestsPresent: null, summary: String(codexQe).slice(0, 500) }; qeReviewerUsed = QE_REVIEWER === 'codex' ? 'codex' : 'codex-fallback' }
+}
 
 // Step 9: Fleet QE (L/XL)
 let fleet = 'skipped (S/M)'
@@ -119,6 +152,9 @@ return {
   docTestsPresent: qe ? qe.docTestsPresent : null,
   fleetQE: fleet,
   plannerUsed: plan ? plan.planner : null,
+  coderUsed: coderUsed,
+  qeReviewerUsed: qeReviewerUsed,
+  codexModel: CODEX_MODEL,
   selfLearning: 'recall@Step0 + teach@Step8 (mandatory)',
   promiseTags: tags,
 }