@dzhechkov/skills-feature-adr 1.3.38 → 1.3.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.38",
+  "version": "1.3.40",
   "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/skills/feature-adr/SKILL.md

@@ -414,6 +414,30 @@ Codex on limit-exhaustion) stays a knob-only behavior; a direct `models.code='co
 'L', models: { code: 'opus', qe: 'codex:gpt-5.6:high', architecture: 'opus', router: 'fable' } } })` —
 Claude writes the code, Codex independently QEs it.
 
+**Usage-adaptive routing (pre-emptive Codex switch under limit pressure).** When routing is opted into,
+the workflow probes Claude SESSION (active 5h-block) and WEEKLY (rolling 7d) usage at EACH phase boundary
+via a minimal `dz usage --json` agent. When either metric is `>= usageThreshold` (default `70`) BEFORE a
+phase launches — OR the probe output is missing (agent-null, which often MEANS the limit was hit) — ALL
+remaining stages switch to `codex:<top>` (design/code/plan at `xhigh`, router/qe/fleet at `high`). When a
+later probe reads BOTH metrics below the threshold (positive numbers, not nulls), the normal Claude+Codex
+mix is RESTORED. Null percentages (unconfigured limits) change NOTHING in either direction. Switched
+stages are tagged ` (usage-switched)` in `modelsUsed`, and every flip is recorded in the result's
+`usageEvents` array (the audit trail — never trust promiseTags for this). Args:
+
+| `args.*` | Default | Effect |
+|---|---|---|
+| `usageAdaptive` | `true` when routing is requested (any `args.models` key or Codex knob); `false` otherwise | `true` forces it on even without other routing; `false` disables all probes (byte-identical to today) |
+| `usageThreshold` | `70` | the `>=` percent (either metric) that triggers the pre-emptive switch |
+| `usageReasoning` | the `OVERRIDE_REASONING` map | per-stage reasoning under the override (merge over the default: design/code/plan → `xhigh`, router/qe/fleet → `high`) |
+
+Configure the limits the probe measures against in `.dz/config.json` — `memory.usage.sessionTokenLimit`
+and `memory.usage.weeklyTokenLimit` (OPTIONAL; absent ⇒ `pct` is `null` and no switch fires). The
+percentages are **ESTIMATES** from local transcript aggregation (there is no official usage API);
+**calibrate** by scaling a limit by `X/100` when a real limit-hit lands at an estimated `X%`.
+**Honest caveat (the wrapper lesson):** at TRUE exhaustion even the Codex dispatch dies because
+`codex:codex-rescue` is a Claude wrapper subagent — so the switch MUST happen BEFORE, which is why the
+70% pre-emptive probe (not just reactive null-detection) is the real defense.
+
 ### Pattern memory loop (self-learning — runs in ALL modes)
 
 **Self-learning is MANDATORY on EVERY `/feature-adr` run — including plain `/feature-adr` without any

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

@@ -67,9 +67,76 @@ const MODELS = (A.models && typeof A.models === 'object') ? A.models : {}
 const KNOWN_CODEX = { 'auto': 1, 'gpt-5.5': 1, 'gpt-5.6': 1 }
 const CLAUDE_NAMES = { fable: 1, opus: 1, sonnet: 1, haiku: 1 }
 const DEFAULT_MODELS = { router: 'fable', requirements: 'sonnet', research: 'sonnet', adr: 'opus', ideation: 'sonnet', ddd: 'opus', architecture: 'opus', plan: 'sonnet', code: null, qe: null, fleet: 'sonnet' }
-const routingRequested = (Object.keys(MODELS).length > 0) || (PLANNER === 'codex') || (CODER === 'codex' || CODER === 'codex-fallback') || (QE_REVIEWER === 'codex' || QE_REVIEWER === 'codex-fallback')
+const routingRequested = (Object.keys(MODELS).length > 0) || (PLANNER === 'codex') || (CODER === 'codex' || CODER === 'codex-fallback') || (QE_REVIEWER === 'codex' || QE_REVIEWER === 'codex-fallback') || (A.usageAdaptive === true)
 const modelsUsed = {}
 
