@plainconceptsplatform/workflows 1.8.0 → 1.8.3

package/loops/actions/housekeeping/action.yml

@@ -223,10 +223,17 @@ runs:
           // every sweep.
           const RELEASE_MARKER = '<!-- housekeeping-release -->';
           let released = 0;
-          for (const issue of issues) {
+          // One child per feature per sweep, the lowest-numbered: children of one stack build on the
+          // same branch, and releasing several at once lets them build side by side and conflict.
+          // The router holds a child while a sibling's pull request is open, and the sibling's
+          // landing releases the next one.
+          const releasedFeatures = new Set();
+          for (const issue of [...issues].sort((a, b) => a.number - b.number)) {
             if (issue.pull_request) continue;
             const labels = names(issue);
             if (!labels.includes('implement')) continue;
+            const feature = /<!-- split-parent: (\d+) -->/.exec(issue.body ?? '')?.[1];
+            if (feature && releasedFeatures.has(feature)) continue;
             if (['bot-working', 'stalled', 'review', 'pr-pending'].some((l) => labels.includes(l))) continue;
             const thread = await github.paginate(github.rest.issues.listComments, {
               ...context.repo, issue_number: issue.number, per_page: 100,
@@ -252,6 +259,7 @@ runs:
                 inputs: { operation: 'implement', 'issue-number': String(issue.number) },
               });
             });
+            if (feature) releasedFeatures.add(feature);
             released += 1;
           }
 

package/loops/actions/verify-route-matrix/verify-route-matrix.sh

@@ -2927,6 +2927,29 @@ else
   FAIL=$((FAIL + 1))
   echo "FAIL: housekeeping does not announce a stack whose children all closed outside the router" >&2
 fi
