@dzhechkov/skills-feature-adr 1.3.43 → 1.3.45

package/README.md

@@ -124,6 +124,15 @@ writing code. Without this the run stalls; with `coder: 'codex-fallback'` the pi
 unavailable (limit?) — falling back to Codex auto"* and finishes the code + tests on Codex, no
 restart and no lost work.
 
+**Codex writes are out-of-band — the Step-7.5 landed barrier waits for them.** Codex applies edits via
+its own runtime, so a naive pipeline runs QE before the async write flushes and false-grades *"Step 7
+never ran"* on real code. For a Codex-coded run the pipeline polls a **bounded 120s backing-off window**
+(`1,2,2,5,5,10,10,15,20,25,25`s), preferring the code stage's *declared expected files* when known, and
+emits an explicit `changed=0 after 120s — genuinely not landed` only when the window truly expires — so
+QE distinguishes "not implemented" from "not yet flushed". A Claude-coded run is synchronous and skips
+the barrier entirely (zero added wait). Note: if Codex flushes slower than 120s, re-verify after the run
+rather than trusting the end-of-run grade.
+
 ```bash
 # Headless login on a VPS (no browser):
 codex login --device-auth                       # prints a code + URL you approve on another device

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.43",
+  "version": "1.3.45",
   "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

@@ -47,6 +47,12 @@ const DZ_TEACH = (lesson, reward, domain) =>
 // ~/.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.)'
+function codexEffortHint(opts) {
+  if (opts && opts.agentType === 'codex:codex-rescue' && opts._reasoning) {
+    return ' (If you are the Codex runtime, run at --effort ' + opts._reasoning + '.)'
+  }
+  return ''
+}
 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'
 const PLANNER = (A.planner === 'codex') ? 'codex' : 'claude'
@@ -66,6 +72,7 @@ const PLANNER = (A.planner === 'codex') ? 'codex' : 'claude'
 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 VALID_REASONING = { none: 1, minimal: 1, low: 1, medium: 1, high: 1, xhigh: 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') || (A.usageAdaptive === true)
 const modelsUsed = {}
@@ -143,7 +150,8 @@ function specToOpts(spec) {
   if (parts[0] === 'codex') {
     let id = parts[1] || CODEX_MODEL
     if (id !== 'auto' && !KNOWN_CODEX[id]) { log('models: unknown codex id ' + id + ' — using ' + CODEX_MODEL); id = CODEX_MODEL }
-    const reasoning = parts[2] || 'high'
+    let reasoning = parts[2] || 'high'
+    if (!VALID_REASONING[reasoning]) { log('models: unknown reasoning ' + reasoning + ' — using high'); reasoning = 'high' }
     return { agentType: 'codex:codex-rescue', codexModel: id, _reasoning: reasoning }
   }
   if (CLAUDE_NAMES[parts[0]]) return { model: parts[0] }
@@ -240,6 +248,116 @@ function stageLabel(baseLabel, opts) {
 // Codex-QE run, do ZERO extra work (byte-identical to today).
 function needsLandedBarrier(opts) { return !!(opts && opts.agentType === 'codex:codex-rescue') }
 
+const DEFAULT_CODE_LANDING_MAX_WAIT_MS = 120000
+const DEFAULT_CODE_LANDING_BACKOFF_MS = [1000, 2000, 2000, 5000, 5000, 10000, 10000, 15000, 20000, 25000, 25000]
+const CODE_LANDED_BARRIER_SLEEPS_SECONDS = DEFAULT_CODE_LANDING_BACKOFF_MS.map((ms) => ms / 1000)
+const CODE_LANDING_PIPELINE_PREFIXES = ['features/', '.dz/', '.agentic-qe/', 'roam/']
+
+function codeLandingEmptySignal(seconds) {
+  return 'changed=0 after ' + seconds + 's — genuinely not landed'
+}
+
+function needsCodeLandedBarrier(coderUsed) {
+  return coderUsed === 'codex' || coderUsed === 'codex-fallback'
+}
+
+function normalizeCodeLandingPath(path) {
+  let p = String(path || '').trim().replace(/\\/g, '/')
+  while (p.indexOf('./') === 0) p = p.slice(2)
+  p = p.replace(/\/+/g, '/')
+  if (!p) return ''
+  if (p[0] === '/') return ''
+  if (p === '..' || p.indexOf('../') === 0 || p.indexOf('/../') >= 0 || p.endsWith('/..')) return ''
+  if (/[\0\r\n\t "'\x60$;&|<>*?()[\]{}!]/.test(p)) return ''
+  if (p.endsWith('/')) return ''
+  for (let i = 0; i < CODE_LANDING_PIPELINE_PREFIXES.length; i++) {
+    const prefix = CODE_LANDING_PIPELINE_PREFIXES[i]
+    const bare = prefix.slice(0, -1)
+    if (p === bare || p.indexOf(prefix) === 0) return ''
+  }
+  return p
+}
+
+function filterPollableCodePaths(paths) {
+  const out = []
+  const seen = {}
+  for (let i = 0; i < (paths || []).length; i++) {
+    const normalized = normalizeCodeLandingPath(paths[i])
+    if (!normalized || seen[normalized]) continue
+    seen[normalized] = 1
+    out.push(normalized)
+  }
+  return out
+}
+
+function codeLandedBarrierPlan(coderUsed, expectedPaths) {
+  const enabled = needsCodeLandedBarrier(coderUsed)
+  const pollWindowSeconds = DEFAULT_CODE_LANDING_MAX_WAIT_MS / 1000
+  if (!enabled) {
+    return { enabled: false, mode: 'any-code-change', sleepsMs: [], sleepsSeconds: [], pollWindowMs: 0, pollWindowSeconds: 0, expectedPaths: [], emptySignal: '' }
+  }
+  const filteredExpectedPaths = filterPollableCodePaths(expectedPaths || [])
+  return {
+    enabled: true,
+    mode: filteredExpectedPaths.length > 0 ? 'expected-files' : 'any-code-change',
+    sleepsMs: DEFAULT_CODE_LANDING_BACKOFF_MS,
+    sleepsSeconds: CODE_LANDED_BARRIER_SLEEPS_SECONDS,
+    pollWindowMs: DEFAULT_CODE_LANDING_MAX_WAIT_MS,
+    pollWindowSeconds: pollWindowSeconds,
+    expectedPaths: filteredExpectedPaths,
+    emptySignal: codeLandingEmptySignal(pollWindowSeconds),
+  }
+}
+
+function addExpectedCodeTarget(value, out) {
+  if (value === null || value === undefined) return
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) addExpectedCodeTarget(value[i], out)
+    return
+  }
+  if (typeof value === 'object') {
+    if (Array.isArray(value.wrote)) addExpectedCodeTarget(value.wrote, out)
+    if (Array.isArray(value.paths)) addExpectedCodeTarget(value.paths, out)
+    return
+  }
+  const lines = String(value).split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    const candidate = lines[i].replace(/^[-*]\s+/, '').replace(/^\x60+|\x60+$/g, '').trim()
+    if (candidate) out.push(candidate)
+  }
+}
+
+function extractExpectedCodeTargetsFromText(text) {
+  const out = []
+  const lines = String(text || '').split(/\r?\n/)
+  let inBlock = false
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim()
+    if (/^EXPECTED_CODE_TARGETS:\s*$/i.test(trimmed)) { inBlock = true; continue }
+    if (!inBlock) continue
+    if (!trimmed) continue
+    if (/^[A-Z][A-Z0-9_ -]*:\s*$/.test(trimmed)) break
+    out.push(trimmed.replace(/^[-*]\s+/, '').replace(/^\x60+|\x60+$/g, '').trim())
+  }
+  return out
+}
+
+function extractExpectedCodeTargets(argTargets, codexText) {
+  const out = []
+  addExpectedCodeTarget(argTargets, out)
+  addExpectedCodeTarget(extractExpectedCodeTargetsFromText(codexText), out)
+  return filterPollableCodePaths(out)
+}
+
+function codeLandingShellQuote(value) {
+  return "'" + String(value).replace(/'/g, "'\"'\"'") + "'"
+}
+
+function codeLandingProbeCmd(repo, plan) {
+  const expectedList = plan.expectedPaths.length > 0 ? plan.expectedPaths.map(codeLandingShellQuote).join(' ') : "''"
+  return 'repo=' + codeLandingShellQuote(repo) + '; sleeps="' + plan.sleepsSeconds.join(' ') + '"; expected_count=' + plan.expectedPaths.length + '; elapsed=0; poll(){ paths=$(git -C "$repo" status --porcelain 2>/dev/null | sed -E "s/^...//" | sed -E "s/.* -> //" | grep -vE "^(features/|[.]dz/|[.]agentic-qe/|roam/)" | sed "/^$/d" | head -200); n=$(printf "%s\\n" "$paths" | sed "/^$/d" | wc -l | tr -d " "); if [ "$expected_count" -gt 0 ]; then matched=""; for p in ' + expectedList + '; do [ -z "$p" ] && continue; if printf "%s\\n" "$paths" | grep -Fx -- "$p" >/dev/null; then matched="$p"; break; fi; done; if [ -n "$matched" ]; then echo "CODEX-LANDING-SIGNAL status=landed changed=1 after=${elapsed}s predicate=expected-path"; echo "matched=$matched"; echo "files:"; printf "%s\\n" "$paths" | head -40; exit 0; fi; else if [ "$n" -gt 0 ]; then echo "CODEX-LANDING-SIGNAL status=landed changed=$n after=${elapsed}s predicate=any-code-change"; echo "files:"; printf "%s\\n" "$paths" | head -40; exit 0; fi; fi; }; poll; for wait in $sleeps; do sleep "$wait"; elapsed=$((elapsed + wait)); poll; done; echo "CODEX-LANDING-SIGNAL status=genuinely-not-landed ' + plan.emptySignal + '"; if [ "$expected_count" -gt 0 ]; then echo "predicate=expected-path observed=$n"; else echo "predicate=any-code-change"; fi; echo "files:"; if [ -n "$paths" ]; then printf "%s\\n" "$paths" | head -40; else echo "(none)"; fi'
+}
+
 // A Bash one-liner that waits for a Codex OUT-OF-BAND artifact write to LAND: polls up to ~40s until
 // the file exists, is non-empty, AND its size is stable across two reads (write finished). Assumes a
 // fresh feature slug (no stale same-path artifact) — true for a normal /feature-adr run.
@@ -257,7 +375,7 @@ async function designStage(promptText, opts, artifactPath, baseLabel) {
   if (!needsLandedBarrier(opts)) return await agent(promptText, opts)
   const codexOpts = {}
   for (const k in opts) if (k !== 'schema') codexOpts[k] = opts[k]
-  const res = await agent(promptText + ' IMPORTANT: run the Codex task in FOREGROUND (synchronous — do NOT pass --background) so this call blocks until the file is fully written to disk.', codexOpts)
+  const res = await agent(promptText + codexEffortHint(codexOpts) + ' IMPORTANT: run the Codex task in FOREGROUND (synchronous — do NOT pass --background) so this call blocks until the file is fully written to disk.', codexOpts)
   const probe = await agent('Confirm a Codex OUT-OF-BAND artifact write has LANDED before the next stage reads it. Run EXACTLY this via Bash and return its stdout verbatim, nothing else:\n' + landedProbeCmd(artifactPath), { label: 'design:confirm-landed', phase: 'Design', effort: 'low' })
   if (res && probe && /landed=/.test(String(probe))) return { wrote: [artifactPath], summary: String(res).slice(0, 300) }
   log('design artifact did not land on codex (' + artifactPath + ') — falling back to Claude')
@@ -278,7 +396,7 @@ const routerPrompt = 'You are Step 0 (Complexity Router) of the /feature-adr pip
 const routerModel = resolveStageModel('router')
 const routerOpts = mergeOpts({ label: stageLabel('router+recall', routerModel), phase: 'Router', schema: ROUTER, effort: 'low' }, routerModel)
 modelsUsed.router = modelLabel(routerOpts)
-const router = await agent(routerPrompt, routerOpts)
+const router = await agent(routerPrompt + codexEffortHint(routerOpts), routerOpts)
 let tier = A.tier || (router ? router.tier : 'M')
 const LEARNED = router ? router.rationale : 'none recalled'
 const isMplus = tier === 'M' || tier === 'L' || tier === 'XL'
@@ -335,8 +453,8 @@ let plan = null
 if (planIsCodex) {
   const planCodexLabelOpts = (planModel.agentType === 'codex:codex-rescue') ? planModel : specToOpts('codex:' + CODEX_MODEL + ':high')
   modelsUsed.plan = modelLabel(planCodexLabelOpts)
-  const codexPlanOpts = mergeOpts({ label: stageLabel('plan:codex', planCodexLabelOpts), phase: 'Plan', agentType: 'codex:codex-rescue' }, planModel.agentType ? planModel : {})
-  const codexPlan = await agent(planPrompt + ' IMPORTANT: run the Codex task in FOREGROUND (synchronous — do NOT pass --background) so this call blocks until 06_implementation_plan.md is fully written to disk.', codexPlanOpts)
+  const codexPlanOpts = mergeOpts({ label: stageLabel('plan:codex', planCodexLabelOpts), phase: 'Plan', agentType: 'codex:codex-rescue' }, planCodexLabelOpts)
+  const codexPlan = await agent(planPrompt + codexEffortHint(codexPlanOpts) + ' IMPORTANT: run the Codex task in FOREGROUND (synchronous — do NOT pass --background) so this call blocks until 06_implementation_plan.md is fully written to disk.', codexPlanOpts)
   // Codex-landed barrier for the plan artifact: a stub return is NOT proof the file was written
   // (codex writes out-of-band). Require the artifact to LAND; otherwise fall through to the Claude planner.
   const planLanded = codexPlan ? await agent('Confirm the Codex plan write has LANDED. Run EXACTLY this via Bash and return its stdout verbatim, nothing else:\n' + landedProbeCmd(FDIR + '/06_implementation_plan.md'), { label: 'plan:confirm-landed', phase: 'Plan', effort: 'low' }) : null
@@ -383,6 +501,7 @@ const codeClaudeModel = codeIsCodexFirst ? {} : (codeModel.agentType ? {} : code
 const codeClaudeOpts = mergeOpts({ label: stageLabel('code', codeClaudeModel), phase: 'Code', schema: ARTIFACT, effort: 'high' }, codeClaudeModel)
 let code = null
 let coderUsed = 'claude'
+let codexCodeText = ''
 if (!codeIsCodexFirst) {
   code = await agent(codePrompt, codeClaudeOpts)
   if (code) { coderUsed = 'claude'; modelsUsed.code = modelLabel(codeClaudeOpts) }
@@ -391,21 +510,23 @@ 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 codeCodexLabelOpts = codeModel.agentType ? codeModel : specToOpts('codex:' + CODEX_MODEL + ':high')
-  const codeCodexOpts = mergeOpts({ label: stageLabel('code:codex', codeCodexLabelOpts), phase: 'Code', agentType: 'codex:codex-rescue' }, codeModel.agentType ? codeModel : {})
-  const codexCode = await agent(codePrompt + CODEX_HINT, codeCodexOpts)
-  if (codexCode) { code = { wrote: [FDIR + '/07_code_changes/change_manifest.md'], summary: String(codexCode).slice(0, 500) }; coderUsed = codeIsCodexFirst ? 'codex' : 'codex-fallback'; modelsUsed.code = modelLabel(codeCodexLabelOpts) }
+  const codeCodexOpts = mergeOpts({ label: stageLabel('code:codex', codeCodexLabelOpts), phase: 'Code', agentType: 'codex:codex-rescue' }, codeCodexLabelOpts)
+  const codexExpectedTargetsHint = '\n\nBecause this is running on Codex, include a final EXPECTED_CODE_TARGETS: block listing the repo-relative production/test files you expect to create or modify. List only real code/test/config/docs targets outside features/, .dz/, .agentic-qe/, and roam/. Example:\nEXPECTED_CODE_TARGETS:\n- packages/example/src/file.ts\n- packages/example/test/file.test.ts'
+  const codexCode = await agent(codePrompt + CODEX_HINT + codexEffortHint(codeCodexOpts) + codexExpectedTargetsHint, codeCodexOpts)
+  if (codexCode) { codexCodeText = String(codexCode); code = { wrote: [FDIR + '/07_code_changes/change_manifest.md'], summary: codexCodeText.slice(0, 500) }; coderUsed = codeIsCodexFirst ? 'codex' : 'codex-fallback'; modelsUsed.code = modelLabel(codeCodexLabelOpts) }
 }
 
 // Step 7.5: Codex-landed barrier. Codex applies edits OUT-OF-BAND via its own runtime; without this,
-// Step-8 QE reads the tree before the async write flushes and false-grades "Step 7 never ran" (grade D
-// on real, landed code — observed on the goap-ed25519 crypto fix). Poll git status (excluding pipeline
-// artifacts) up to ~30s until real code changes appear, and hand the confirmed file list to QE so it
-// reviews the ACTUAL landed changes. Claude-coded runs are synchronous → this barrier is skipped.
+// Step-8 QE can read the tree before the async write flushes and false-grade "Step 7 never ran" on real
+// completed code. Poll a bounded 120s backing-off window, preferring declared expected code targets when
+// known. Claude-coded runs are synchronous → this barrier is skipped with zero target parsing/probe work.
 let landedNote = ''
-if (coderUsed === 'codex' || coderUsed === 'codex-fallback') {
-  const barrierCmd = 'for i in 1 2 3 4 5 6; do n=$(git -C ' + REPO + ' status --porcelain 2>/dev/null | grep -vE "features/|[.]dz/|[.]agentic-qe/|roam/" | wc -l); [ "$n" -gt 0 ] && break; sleep 5; done; echo "changed=$n"; git -C ' + REPO + ' status --porcelain 2>/dev/null | grep -vE "features/|[.]dz/|[.]agentic-qe/|roam/" | head -40'
-  const probe = await agent('Confirm the Codex Step-7 edits have LANDED in the working tree BEFORE QE runs (Codex writes out-of-band). Run EXACTLY this via Bash and return its stdout verbatim, nothing else:\n' + barrierCmd, { label: 'code:confirm-landed', phase: 'Code' })
-  landedNote = '\n\nCODEX-CODED (out-of-band): review the CONFIRMED landed working-tree changes below — do NOT report "Step 7 never ran" if files are listed. If changed=0 the implementation genuinely did not land, then grade accordingly.\n' + String(probe || '(landed-probe failed)').slice(0, 1500)
+if (needsCodeLandedBarrier(coderUsed)) {
+  const expectedCodeTargets = extractExpectedCodeTargets(A.expectedCodeTargets, codexCodeText)
+  const barrierPlan = codeLandedBarrierPlan(coderUsed, expectedCodeTargets)
+  const barrierCmd = codeLandingProbeCmd(REPO, barrierPlan)
+  const probe = await agent('Confirm the Codex Step-7 edits have LANDED in the working tree BEFORE QE runs (Codex writes out-of-band). Expected-file mode must be satisfied by one of the declared expected paths; unrelated dirty files do not count in that mode. Run EXACTLY this via Bash and return its stdout verbatim, nothing else:\n' + barrierCmd, { label: 'code:confirm-landed', phase: 'Code' })
+  landedNote = '\n\nCODEX-CODED (out-of-band): Step 7.5 landing barrier used mode=' + barrierPlan.mode + ', window=' + barrierPlan.pollWindowSeconds + 's. Review the signal below. If status=landed, read the listed files and do NOT report "Step 7 never ran". Only status=genuinely-not-landed with "' + barrierPlan.emptySignal + '" means the bounded barrier found no intended code after the full window.\nExpected code targets: ' + (barrierPlan.expectedPaths.length ? barrierPlan.expectedPaths.join(', ') : '(none declared; fallback accepts any non-pipeline code change)') + '\n' + String(probe || '(landed-probe failed)').slice(0, 1500)
 }
 
 // Step 8: QE (brutal-honesty, agentic-qe) + MANDATORY teach
@@ -434,8 +555,8 @@ 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 qeCodexLabelOpts = qeModel.agentType ? qeModel : specToOpts('codex:' + CODEX_MODEL + ':high')
-  const qeCodexOpts = mergeOpts({ label: stageLabel('qe:codex', qeCodexLabelOpts), phase: 'QE', agentType: 'codex:codex-rescue' }, qeModel.agentType ? qeModel : {})
-  const codexQe = await agent(qePrompt + CODEX_HINT, qeCodexOpts)
+  const qeCodexOpts = mergeOpts({ label: stageLabel('qe:codex', qeCodexLabelOpts), phase: 'QE', agentType: 'codex:codex-rescue' }, qeCodexLabelOpts)
+  const codexQe = await agent(qePrompt + CODEX_HINT + codexEffortHint(qeCodexOpts), qeCodexOpts)
   if (codexQe) { qe = { grade: 'codex-review', gaps: [], codeTestsAdequate: null, docTestsPresent: null, summary: String(codexQe).slice(0, 500) }; qeReviewerUsed = qeIsCodex ? 'codex' : 'codex-fallback'; modelsUsed.qe = modelLabel(qeCodexLabelOpts) }
 }
 // Belt: if a codex-first QE returned null (codex unavailable), fall back to a Claude reviewer — never block.
@@ -457,8 +578,8 @@ if (isLplus) {
   const fleetTraceOpts = mergeOpts({ label: stageLabel('fleet:trace', fleetModel), phase: 'FleetQE', agentType: 'qe-requirements-validator' }, fleetModel)
   const fleetCovOpts = mergeOpts({ label: stageLabel('fleet:cov', fleetModel), phase: 'FleetQE', agentType: 'qe-coverage-specialist' }, fleetModel)
   const fleetThunks = [
-    () => agent('Step 9 fleet-QE (requirements traceability + risk) for ' + SLUG + ': map ADR decisions to code to tests; flag orphans + high risk. Write ' + FDIR + '/09_fleet_qe_assessment.md.', fleetTraceOpts),
-    () => agent('Step 9 fleet-QE (coverage + regression) for ' + SLUG + ': risk-weighted coverage gaps + regression selection for the changed files. Append to ' + FDIR + '/09_fleet_qe_assessment.md.', fleetCovOpts),
+    () => agent('Step 9 fleet-QE (requirements traceability + risk) for ' + SLUG + ': map ADR decisions to code to tests; flag orphans + high risk. Write ' + FDIR + '/09_fleet_qe_assessment.md.' + codexEffortHint(fleetTraceOpts), fleetTraceOpts),
+    () => agent('Step 9 fleet-QE (coverage + regression) for ' + SLUG + ': risk-weighted coverage gaps + regression selection for the changed files. Append to ' + FDIR + '/09_fleet_qe_assessment.md.' + codexEffortHint(fleetCovOpts), fleetCovOpts),
   ]
   await parallel(fleetThunks)
   fleet = 'run'