muse-crew 0.4.0 → 0.4.2

package/docs/guide.md

@@ -18,7 +18,7 @@ This is the full setup and operations reference. If you're new, start with the [
 - An **`.orchestration/` directory** in the crew home with identities, personas, workflow docs, and feedback conventions.
 - A **project registration** — the task service registered as its own first project.
 - A **polling loop** — checks for work every 3 minutes via Muse's scheduling, even when nobody's in the conversation.
-- An **orphan sweep** — runs every 30 minutes to clean merged worktrees and break stale merge locks.
+- An **orphan sweep** — runs every 30 minutes to clean merged worktrees and break stale merge locks. It never touches worktrees belonging to tasks with a running dashboard session.
 
 The agent running in the main chat receives the dispatcher's claims and launches each task workflow. Workflows can't launch workflows, so this handoff is structural.
 

package/lib/AGENTS.md

@@ -6,3 +6,4 @@ Shell scripts for the crew's infrastructure. Called by workflow scripts, cron, a
 - `merge-lock.sh` — serialized merge lock for concurrent agents; records owner PID
 - `worktree-lifecycle.sh` — git worktree create/cleanup for isolated agent work
 - `orphan-sweep.sh` — find and clean stale worktrees and merge locks
+- `test-orphan-sweep.sh` — regression tests for orphan-sweep.sh (active-run guard, verified removal, fail-closed)

package/lib/orphan-sweep.sh

@@ -3,9 +3,24 @@
 #
 # Usage:
 #   orphan-sweep.sh report  — list orphans (read-only for worktrees);
-#                              force-releases stale locks with dead PIDs
+#                              stale locks with dead PIDs are released
 #   orphan-sweep.sh clean   — remove safe-to-clean orphans (merged branches only)
-#                              and force-release stale merge locks (>30 min)
+#                              and release stale merge locks
+#
+# Active-run knowledge is injected by the caller, never fetched here:
+#   CREW_ACTIVE_TASKS      — space-separated task IDs with a running session
+#   CREW_ACTIVE_TASKS_FILE — path to a file with one task ID per line
+#                            (blank lines and '#' comments are ignored)
+# Both inputs feed one active set, matched exactly against worktree dir names.
+# A task in the active set is never touched: its worktree and any merge lock
+# it holds are skipped regardless of merge status, lock age, or PID liveness.
+#
+# Fail closed: clean mode without either input refuses to remove anything
+# and exits 2. Report mode without either input still runs read-only but
+# prints a banner noting the ACTIVE checks were skipped.
+#
+# Callers (the sweep cron body; worktree-lifecycle.sh cmd_sweep is a
+# passthrough) must export CREW_ACTIVE_TASKS.
 #
 # "Safe to clean" means the task branch is fully merged into main.
 # Dirty or unmerged worktrees are always preserved and reported.
@@ -19,33 +34,74 @@ STALE_LOCK_MIN=30
 
 cmd="${1:-report}"
 found=0