+# The router announces a finished stack when the last child lands, not only when the root's CI
+# happens to be green at that instant: the landing pushes to the root, so its CI is usually still
+# running, and an unannounced root is held by the gate whatever its verdict (Odyssey #332).
+if grep -qF 'not green/mergeable yet' "${WORKFLOWS_DIR}/work-router.yml"; then
+  FAIL=$((FAIL + 1))
+  echo "FAIL: the stack-complete announcement waits for the root's CI, and nothing re-announces it" >&2
+else
+  PASS=$((PASS + 1))
+fi
+# Children of one stack build one at a time: every releaser lets one child go per feature, and the
+# router holds a child while a sibling's pull request is open on the feature branch (Odyssey
+# feat/323 built three children side by side and two landed conflicting).
+ONE_AT_A_TIME_OK=1
+grep -qF 'The next landing releases the next one."' "${WORKFLOWS_DIR}/work-router.yml" ||
+  { ONE_AT_A_TIME_OK=0; echo "FAIL: land-stack-child releases every free sibling at once" >&2; }
+grep -qF 'echo "Released #$child of feature #$feature."' "${WORKFLOWS_DIR}/work-router.yml" &&
+  grep -A1 -F 'echo "Released #$child of feature #$feature."' "${WORKFLOWS_DIR}/work-router.yml" | grep -qE '^\s+break$' ||
+  { ONE_AT_A_TIME_OK=0; echo "FAIL: stack-landed releases every free child of the next feature at once" >&2; }
+grep -qF -- '--base "$STACK_BRANCH" --limit 100 --json number,body' "${WORKFLOWS_DIR}/work-router.yml" ||
+  { ONE_AT_A_TIME_OK=0; echo "FAIL: check-stack-branch dispatches a child while a sibling's pull request is open" >&2; }
+grep -qF 'releasedFeatures' "${HERE}/../housekeeping/action.yml" ||
+  { ONE_AT_A_TIME_OK=0; echo "FAIL: housekeeping releases several children of one feature in a sweep" >&2; }
+if [ "$ONE_AT_A_TIME_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
 # A stack child runs the feature branch's copy of the workflows, so the router brings the default
 # branch in before it dispatches one.
 if grep -qF 'bring $DEFAULT_BRANCH into $STACK_BRANCH before a child runs' "${WORKFLOWS_DIR}/work-router.yml"; then

package/loops/workflows/work-router.yml

@@ -542,6 +542,7 @@ jobs:
       stack-branch: ${{ steps.stack.outputs.stack-branch }}
       stack-in-flight: ${{ steps.inflight.outputs.stack-in-flight }}
       stack-blocked: ${{ steps.blocked.outputs.stack-blocked }}
+      flat-blocked: ${{ steps.flatblocked.outputs.flat-blocked }}
       implement-queue: ${{ steps.queue.outputs.queue }}
     steps:
       # Which implement queue this issue waits in. The children of one refine share a queue,
@@ -682,6 +683,17 @@ jobs:
               done
             fi
           fi
+          # One child of a stack at a time. A sibling's pull request still open on the feature branch
+          # means this child would cut from a branch that is about to change under it, and whichever
+          # lands second conflicts (Odyssey feat/323: three children built side by side, two left
+          # DIRTY). That sibling's landing releases the next child. The child's own pull request,
+          # if it has one, is not a sibling.
+          if [ -z "$waiting" ]; then
+            for pr in $(gh pr list --repo "$REPO" --state open --base "$STACK_BRANCH" --limit 100 --json number,body \
+                          --jq ".[] | select(.body | test(\"(?i)(close[sd]?|fix(e[sd])?|resolve[sd]?) #${ISSUE_NUMBER}([^0-9]|$)\") | not) | .number" 2>/dev/null || true); do
+              waiting="$waiting #$pr"
+            done
+          fi
           [ -n "$waiting" ] || exit 0
           echo "::notice::#$ISSUE_NUMBER is blocked by$waiting, not yet landed; holding it."
           echo "stack-blocked=true" >> "$GITHUB_OUTPUT"
@@ -695,6 +707,38 @@ jobs:
             gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body-file /tmp/held.md >/dev/null || true
           fi
 
+      # Unattended, a feature refine did not split takes the flat path, which has no stack to wait
+      # in. Blocked by a feature that has not landed, it would build on a default branch without
+      # that feature. It is held the same way a child is, and stack-landed releases it.
+      - name: Hold an unsplit feature whose blockers have not landed
+        id: flatblocked
+        if: steps.stack.outputs.is-stack != 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          ISSUE_NUMBER: ${{ needs.classify.outputs.issue-number }}
+        run: |
+          set -euo pipefail
+          echo "flat-blocked=false" >> "$GITHUB_OUTPUT"
+          [ "${UNATTENDED:-false}" = true ] || exit 0
+          waiting=""
+          for b in $( { gh api "repos/$REPO/issues/$ISSUE_NUMBER/dependencies/blocked_by" --jq '.[].number' 2>/dev/null || true
+                        gh issue view "$ISSUE_NUMBER" --repo "$REPO" --json body --jq '.body // ""' 2>/dev/null \
+                          | grep -oiE 'blocked by #[0-9]+' | grep -oE '[0-9]+' || true
+                      } | sort -u ); do
+            gh issue view "$b" --repo "$REPO" --json state --jq '.state' 2>/dev/null | grep -qix open || continue
+            waiting="$waiting #$b"
+          done
+          [ -n "$waiting" ] || exit 0
+          echo "::notice::#$ISSUE_NUMBER is blocked by$waiting, not yet landed; holding it."
+          echo "flat-blocked=true" >> "$GITHUB_OUTPUT"
+          gh issue edit "$ISSUE_NUMBER" --repo "$REPO" --remove-label bot-working >/dev/null 2>&1 || true
+          marker='<!-- stack-held -->'
+          if ! gh api "repos/$REPO/issues/$ISSUE_NUMBER/comments?per_page=100" --jq '.[].body' 2>/dev/null | grep -qF "$marker"; then
+            printf '%s\nHeld until%s have landed on the default branch: this feature builds on them. It keeps `implement` and is released when they merge.\n' "$marker" "$waiting" > /tmp/held.md
+            gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body-file /tmp/held.md >/dev/null || true
+          fi
+
       - name: Detect an in-flight implement on the feature branch
         id: inflight
         if: steps.stack.outputs.is-stack == 'true'
@@ -720,7 +764,7 @@ jobs:
 
   call-implement:
     needs: [classify, authorize, check-implement-pr, check-stack-branch]
-    if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true' && needs.check-implement-pr.outputs.has-open-pr != 'true' && needs.check-stack-branch.outputs.is-stack != 'true'
+    if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true' && needs.check-implement-pr.outputs.has-open-pr != 'true' && needs.check-stack-branch.outputs.is-stack != 'true' && needs.check-stack-branch.outputs.flat-blocked != 'true'
     uses: ./.github/workflows/agent-implement.lock.yml
     # One FIFO queue per IMPLEMENT_PARALLELISM slot, chosen by check-stack-branch: the children of
     # one refine always share a queue, independent issues spread across them.
@@ -1242,13 +1286,21 @@ jobs:
                   # so the landing does: re-adding `implement` with the App token is a bot label
                   # event, which the router routes straight to implement. The child that just
                   # landed counts as done even before the gate closes its issue a moment later.
-                  for child in $children; do
+                  #
+                  # One child per landing, the lowest-numbered one that is free. Releasing every free
+                  # sibling at once started three implements on Odyssey's feat/323 within a second;
+                  # each cut from the same branch, and every landing left the others conflicting. The
+                  # next landing releases the next child. A held child with no `Blocked by` of its
+                  # own (held because a sibling was in flight) is free once it carries the hold marker.
+                  for child in $(printf '%s\n' $children | sort -n); do
                     [ "$child" = "$closed_issue" ] && continue
                     meta=$(gh issue view "$child" --repo "$REPO" --json state,labels,body 2>/dev/null || echo '{}')
                     printf '%s' "$meta" | jq -e '(.state // "" | ascii_downcase) == "open"' >/dev/null || continue
-                    printf '%s' "$meta" | jq -e '[.labels[]?.name] | (index("implement") != null) and (index("bot-working") == null)' >/dev/null || continue
+                    printf '%s' "$meta" | jq -e '[.labels[]?.name] | (index("implement") != null) and (index("bot-working") == null) and (index("pr-pending") == null)' >/dev/null || continue
                     blockers=$(printf '%s' "$meta" | jq -r '.body // ""' | grep -oiE 'blocked by #[0-9]+' | grep -oE '[0-9]+' | sort -u || true)
-                    [ -n "$blockers" ] || continue
+                    if [ -z "$blockers" ]; then
+                      gh api "repos/$REPO/issues/$child/comments?per_page=100" --jq '.[].body' 2>/dev/null | grep -qF '<!-- stack-held -->' || continue
+                    fi
                     waiting=""
                     for b in $blockers; do
                       [ "$b" = "$closed_issue" ] && continue
@@ -1262,7 +1314,8 @@ jobs:
                     fi
                     gh issue edit "$child" --repo "$REPO" --remove-label implement >/dev/null 2>&1 || true
                     gh issue edit "$child" --repo "$REPO" --add-label implement >/dev/null
-                    echo "Released #$child: everything it was blocked by has landed."
+                    echo "Released #$child: everything it was blocked by has landed. The next landing releases the next one."
+                    break
                   done
                   open_children=0
                   for child in $children; do
@@ -1275,37 +1328,23 @@ jobs:
                   if [ "$open_children" -gt 0 ]; then
                     echo "$open_children child issue(s) still open on stack #$parent; the stack continues."
                   else
-                    # The root pull request must be green and mergeable. Green: a successful
-                    # CI run on its head SHA. Mergeable: the same on-demand computation
-                    # every gate dispatch already relies on; UNKNOWN settles in the
-                    # background, so ask until it does, like mergeable_state() does.
-                    root_state=UNKNOWN
-                    for _ in 1 2 3 4 5 6; do
-                      root_state=$(gh pr view "$root_pr" --repo "$REPO" --json mergeable --jq '.mergeable' 2>/dev/null || echo UNKNOWN)
-                      [ "$root_state" = "UNKNOWN" ] || break
-                      sleep 5
-                    done
-                    root_sha=$(gh api "repos/$REPO/pulls/$root_pr" --jq '.head.sha')
-                    root_ci=$(gh api "repos/$REPO/actions/runs?head_sha=$root_sha&per_page=100" \
-                      --jq '[.workflow_runs[]
-                        | select(.name == env.CI_WORKFLOW_NAME and .status == "completed"
-                                 and .conclusion == "success")]
-                      | sort_by(.created_at) | last // empty')
-                    if [ -z "$root_ci" ] || [ "$root_state" != "MERGEABLE" ]; then
-                      echo "Root PR #$root_pr is not green/mergeable yet; the human will merge when it is."
+                    # Announce as soon as the last child lands, whatever the root's CI is doing at
+                    # this instant. The landing itself pushes to the feature branch, so the root's CI
+                    # is usually still running here; waiting for green left the announcement unposted
+                    # with nothing to post it later but the six-hourly housekeeping (Odyssey #332 sat
+                    # with an auto-merge verdict, held, from 00:09 until a person announced it). The
+                    # gate still reads CI and mergeability itself before it merges the root.
+                    completion_marker='<!-- stack-complete -->'
+                    # The announcement is a pull request comment, and pull request
+                    # comments live at the issue endpoint for the pull request number,
+                    # so the marker is looked for where the comment was posted.
+                    already=$(gh api "repos/$REPO/issues/$root_pr/comments?per_page=100" \
+                      --jq "[.[] | select(.body | contains(\"$completion_marker\"))] | length" 2>/dev/null || echo 0)
+                    if [ "${already:-0}" -gt 0 ]; then
+                      echo "Stack #$parent already has a completion announcement; staying silent."
                     else
-                      completion_marker='<!-- stack-complete -->'
-                      # The announcement is a pull request comment, and pull request
-                      # comments live at the issue endpoint for the pull request number,
-                      # so the marker is looked for where the comment was posted.
-                      already=$(gh api "repos/$REPO/issues/$root_pr/comments?per_page=100" \
-                        --jq "[.[] | select(.body | contains(\"$completion_marker\"))] | length" 2>/dev/null || echo 0)
-                      if [ "${already:-0}" -gt 0 ]; then
-                        echo "Stack #$parent already has a completion announcement; staying silent."
-                      else
-                        gh pr comment "$root_pr" --repo "$REPO" --body "Stack complete: all children have merged into the feature branch and CI is green. This root pull request is ready to merge into $DEFAULT_BRANCH: the merge gate decides it next, and a person is asked only when its blast radius or a finding says so. $completion_marker"
-                        echo "Stack #$parent complete: announced root PR #$root_pr."
-                      fi
+                      gh pr comment "$root_pr" --repo "$REPO" --body "Stack complete: all children have merged into the feature branch. This root pull request is ready to merge into $DEFAULT_BRANCH once its CI is green: the merge gate decides it next, and a person is asked only when its blast radius or a finding says so. $completion_marker"
+                      echo "Stack #$parent complete: announced root PR #$root_pr."
                     fi
                   fi
                   fi
@@ -1429,7 +1468,9 @@ jobs:
               gh issue comment "$feature" --repo "$REPO" --body "Feature #$parent landed on $DEFAULT_BRANCH, but \`$DEFAULT_BRANCH\` could not be merged into \`$branch\` ($answer). The children of this feature stay held until a person resolves the branch and re-adds \`implement\` to the first one." >/dev/null || true
               continue
             fi
-            for child in ${next_children[$feature]}; do
+            # One child per feature, the lowest-numbered free one; each landing on the feature branch
+            # releases the next (land-stack-child), so siblings never build side by side.
+            for child in $(printf '%s\n' ${next_children[$feature]} | sort -n); do
               own=$(gh issue view "$child" --repo "$REPO" --json body --jq '.body // ""' 2>/dev/null \
                 | grep -oiE 'blocked by #[0-9]+' | grep -oE '[0-9]+' | sort -u || true)
               waiting=""
@@ -1443,9 +1484,24 @@ jobs:
               gh issue edit "$child" --repo "$REPO" --remove-label implement >/dev/null 2>&1 || true
               gh issue edit "$child" --repo "$REPO" --add-label implement >/dev/null
               echo "Released #$child of feature #$feature."
+              break
             done
           done
 
+          # A feature refine did not split waits on the issue itself, held by check-stack-branch with
+          # `implement` kept. It cuts from the default branch, which now has what it waited on.
+          flat=$(gh issue list --repo "$REPO" --state open --label implement --limit 200 \
+            --json number,labels,body \
+            --jq '.[] | select([.labels[].name] | index("bot-working") | not)
+                      | select(.body | test("<!-- split-parent: [0-9]+ -->") | not) | .number')
+          for issue in $flat; do
+            depends_on_parent "$issue" || continue
+            [ -z "$(blockers_of "$issue")" ] || { echo "#$issue still waits on other work."; continue; }
+            gh issue edit "$issue" --repo "$REPO" --remove-label implement >/dev/null 2>&1 || true
+            gh issue edit "$issue" --repo "$REPO" --add-label implement >/dev/null
+            echo "Released unsplit feature #$issue."
+          done
+
           # The report: what merged without a person, and what the gate noted on the way. One issue
           # per feature, written once; its marker makes a rerun a no-op.
           marker="<!-- unattended-report: $parent -->"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/workflows",
-  "version": "1.8.0",
+  "version": "1.8.3",
   "description": "Install and update Platform GitHub agentic workflows.",
   "keywords": [
     "github-actions",