muse-crew 0.4.3 → 0.4.5

package/lib/test-publish-verify.sh

@@ -0,0 +1,157 @@
+#!/usr/bin/env bash
+# test-publish-verify.sh — regression test for the retry-tolerant step-12
+# publish verification in publish-npm.sh (canary 5a027278).
+#
+# Self-contained: extracts the shipped step-12 block from lib/publish-npm.sh
+# by anchor and runs it against a fake `npm` on PATH whose read replica
+# lags — non-zero exits, then the old version, then the target version —
+# and requires the block to converge on success. Also asserts fail-closed
+# exhaustion when the replica never converges.
+#
+# Anchors: `# STEP-12-ANCHOR` ... `# STEP-12-END` in lib/publish-npm.sh.
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PUBLISH="$SCRIPT_DIR/publish-npm.sh"
+
+PKG="muse-crew"
+OLD_VERSION="9.9.8"
+TARGET_VERSION="9.9.9"
+
+pass=0
+fail_count=0
+ok() { echo "PASS: $1"; pass=$((pass + 1)); }
+no() { echo "FAIL: $1"; fail_count=$((fail_count + 1)); }
+
+TMPBASE="$(mktemp -d)"
+trap 'rm -rf "$TMPBASE"' EXIT
+
+# --- Extract the shipped step-12 block by anchor ---
+BLOCK="$TMPBASE/step12.sh"
+sed -n '/# STEP-12-ANCHOR/,/# STEP-12-END/p' "$PUBLISH" > "$BLOCK"
+if grep -q 'PUBLISH_VERIFIED' "$BLOCK" && grep -q 'fail "verify"' "$BLOCK"; then
+  ok "extracted step-12 block from publish-npm.sh"
+else
+  no "step-12 extraction failed (anchors missing)"
+fi
+
+# --- Runner: fake npm first in PATH, behavior baked in at generation time ---
+FAKEBIN="$TMPBASE/fakebin"
+mkdir -p "$FAKEBIN"
+
+# write_fake_npm <behavior>
+#   laggy: exit 1 twice (npm failure), old version twice (stale replica),
+#          then the target version (replica converged)
+#   stale: old version forever (replica never converges)
+write_fake_npm() {
+  case "$1" in
+    laggy) BEHAVIOR='
+      if [ "$n" -le 2 ]; then exit 1; fi
+      if [ "$n" -le 4 ]; then echo "'"$OLD_VERSION"'"; exit 0; fi
+      echo "'"$TARGET_VERSION"'"; exit 0' ;;
+    stale) BEHAVIOR='echo "'"$OLD_VERSION"'"; exit 0' ;;
+    *) echo "unknown behavior: $1" >&2; exit 1 ;;
+  esac
+  cat > "$FAKEBIN/npm" <<EOF
+#!/usr/bin/env bash
+# Records its own argv (for the cache-busting assertion) and its call count.
+echo "\$*" >> "$TMPBASE/argv"
+n=\$(cat "$TMPBASE/calls" 2>/dev/null || echo 0)
+n=\$((n + 1))
+echo "\$n" > "$TMPBASE/calls"
+$BEHAVIOR
+EOF
+  chmod +x "$FAKEBIN/npm"
+}
+
+# run_step12: runs the shipped block; env: PKG TARGET_VERSION
+# VERIFY_ATTEMPTS VERIFY_SLEEP_SECS; returns the block's exit code and
+# captures its stdout in $OUT.
+run_step12() {
+  local runner="$TMPBASE/run-$RANDOM.sh"
+  {
+    echo 'fail() { echo "PUBLISH_FAILED=$1"; shift; echo "$1"; exit 1; }'
+    cat "$BLOCK"
+  } > "$runner"
+  chmod +x "$runner"
+  rm -f "$TMPBASE/calls" "$TMPBASE/argv"
+  OUT="$(PATH="$FAKEBIN:$PATH" \
+    PKG="$PKG" TARGET_VERSION="$TARGET_VERSION" \
+    VERIFY_ATTEMPTS="${VERIFY_ATTEMPTS:-12}" \
+    VERIFY_SLEEP_SECS="${VERIFY_SLEEP_SECS:-0}" \
+    bash "$runner" 2>&1)"
+  local code=$?
+  echo "$OUT"
+  return "$code"
+}
+
+# --- Case 1: lagging replica converges — block must succeed ---
+write_fake_npm laggy
+OUT="$(run_step12)"
+CODE=$?
+if [ "$CODE" -eq 0 ]; then
+  ok "laggy replica converges: block exits 0"
+else
+  no "laggy replica converges: block exited $CODE (output: $OUT)"
+fi
+case "$OUT" in
+  *"PUBLISH_VERIFIED=$TARGET_VERSION"*)
+    ok "prints PUBLISH_VERIFIED=$TARGET_VERSION on convergence" ;;
+  *) no "missing PUBLISH_VERIFIED=$TARGET_VERSION (output: $OUT)" ;;
+esac
+case "$OUT" in
+  *"PUBLISH_FAILED"*) no "PUBLISH_FAILED printed despite convergence" ;;
+  *) ok "no PUBLISH_FAILED on convergence" ;;
+esac
+CALLS="$(cat "$TMPBASE/calls" 2>/dev/null || echo 0)"
+if [ "$CALLS" = "5" ]; then
+  ok "converged after exactly 5 reads (2 failures, 2 stale, 1 good)"
+else
+  no "expected 5 npm calls on convergence, saw $CALLS"
+fi
+RETRIES="$(grep -c 'PUBLISH_VERIFY_RETRY=' <<< "$OUT" || true)"
+if [ "$RETRIES" = "4" ]; then
+  ok "prints a PUBLISH_VERIFY_RETRY progress line per miss"
+else
+  no "expected 4 PUBLISH_VERIFY_RETRY lines, saw $RETRIES"
+fi
+
+# --- Case 2: replica never converges — fail closed with the verify marker ---
+write_fake_npm stale
+VERIFY_ATTEMPTS=3 OUT="$(run_step12)"
+CODE=$?
+if [ "$CODE" -ne 0 ]; then
+  ok "stale replica: block fails closed (non-zero exit)"
+else
+  no "stale replica: block exited 0 despite persistent mismatch"
+fi
+case "$OUT" in
+  *"PUBLISH_FAILED=verify"*)
+    ok "exhaustion keeps the PUBLISH_FAILED=verify marker contract" ;;
+  *) no "missing PUBLISH_FAILED=verify (output: $OUT)" ;;
+esac
+case "$OUT" in
+  *"registry=$OLD_VERSION after 3 attempts"*)
+    ok "exhaustion detail names registry value and attempt count" ;;
+  *) no "missing exhaustion detail (output: $OUT)" ;;
+esac
+CALLS="$(cat "$TMPBASE/calls" 2>/dev/null || echo 0)"
+if [ "$CALLS" = "3" ]; then
+  ok "bounded: stops after VERIFY_ATTEMPTS reads"
+else
+  no "expected 3 npm calls on exhaustion, saw $CALLS"
+fi
+
+# --- Case 3: every read goes through --prefer-online (client cache-bust) ---
+write_fake_npm laggy
+run_step12 >/dev/null
+if grep -q -- '--prefer-online' "$TMPBASE/argv"; then
+  ok "every npm view read passes --prefer-online"
+else
+  no "npm view reads missing --prefer-online"
+fi
+
+echo ""
+echo "$pass passed, $fail_count failed."
+[ "$fail_count" -eq 0 ]

