fix(#4628): expose DAG-ready plans and restrict dispatch to them (#4781)

Emitted-Drift-Ack-Growth: execute-phase.md — #4628 consumer wiring: ready_plans parse pointer, not-ready named skip, and waiting condition 2b reference to the ready-wave-gate step file

Co-authored-by: sim <sim@local>
This commit is contained in:
Tom Boucher
2026-09-16 02:38:43 -04:00
committed by GitHub
parent febe6c9885
commit 740ba0d8a3
41 changed files with 432 additions and 684 deletions

View File

@@ -63,7 +63,7 @@ executor skips them.
**Activation logic:**
1. If `CROSS_AI_DISABLED` is true (`--no-cross-ai` flag): skip this step entirely.
2. If `CROSS_AI_FORCE` is true (`--cross-ai` flag): mark ALL incomplete plans for cross-AI execution.
2. If `CROSS_AI_FORCE` is true (`--cross-ai` flag): mark ALL incomplete plans that are `ready` (#4628 — every dependency has completion evidence) for cross-AI execution. A not-ready plan is never delegated: it would dispatch over an incomplete predecessor, the exact failure #4628 reports.
3. Otherwise: check each plan's frontmatter for `cross_ai: true` AND verify config
`workflow.cross_ai_execution` is `true`. Plans matching both conditions are marked for cross-AI.

View File

@@ -28,9 +28,9 @@ block indefinitely waiting for a signal; verify via filesystem and git state.
SUMMARY_EXISTS=$(test -f "{phase_dir}/{plan_number}-{plan_padded}-SUMMARY.md" && echo "true" || echo "false")
# #4003: anchored, zero-pad-tolerant scope (see safe_resume_gate); --since stays.
SPOT_PHASE_NUMBER="{phase_number}"
# #4619 / #4748: same decimal/N-segment/letter-suffix handling as safe_resume_gate.
SPOT_PHASE_INT=${SPOT_PHASE_NUMBER%%[!0-9]*}; SPOT_PHASE_REST=${SPOT_PHASE_NUMBER#"$SPOT_PHASE_INT"}
SPOT_PHASE_N="$((10#$SPOT_PHASE_INT))${SPOT_PHASE_REST//./\\.}"
# #4619: same decimal/N-segment handling as safe_resume_gate.
SPOT_PHASE_INT=${SPOT_PHASE_NUMBER%%.*}; SPOT_PHASE_FRAC=${SPOT_PHASE_NUMBER#"$SPOT_PHASE_INT"}
SPOT_PHASE_N="$((10#$SPOT_PHASE_INT))${SPOT_PHASE_FRAC//./\\.}"
SPOT_PLAN_N=$((10#{plan_padded}))
COMMITS_FOUND=$(git log --oneline --all -E --grep="^[a-z]+\((0*${SPOT_PHASE_N})-(0*${SPOT_PLAN_N})\):" --since="1 hour ago" | head -1)
COMMITS_SINCE_DISPATCH=$(git log "${EXPECTED_BRANCH}" --since="${DISPATCH_TS}" --oneline | head -1)

View File

@@ -0,0 +1,37 @@
# Ready-wave gate (#4628)
Read and follow this fragment from `execute-phase.md` step 1
(`discover_and_group_plans`). It owns the #4628 readiness rules so the host
stays inside its ADR-857 Phase 6 byte budget (#1168).
`phase-plan-index` now exposes, additively: `ready_plans` (top level), and —
on every INCOMPLETE plan — `ready` plus `unresolved_dependencies`. `runnable`
keeps its #2830 meaning ("not halted-blocked") and says nothing about
completion evidence: a runnable plan whose dependencies lack a SUMMARY is not
DAG-ready.
**Named skip (#4628):** additionally skip any incomplete plan whose `ready` is
`false` — it has direct dependencies without completion evidence, and
dispatching it would violate the declared DAG — and report it by name with the
missing predecessors: "Skipping {plan.id}: incomplete predecessor
{unresolved_dependencies.join(', ')}". Readiness is transitive: a ready
plan's own dependencies are already complete, so **a not-ready plan must
never be dispatched in this run, even when a later wave's plans are ready**.
**Waiting is not done (#4628).** In step 1's filtered-out evaluation order,
after the #2830 blocked condition and before the all-summarized condition,
insert:
> 2b. **No filter is active, no blocked-plan skip occurred, and at least one
> filtered plan was skipped because `ready: false` (#4624 cross-reference; #4628 scope)** — the wave
> is WAITING on incomplete predecessors, not finished: report "Phase waiting:
> {plan ids} await incomplete predecessors {unresolved_dependencies} —
> dispatch the ready wave, then re-run." → exit. Do not fall through to the
> completion states; nothing here is a completion state. (The ready plans
> themselves were already dispatched this run — the executor wave loop
> dispatches every ready plan of the earliest ready wave onward.)
This ordering is fail-closed: a later wave is never selected while any
predecessor is incomplete, because a ready plan's own dependencies are
complete by construction — anything not ready is reported and the run stops
at the waiting condition.