@dzhechkov/skills-feature-adr 1.3.43 → 1.3.44

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.44",
   "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

@@ -240,6 +240,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.
@@ -383,6 +493,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) }
@@ -392,20 +503,22 @@ 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 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 + 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