@dzhechkov/skills-feature-adr 1.3.52 → 1.3.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.52",
+  "version": "1.3.53",
   "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/workflows/feature-adr.js

@@ -570,6 +570,36 @@ const isMplus = tier === 'M' || tier === 'L' || tier === 'XL'
 const isLplus = tier === 'L' || tier === 'XL'
 log('Router: tier ' + tier)
 
+// ── AUTO-COST pre-resolution (feature learned-cost-routing) ──
+// A stage whose spec is 'auto-cost' is resolved HERE (tier is now known) to a concrete model via
+// `dz routing --select` — the workflow is sandboxed (no fs), so selection I/O shells out to dz. Byte-identical
+// no-op (ZERO agent calls) when no stage is 'auto-cost'. Order matters: resolve `code` FIRST so `qe` can be
+// forced to the CROSS-family of the coder (the named cross-model-QE guard). Escalate-on-fail across runs is
+// automatic: a gate-FAIL recorded below down-ranks the model so the NEXT run's select picks the next rung.
+const AUTOCOST = {}
+function acFamOf(spec) { return /codex|gpt|openai/i.test(String(spec)) ? 'openai' : 'claude' }
+function acConcrete(model) { return CLAUDE_NAMES[model] ? model : ('codex:' + model + ':high') }
+function acBareId(spec) { var s = String(spec || ''); return s.indexOf('codex:') === 0 ? (s.split(':')[1] || s) : s }
+async function resolveAutoCost(stage, familyArg) {
+  const famFlag = familyArg ? (' --family ' + familyArg) : ''
+  const out = await agent('Run EXACTLY this via Bash and reply with ONLY its stdout (a single JSON line), nothing else: ' + DZ + ' routing --select --stage ' + stage + ' --tier ' + tier + famFlag, { label: 'auto-cost:select:' + stage, phase: 'Route', effort: 'low' })
+  let pick = null
+  try { pick = JSON.parse(String(out).replace(/^[^{]*/, '').replace(/[^}]*$/, '')) } catch { pick = null }
+  if (!pick || !pick.model) { log('auto-cost ' + stage + ': no candidate model — leaving session-inherited'); MODELS[stage] = undefined; return }
+  MODELS[stage] = acConcrete(pick.model)
+  AUTOCOST[stage] = { chain: (pick.chain || []), tier: tier, evidence: pick.evidence || '' }
+  log('auto-cost ' + stage + ' → ' + MODELS[stage] + ' [' + (pick.metBar ? 'learned' : 'cold-start') + ']')
+}
+const autoCostStages = Object.keys(MODELS).filter(function (s) { return MODELS[s] === 'auto-cost' })
+if (autoCostStages.length > 0) {
+  for (const s of autoCostStages) { if (s !== 'qe') await resolveAutoCost(s, null) }
+  if (MODELS.qe === 'auto-cost') {
+    // cross-family of the resolved coder (guard): coder codex → qe claude; coder claude → qe openai.
+    const coderSpec = (MODELS.code !== undefined && MODELS.code !== null && MODELS.code !== 'auto-cost') ? MODELS.code : ((CODER === 'codex' || CODER === 'codex-fallback') ? 'codex' : 'opus')
+    await resolveAutoCost('qe', acFamOf(coderSpec) === 'openai' ? 'claude' : 'openai')
+  }
+}
+
 // GUARANTEED fa-panel write (the router, being low-effort + multi-job, tends to skip the fa-record
 // Bash call). A dedicated single-command agent reliably lights up the live /feature-adr panel at the
 // most visible moment. Uses the workspace bin (PATH-independent). Best-effort — never blocks.