package/lib/test-version-write.sh

@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+# test-version-write.sh — regression test for the escape-preserving step-8
+# version write in publish-npm.sh (canary 5a027278).
+#
+# Self-contained: seeds a temp git repo with the repo's current package.json
+# (which carries the \u2014 escape in its description field), extracts the
+# shipped step-8 block from lib/publish-npm.sh by anchor, and runs it.
+# Exits 0 only if the write lands a true one-line diff, the version parses
+# back to TARGET_VERSION, and the \u2014 escape survives as escape bytes.
+#
+# Anchors: `# STEP-8-ANCHOR` ... `# STEP-8-END` in lib/publish-npm.sh.
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+PUBLISH="$SCRIPT_DIR/publish-npm.sh"
+
+# Target the next patch after the repo's current version. (A hardcoded target
+# goes stale the moment the repo releases it: writing the version that's
+# already there produces no diff and the preservation check fails closed.)
+TARGET_VERSION="$(node -e 'const fs=require("fs");const v=JSON.parse(fs.readFileSync(process.argv[1],"utf8")).version.split(".");v[v.length-1]=String(Number(v[v.length-1])+1);console.log(v.join("."))' "$REPO_DIR/package.json")"
+
+pass=0
+fail_count=0
+ok() { echo "PASS: $1"; pass=$((pass + 1)); }
+no() { echo "FAIL: $1"; fail_count=$((fail_count + 1)); }
+
+TMPBASE="$(mktemp -d)"
+trap 'rm -rf "$TMPBASE"' EXIT
+
+# --- Fixture: temp git repo seeded with the repo's current package.json ---
+FIX="$TMPBASE/fixture"
+mkdir -p "$FIX"
+git init -q -b main "$FIX" >/dev/null
+git -C "$FIX" config user.email "test@example.com"
+git -C "$FIX" config user.name "test"
+cp "$REPO_DIR/package.json" "$FIX/package.json"
+git -C "$FIX" add package.json
+git -C "$FIX" commit -qm "initial"
+
+# Sanity: fixture actually carries the escape this regression is about.
+if grep -q '\\u2014' "$FIX/package.json"; then
+  ok "fixture package.json carries the \\u2014 escape"
+else
+  no "fixture package.json lacks the \\u2014 escape"
+fi
+
+# --- Extract the shipped step-8 block by anchor ---
+BLOCK="$TMPBASE/step8.sh"
+sed -n '/# STEP-8-ANCHOR/,/# STEP-8-END/p' "$PUBLISH" > "$BLOCK"
+if grep -q 'fail "version-diff"' "$BLOCK" && grep -q 'sed -i -E' "$BLOCK"; then
+  ok "extracted step-8 block from publish-npm.sh"
+else
+  no "step-8 extraction failed (anchors missing)"
+fi
+
+# --- Run the shipped block against the fixture ---
+RUNNER="$TMPBASE/run.sh"
+{
+  echo 'fail() { echo "STEP_FAIL=$1" >&2; exit 1; }'
+  cat "$BLOCK"
+} > "$RUNNER"
+chmod +x "$RUNNER"
+
+if REPO_PATH="$FIX" TARGET_VERSION="$TARGET_VERSION" bash "$RUNNER" >/dev/null 2>&1; then
+  ok "shipped step-8 block exits 0 on escape-carrying package.json"
+else
+  no "shipped step-8 block failed closed on escape-carrying package.json"
+fi
+
+# --- Assertions on the result ---
+VER="$(node -p "JSON.parse(require('fs').readFileSync('$FIX/package.json','utf8')).version")"
+if [ "$VER" = "$TARGET_VERSION" ]; then
+  ok "package.json version is $TARGET_VERSION after write"
+else
+  no "package.json version is $VER, expected $TARGET_VERSION"
+fi
+
+NUMSTAT="$(git -C "$FIX" diff --numstat -- package.json | tr '\t' ' ')"
+if [ "$NUMSTAT" = "1 1 package.json" ]; then
+  ok "diff is exactly one line (preservation check passes)"
+else
+  no "numstat is '$NUMSTAT', expected '1 1 package.json'"
+fi
+
+if grep -q '\\u2014' "$FIX/package.json"; then
+  ok "\\u2014 escape preserved as escape bytes (not expanded)"
+else
+  no "\\u2014 escape was expanded by the write"
+fi
+
+DESC_DIFF="$(git -C "$FIX" diff -- package.json | grep -c '^[-+].*description' || true)"
+if [ "$DESC_DIFF" = "0" ]; then
+  ok "description line untouched by the write"
+else
+  no "description line was rewritten"
+fi
+
+echo ""
+echo "$pass passed, $fail_count failed."
+[ "$fail_count" -eq 0 ]