+// ── USAGE-ADAPTIVE ROUTING (pre-emptive codex switch at >= usageThreshold, default 70%) ──
+// At every phase boundary a minimal haiku probe runs 'dz usage --json'; when SESSION or WEEKLY
+// usage crosses the threshold BEFORE a phase launches, ALL remaining stages switch to
+// codex:<topCodexId> (design/code/plan at xhigh, router/qe/fleet at high). When a later probe reads
+// BOTH metrics below threshold (positive numbers, not nulls) the normal mix is RESTORED. The
+// load-bearing asymmetry: an agent-null probe (dispatch died — often MEANS limits) fail-safe-switches
+// TO codex; a value-null (unconfigured limits) flips NOTHING. All additive behind USAGE_ADAPTIVE:
+// usageAdaptive:false OR no routing requested ⇒ zero probes, byte-identical to today.
+// The single mutable routing bit usageOverride lives HERE (the workflow is its own environment);
+// the pure library mirror (feature-adr-routing.ts) threads it via RoutingEnv — never a global.
+const USAGE_THRESHOLD = Number(A.usageThreshold) > 0 ? Number(A.usageThreshold) : 70
+const USAGE_ADAPTIVE = (A.usageAdaptive !== false) && (routingRequested || A.usageAdaptive === true)
+const OVERRIDE_REASONING = mergeOpts({ router: 'high', requirements: 'xhigh', research: 'xhigh', adr: 'xhigh', ideation: 'xhigh', ddd: 'xhigh', architecture: 'xhigh', plan: 'xhigh', code: 'xhigh', qe: 'high', fleet: 'high' }, (A.usageReasoning && typeof A.usageReasoning === 'object') ? A.usageReasoning : {})
+const usageReasoning = OVERRIDE_REASONING
+let usageOverride = false
+const usageEvents = []
+
+// decideUsageAction: the PURE hysteresis core (byte-equivalent to feature-adr-routing.ts). Given the
+// previous override bit, a probe signal (or null when the probe agent DIED), and the threshold,
+// decide the new override bit + the LOCKED 6-value action. Total function.
+function decideUsageAction(prevOverride, signal, threshold) {
+  if (signal === null || signal === undefined) {
+    if (prevOverride) return { override: true, action: 'keep' }
+    return { override: true, action: 'fail-safe-switch' }
+  }
+  const s = signal.sessionPct
+  const w = signal.weeklyPct
+  const sKnown = typeof s === 'number' && isFinite(s) && s >= 0
+  const wKnown = typeof w === 'number' && isFinite(w) && w >= 0
+  if ((sKnown && s >= threshold) || (wKnown && w >= threshold)) {
+    return { override: true, action: prevOverride ? 'keep' : 'switch' }
+  }
+  if (sKnown && wKnown) {
+    return { override: false, action: prevOverride ? 'restore' : 'none' }
+  }
+  return { override: prevOverride, action: prevOverride ? 'keep' : 'none' }
+}
+
+const PROBE_SCHEMA = { type: 'object', additionalProperties: false, required: ['sessionPct', 'weeklyPct'], properties: { sessionPct: { type: ['number', 'null'] }, weeklyPct: { type: ['number', 'null'] } } }
+
+// usageProbe: at each phase boundary, dispatch a minimal haiku/effort-low agent that runs EXACTLY
+// one shell command ('dz usage --json') — the same guaranteed-single-command shape as fa-record:step0.
+// Feed the reading to decideUsageAction, flip usageOverride, record a usageEvents entry. First
+// statement is the BC guard: when USAGE_ADAPTIVE is off, ZERO probe agents are dispatched (AC-4).
+async function usageProbe(phaseName) {
+  if (!USAGE_ADAPTIVE) return
+  const probePrompt = 'Run EXACTLY this one shell command via your Bash tool and return ONLY its parsed JSON fields sessionPct and weeklyPct (numbers or null), nothing else, do not summarize: ' + DZ + ' usage --json --project ' + REPO
+  const r = await agent(probePrompt, { label: 'usage:probe', phase: phaseName, model: 'haiku', effort: 'low', schema: PROBE_SCHEMA })
+  const d = decideUsageAction(usageOverride, r, USAGE_THRESHOLD)
+  if (d.action === 'switch') log('usage: session ' + (r ? r.sessionPct : null) + '% / week ' + (r ? r.weeklyPct : null) + '% >= ' + USAGE_THRESHOLD + '% — switching remaining stages to codex:' + topCodexId())
+  if (d.action === 'fail-safe-switch') log('usage: probe died (agent-null — often MEANS limits) — fail-safe switching remaining stages to codex:' + topCodexId())
+  if (d.action === 'restore') log('usage: back to ' + (r ? r.sessionPct : null) + '%/' + (r ? r.weeklyPct : null) + '% — restoring normal routing')
+  usageOverride = d.override
+  usageEvents.push({ phase: phaseName, sessionPct: r ? r.sessionPct : null, weeklyPct: r ? r.weeklyPct : null, action: d.action })
+}
+
+// reactiveBelt: generalizes today's codex-fallback. When a stage agent returns null while NOT already
+// overridden (a possible limit event), flip the override so the REMAINING stages don't walk into the
+// same wall. The legacy codex-fallback same-stage retry is untouched. Best-effort: at TRUE exhaustion
+// even codex dispatch dies (codex:codex-rescue is a Claude wrapper) — the 70% pre-emptive probe is the real defense.
+function reactiveBelt(phaseName) {
+  if (!USAGE_ADAPTIVE || usageOverride) return
+  usageOverride = true
+  usageEvents.push({ phase: phaseName, sessionPct: null, weeklyPct: null, action: 'reactive-switch' })
+  log('usage: stage agent returned null while not overridden — possible limit event, switching remaining stages to codex:' + topCodexId())
+}
+
 function specToOpts(spec) {
   if (!spec) return {}
   const parts = String(spec).split(':')
@@ -96,16 +163,20 @@ function coderIsCodex() {
   return false
 }
 
-function resolveQeSpec() {
-  if (coderIsCodex()) return 'opus'
-  const CODEX_AVAILABLE = A.codexAvailable !== false
-  if (!CODEX_AVAILABLE) return 'opus'
+function topCodexId() {
   let top = CODEX_MODEL
   if (top === 'auto') {
     const ids = Object.keys(KNOWN_CODEX)
     for (let i = 0; i < ids.length; i++) { if (ids[i] !== 'auto') top = ids[i] || top }
   }
-  return 'codex:' + top + ':high'
+  return top
+}
+
+function resolveQeSpec() {
+  if (coderIsCodex()) return 'opus'
+  const CODEX_AVAILABLE = A.codexAvailable !== false
+  if (!CODEX_AVAILABLE) return 'opus'
+  return 'codex:' + topCodexId() + ':high'
 }
 
 // qeShouldUseCodex: the load-bearing cross-model gate — the model that wrote the code must NEVER self-QE.
@@ -121,6 +192,12 @@ function qeShouldUseCodex() {
 }
 
 function resolveStageModel(stage) {
+  if (usageOverride) {
+    const r = (usageReasoning && usageReasoning[stage]) || OVERRIDE_REASONING[stage] || 'high'
+    const o = specToOpts('codex:' + topCodexId() + ':' + r)
+    o._usageSwitched = true
+    return o
+  }
   let spec = MODELS[stage]
   if (spec === undefined) {
     if (!routingRequested) return {}
@@ -140,7 +217,11 @@ function mergeOpts(base, extra) {
 
 // modelLabel: record the resolved spec for a stage in modelsUsed (for the run report / who-did-what).
 function modelLabel(opts) {
-  if (opts && opts.agentType === 'codex:codex-rescue') return 'codex:' + opts.codexModel + ':' + opts._reasoning
+  if (opts && opts.agentType === 'codex:codex-rescue') {
+    const base = 'codex:' + opts.codexModel + ':' + opts._reasoning
+    if (opts._usageSwitched) return base + ' (usage-switched)'
+    return base
+  }
   if (opts && opts.model) return opts.model
   return 'session'
 }
@@ -151,7 +232,8 @@ const QE = { type: 'object', additionalProperties: false, required: ['grade', 'g
 
 // Step 0: Router + MANDATORY self-learning recall
 phase('Router')
-const routerPrompt = 'You are Step 0 (Complexity Router) of the /feature-adr pipeline. TWO jobs. (1) MANDATORY SELF-LEARNING RECALL (never skip — run BOTH Bash commands VERBATIM, do not summarize instead of running them): the learned patterns live in the CANONICAL BRAIN store at `' + BRAIN + '` — pin every recall to it. Via your Bash tool run EXACTLY `' + DZ_RECALL('<the key domain terms of this feature>') + '` (and `' + DZ_RECALL('<the key domain terms of this feature>') + ' --all` if narrow) to load relevant LEARNED PATTERNS from the brain, then run `dz statusline --fa-record --slug ' + SLUG + ' --step "Step 0 recall" --recalled <count> --mode ' + MODE + ' --project ' + REPO + '`. Summarize the top 3 applicable patterns in the rationale. (2) Classify S/M/L/XL + active steps. Feature: "' + DESC + '". Code: ' + CODE_HINT + '. S=1-3 files (0,1,6,7,8); M=4-10 (0,1,3,3.5,5,6,7,8); L=11-30 (all+9); XL=30+ (full+9). Return {tier, activeSteps, rationale} with the recalled patterns folded into rationale.'
+await usageProbe('Router')
+const routerPrompt = 'You are Step 0 (Complexity Router) of the /feature-adr pipeline. TWO jobs. (1) MANDATORY SELF-LEARNING RECALL (never skip — run BOTH Bash commands VERBATIM, do not summarize instead of running them): the learned patterns live in the CANONICAL BRAIN store at `' + BRAIN + '` — pin every recall to it. Via your Bash tool run EXACTLY `' + DZ_RECALL('<the key domain terms of this feature>') + '` (and `' + DZ_RECALL('<the key domain terms of this feature>') + ' --all` if narrow) to load relevant LEARNED PATTERNS from the brain. Preserve recalled pattern TEXT, reward, domain, and any visible id in the rationale as a concrete list so Step 8 can compare candidate lessons against it. Then run `dz statusline --fa-record --slug ' + SLUG + ' --step "Step 0 recall" --recalled <count> --mode ' + MODE + ' --project ' + REPO + '`. Summarize the top 3 applicable patterns in the rationale. (2) Classify S/M/L/XL + active steps. Feature: "' + DESC + '". Code: ' + CODE_HINT + '. S=1-3 files (0,1,6,7,8); M=4-10 (0,1,3,3.5,5,6,7,8); L=11-30 (all+9); XL=30+ (full+9). Return {tier, activeSteps, rationale} with the recalled patterns folded into rationale.'
 const routerOpts = mergeOpts({ label: 'router+recall', phase: 'Router', schema: ROUTER, effort: 'low' }, resolveStageModel('router'))
 modelsUsed.router = modelLabel(routerOpts)
 const router = await agent(routerPrompt, routerOpts)
@@ -168,6 +250,7 @@ await agent('Run EXACTLY this one shell command via your Bash tool and report it
 
 // Steps 1-5: Design (tier-gated thunks built explicitly - no inline ternary-null)
 phase('Design')
+await usageProbe('Design')
 const designThunks = []
 const reqExtra = isLplus ? ' Also write ' + FDIR + '/02_research.md (codebase patterns + external analogues; read the repo for the closest existing implementation to mirror).' : ''
 // Resolve per-stage model opts up-front (parser-safe: no inline resolveStageModel inside the thunk arrays).
@@ -196,6 +279,7 @@ const design = await parallel(designThunks)
 // the codex:codex-rescue runtime and GRACEFULLY FALL BACK to the default (Claude) planner if Codex is
 // unavailable/errors — the pipeline never blocks on Codex.
 phase('Plan')
+await usageProbe('Plan')
 const planPrompt = 'Step 6 (SPARC-GOAP implementation plan) of /feature-adr for "' + DESC + '" (' + SLUG + ', tier ' + tier + '). Given the requirements + ADR + architecture in ' + FDIR + ', decompose into milestones + concrete tasks with success metrics. Write ' + FDIR + '/06_implementation_plan.md. Return wrote[] + summary.'
 // Resolve the plan model. args.models.plan wins; else the planner:'codex' knob (via routingRequested +
 // DEFAULT_MODELS/coder-fold) or the DEFAULT_MODELS.plan ('sonnet') under routing; else {} (BC).
@@ -213,6 +297,7 @@ if (planIsCodex) {
     log('Plan: Codex unavailable — falling back to the default planner')
   }
 }
+if (plan === null && planIsCodex) reactiveBelt('Plan')
 if (plan === null) {
   const claudePlanOpts = mergeOpts({ label: 'plan', phase: 'Plan', schema: ARTIFACT }, planIsCodex ? {} : planModel)
   modelsUsed.plan = planIsCodex ? 'claude-fallback' : modelLabel(claudePlanOpts)
@@ -230,11 +315,12 @@ if (stopHere) {
   const qePlanned = qeShouldUseCodex() ? modelLabel(resolveStageModel('qe')) : modelLabel(mergeOpts({ agentType: 'qe-code-reviewer' }, resolveStageModel('qe')))
   const plannedModels = mergeOpts(modelsUsed, { code: codePlanned + ' (planned)', qe: qePlanned + ' (planned)' })
   if (isLplus) plannedModels.fleet = modelLabel(resolveStageModel('fleet')) + ' (planned)'
-  return { tier: tier, phase: 'checkpoint-after-plan', artifactsDir: FDIR, planner: (plan ? plan.planner : null), plan: (plan ? plan.summary : null), modelsUsed: plannedModels, note: 'L/XL checkpoint - review the ADR + plan (+ the planned code/qe/fleet models), then re-invoke with args.stopAfter="none" to implement + QE.' }
+  return { tier: tier, phase: 'checkpoint-after-plan', artifactsDir: FDIR, planner: (plan ? plan.planner : null), plan: (plan ? plan.summary : null), modelsUsed: plannedModels, usageEvents: usageEvents, usageThreshold: USAGE_THRESHOLD, note: 'L/XL checkpoint - review the ADR + plan (+ the planned code/qe/fleet models), then re-invoke with args.stopAfter="none" to implement + QE.' }
 }
 
 // Step 7: Code (optional Codex fallback on Claude-limit exhaustion)
 phase('Code')
+await usageProbe('Code')
 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.'
 // Resolve the coder model. args.models.code wins (a direct 'codex' spec = codex-first); else the legacy
 // CODER knob drives it (with its codex-fallback null-guard). resolveStageModel('code') folds both via the
@@ -249,6 +335,7 @@ if (!codeIsCodexFirst) {
   code = await agent(codePrompt, codeClaudeOpts)
   if (code) { coderUsed = 'claude'; modelsUsed.code = modelLabel(codeClaudeOpts) }
 }
+if (code === null && !codeIsCodexFirst) reactiveBelt('Code')
 if (code === null && (codeIsCodexFirst || CODER === 'codex-fallback')) {
   if (CODER === 'codex-fallback' && !codeIsCodexFirst) log('Code: Claude unavailable (limit?) — falling back to Codex ' + CODEX_MODEL)
   const codeCodexOpts = mergeOpts({ label: 'code:codex', phase: 'Code', agentType: 'codex:codex-rescue' }, codeModel.agentType ? codeModel : {})
@@ -270,7 +357,8 @@ if (coderUsed === 'codex' || coderUsed === '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): store every lesson in the CANONICAL BRAIN store at `' + BRAIN + '` so it is NOT lost to a target repo you may have cd`d into. Via Bash run EXACTLY `' + DZ_TEACH('<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>', '<0.7-0.95>', '<area>') + '` for each genuine lesson (1-3 max, high-signal) — the `cd ' + BRAIN + ' &&` prefix + `--project ' + BRAIN + '` pin guarantee the lesson lands in the brain regardless of your CWD. 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}.' + landedNote
+await usageProbe('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): compare every candidate lesson against the Step-0 recalled LEARNED patterns above. Teach ONLY lessons NOT covered by Step-0 recall. On overlap, run `dz teach --reinforce "<recalled pattern id or exact text>" --project ' + BRAIN + '` instead of minting a near-duplicate; if --reinforce is unavailable, skip the duplicate teach and report `reinforced existing pattern <id>` in the QE report. Store every genuinely new lesson in the CANONICAL BRAIN store at `' + BRAIN + '` so it is NOT lost to a target repo you may have cd`d into. Via Bash run EXACTLY `' + DZ_TEACH('<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>', '<0.7-0.95>', '<area>') + '` for each genuine NEW lesson (1-3 max, high-signal) — the `cd ' + BRAIN + ' &&` prefix + `--project ' + BRAIN + '` pin guarantee the lesson lands in the brain regardless of your CWD. Then run `' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 8 QE" --recalled 3 --stored <count taught> --reinforced <count reinforced> --mode ' + MODE + ' --project ' + REPO + '` (run it verbatim via Bash, do not skip). Do NOT teach trivia or invent gaps. Return {grade, gaps, codeTestsAdequate, docTestsPresent}.' + landedNote
 // CROSS-MODEL QE (load-bearing): resolveStageModel('qe') derives the OTHER family than the resolved
 // coder when args.models.qe is unset (coder-codex ⇒ opus; coder-Claude ⇒ codex, or opus if codex absent).
 // An explicit args.models.qe wins. A Claude qe spec is merged onto the qe-code-reviewer base (role
@@ -288,6 +376,7 @@ if (!qeIsCodex) {
   qe = await agent(qePrompt, qeClaudeOpts)
   if (qe) { qeReviewerUsed = 'claude'; modelsUsed.qe = modelLabel(qeClaudeOpts) }
 }
+if (qe === null && !qeIsCodex) reactiveBelt('QE')
 if (qe === null && (qeIsCodex || QE_REVIEWER === 'codex-fallback')) {
   if (QE_REVIEWER === 'codex-fallback' && !qeIsCodex) log('QE: Claude unavailable (limit?) — falling back to Codex ' + CODEX_MODEL)
   const qeCodexOpts = mergeOpts({ label: 'qe:codex', phase: 'QE', agentType: 'codex:codex-rescue' }, qeModel.agentType ? qeModel : {})
@@ -306,6 +395,7 @@ if (qe === null && qeIsCodex) {
 let fleet = 'skipped (S/M)'
 if (isLplus) {
   phase('FleetQE')
+  await usageProbe('FleetQE')
   const fleetModel = resolveStageModel('fleet')
   modelsUsed.fleet = modelLabel(mergeOpts({}, fleetModel))
   const fleetTraceOpts = mergeOpts({ label: 'fleet:trace', phase: 'FleetQE', agentType: 'qe-requirements-validator' }, fleetModel)
@@ -334,6 +424,8 @@ return {
   qeReviewerUsed: qeReviewerUsed,
   codexModel: CODEX_MODEL,
   modelsUsed: modelsUsed,
+  usageEvents: usageEvents,
+  usageThreshold: USAGE_THRESHOLD,
   selfLearning: 'recall@Step0 + teach@Step8 (mandatory)',
   brain: BRAIN,
   promiseTags: tags,