+any_failed=0
+
+# --- Active-run set (union of both inputs) ---
+have_active_data=0
+ACTIVE_TASKS=""
+if [ -n "${CREW_ACTIVE_TASKS+set}" ]; then
+  have_active_data=1
+  ACTIVE_TASKS="${ACTIVE_TASKS} ${CREW_ACTIVE_TASKS}"
+fi
+if [ -n "${CREW_ACTIVE_TASKS_FILE+set}" ]; then
+  if [ -r "${CREW_ACTIVE_TASKS_FILE}" ]; then
+    have_active_data=1
+    while IFS= read -r line || [ -n "$line" ]; do
+      case "$line" in ''|\#*) continue ;; esac
+      ACTIVE_TASKS="${ACTIVE_TASKS} ${line}"
+    done < "${CREW_ACTIVE_TASKS_FILE}"
+  fi
+fi
+
+task_is_active() {
+  [ -n "${1:-}" ] || return 1
+  case " ${ACTIVE_TASKS} " in
+    *" $1 "*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+if [ "$cmd" = "clean" ] && [ "$have_active_data" -eq 0 ]; then
+  echo "BLOCKED: clean mode requires the active-run list (set CREW_ACTIVE_TASKS or CREW_ACTIVE_TASKS_FILE) — refusing to remove anything"
+  exit 2
+fi
+
+if [ "$cmd" != "clean" ] && [ "$have_active_data" -eq 0 ]; then
+  echo "NOTE: no active-run data provided; ACTIVE checks skipped"
+fi
 
 # --- Stale merge lock ---
 if [ -f "$LOCK_FILE" ]; then
   lock_holder=$(cut -d' ' -f1 "$LOCK_FILE" 2>/dev/null || echo "unknown")
-  lock_time=$(cut -d' ' -f2 "$LOCK_FILE" 2>/dev/null || echo "")
-  lock_pid=$(awk '{print $3}' "$LOCK_FILE" 2>/dev/null || echo "")
-  if [ -n "$lock_time" ]; then
-    lock_epoch=$(date -d "$lock_time" +%s 2>/dev/null || echo 0)
-    now_epoch=$(date -u +%s)
-    age_min=$(( (now_epoch - lock_epoch) / 60 ))
-    if [ "$age_min" -gt "$STALE_LOCK_MIN" ]; then
-      # Check if owner process is still alive
-      pid_alive=0
-      if [ -n "$lock_pid" ] && [ "$lock_pid" != "-" ] && kill -0 "$lock_pid" 2>/dev/null; then
-        pid_alive=1
-      fi
+  if task_is_active "$lock_holder"; then
+    echo "ACTIVE_LOCK: held by $lock_holder (active run on dashboard) — skipping"
+    found=1
+  else
+    lock_time=$(cut -d' ' -f2 "$LOCK_FILE" 2>/dev/null || echo "")
+    lock_pid=$(awk '{print $3}' "$LOCK_FILE" 2>/dev/null || echo "")
+    if [ -n "$lock_time" ]; then
+      lock_epoch=$(date -d "$lock_time" +%s 2>/dev/null || echo 0)
+      now_epoch=$(date -u +%s)
+      age_min=$(( (now_epoch - lock_epoch) / 60 ))
+      if [ "$age_min" -gt "$STALE_LOCK_MIN" ]; then
+        # Check if owner process is still alive
+        pid_alive=0
+        if [ -n "$lock_pid" ] && [ "$lock_pid" != "-" ] && kill -0 "$lock_pid" 2>/dev/null; then
+          pid_alive=1
+        fi
 
-      if [ "$pid_alive" -eq 1 ]; then
-        echo "ACTIVE_LOCK: held ${age_min}m by $lock_holder (pid $lock_pid alive) — skipping"
-      else
-        echo "STALE_LOCK: held ${age_min}m by $lock_holder (pid ${lock_pid:-none} dead) — threshold ${STALE_LOCK_MIN}m"
-        found=1
-        rm -f "$LOCK_FILE"
-        if [ ! -f "$LOCK_FILE" ]; then
-          echo "  → released (dead PID)"
+        if [ "$pid_alive" -eq 1 ]; then
+          echo "ACTIVE_LOCK: held ${age_min}m by $lock_holder (pid $lock_pid alive) — skipping"
         else
-          echo "  → ERROR: lock file still exists after rm at $LOCK_FILE"
+          echo "STALE_LOCK: held ${age_min}m by $lock_holder (pid ${lock_pid:-none} dead) — threshold ${STALE_LOCK_MIN}m"
+          found=1
+          rm -f "$LOCK_FILE"
+          if [ ! -f "$LOCK_FILE" ]; then
+            echo "  → released (dead PID)"
+          else
+            echo "  → FAILED: lock file still present after rm"
+            any_failed=1
+          fi
         fi
       fi
     fi
@@ -67,19 +123,31 @@ if [ -d "$WORKTREE_DIR" ]; then
 
     branch="task/$task_id"
 
+    found=1
+
+    # Active runs are never touched, regardless of merge status.
+    if task_is_active "$task_id"; then
+      echo "ACTIVE: $task_id — dashboard shows a running session, skipped"
+      continue
+    fi
+
     # Is the branch merged into main?
     merged=$(git branch --merged main 2>/dev/null | sed 's/^[* +]*//' | grep -Fx "$branch" || true)
 
     # Is the worktree dirty?
     dirty=$(cd "$wt" && git status --porcelain 2>/dev/null | wc -l)
 
-    found=1
     if [ -n "$merged" ]; then
       echo "MERGED: $task_id — branch merged into main, safe to remove"
       if [ "$cmd" = "clean" ]; then
         git worktree remove "$wt" 2>/dev/null || true
         git branch -d "$branch" 2>/dev/null || true
-        echo "  → removed"
+        if [ ! -d "$wt" ] && ! git show-ref --verify --quiet "refs/heads/$branch"; then
+          echo "  → removed"
+        else
+          echo "  → FAILED: removal attempted but worktree/branch still present, left in place"
+          any_failed=1
+        fi
       fi
     elif [ "$dirty" -gt 0 ]; then
       echo "DIRTY: $task_id — $dirty uncommitted changes, preserved"
@@ -92,3 +160,8 @@ fi
 if [ "$found" -eq 0 ]; then
   echo "CLEAN: no orphans, no stale locks"
 fi
+
+if [ "$any_failed" -eq 1 ]; then
+  exit 1
+fi
+exit 0

package/lib/test-orphan-sweep.sh

@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+# test-orphan-sweep.sh — regression tests for orphan-sweep.sh
+#
+# Self-contained: builds throwaway git fixtures in a temp dir and drives
+# lib/orphan-sweep.sh through the CREW_ACTIVE_TASKS / CREW_ACTIVE_TASKS_FILE
+# seam (no network, no dashboard). Exits 0 only if every case passes.
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SWEEP="$SCRIPT_DIR/orphan-sweep.sh"
+
+pass=0
+fail=0
+ok() { echo "PASS: $1"; pass=$((pass + 1)); }
+no() { echo "FAIL: $1"; fail=$((fail + 1)); }
+
+TMPBASE="$(mktemp -d)"
+trap 'rm -rf "$TMPBASE"' EXIT
+
+# new_fixture <name> — fresh git repo, one commit on main; exports CREW_REPO.
+new_fixture() {
+  local dir="$TMPBASE/$1"
+  mkdir -p "$dir"
+  git init -q -b main "$dir" >/dev/null
+  git -C "$dir" config user.email "test@example.com"
+  git -C "$dir" config user.name "test"
+  echo base > "$dir/seed.txt"
+  git -C "$dir" add seed.txt
+  git -C "$dir" commit -qm "initial"
+  export CREW_REPO="$dir"
+  cd "$dir" || exit 1
+}
+
+# merged_worktree <task_id> — worktree whose branch gets a real merge commit.
+merged_worktree() {
+  local t="$1"
+  git worktree add -q ".worktrees/$t" -b "task/$t" >/dev/null
+  echo "$t" > ".worktrees/$t/work.txt"
+  git -C ".worktrees/$t" add work.txt
+  git -C ".worktrees/$t" commit -qm "work for $t"
+  git merge -q --no-ff "task/$t" -m "merge $t" >/dev/null
+}
+
+# --- Case 1: live run protected (the incident's exact case) ---
+# T1's branch tip equals main (no commits — "merged" by equality), clean tree.
+new_fixture case1
+git worktree add -q .worktrees/T1 -b task/T1 >/dev/null
+out=$(CREW_ACTIVE_TASKS="T1" "$SWEEP" clean 2>&1); code=$?
+[ "$code" -eq 0 ] && ok "1: clean exits 0 with only an active run present" || no "1: exit $code, want 0"
+[ -d .worktrees/T1 ] && ok "1: active worktree dir preserved" || no "1: active worktree dir removed"
+git show-ref --verify --quiet refs/heads/task/T1 && ok "1: active branch preserved" || no "1: active branch deleted"
+echo "$out" | grep -q "ACTIVE: T1" && ok "1: ACTIVE line printed" || no "1: no ACTIVE line in output"
+
+# --- Case 2: dead run cleaned ---
+new_fixture case2
+merged_worktree T2
+out=$(CREW_ACTIVE_TASKS="" "$SWEEP" clean 2>&1); code=$?
+[ "$code" -eq 0 ] && ok "2: clean exits 0" || no "2: exit $code, want 0"
+[ ! -d .worktrees/T2 ] && ok "2: merged worktree dir removed" || no "2: merged worktree dir still present"
+git show-ref --verify --quiet refs/heads/task/T2 && no "2: merged branch still present" || ok "2: merged branch deleted"
+echo "$out" | grep -q "→ removed" && ok "2: removal reported" || no "2: no removal line in output"
+
+# --- Case 3: fail closed ---
+new_fixture case3
+merged_worktree T3
+out=$(env -u CREW_ACTIVE_TASKS -u CREW_ACTIVE_TASKS_FILE "$SWEEP" clean 2>&1); code=$?
+[ "$code" -eq 2 ] && ok "3: clean without active data exits 2" || no "3: exit $code, want 2"
+echo "$out" | grep -q "BLOCKED" && ok "3: BLOCKED line printed" || no "3: no BLOCKED line in output"
+[ -d .worktrees/T3 ] && ok "3: worktree left alone (dir)" || no "3: worktree removed despite BLOCKED"
+git show-ref --verify --quiet refs/heads/task/T3 && ok "3: worktree left alone (branch)" || no "3: branch deleted despite BLOCKED"
+
+# --- Case 4: false report impossible (forced removal failure via worktree lock) ---
+new_fixture case4
+merged_worktree T4
+git worktree lock .worktrees/T4
+out=$(CREW_ACTIVE_TASKS="" "$SWEEP" clean 2>&1); code=$?
+[ "$code" -eq 1 ] && ok "4: clean with failed removal exits 1" || no "4: exit $code, want 1"
+echo "$out" | grep -q "→ FAILED" && ok "4: FAILED line printed (no false 'removed')" || no "4: no FAILED line — false report!"
+[ -d .worktrees/T4 ] && ok "4: failed worktree left in place" || no "4: worktree gone despite failed removal"
+git worktree unlock .worktrees/T4 2>/dev/null || true
+
+# --- Case 5: lock path ---
+new_fixture case5
+mkdir -p .worktrees
+printf 'T5 2020-01-01T00:00:00Z 999999\n' > .worktrees/.merge-lock
+out=$(CREW_ACTIVE_TASKS="" "$SWEEP" clean 2>&1); code=$?
+[ ! -f .worktrees/.merge-lock ] && ok "5a: stale lock released" || no "5a: stale lock file still present"
+echo "$out" | grep -q "released (dead PID)" && ok "5a: release reported" || no "5a: no release line in output"
+[ "$code" -eq 0 ] && ok "5a: exit 0" || no "5a: exit $code, want 0"
+
+printf 'T6 2020-01-01T00:00:00Z 999999\n' > .worktrees/.merge-lock
+out=$(CREW_ACTIVE_TASKS="T6" "$SWEEP" clean 2>&1); code=$?
+[ -f .worktrees/.merge-lock ] && ok "5b: active holder's lock not released" || no "5b: active holder's lock was released"
+echo "$out" | grep -q "ACTIVE_LOCK" && ok "5b: ACTIVE_LOCK line printed" || no "5b: no ACTIVE_LOCK line in output"
+[ "$code" -eq 0 ] && ok "5b: exit 0" || no "5b: exit $code, want 0"
+
+# --- Case 6: report mode without active data ---
+new_fixture case6
+merged_worktree T7
+out=$(env -u CREW_ACTIVE_TASKS -u CREW_ACTIVE_TASKS_FILE "$SWEEP" report 2>&1); code=$?
+[ "$code" -eq 0 ] && ok "6: report exits 0" || no "6: exit $code, want 0"
+echo "$out" | grep -q "NOTE: no active-run data provided; ACTIVE checks skipped" && ok "6: NOTE banner printed" || no "6: no NOTE banner in output"
+[ -d .worktrees/T7 ] && ok "6: report mode removes nothing" || no "6: report mode removed a worktree"
+echo "$out" | grep -q "MERGED: T7" && ok "6: MERGED line still listed" || no "6: MERGED line missing from report"
+
+echo ""
+echo "== $pass passed, $fail failed =="
+[ "$fail" -eq 0 ]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muse-crew",
-  "version": "0.4.0",
-  "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
+  "version": "0.4.2",
+  "description": "Opinionated orchestration for Muse \u2014 workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,
   "repository": {

package/workflows/bugfix.js

@@ -320,6 +320,7 @@ while (i < STEPS.length) {
         "Run: npm view muse-crew version 2>/dev/null || echo NOT_FOUND\n" +
         "If NOT_FOUND, use the local package.json version as the base instead.\n\n" +
         "STEP 3: Apply the version_bump scope (" + releaseDecision.version_bump + ") to the base version: patch increments the last segment; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0. Example: base 1.2.3 + minor → 1.3.0. Call the result <new-version>.\n" +
+        "STEP 3B: Make the version math auditable. State the computed target version explicitly — your summary MUST include the line: TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version> (example: TARGET_VERSION=0.3.1 computed as 0.3.0 + patch → 0.3.1). Every later step uses exactly this version. Do not improvise the arithmetic: 0.3.0 + patch is 0.3.1, never 0.4.0.\n" +
         "STEP 4: Write <new-version> into package.json (only the `version` field), then commit it under the still-held merge lock: cd " + REPO_PATH + " && git add package.json && git commit -m \"release: muse-crew@<new-version>\". The lock serializes Publish per repo, so two tasks can never pick the same version.\n" +
         "STEP 5: Pack and publish.\n" +
         "Run: cd " + REPO_PATH + " && npm pack\n" +
@@ -333,7 +334,9 @@ while (i < STEPS.length) {
         "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
         "If the output contains DEPLOYED, finalization is complete.\n\n" +
         "Do NOT compare the local package.json version to the registry version: with versions assigned at publish time, local==registry is the normal steady state before assignment — not a signal to skip. Execute every step above.\n\n" +
-        "End your summary with exactly this line: published: muse-crew@<new-version>\n\n" +
+        "End your summary with exactly these two lines, in this order — lowercase, no trailing period, do not rephrase (the QA backstop extracts them by pattern):\n" +
+        "TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version>\n" +
+        "published: muse-crew@<new-version>\n\n" +
         "Your final response MUST be valid JSON and nothing else: { \"summary\": \"result\", \"passed\": true }.\n" +
         "No prose, no markdown, just the JSON object.";
     } else if (PUBLISH_TYPE === "artifact") {
@@ -374,7 +377,10 @@ while (i < STEPS.length) {
     // declared release: yes, QA verifies the registry actually moved. A silent
     // publish skip becomes a loud QA failure with evidence, not a pass.
     var npmPublishCheck = (PUBLISH_TYPE === "npm" && releaseDecision && releaseDecision.release === "yes")
-      ? "NPM PUBLISH CHECK: the accepted Build summary declared release: yes, so this run's Publish phase must have published. Find this task's recorded Publish result: call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }, then find the session for this task_id with step \"Publish\" (status completed) in the returned sessions array and extract its `published: muse-crew@<version>` line from the session notes (the Publish agent ends its summary with exactly that line — event history does NOT carry it). Then run: npm view muse-crew version. The registry version MUST equal the published version. If there is no completed Publish session with a published: line, or the registry version does not match, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: [details]\" }.\n"
+      ? "NPM PUBLISH CHECK: the accepted Build summary declared release: yes, so this run's Publish phase must have published. Find this task's recorded Publish result: call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }, then find the session for this task_id with step \"Publish\" (status completed) in the returned sessions array and read its session notes (the Publish agent's summary — event history does NOT carry it).\n" +
+      "Extract the line matching TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version>. If the line is missing, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: Publish summary did not echo its computed target version (STEP 3B)\" }.\n" +
+      "Verify the bump SCOPE: the <scope> in that line MUST equal the accepted version_bump scope \"" + releaseDecision.version_bump + "\" — if the Publish agent applied a different scope, FAIL. Verify the ARITHMETIC: <base> + <scope> must equal <new-version> (patch increments the last segment only, e.g. 0.3.0 + patch → 0.3.1; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0) — if the math is wrong, FAIL.\n" +
+      "Extract the published version from the notes line matching published: muse-crew@<version> (match case-insensitively and ignore any trailing period — agents sometimes rephrase it). It MUST equal <new-version> from the TARGET_VERSION line. Then run: npm view muse-crew version. The registry version MUST equal <new-version>. If any of these checks fails, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: [details]\" }.\n"
       : "";
     instructions = "Final QA testing. You are CODE-BLIND — do NOT read source code.\n" +
       "Public docs (API.md, README, published action schemas) are NOT source code — read them freely, exactly as a user would.\n" +

package/workflows/chore.js

@@ -302,6 +302,7 @@ while (i < STEPS.length) {
         "Run: npm view muse-crew version 2>/dev/null || echo NOT_FOUND\n" +
         "If NOT_FOUND, use the local package.json version as the base instead.\n\n" +
         "STEP 3: Apply the version_bump scope (" + releaseDecision.version_bump + ") to the base version: patch increments the last segment; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0. Example: base 1.2.3 + minor → 1.3.0. Call the result <new-version>.\n" +
+        "STEP 3B: Make the version math auditable. State the computed target version explicitly — your summary MUST include the line: TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version> (example: TARGET_VERSION=0.3.1 computed as 0.3.0 + patch → 0.3.1). Every later step uses exactly this version. Do not improvise the arithmetic: 0.3.0 + patch is 0.3.1, never 0.4.0.\n" +
         "STEP 4: Write <new-version> into package.json (only the `version` field), then commit it under the still-held merge lock: cd " + REPO_PATH + " && git add package.json && git commit -m \"release: muse-crew@<new-version>\". The lock serializes Publish per repo, so two tasks can never pick the same version.\n" +
         "STEP 5: Pack and publish.\n" +
         "Run: cd " + REPO_PATH + " && npm pack\n" +
@@ -315,7 +316,9 @@ while (i < STEPS.length) {
         "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
         "If the output contains DEPLOYED, finalization is complete.\n\n" +
         "Do NOT compare the local package.json version to the registry version: with versions assigned at publish time, local==registry is the normal steady state before assignment — not a signal to skip. Execute every step above.\n\n" +
-        "End your summary with exactly this line: published: muse-crew@<new-version>\n\n" +
+        "End your summary with exactly these two lines, in this order — lowercase, no trailing period, do not rephrase (the QA backstop extracts them by pattern):\n" +
+        "TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version>\n" +
+        "published: muse-crew@<new-version>\n\n" +
         "Your final response MUST be valid JSON and nothing else: { \"summary\": \"result\", \"passed\": true }.\n" +
         "No prose, no markdown, just the JSON object.";
     } else if (PUBLISH_TYPE === "artifact") {

package/workflows/crew-init.js

@@ -251,10 +251,12 @@ try {
     "Body text for the cron:\n" +
     "---\n" +
     "## Muse Crew Orphan Sweep\n\n" +
-    "Run the orphan sweep to clean merged worktrees and break stale merge locks.\n\n" +
-    "Run this command:\n" +
-    crewHome + "/lib/orphan-sweep.sh clean\n\n" +
-    "Report the output. If it says CLEAN, no action was needed.\n" +
+    "1. Call artifact_invoke_action on slug \"" + dashboardSlug + "\", action \"getdispatchstate\", args {}.\n" +
+    "2. Collect the task IDs of every entry in ready_tasks whose latest_session.status is \"running\".\n" +
+    "   (Sessions older than 1h are already reclassified as timed_out by the dashboard — no extra math.)\n" +
+    "3. Run: CREW_ACTIVE_TASKS=\"<space-separated ids>\" " + crewHome + "/lib/orphan-sweep.sh clean\n" +
+    "   If the list is empty, pass an empty string — do NOT omit the variable (the sweep fails closed without it).\n" +
+    "4. Report the output. If it says CLEAN, no action was needed.\n" +
     "---\n\n" +
     "Return JSON with existed (boolean).",
     {

package/workflows/standard.js

@@ -318,6 +318,7 @@ while (i < STEPS.length) {
         "Run: npm view muse-crew version 2>/dev/null || echo NOT_FOUND\n" +
         "If NOT_FOUND, use the local package.json version as the base instead.\n\n" +
         "STEP 3: Apply the version_bump scope (" + releaseDecision.version_bump + ") to the base version: patch increments the last segment; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0. Example: base 1.2.3 + minor → 1.3.0. Call the result <new-version>.\n" +
+        "STEP 3B: Make the version math auditable. State the computed target version explicitly — your summary MUST include the line: TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version> (example: TARGET_VERSION=0.3.1 computed as 0.3.0 + patch → 0.3.1). Every later step uses exactly this version. Do not improvise the arithmetic: 0.3.0 + patch is 0.3.1, never 0.4.0.\n" +
         "STEP 4: Write <new-version> into package.json (only the `version` field), then commit it under the still-held merge lock: cd " + REPO_PATH + " && git add package.json && git commit -m \"release: muse-crew@<new-version>\". The lock serializes Publish per repo, so two tasks can never pick the same version.\n" +
         "STEP 5: Pack and publish.\n" +
         "Run: cd " + REPO_PATH + " && npm pack\n" +
@@ -331,7 +332,9 @@ while (i < STEPS.length) {
         "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
         "If the output contains DEPLOYED, finalization is complete.\n\n" +
         "Do NOT compare the local package.json version to the registry version: with versions assigned at publish time, local==registry is the normal steady state before assignment — not a signal to skip. Execute every step above.\n\n" +
-        "End your summary with exactly this line: published: muse-crew@<new-version>\n\n" +
+        "End your summary with exactly these two lines, in this order — lowercase, no trailing period, do not rephrase (the QA backstop extracts them by pattern):\n" +
+        "TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version>\n" +
+        "published: muse-crew@<new-version>\n\n" +
         "Your final response MUST be valid JSON and nothing else: { \"summary\": \"result\", \"passed\": true }.\n" +
         "No prose, no markdown, just the JSON object.";
     } else if (PUBLISH_TYPE === "artifact") {
@@ -372,7 +375,10 @@ while (i < STEPS.length) {
     // declared release: yes, QA verifies the registry actually moved. A silent
     // publish skip becomes a loud QA failure with evidence, not a pass.
     var npmPublishCheck = (PUBLISH_TYPE === "npm" && releaseDecision && releaseDecision.release === "yes")
-      ? "NPM PUBLISH CHECK: the accepted Build summary declared release: yes, so this run's Publish phase must have published. Find this task's recorded Publish result: call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }, then find the session for this task_id with step \"Publish\" (status completed) in the returned sessions array and extract its `published: muse-crew@<version>` line from the session notes (the Publish agent ends its summary with exactly that line — event history does NOT carry it). Then run: npm view muse-crew version. The registry version MUST equal the published version. If there is no completed Publish session with a published: line, or the registry version does not match, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: [details]\" }.\n"
+      ? "NPM PUBLISH CHECK: the accepted Build summary declared release: yes, so this run's Publish phase must have published. Find this task's recorded Publish result: call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }, then find the session for this task_id with step \"Publish\" (status completed) in the returned sessions array and read its session notes (the Publish agent's summary — event history does NOT carry it).\n" +
+      "Extract the line matching TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version>. If the line is missing, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: Publish summary did not echo its computed target version (STEP 3B)\" }.\n" +
+      "Verify the bump SCOPE: the <scope> in that line MUST equal the accepted version_bump scope \"" + releaseDecision.version_bump + "\" — if the Publish agent applied a different scope, FAIL. Verify the ARITHMETIC: <base> + <scope> must equal <new-version> (patch increments the last segment only, e.g. 0.3.0 + patch → 0.3.1; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0) — if the math is wrong, FAIL.\n" +
+      "Extract the published version from the notes line matching published: muse-crew@<version> (match case-insensitively and ignore any trailing period — agents sometimes rephrase it). It MUST equal <new-version> from the TARGET_VERSION line. Then run: npm view muse-crew version. The registry version MUST equal <new-version>. If any of these checks fails, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: [details]\" }.\n"
       : "";
     if (PUBLISH_TYPE === "artifact") {
       var safeDesc = taskDescription.replace(/"/g, "'").replace(/\\/g, "\\\\").slice(0, 500);