package/lib/test-worktree-backend.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# test-worktree-backend.sh — regression tests for lib/worktree-lifecycle.sh
+# (git worktree backend).
+#
+# Lifecycle on a scratch repo:
+#   validate → prepare (CREATED) → prepare (REUSED) → inspect → status →
+#   cleanup → cleanup (idempotent) → dirty-main preflight (exit 4)
+set -u
+
+REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+LIFECYCLE="$REPO_DIR/lib/worktree-lifecycle.sh"
+
+fail() { echo "FAIL: $1"; exit 1; }
+
+T=/tmp/crew-git-backend-test
+rm -rf "$T"
+mkdir -p "$T"
+cd "$T"
+git init -q -b main .
+git config user.email test@test.t
+git config user.name test
+echo x > f.txt
+git add -A
+git commit -qm init
+
+export CREW_REPO="$T"
+tid="backendtest1"
+
+# validate: good id passes, bad id is rejected
+bash "$LIFECYCLE" validate "$tid" >/dev/null || fail "validate rejected a good id"
+bash "$LIFECYCLE" validate "bad id!" >/dev/null 2>&1 && fail "validate accepted a bad id"
+
+# prepare: creates worktree + branch + registry entry
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "prepare exited non-zero: $out"
+echo "$out" | grep -q '^CREATED' || fail "prepare: expected CREATED, got: $out"
+echo "$out" | grep -q '^BASE: ' || fail "prepare: no BASE: line"
+[ -d "$T/.worktrees/$tid" ] || fail "prepare: .worktrees/$tid missing"
+git -C "$T" rev-parse --verify "task/$tid" >/dev/null 2>&1 || fail "prepare: branch task/$tid missing"
+[ -f "$T/.worktrees/.registry/$tid" ] || fail "prepare: registry entry missing"
+grep -q '^branch=task/backendtest1$' "$T/.worktrees/.registry/$tid" || fail "prepare: registry branch wrong"
+grep -q "^path=$T/.worktrees/$tid\$" "$T/.worktrees/.registry/$tid" || fail "prepare: registry path wrong"
+
+# prepare again: reuses the existing worktree
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "prepare (reuse) exited non-zero"
+echo "$out" | grep -q '^REUSED' || fail "prepare: expected REUSED on second run: $out"
+
+# inspect: diffs the task branch against main
+echo change >> "$T/.worktrees/$tid/f.txt"
+(cd "$T/.worktrees/$tid" && git commit -qam work)
+out=$(bash "$LIFECYCLE" inspect "$tid") || fail "inspect exited non-zero"
+echo "$out" | grep -q "=== Branch: task/$tid ===" || fail "inspect: wrong branch header"
+echo "$out" | grep -q "change" || fail "inspect: diff missing the worktree change"
+
+# status: reports registry, worktree, branch
+out=$(bash "$LIFECYCLE" status "$tid") || fail "status exited non-zero"
+echo "$out" | grep -q "=== Worktree: $tid ===" || fail "status: missing header"
+echo "$out" | grep -q "task/$tid" || fail "status: missing branch info"
+
+# cleanup: removes worktree + branch + registry entry
+out=$(bash "$LIFECYCLE" cleanup "$tid") || fail "cleanup exited non-zero"
+[ -d "$T/.worktrees/$tid" ] && fail "cleanup: worktree still exists"
+git -C "$T" rev-parse --verify "task/$tid" >/dev/null 2>&1 && fail "cleanup: branch still exists"
+[ -f "$T/.worktrees/.registry/$tid" ] && fail "cleanup: registry entry still exists"
+
+# cleanup again: idempotent
+out=$(bash "$LIFECYCLE" cleanup "$tid") || fail "cleanup (idempotent) exited non-zero"
+echo "$out" | grep -q "already clean" || fail "cleanup: expected already-clean on second run"
+
+# prepare fails closed when main is dirty (exit 4)
+echo dirty >> "$T/f.txt"
+if bash "$LIFECYCLE" prepare "backendtest2" >/dev/null 2>&1; then
+  fail "prepare succeeded with dirty main"
+else
+  [ "$?" -eq 4 ] || fail "prepare with dirty main: expected exit 4"
+fi
+git -C "$T" checkout -q -- f.txt
+
+rm -rf "$T"
+echo "worktree-backend: OK"

