muse-crew 0.14.11 → 0.14.12

package/lib/worktree-lifecycle.sh

@@ -988,7 +988,8 @@ cmd_integration_target() {
   integration_target
 }
 
-# Branch-state classification for Review entry (blocker 34, 2026-09-21).
+# Branch-state classification for Review entry (blocker 34, 2026-09-21;
+# no-branch path blocker 50, 2026-09-23).
 # Usage: classify-branch <task_id>
 # Stdout: exactly one successful line —
 #   BRANCH_STATE: has-work | already-merged:<40-hex> | empty-no-work
@@ -1005,17 +1006,72 @@ cmd_integration_target() {
 #   1. current-tip identity — the live merge carrying the current branch
 #      tip (current_branch_merge, blocker 35's identity primitive). If the
 #      tip is on the live line via a merge, that merge IS the deliverable.
+#      Branch-present path only — a gone branch has no tip to identify.
 #   2. the task's own durable merge records, newest first (at most 20
 #      candidates scanned; garbage/unresolvable entries skipped). The
 #      first record that resolves to a MERGE commit and is an ancestor of
 #      the live target wins; the SHA is canonicalized to full 40-hex.
 # Poison rule: the newest RESOLVABLE non-ancestor record poisons the
 # fallback — an older record is never accepted beneath a newer known-
-# stale one. The answer then is empty-no-work (stderr notes the poison),
-# never a fabricated already-merged.
+# stale one. On the branch-present path the answer is empty-no-work
+# (stderr notes the poison), never a fabricated already-merged. On the
+# no-branch path the poison fails closed (exit 1): without a branch,
+# "empty" is indistinguishable from evidence loss.
 # The branch is empty here, so the blocker-35 identity/ancestry
 # distinction does not apply: there is no moved branch to go stale
 # against, and every candidate is this task's own record.
+#
+# No-branch path (blocker 50): a missing branch is the normal
+# post-integrate state — Integrate merges, the worktree lifecycle reclaims
+# the branch, and QA/rework run after. The classifier resolves the
+# integration target independently of the branch and runs the durable
+# merge-record scan (step 2 below). A hit prints already-merged:<sha> with
+# the real DIAG counts, exit 0. No hit — no records, none resolvable, none
+# an ancestor, or poisoned — exits 1 with diagnostics, never empty-no-work.
+
+# Durable merge-record scan, shared by classify-branch's branch-present
+# and no-branch paths (blocker 50). Newest first, at most 20 candidates:
+# valid-hex merge_commit= lines only; a candidate must resolve to a MERGE
+# commit (^2 exists) to count as resolvable. The first resolvable record
+# that is an ancestor of $2 wins. Results in SCAN_MERGED (full 40-hex or
+# empty) and SCAN_POISONED (1 when the newest resolvable record is a
+# non-ancestor — an older ancestor beneath it is refused, stderr-noted).
+# Updates the caller's diag_records/diag_resolvable (dynamic scope; the
+# defaults keep set -u safe). No stdout of its own.
+scan_merge_records() {
+  local task_id="$1" target="$2"
+  SCAN_MERGED=""; SCAN_POISONED=0
+  : "${diag_records:=0}" "${diag_resolvable:=0}"
+  local rec="$MERGE_RECORDS_DIR/$task_id"
+  [ -f "$rec" ] || return 0
+  local count=0 sha full poisoned=""
+  while IFS= read -r line && [ "$count" -lt 20 ]; do
+    case "$line" in
+      merge_commit=*) sha="${line#merge_commit=}" ;;
+      *) continue ;;
+    esac
+    case "$sha" in ""|*[!0-9a-f]*) continue ;; esac
+    count=$((count + 1))
+    diag_records=$((diag_records + 1))
+    full=$(git rev-parse --verify --quiet "$sha" 2>/dev/null) || continue
+    # A merge commit: the frozen first-parent diff the workflow reviews
+    # only exists for merges. A non-merge ancestor is never the task's
+    # merge — skipped, not poison (garbage must not veto delivery).
+    git rev-parse --verify --quiet "$full^2" >/dev/null 2>&1 || continue
+    diag_resolvable=$((diag_resolvable + 1))
+    if git merge-base --is-ancestor "$full" "$target" 2>/dev/null; then
+      if [ -n "$poisoned" ]; then
+        echo "classify-branch: newest resolvable record $poisoned is stale (not an ancestor of $target); refusing older record $full" >&2
+        SCAN_POISONED=1
+        return 0
+      fi
+      SCAN_MERGED="$full"
+      return 0
+    fi
+    [ -z "$poisoned" ] && poisoned="$full"
+  done < <(tac "$rec" 2>/dev/null)
+  return 0
+}
 cmd_classify_branch() {
   local task_id="$1"
   validate_task_id "$task_id"
@@ -1035,7 +1091,29 @@ cmd_classify_branch() {
   branch=$(resolve_branch "$task_id") || { echo "classify-branch: cannot resolve task branch" >&2; diag; return 1; }
 
   cd "$REPO"
-  git rev-parse --verify "$branch" >/dev/null 2>&1 || { echo "classify-branch: branch $branch does not exist" >&2; diag; return 1; }
+
+  # Blocker 50: a missing branch is the normal post-integrate state, not a
+  # classification failure — Integrate merges, the worktree lifecycle
+  # reclaims the branch, and QA/rework run after. Resolve the target
+  # independently of the branch and let the durable merge records plus
+  # trunk ancestry decide. Never empty-no-work here: without a branch,
+  # "empty" is indistinguishable from evidence loss.
+  if ! git rev-parse --verify "$branch" >/dev/null 2>&1; then
+    echo "classify-branch: branch $branch does not exist; scanning durable merge records" >&2
+    local nb_target
+    nb_target=$(integration_target) || { echo "classify-branch: cannot resolve integration target" >&2; diag; return 1; }
+    scan_merge_records "$task_id" "$nb_target"
+    if [ -n "$SCAN_MERGED" ]; then
+      diag
+      echo "BRANCH_STATE: already-merged:$SCAN_MERGED"
+      return 0
+    fi
+    if [ "$SCAN_POISONED" != "1" ]; then
+      echo "classify-branch: no merge record for $task_id is an ancestor of $nb_target" >&2
+    fi
+    diag
+    return 1
+  fi
 
   local target
   target=$(integration_target) || { echo "classify-branch: cannot resolve integration target" >&2; diag; return 1; }
@@ -1059,36 +1137,13 @@ cmd_classify_branch() {
     fi
   fi
 
-  # 2. Durable merge records, newest first. Empty-file-safe: no pipelines
-  # under set -e/pipefail, at most 20 candidate lines read.
-  local rec="$MERGE_RECORDS_DIR/$task_id"
-  if [ -f "$rec" ]; then
-    local count=0 sha full poisoned=""
-    while IFS= read -r line && [ "$count" -lt 20 ]; do
-      case "$line" in
-        merge_commit=*) sha="${line#merge_commit=}" ;;
-        *) continue ;;
-      esac
-      case "$sha" in ""|*[!0-9a-f]*) continue ;; esac
-      count=$((count + 1))
-      diag_records=$((diag_records + 1))
-      full=$(git rev-parse --verify --quiet "$sha" 2>/dev/null) || continue
-      # A merge commit: the frozen first-parent diff the workflow reviews
-      # only exists for merges. A non-merge ancestor is never the task's
-      # merge — skipped, not poison (garbage must not veto delivery).
-      git rev-parse --verify --quiet "$full^2" >/dev/null 2>&1 || continue
-      diag_resolvable=$((diag_resolvable + 1))
-      if git merge-base --is-ancestor "$full" "$target" 2>/dev/null; then
-        if [ -n "$poisoned" ]; then
-          echo "classify-branch: newest resolvable record $poisoned is stale (not an ancestor of $target); refusing older record $full" >&2
-          break
-        fi
-        diag
-        echo "BRANCH_STATE: already-merged:$full"
-        return 0
-      fi
-      [ -z "$poisoned" ] && poisoned="$full"
-    done < <(tac "$rec" 2>/dev/null)
+  # 2. Durable merge records, newest first (scan_merge_records; blocker 50
+  # shares this scan with the no-branch path).
+  scan_merge_records "$task_id" "$target"
+  if [ -n "$SCAN_MERGED" ]; then
+    diag
+    echo "BRANCH_STATE: already-merged:$SCAN_MERGED"
+    return 0
   fi
 
   diag

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.14.11",
+  "version": "0.14.12",
   "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,