@@ -845,6 +875,55 @@ if (qe === null && qeIsCodex) {
 const claimGate = step8ClaimGate(qe && qe.claimCheck ? qe.claimCheck : null)
 log(claimGate.note)
 
+// ── AUTO-COST outcome recording (feature learned-cost-routing) ──
+// The two-phase label lands here: every auto-cost stage that produced an artifact records a PROVISIONAL (i);
+// the CODE stage's authoritative gate (ii) is the Step-8 QE grade (A/B = pass) — a produced-but-gate-FAILED
+// run is recorded as a FAILURE, down-ranking that model for the next run (ADR §2). Byte-identical no-op when
+// nothing was auto-cost. Gate-less stages get weak provisional credit; richer per-stage gates are Phase-2.
+if (Object.keys(AUTOCOST).length > 0) {
+  const recPhase = isLplus ? 'FleetQE' : 'QE'
+  // Record ONLY stages that ACTUALLY RAN and produced an artifact (QE finding: a blanket loop over configured
+  // auto-cost stages credited skipped/failed/fallback stages). `code`/`plan` are guarded by their result var.
+  // ATTRIBUTION guard (QE #2): the auto-cost pick's outcome must be attributed to the PICK's model — but a
+  // codex-FALLBACK produces the code on a DIFFERENT model when the picked model returned null. So:
+  //   • the picked model ran & produced  → provisional + finalize by the QE gate.
+  //   • a fallback fired (pick returned null) → the PICK FAILED to deliver → finalize(pick, false), NOT the
+  //     fallback model (which was not auto-cost-selected). This down-ranks the pick honestly.
+  const codeMid = acBareId(MODELS.code)
+  if (AUTOCOST.code && codeMid) {
+    const pickIsCodex = /codex|gpt/i.test(String(MODELS.code))
+    const pickRan = pickIsCodex ? (coderUsed === 'codex') : (coderUsed === 'claude')
+    if (pickRan && code) {
+      const codePassed = !!(qe && /^[AB]$/i.test(String(qe.grade || '').trim()))
+      await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --record-provisional --stage code --tier ' + AUTOCOST.code.tier + ' --model ' + codeMid, { label: 'auto-cost:record:code', phase: recPhase, effort: 'low' })
+      await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --finalize --stage code --tier ' + AUTOCOST.code.tier + ' --model ' + codeMid + ' --success ' + (codePassed ? 'true' : 'false'), { label: 'auto-cost:finalize:code', phase: recPhase, effort: 'low' })
+    } else {
+      // the picked model did not deliver (fallback fired or produced nothing) → record it as a failure.
+      log('auto-cost code: picked model ' + codeMid + ' did not deliver (coderUsed=' + coderUsed + ') — recording a failure')
+      await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --finalize --stage code --tier ' + AUTOCOST.code.tier + ' --model ' + codeMid + ' --success false', { label: 'auto-cost:finalize:code-fail', phase: recPhase, effort: 'low' })
+    }
+  }
+  // PLAN: provisional only (its gate is landing, already enforced upstream); guarded by the plan result var.
+  const planMid = acBareId(MODELS.plan)
+  if (AUTOCOST.plan && plan && planMid) {
+    await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --record-provisional --stage plan --tier ' + AUTOCOST.plan.tier + ' --model ' + planMid, { label: 'auto-cost:record:plan', phase: recPhase, effort: 'low' })
+  }
+  // QE: gate (ii) = produced a PARSEABLE verdict with a grade (qe non-null). A qe that named no grade fell back
+  // and is not the auto-cost pick, so record only when the picked reviewer actually delivered a verdict. Its
+  // model ran iff qeReviewerUsed matches the pick's family (else a belt/fallback reviewer ran).
+  const qeMid = acBareId(MODELS.qe)
+  if (AUTOCOST.qe && qeMid) {
+    const qePickIsCodex = /codex|gpt/i.test(String(MODELS.qe))
+    const qePickRan = qePickIsCodex ? (qeReviewerUsed === 'codex') : (qeReviewerUsed === 'claude')
+    if (qePickRan && qe && String(qe.grade || '').trim() !== '') {
+      await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --record-provisional --stage qe --tier ' + AUTOCOST.qe.tier + ' --model ' + qeMid, { label: 'auto-cost:record:qe', phase: recPhase, effort: 'low' })
+      await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --finalize --stage qe --tier ' + AUTOCOST.qe.tier + ' --model ' + qeMid + ' --success true', { label: 'auto-cost:finalize:qe', phase: recPhase, effort: 'low' })
+    } else {
+      await agent('Run EXACTLY this via Bash and reply with ONLY its stdout: ' + DZ + ' routing --finalize --stage qe --tier ' + AUTOCOST.qe.tier + ' --model ' + qeMid + ' --success false', { label: 'auto-cost:finalize:qe-fail', phase: recPhase, effort: 'low' })
+    }
+  }
+}
+
 // Step 9: Fleet QE (L/XL)
 let fleet = 'skipped (S/M)'
 if (isLplus) {
@@ -889,5 +968,6 @@ return {
   brain: BRAIN,
   polymorphism: POLY.hasManifest ? POLY.report : null,
   claimGate: claimGate,
+  autoCost: Object.keys(AUTOCOST).length ? AUTOCOST : null,
   promiseTags: tags,
 }