package/lib/worktree-lifecycle.sh

@@ -1,5 +1,14 @@
 #!/usr/bin/env bash
-# worktree-lifecycle.sh — git worktree lifecycle manager for Muse Crew
+# worktree-lifecycle.sh — worktree lifecycle manager for Muse Crew
+#
+# Git backend: task worktrees live in $REPO/.worktrees/<task_id>, on
+# branches named task/<task_id>. This script is the single seam where the
+# worktree strategy lives — workflows and agents never run raw git worktree
+# commands; they call these lifecycle commands instead.
+#
+# The crew's registry ($REPO/.worktrees/.registry/<task_id>) is the source
+# of truth for task→branch/path. Never reconstruct the mapping from git
+# state alone.
 #
 # Commands:
 #   validate  <task_id>                  — check task ID is safe for branches/paths
@@ -30,6 +39,28 @@ ORPHAN_SWEEP="$LIB_DIR/orphan-sweep.sh"
 
 # --- helpers ---
 
+# Task branch name: task/<id>. The registry wins when the task was
+# prepared before.
+resolve_branch() {
+  local task_id="$1" b
+  if [ -f "$REGISTRY_DIR/$task_id" ]; then
+    b=$(grep '^branch=' "$REGISTRY_DIR/$task_id" | cut -d= -f2-)
+    if [ -n "$b" ]; then printf '%s' "$b"; return 0; fi
+  fi
+  printf 'task/%s' "$task_id"
+}
+
+# Worktree path: $REPO/.worktrees/<id>. The registry wins when the task
+# was prepared before.
+resolve_path() {
+  local task_id="$1" p
+  if [ -f "$REGISTRY_DIR/$task_id" ]; then
+    p=$(grep '^path=' "$REGISTRY_DIR/$task_id" | cut -d= -f2-)
+    if [ -n "$p" ]; then printf '%s' "$p"; return 0; fi
+  fi
+  printf '%s/%s' "$WORKTREE_DIR" "$task_id"
+}
+
 validate_task_id() {
   local id="$1"
   if [[ ! "$id" =~ ^[a-zA-Z0-9][a-zA-Z0-9_-]*$ ]]; then
@@ -57,12 +88,12 @@ require_clean_main() {
 }
 
 register() {
-  local task_id="$1" base_commit="$2"
+  local task_id="$1" base_commit="$2" branch="$3" wt_path="$4"
   mkdir -p "$REGISTRY_DIR"
   cat > "$REGISTRY_DIR/$task_id" <<EOF
 task_id=$task_id
-branch=task/$task_id
-path=$WORKTREE_DIR/$task_id
+branch=$branch
+path=$wt_path
 base_commit=$base_commit
 created=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 EOF
@@ -96,7 +127,7 @@ cmd_prepare() {
     return 0
   fi
 
-  # Preflight: main must be clean
+  # Preflight: main must be clean — prepare fails closed.
   require_clean_main || exit 4
 
   local base_commit
@@ -107,7 +138,7 @@ cmd_prepare() {
   mkdir -p "$WORKTREE_DIR"
   git worktree add "$WORKTREE_DIR/$task_id" -b "task/$task_id"
 
-  register "$task_id" "$base_commit"
+  register "$task_id" "$base_commit" "task/$task_id" "$WORKTREE_DIR/$task_id"
 
   echo "CREATED: .worktrees/$task_id on branch task/$task_id"
   echo "BASE: $base_commit"
@@ -117,26 +148,29 @@ cmd_inspect() {
   local task_id="$1"
   validate_task_id "$task_id"
 
+  local branch
+  branch=$(resolve_branch "$task_id")
+
   cd "$REPO"
 
   # Verify the branch exists
-  if ! git rev-parse --verify "task/$task_id" >/dev/null 2>&1; then
-    echo "ERROR: branch task/$task_id does not exist"
+  if ! git rev-parse --verify "$branch" >/dev/null 2>&1; then
+    echo "ERROR: branch $branch does not exist"
     return 1
   fi
 
-  echo "=== Branch: task/$task_id ==="
+  echo "=== Branch: $branch ==="
   local tip
-  tip=$(git rev-parse "task/$task_id")
+  tip=$(git rev-parse "$branch")
   echo "TIP: $tip"
   echo ""
   echo "=== Commits ahead of main ==="
-  git log --oneline "main..task/$task_id"
+  git log --oneline "main..$branch"
   echo ""
-  echo "=== Diff: main...task/$task_id ==="
-  git diff --stat "main...task/$task_id"
+  echo "=== Diff: main...$branch ==="
+  git diff --stat "main...$branch"
   echo ""
-  git diff "main...task/$task_id"
+  git diff "main...$branch"
 }
 
 cmd_integrate() {
@@ -144,24 +178,27 @@ cmd_integrate() {
   local commit_msg="${2:-merge: $task_id}"
   validate_task_id "$task_id"
 
+  local branch
+  branch=$(resolve_branch "$task_id")
+
   cd "$REPO"
 
   # Preflight: main must be clean
   require_clean_main || exit 4
 
   # Verify task branch exists and has commits ahead of main
-  if ! git rev-parse --verify "task/$task_id" >/dev/null 2>&1; then
-    echo "ERROR: branch task/$task_id does not exist"
+  if ! git rev-parse --verify "$branch" >/dev/null 2>&1; then
+    echo "ERROR: branch $branch does not exist"
     return 1
   fi
 
   local ahead
-  ahead=$(git rev-list --count "main..task/$task_id")
+  ahead=$(git rev-list --count "main..$branch")
   if [ "$ahead" -eq 0 ]; then
     # Approved empty diff: the deliverable was runtime state (cron,
     # scheduler, dashboard config), not a repo change. Nothing to merge,
     # nothing to serialize — the merge lock is intentionally not taken.
-    echo "MERGED_EMPTY: task/$task_id has no commits ahead of main — runtime-state deliverable, nothing to merge"
+    echo "MERGED_EMPTY: $branch has no commits ahead of main — runtime-state deliverable, nothing to merge"
     return 0
   fi
 
@@ -174,7 +211,7 @@ cmd_integrate() {
   echo "$lock_result"
 
   # Merge
-  if ! git merge --no-ff "task/$task_id" -m "$commit_msg" 2>&1; then
+  if ! git merge --no-ff "$branch" -m "$commit_msg" 2>&1; then
     echo "CONFLICT: merge failed — aborting"
     git merge --abort 2>/dev/null || true
     exit 3
@@ -248,6 +285,10 @@ cmd_status() {
   local task_id="$1"
   validate_task_id "$task_id"
 
+  local branch wt_path
+  branch=$(resolve_branch "$task_id")
+  wt_path=$(resolve_path "$task_id")
+
   cd "$REPO"
 
   echo "=== Worktree: $task_id ==="
@@ -261,11 +302,11 @@ cmd_status() {
   fi
 
   # Worktree existence
-  if [ -d "$WORKTREE_DIR/$task_id" ]; then
-    echo "Worktree: exists at .worktrees/$task_id"
+  if [ -n "$wt_path" ] && [ -d "$wt_path" ]; then
+    echo "Worktree: exists at $wt_path"
     local head dirty
-    head=$(cd "$WORKTREE_DIR/$task_id" && git rev-parse --short HEAD 2>/dev/null || echo "unknown")
-    dirty=$(cd "$WORKTREE_DIR/$task_id" && git status --porcelain 2>/dev/null | wc -l)
+    head=$(cd "$wt_path" && git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+    dirty=$(cd "$wt_path" && git status --porcelain 2>/dev/null | wc -l)
     echo "HEAD: $head"
     [ "$dirty" -gt 0 ] && echo "Dirty: $dirty uncommitted changes" || echo "Dirty: clean"
   else
@@ -273,13 +314,13 @@ cmd_status() {
   fi
 
   # Branch existence and merge status
-  if git rev-parse --verify "task/$task_id" >/dev/null 2>&1; then
+  if git rev-parse --verify "$branch" >/dev/null 2>&1; then
     local ahead behind
-    ahead=$(git rev-list --count "main..task/$task_id" 2>/dev/null || echo "?")
-    behind=$(git rev-list --count "task/$task_id..main" 2>/dev/null || echo "?")
-    echo "Branch: task/$task_id (${ahead} ahead, ${behind} behind main)"
+    ahead=$(git rev-list --count "main..$branch" 2>/dev/null || echo "?")
+    behind=$(git rev-list --count "$branch..main" 2>/dev/null || echo "?")
+    echo "Branch: $branch (${ahead} ahead, ${behind} behind main)"
     local merged
-    merged=$(git branch --merged main 2>/dev/null | sed 's/^[* +]*//' | grep -Fx "task/$task_id" || true)
+    merged=$(git branch --merged main 2>/dev/null | sed 's/^[* +]*//' | grep -Fx "$branch" || true)
     [ -n "$merged" ] && echo "Merged: yes" || echo "Merged: no"
   else
     echo "Branch: not found"

package/package.json

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

package/seed/cron-body-template.md

@@ -6,15 +6,17 @@ You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher wor
 
 1. **Load tools:** Call tool_search_load_tool_namespace with paths ["workflow_launch"].
 
-2. **Run the dispatcher:** Call workflow_launch with scriptPath "{crewHome}/workflows/crew-dispatch.js" and args {"dashboardSlug": "{dashboardSlug}", "crewHome": "{crewHome}"}.
+2. **Load the workflow registry:** Read the file "{crewHome}/workflows/registry.json" with the read tool and parse it as JSON. If the file does not exist (the live release predates the registry), proceed without it — omit the `registry` arg and the dispatcher will load the registry the slow way and log a warning.
+
+3. **Run the dispatcher:** Call workflow_launch with scriptPath "{crewHome}/workflows/crew-dispatch.js" and args {"dashboardSlug": "{dashboardSlug}", "crewHome": "{crewHome}", "registry": <parsed registry JSON, or omit the key when the file was missing>}.
 
    Wait for it to complete. It reads the board, determines eligibility, claims tasks, acknowledges the poll, and returns structured results.
 
-3. **Report claims:** Extract the `claims` array from the dispatcher result. For each claim, emit one line:
+4. **Report claims:** Extract the `claims` array from the dispatcher result. For each claim, emit one line:
    LAUNCH: script={claim.scriptPath} args={JSON.stringify(claim.args)}
 
    If the dispatcher returned no claims or the claims array is empty, report: NO_DISPATCH
 
    Do NOT call workflow_launch_async for any task workflow. The main chat agent does that.
 
-4. Exit silently.
+5. Exit silently.

package/seed/workflows/bugfix.md

@@ -6,7 +6,11 @@ The full software engineering workflow. Use for bug reports where reproduction m
 
 ### Triage
 **Identity:** Sage
-Validate, prioritize, connect dependencies, assign this workflow. If the task needs decomposition, break it into subtasks first.
+Validate, prioritize, connect dependencies, assign this workflow. If the task needs decomposition, break it into subtasks first. Flags the task experiential when it changes anything rendered and visible in the artifact.
+
+### Capture
+**Identity:** Hazel
+Baseline evidence for experiential tasks only — skipped otherwise. The capture itself is parent-driven; the workflow records a baseline request and parks for the parent protocol (`docs/visual-verdict.md`). After two requests the task continues with `baseline: none`.
 
 ### Reproduce
 **Identity:** Hazel
@@ -15,7 +19,7 @@ Validate, prioritize, connect dependencies, assign this workflow. If the task ne
 
 ### Map
 **Identity:** Mara
-Update the task with a solution-oriented spec. Research options, pick the shortest path, write it clearly enough that the builder doesn't need to ask questions.
+Update the task with a solution-oriented spec. Research options, pick the shortest path, write it clearly enough that the builder doesn't need to ask questions. For experiential tasks, the spec cannot be written without baseline evidence (or an explicit `baseline: none`) — without it Map bounces back to Capture.
 
 ### Build
 **Identity:** Wren
@@ -40,3 +44,4 @@ Optional. Ships the merged code to the project's publish target (`deploy_type` o
 **Personas:** Yes — Hazel wears a persona costume to test from that perspective.
 **Constraint:** No code context. Same tools and process as reproduction. Pass or fail. File follow-up tasks for related issues found during testing.
 Fail if public-affecting changes lack public docs. Public docs are not code — Hazel reads them as a user would.
+**Visual verdict:** for experiential artifact tasks, the QA agent covers the mechanical checks only — the visual verdict is owned by the parent after the rendered post-change inspection results arrive (`docs/visual-verdict.md`). No experiential task completes without a recorded visual PASS.

package/seed/workflows/chore.md

@@ -1,16 +1,20 @@
 # Chore
 
-For routine maintenance and simple tasks. Like Standard but without QA — the change is low-risk enough to ship after review.
+For routine maintenance and simple tasks. Like Standard but without QA — the change is low-risk enough to ship after review. Capture keeps its baseline pass for experiential tasks, but there is no visual verdict and no QA gate here.
 
 ## Steps
 
 ### Triage
 **Identity:** Sage
-Validate, prioritize, connect dependencies, assign this workflow.
+Validate, prioritize, connect dependencies, assign this workflow. Flags the task experiential when it changes anything rendered and visible in the artifact.
+
+### Capture
+**Identity:** Hazel
+Baseline evidence for experiential tasks only — skipped otherwise. The capture itself is parent-driven; the workflow records a baseline request and parks for the parent protocol (`docs/visual-verdict.md`). After two requests the task continues with `baseline: none`.
 
 ### Map
 **Identity:** Mara
-Research options, pick the path, write the spec.
+Research options, pick the path, write the spec. For experiential tasks, the spec cannot be written without baseline evidence (or an explicit `baseline: none`) — without it Map bounces back to Capture.
 
 ### Build
 **Identity:** Wren

package/seed/workflows/standard.md

@@ -6,11 +6,15 @@ The default workflow for feature work and improvements. Like Bugfix but without
 
 ### Triage
 **Identity:** Sage
-Validate, prioritize, connect dependencies, assign this workflow.
+Validate, prioritize, connect dependencies, assign this workflow. Flags the task experiential when it changes anything rendered and visible in the artifact.
+
+### Capture
+**Identity:** Hazel
+Baseline evidence for experiential tasks only — skipped otherwise. The capture itself is parent-driven; the workflow records a baseline request and parks for the parent protocol (`docs/visual-verdict.md`). After two requests the task continues with `baseline: none` and final QA judges on the rubric alone.
 
 ### Map
 **Identity:** Mara
-Research options, pick the path, write the spec.
+Research options, pick the path, write the spec. For experiential tasks, the spec cannot be written without baseline evidence (or an explicit `baseline: none`) — without it Map bounces back to Capture.
 
 ### Build
 **Identity:** Wren
@@ -35,3 +39,4 @@ Optional. Ships the merged code to the project's publish target (`deploy_type` o
 **Personas:** Yes — Hazel wears a persona costume to test from that perspective.
 **Constraint:** No code context. Pass or fail. File follow-up tasks for related issues found during testing.
 Fail if public-affecting changes lack public docs. Public docs are not code — Hazel reads them as a user would.
+**Visual verdict:** for experiential artifact tasks, the QA agent covers the mechanical checks only — the visual verdict is owned by the parent after the rendered post-change inspection results arrive (`docs/visual-verdict.md`). No experiential task completes without a recorded visual PASS.

package/workflows/AGENTS.md

@@ -2,11 +2,11 @@
 
 Executable Muse workflow scripts (JavaScript). These are what the workflow runtime actually runs.
 
-- `crew-dispatch.js` — reads the board, claims eligible tasks, returns structured launch records
+- `crew-dispatch.js` — reads the board, recommends eligible tasks, returns structured launch records (the launched workflow self-claims; the dispatcher never writes claims)
 - `crew-init.js` — sets up a new crew instance: orchestration folders, dashboard, cron, sample project
-- `standard.js` — default task workflow: Triage → Map → Build → Review → Integrate → Publish → QA
-- `bugfix.js` — adds Reproduce after Triage
-- `chore.js` — drops QA (low-risk)
+- `standard.js` — default task workflow: Triage → Capture → Map → Build → Review → Integrate → Publish → QA
+- `bugfix.js` — adds Capture after Triage, then Reproduce
+- `chore.js` — adds Capture after Triage, drops QA (low-risk)
 - `docs.js` — Tate writes, Cass reviews
 
 The `.js` scripts here are distinct from the `.md` definitions in `seed/workflows/` and `.orchestration/workflows/`. The `.md` files describe phases and prompts; these `.js` files execute them.