@ionivetech/mugiwara 0.6.4 → 0.6.6

package/scripts/lane.sh

@@ -19,9 +19,13 @@ if ! git rev-parse "$BASE" >/dev/null 2>&1; then
   [ -n "$ALT" ] && BASE="$ALT" || BASE="HEAD~1"
 fi
 
-CHANGED=$(git diff --name-only "$BASE"..HEAD 2>/dev/null || git diff --name-only --cached 2>/dev/null || true)
+# union of committed + staged + unstaged + untracked (F) — see patterns.sh
+CHANGED=$(changed_files "$BASE")
 FILE_COUNT=0
 [ -n "$CHANGED" ] && FILE_COUNT=$(echo "$CHANGED" | wc -l | tr -d ' ')
+read -r ADDED_INS ADDED_DEL <<EOF
+$(changed_loc "$BASE")
+EOF
 
 SENSITIVE=$(echo "$CHANGED" | grep -E "$SENSITIVE_PATS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
 HAS_SENSITIVE=0
@@ -35,7 +39,7 @@ if [ "$FILE_COUNT" -eq 0 ] 2>/dev/null; then
   LANE="direct"
   REASON="no changed files"
 elif [ "$FILE_COUNT" -le 1 ] 2>/dev/null; then
-  ADDED=$(git diff --numstat "$BASE"..HEAD 2>/dev/null | awk '{s+=$1} END {print s+0}' || echo 0)
+  ADDED="${ADDED_INS:-0}"
   if [ "$ADDED" -lt 20 ] 2>/dev/null; then
     LANE="direct"
     REASON="1 file, <20 LOC"

package/scripts/lib/patterns.sh

@@ -19,3 +19,87 @@ SENSITIVE_PATS="auth/|oauth2?/|payment/|payments/|billing/|crypto/|secrets/|cred
 # outside this surface are docs/config/asset and never escalate to full on
 # count alone (path-weighted sizing).
 PRODUCT_PAT="^content/|^src/|^scripts/|^test/|^hooks/|^\.opencode/|^\.claude/|^evals/"
+
+# Installed-harness rules dirs — what `mugiwara install` writes into a project
+# (~50 files across the 9 targets). In a CONSUMER project these are installed
+# config, no different from the crew's own .mugiwara/ bookkeeping: the first
+# savepoint after an install counted them and sized every fresh mission Lane 3
+# before a single line of the user's own work existed. In MUGIWARA'S OWN repo
+# the same dirs are the product surface (they are in PRODUCT_PAT), so the
+# exclusion is conditional on the repo identity, never unconditional.
+# Unanchored on purpose — call sites anchor with ^ (name lists) or a tab
+# (numstat rows).
+HARNESS_PAT="\.claude/|\.opencode/|\.github/(instructions|agents)/|\.gemini/mugiwara/|\.codex/mugiwara/|\.devin/rules/|\.clinerules/|\.kilo/rules/|\.agents/rules/"
+
+# harness_excluded — true (exit 0) when harness rules dirs must NOT count
+# toward mission sizing, i.e. this repo is not mugiwara itself. Identity comes
+# from the repo root package.json name ("mugiwara" or "@scope/mugiwara"), the
+# same manifest savepoint already trusts for skill_version.
+harness_excluded() {
+  local root
+  root=$(git rev-parse --show-toplevel 2>/dev/null || echo .)
+  ! grep -qE '"name"[[:space:]]*:[[:space:]]*"(@[^"/]+/)?mugiwara"' "$root/package.json" 2>/dev/null
+}
+
+# drop_harness <anchor> — filter stdin, dropping harness paths in consumer
+# repos and passing everything through in mugiwara's own.
+drop_harness() {
+  if harness_excluded; then grep -vE "$1($HARNESS_PAT)" || true; else cat; fi
+}
+
+# --- working-tree-aware change set (F) -------------------------------------
+# `git diff BASE..HEAD` alone is blind to uncommitted work, and the old
+# `|| git diff --cached` fallback was dead code (|| fires on non-zero exit,
+# never on empty output). With auto_commit=off nothing is committed, so lane
+# sizing and files_touched read 0 while the tree holds real changes.
+# These two helpers are the single source of truth for BOTH lane.sh and
+# savepoint.sh so the two can never drift (lane-integrity case 15).
+
+# Path of the crew's bookkeeping dir, relative to the repo root. MUGIWARA_DIR
+# may be absolute (the harness passes a full path); git reports repo-relative
+# paths, so normalize before comparing.
+mugiwara_rel() {
+  local d="${MUGIWARA_DIR:-.mugiwara}" root
+  case "$d" in
+    /*) root=$(git rev-parse --show-toplevel 2>/dev/null || true)
+        [ -n "$root" ] && d="${d#"$root"/}"
+        # symlinked repo roots (/var vs /private/var on macOS) defeat the
+        # prefix strip; fall back to the leaf name, which is what git reports.
+        case "$d" in /*) d=$(basename "$d") ;; esac ;;
+  esac
+  printf '%s' "$d"
+}
+
+# changed_files <base-ref> — union of committed (BASE..HEAD), staged, unstaged
+# and untracked files. .gitignore'd files are excluded (git status default),
+# and so is the crew's own .mugiwara/ bookkeeping: savepoint writes state on
+# every wave, and mission state must never size the mission it measures.
+changed_files() {
+  local base="${1:-}"
+  {
+    if [ -n "$base" ] && [ "$base" != "unknown" ]; then
+      git diff --name-only "$base"..HEAD 2>/dev/null || true
+    fi
+    # porcelain covers staged + unstaged + untracked in one pass; strip the
+    # 2-char status + space, and keep the destination side of a rename.
+    git status --porcelain --untracked-files=all 2>/dev/null | sed 's/^...//; s/^.* -> //' || true
+  } | grep -v '^[[:space:]]*$' | grep -v "^$(mugiwara_rel)/" | drop_harness '^' | sort -u
+}
+
+# changed_loc <base-ref> — echoes "<insertions> <deletions>" over the same
+# union. Untracked files count every line as an insertion.
+changed_loc() {
+  local base="${1:-}" MUGI_REL
+  MUGI_REL=$(mugiwara_rel)
+  {
+    if [ -n "$base" ] && [ "$base" != "unknown" ]; then
+      git diff --numstat "$base"..HEAD 2>/dev/null || true
+    fi
+    git diff --numstat HEAD 2>/dev/null || true
+    git ls-files --others --exclude-standard 2>/dev/null | while IFS= read -r f; do
+      [ -f "$f" ] || continue
+      case "$f" in "$MUGI_REL"/*) continue ;; esac
+      printf '%s\t0\t%s\n' "$(wc -l < "$f" 2>/dev/null | tr -d ' ' || echo 0)" "$f"
+    done
+  } | grep -v "	$MUGI_REL/" | drop_harness '	' | awk '{ if ($1 ~ /^[0-9]+$/) i+=$1; if ($2 ~ /^[0-9]+$/) d+=$2 } END { print (i+0)" "(d+0) }'
+}

package/scripts/mission-report.sh

@@ -70,11 +70,12 @@ const now = new Date().toISOString().slice(0, 10);
 const reportFile = path.join(reportDir, now + "-" + mission + ".md");
 const lane = val(s, 'lane', 'n/a');
 const lanePeak = val(s, 'lane_peak', 'n/a');
+const laneRose = val(s, 'lane_rose', false);
 const laneReason = val(s, 'lane_reason', 'n/a');
 const mode = val(s, 'mode', 'n/a');
 const actor = val(s, 'actor', 'n/a');
 const branch = val(s, 'branch', 'n/a');
-const wave = val(s, 'wave', 'n/a');
+const wave = val(s, 'flow', val(s, 'wave', 'n/a'));
 const filesTouched = val(s, 'files_touched', 0);
 const locDelta = val(s, 'loc_delta', 0);
 const locChurn = val(s, 'loc_churn', 0);
@@ -91,12 +92,12 @@ const updated = val(s, 'updated_at', now);
 
 // --- wave artifact scan: results/<mission>/NN-*.md with verdict sniffing ---
 const WAVE_LABEL = {
-  "01-execution": "Execute (Wave 3)",
-  "02-audit": "Checkpoint (Wave 4)",
-  "03-quality": "Quality (Wave 5)",
-  "04-gates": "Gates (Wave 6)",
-  "05-healing": "Healing (Wave 8)",
-  "06-closure": "Closure (Wave 9)",
+  "01-execution": "Execute (Flow 3)",
+  "02-audit": "Checkpoint (Flow 4)",
+  "03-quality": "Quality (Flow 5)",
+  "04-gates": "Gates (Flow 6)",
+  "05-healing": "Healing (Flow 8)",
+  "06-closure": "Closure (Flow 9)",
   "07-pr-verdict": "PR material",
 };
 
@@ -227,11 +228,11 @@ let report = "# Mission: " + mission + " . " + now + "\n\n";
 report += "## Mission header\n\n| Field | Value |\n|-------|-------|\n";
 report += "| Mission | " + mission + " |\n";
 report += "| Branch | " + branch + " |\n";
-report += "| Lane | " + lane + " |\n";
+report += "| Lane | " + lane + (laneRose ? " ⬆ ROSE" : "") + " |\n";
 report += "| Lane peak | " + lanePeak + " |\n";
 report += "| Lane reason | " + laneReason + " |\n";
 report += "| Mode | " + mode + " |\n";
-report += "| Wave | " + wave + " |\n";
+report += "| Flow | " + wave + " |\n";
 report += "| Actor | " + actor + " |\n\n";
 
 report += "## Token budget\n\n| Field | Value |\n|-------|-------|\n";
@@ -252,7 +253,7 @@ report += filesTouched + " files, +" + locDelta + " LOC (" + locChurn + " churn)
 if (sensitive.length) report += "\nSensitive paths: " + sensitive.join(", ");
 report += "\n\n";
 
-report += "## Waves\n\n| Wave | Artifact | Verdict |\n|------|----------|---------|";
+report += "## Flow stages\n\n| Flow stage | Artifact | Verdict |\n|------|----------|---------|";
 if (waveRows.length) {
   for (const r of waveRows) report += "\n| " + r.label + " | `" + r.file + "` | " + r.verdict + " |";
 } else {
@@ -277,7 +278,7 @@ report += "Blocker ledger rows: " + issueRows.length + (issueRows.length ? "\n"
 report += "\n\n";
 
 report += "## State\n\n| Field | Value |\n|-------|-------|\n";
-report += "| Wave | " + wave + " |\n";
+report += "| Flow | " + wave + " |\n";
 report += "| Tasks | " + (tasks.done || 0) + "/" + (tasks.total || 0) + " done |\n";
 report += "| Blockers open | " + blockers + " |\n";
 report += "| Heal cycles | " + healCycle + " |\n";

package/scripts/savepoint.sh

@@ -3,7 +3,7 @@
 # wave boundary. Computed from git + file counts; zero model judgement.
 # Identity is (mission, member), never branch. Solo = member empty → the file
 # is named state.json. Usage:
-#   savepoint.sh <mission> [member] [wave] [mode]
+#   savepoint.sh <mission> [member] [wave] [mode] [lane]
 set -u
 
 die() { echo "savepoint: $*" >&2; exit 1; }
@@ -42,7 +42,62 @@ MISSION="${1:-${STATE_MISSION:-}}"
 MEMBER="${2:-${STATE_MEMBER:-}}"
 WAVE="${3:-${STATE_WAVE:-1}}"
 MODE="${4:-${STATE_MODE:-guided}}"
-ACTOR="${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${GIT_ID:-${USER:-}}}}"
+# Triage lane (M7): the lane Luffy assigned at Flow 0. Without it savepoint
+# recomputed the lane from file counts alone and silently discarded the
+# triage decision — a Lane 3 mission recorded itself as "direct". Explicit
+# lane acts as a FLOOR: the computed lane may still raise it, never lower it.
+LANE_EXPLICIT="${5:-${STATE_LANE:-}}"
+case "$LANE_EXPLICIT" in
+  ""|direct|lean|standard|full|spike) ;;
+  *) die "invalid lane \"$LANE_EXPLICIT\" (one of: direct lean standard full spike)" ;;
+esac
+# Wave may be fractional in the docs (4.5 = the checkpoint between waves).
+# parseInt("4.5")=4 while tr -cd '0-9' gives "45", so state and continue
+# disagreed on the same mission. Normalize once, here, for both writers.
+# Keep only digits and the decimal point, then take the integer part. Garbage
+# input still sanitizes to 0 (the N2 contract the continue writer already had);
+# a fractional wave now truncates identically in BOTH writers instead of
+# splitting into 4 (parseInt) and 45 (digit-strip).
+WAVE_INT=$(printf '%s' "$WAVE" | tr -cd '0-9.')
+WAVE_INT=${WAVE_INT%%.*}
+case "$WAVE_INT" in
+  ''|*[!0-9]*) WAVE_INT=0 ;;
+esac
+
+# verbosity from config (project .mugiwara/config), default normal; env override
+VERBOSITY="${STATE_VERBOSITY:-normal}"
+if [ -f "$MUGIWARA_DIR/config" ]; then
+  CFG_VERBOSITY=$(grep -E '^verbosity=' "$MUGIWARA_DIR/config" 2>/dev/null | head -1 | cut -d= -f2- | tr -d '[:space:]')
+  [ -n "$CFG_VERBOSITY" ] && VERBOSITY="$CFG_VERBOSITY"
+fi
+case "$VERBOSITY" in
+  normal|full) ;;
+  *) VERBOSITY="normal" ;;
+esac
+
+# heal_max_cycles from config (project .mugiwara/config), default 3; env override
+HEAL_MAX_CYCLES="${STATE_HEAL_MAX_CYCLES:-3}"
+if [ -f "$MUGIWARA_DIR/config" ]; then
+  CFG_HEAL_MAX=$(grep -E '^heal_max_cycles=' "$MUGIWARA_DIR/config" 2>/dev/null | head -1 | cut -d= -f2- | tr -d '[:space:]')
+  [ -n "$CFG_HEAL_MAX" ] && HEAL_MAX_CYCLES="$CFG_HEAL_MAX"
+fi
+case "$HEAL_MAX_CYCLES" in
+  ''|*[!0-9]*) HEAL_MAX_CYCLES=3 ;;
+esac
+[ "$HEAL_MAX_CYCLES" -lt 1 ] 2>/dev/null && HEAL_MAX_CYCLES=3
+
+# delegate_threshold from config (project .mugiwara/config), default 60; env override
+DELEGATE_THRESHOLD="${STATE_DELEGATE_THRESHOLD:-60}"
+if [ -f "$MUGIWARA_DIR/config" ]; then
+  CFG_DELEGATE=$(grep -E '^delegate_threshold=' "$MUGIWARA_DIR/config" 2>/dev/null | head -1 | cut -d= -f2- | tr -d '[:space:]')
+  [ -n "$CFG_DELEGATE" ] && DELEGATE_THRESHOLD="$CFG_DELEGATE"
+fi
+case "$DELEGATE_THRESHOLD" in
+  ''|*[!0-9]*) DELEGATE_THRESHOLD=60 ;;
+esac
+[ "$DELEGATE_THRESHOLD" -lt 1 ] 2>/dev/null && DELEGATE_THRESHOLD=1
+[ "$DELEGATE_THRESHOLD" -gt 100 ] 2>/dev/null && DELEGATE_THRESHOLD=100
+ACTOR="${STATE_ACTOR:-${GIT_AUTHOR_NAME:-${GIT_ID:-${USER:-${USERNAME:-}}}}}"
 BRANCH="$(git branch --show-current 2>/dev/null || echo 'unknown')"
 
 # treat the legacy empty-actor placeholder '""' as "no member" (solo). The old
@@ -86,31 +141,25 @@ else
   CONTINUE_FILE="$CONTINUE_DIR/state.json"
 fi
 
-[ -z "$MISSION" ] && die "usage: savepoint.sh <mission> [member] [wave] [mode]"
+[ -z "$MISSION" ] && die "usage: savepoint.sh <mission> [member] [wave] [mode] [lane]"
 [ -d .git ] || die "not a git repository"
 
 # --- computed fields ---
 BASE_SHA=$(git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null || git merge-base HEAD "$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|refs/remotes/origin/||')" 2>/dev/null || git rev-parse HEAD~1 2>/dev/null || echo "unknown")
 HEAD_SHA=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
 
-CHANGED_FILES=$(git diff --name-only "$BASE_SHA"..HEAD 2>/dev/null || git diff --name-only --cached 2>/dev/null || true)
+# union of committed + staged + unstaged + untracked (F) — see patterns.sh
+CHANGED_FILES=$(changed_files "$BASE_SHA")
 FILES_TOUCHED=$( [ -n "$CHANGED_FILES" ] && echo "$CHANGED_FILES" | wc -l | tr -d ' ' || echo 0 )
 
-LOC_INS=0
-LOC_DEL=0
-LOC_DELTA=0
-LOC_CHURN=0
-if [ "$BASE_SHA" != "unknown" ]; then
-  STAT=$(git diff --shortstat "$BASE_SHA"..HEAD 2>/dev/null || echo "")
-  INS=$(echo "$STAT" | grep -oE '[0-9]+ insertion' | grep -oE '[0-9]+' || echo 0)
-  DEL=$(echo "$STAT" | grep -oE '[0-9]+ deletion'  | grep -oE '[0-9]+' || echo 0)
-  LOC_INS=$(( ${INS:-0} + 0 ))
-  LOC_DEL=$(( ${DEL:-0} + 0 ))
-  LOC_DELTA=$(( LOC_INS - LOC_DEL ))
-  # churn is insertion+deletion — refactors and deletions are work too (D4)
-  LOC_CHURN=$(( LOC_INS + LOC_DEL ))
-fi
-[ -z "$LOC_DELTA" ] && LOC_DELTA=0
+read -r LOC_INS LOC_DEL <<EOF
+$(changed_loc "$BASE_SHA")
+EOF
+LOC_INS=$(( ${LOC_INS:-0} + 0 ))
+LOC_DEL=$(( ${LOC_DEL:-0} + 0 ))
+LOC_DELTA=$(( LOC_INS - LOC_DEL ))
+# churn is insertion+deletion — refactors and deletions are work too (D4)
+LOC_CHURN=$(( LOC_INS + LOC_DEL ))
 
 SENSITIVE_PATHS=$(echo "$CHANGED_FILES" | grep -E "$SENSITIVE_PATS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
 
@@ -132,7 +181,7 @@ elif [ "$FILES_TOUCHED" -ge 2 ] 2>/dev/null; then
   LANE_REASON="$FILES_TOUCHED files"
 elif [ "$FILES_TOUCHED" -eq 1 ] 2>/dev/null; then
   # 1-file rule mirrors lane.sh: >=20 added LOC -> lean, else direct
-  ADDED=$(git diff --numstat "$BASE_SHA"..HEAD 2>/dev/null | awk '{s+=$1} END {print s+0}')
+  ADDED="$LOC_INS"
   if [ "${ADDED:-0}" -ge 20 ] 2>/dev/null; then
     LANE="lean"
     LANE_REASON="1 file, $ADDED LOC"
@@ -157,6 +206,19 @@ if [ "$LANE" = "full" ] && [ -z "$SENSITIVE_PATHS" ] && [ -n "$CHANGED_FILES" ];
   fi
 fi
 
+# explicit triage lane (M7) applied as a floor — the computed lane above may
+# raise it, never lower it. Sensitive-path escalation still wins
+# unconditionally: spike is a resize, not a rise, so it never displaces the
+# full lane a sensitive path forced.
+if [ -n "$LANE_EXPLICIT" ]; then
+  if [ "$LANE_EXPLICIT" = "spike" ] && [ -n "$SENSITIVE_PATHS" ]; then
+    LANE_REASON="$LANE_REASON (explicit spike ignored — sensitive paths)"
+  elif [ "$(lane_rank "$LANE_EXPLICIT")" -gt "$(lane_rank "$LANE")" ]; then
+    LANE_REASON="triage lane $LANE_EXPLICIT (floor; computed $LANE — $LANE_REASON)"
+    LANE="$LANE_EXPLICIT"
+  fi
+fi
+
 # --- lane-rise compare (F9) + monotonic clamp (D2): read previous state ---
 # Clamp runs here — before LANE_BASE/BUDGET — so tokens and budget follow the
 # held lane, never the raw shrunken one.
@@ -207,7 +269,11 @@ if [ -n "$PLAN_FILE" ] && [ -f "$PLAN_FILE" ]; then
 fi
 
 # blocker count
-BLOCKERS_FILE=$(ls "$MUGIWARA_DIR/issues/${MISSION}-blockers.md" 2>/dev/null || true)
+# The crew writes the DATED name (`YYYY-MM-DD-<mission>-blockers.md`) — that is
+# what 15 prose sites mandate and what lands on disk. Matching only the bare
+# name made blockers_open structurally 0 forever, and that zero feeds the DoD
+# ship-readiness axis. Accept both; newest wins.
+BLOCKERS_FILE=$(ls -t "$MUGIWARA_DIR/issues/${MISSION}-blockers.md" "$MUGIWARA_DIR"/????-??-??-"${MISSION}"-blockers.md "$MUGIWARA_DIR/issues"/????-??-??-"${MISSION}"-blockers.md 2>/dev/null | head -1 || true)
 BLOCKERS_OPEN=0
 if [ -n "$BLOCKERS_FILE" ] && [ -f "$BLOCKERS_FILE" ]; then
   # data rows start with a wave number; header "| wave |" and separator
@@ -215,16 +281,39 @@ if [ -n "$BLOCKERS_FILE" ] && [ -f "$BLOCKERS_FILE" ]; then
   BLOCKERS_OPEN=$(grep -cE '^\| ?[0-9]+ ?\|' "$BLOCKERS_FILE" 2>/dev/null || true)
 fi
 
-# heal cycle — count WAVE-8 banner occurrences in the trace, not the word
-# "heal" anywhere (heal workers/healing text would inflate the counter and
-# cause a premature halt)
+# heal cycle — count Flow-8 (healing) section headings in the DECISION LOG,
+# which every mission writes (luffy-orchestrator rule 10). Not the word "heal"
+# anywhere (heal workers/healing text would inflate the counter and cause a
+# premature halt). Each heal cycle is logged as a "## Flow 8 — healing" section;
+# the [^0-9a-z] guard keeps adjacent "## Flow 8b"-style sections from counting.
+# Aggregate across ALL dated logs (a multi-day mission spans several files) —
+# reading only the newest would undercount earlier days' heal cycles.
 HEAL_CYCLE=1
-TRACE_FILE=$(ls "$MUGIWARA_DIR/results/${MISSION}/"*trace*.md 2>/dev/null | head -1 || true)
-if [ -n "$TRACE_FILE" ] && [ -f "$TRACE_FILE" ]; then
-  HEAL_COUNT=$(grep -ci '^.*Wave 8.*\|wave 8' "$TRACE_FILE" 2>/dev/null || true)
+HEAL_COUNT=0
+# Cap the date prefix to today: a future-dated log (9999-…) must not inflate
+# the heal counter and trigger a premature halt.
+TODAY=$(date +%Y-%m-%d)
+for LOG_FILE in "$MUGIWARA_DIR"/????-??-??-"${MISSION}".md "$MUGIWARA_DIR/logs"/????-??-??-"${MISSION}".md; do
+  [ -f "$LOG_FILE" ] || continue
+  LOG_DATE=$(basename "$LOG_FILE" | cut -c1-10)
+  case "$LOG_DATE" in
+    ''|*[!0-9-]*) continue ;;
+  esac
+  if [ "$LOG_DATE" \> "$TODAY" ]; then continue; fi
+  HEAL_COUNT=$((HEAL_COUNT + $(grep -ciE '^## flow 8([^0-9a-z]|$)' "$LOG_FILE" 2>/dev/null || true)))
+done
+if [ "$HEAL_COUNT" -gt 0 ]; then
   HEAL_CYCLE=$((HEAL_COUNT + 1))
 fi
 
+# heal halt — computed from the heal counter and the config cap (task 4f wires
+# heal_max_cycles into the counter's home). heal_cycle starts at 1, so
+# heal_cycle >= heal_max_cycles means the cap is reached: escalate, never re-run.
+HEAL_HALT=false
+if [ "$HEAL_CYCLE" -ge "$HEAL_MAX_CYCLES" ] 2>/dev/null; then
+  HEAL_HALT=true
+fi
+
 # evidence paths — per-mission results folder (quoted printf, no sed — mission
 # name is allowlisted above, but avoid sed metacharacter semantics entirely)
 EVIDENCE=""
@@ -233,12 +322,19 @@ for evf in "$MUGIWARA_DIR/results/${MISSION}/"*.md; do
   EVIDENCE="${EVIDENCE}${EVIDENCE:+,}.mugiwara/results/${MISSION}/$(basename "$evf")"
 done
 
-# skill version from package.json (argv-passing — never interpolate paths into node -e)
-SKILL_VERSION="1"
-if [ -f package.json ]; then
-  PKG_JSON="$MUGIWARA_DIR/../package.json"
-  [ -f "$PKG_JSON" ] && SKILL_VERSION=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync(process.argv[1],'utf8')).version.split('.')[0])}catch(e){console.log('1')}" "$PKG_JSON" 2>/dev/null || echo "1")
+# skill version — MUGIWARA's own package.json, resolved from the script
+# location (B3). The old "$MUGIWARA_DIR/../package.json" was the USER's
+# project manifest: the version-mismatch resume prompt fired when a user
+# shipped their own v2.0.0 and stayed silent across every real mugiwara
+# release. Never fall back to the user's file — "unknown" is the honest
+# answer. Full version, not the major: mugiwara's breaking changes land in
+# 0.x minors, which a major-only string can never see.
+SKILL_VERSION="unknown"
+PKG_JSON="$(dirname "$0")/../package.json"
+if [ -f "$PKG_JSON" ]; then
+  SKILL_VERSION=$(node -e "try{const v=JSON.parse(require('fs').readFileSync(process.argv[1],'utf8')).version;console.log(v||'unknown')}catch(e){console.log('unknown')}" "$PKG_JSON" 2>/dev/null || echo "unknown")
 fi
+[ -z "$SKILL_VERSION" ] && SKILL_VERSION="unknown"
 
 # tokens proxy (F7): deterministic estimate when the harness does not report
 # real usage. Monotonic beats precise — LANE_BASE stands in for the skills
@@ -281,6 +377,19 @@ elif [ "$BUDGET" -gt 0 ] && [ "$TOKENS_EST" -ge "$WARN_AT" ] 2>/dev/null; then
   STATUS="warn"
 fi
 
+# delegate due — the execution skill's context-pressure trigger (task 4f wires
+# delegate_threshold into a computed flag). tokens_est >= threshold% of budget
+# → remaining sequential tasks dispatch to workers. Threshold stays relative:
+# a bigger budget raises the bar, it does not remove it. Budget 0 (unknown
+# lane) → never due.
+DELEGATE_DUE=false
+if [ "$BUDGET" -gt 0 ] 2>/dev/null; then
+  DELEGATE_AT=$(( BUDGET * DELEGATE_THRESHOLD / 100 ))
+  if [ "$TOKENS_EST" -ge "$DELEGATE_AT" ] 2>/dev/null; then
+    DELEGATE_DUE=true
+  fi
+fi
+
 mkdir -p "$MUGIWARA_DIR/state/$MISSION" "$MUGIWARA_DIR/continue/$MISSION"
 
 node -e "
@@ -294,8 +403,9 @@ const data = {
   lane_prev: process.argv[24] || null,
   lane_peak: process.argv[27] || null,
   lane_rose: process.argv[25] === 'true',
-  wave: parseInt(process.argv[6], 10),
+  flow: parseInt(process.argv[6], 10),
   mode: process.argv[7],
+  verbosity: process.argv[32] || 'normal',
   base_sha: process.argv[8],
   head_sha: process.argv[9],
   files_touched: parseInt(process.argv[10], 10),
@@ -307,6 +417,10 @@ const data = {
   tasks: { done: parseInt(process.argv[13], 10), total: parseInt(process.argv[14], 10) },
   blockers_open: parseInt(process.argv[15], 10),
   heal_cycle: parseInt(process.argv[16], 10),
+  heal_max_cycles: parseInt(process.argv[33], 10) || 3,
+  heal_halt: process.argv[34] === 'true',
+  delegate_threshold: parseInt(process.argv[35], 10) || 60,
+  delegate_due: process.argv[36] === 'true',
   tokens_est: parseInt(process.argv[17], 10) || 0,
   tokens_source: process.argv[26] || 'computed',
   budget: parseInt(process.argv[18], 10) || 0,
@@ -318,13 +432,14 @@ const data = {
 require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\n');
 " \
   "$MISSION" "$ACTOR" "$BRANCH" "$LANE" "$LANE_REASON" \
-  "$WAVE" "$MODE" "$BASE_SHA" "$HEAD_SHA" "$FILES_TOUCHED" \
+  "$WAVE_INT" "$MODE" "$BASE_SHA" "$HEAD_SHA" "$FILES_TOUCHED" \
   "$LOC_DELTA" "$SENSITIVE_PATHS" "$TASKS_DONE" "$TASKS_TOTAL" \
   "$BLOCKERS_OPEN" "$HEAL_CYCLE" "$TOKENS_EST" "$BUDGET" \
   "$STATUS" "$SKILL_VERSION" "$EVIDENCE" \
   "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
   "$STATE_FILE" "$LANE_PREV" "$LANE_ROSE" "$TOKENS_SOURCE" "$LANE_PEAK" \
-  "$LOC_INS" "$LOC_DEL" "$LOC_CHURN" "$MEMBER"
+  "$LOC_INS" "$LOC_DEL" "$LOC_CHURN" "$MEMBER" "$VERBOSITY" \
+  "$HEAL_MAX_CYCLES" "$HEAL_HALT" "$DELEGATE_THRESHOLD" "$DELEGATE_DUE"
 
 if [ "$LANE_ROSE" = true ]; then
   echo "⚠ LANE ROSE: $LANE_PREV → $LANE ($LANE_REASON) — escalate per check-in protocol"
@@ -345,7 +460,7 @@ if [ -n "$MISSION" ]; then
   fi
   # N2: every field echoed into continue is validated first. MISSION + MEMBER
   # are allowlisted upstream; WAVE numeric, MODE enum, BRANCH slug-sanitized.
-  CONT_WAVE=$(echo "$WAVE" | tr -cd '0-9')
+  CONT_WAVE="$WAVE_INT"
   case "$MODE" in
     guided|semi|auto) CONT_MODE="$MODE" ;;
     *) CONT_MODE="guided" ;;
@@ -358,7 +473,7 @@ if [ -n "$MISSION" ]; then
     member: process.argv[2] || null,
     actor: process.argv[13] || '',
     branch: process.argv[3],
-    wave: parseInt(process.argv[4], 10) || 0,
+    flow: parseInt(process.argv[4], 10) || 0,
     mode: process.argv[5],
     tasks_done: parseInt(process.argv[6], 10) || 0,
     tasks_total: parseInt(process.argv[7], 10) || 0,

package/scripts/validate-content.ts

@@ -207,10 +207,15 @@ for (const f of [...agentFiles, ...skillDirs.map(d => join(root, 'skills', d, 'S
   }
 }
 
-// --- manifest-sync check: .claude-plugin/plugin.json must set-equal content/ ---
+// --- manifest-sync check: every marketplace plugin.json set-equal content/ ---
 const manifestArg = process.argv.indexOf('--check-manifest');
 if (manifestArg !== -1) {
-  const manifests = ['.claude-plugin/plugin.json'];
+  const manifests = [
+    '.claude-plugin/plugin.json',
+    '.codex-plugin/plugin.json',
+    '.cursor-plugin/plugin.json',
+    '.kimi-plugin/plugin.json',
+  ];
   let manifestErrors = 0;
 
   for (const mp of manifests) {
@@ -380,5 +385,20 @@ if (integrityArg !== -1) {
   }
 }
 
+// Conditional-assertion guard: an expect() reachable only inside a truthiness
+// check silently passes when the value is absent. This class produced 9 defects.
+// Allowed: checks keyed on a declared invariant (tier, fixture keys).
+const ALLOWED_COND = /if \((?:t\.tier === 3|keys\.length|label === 'exact'|fx\.expect\.(?:lane|sensitive_paths_(?:min|max)))/;
+const repoRoot = join(import.meta.dirname, '..');
+for (const f of readdirSync(join(repoRoot, 'test')).filter(x => x.endsWith('.test.ts'))) {
+  const src = readFileSync(join(repoRoot, 'test', f), 'utf8');
+  // matches both braced and brace-less conditionals whose body reaches an expect()
+  for (const m of src.matchAll(/if \([^)]+\)(?:\s*\{[^}]{0,400}?)?expect\(/gs)) {
+    if (!ALLOWED_COND.test(m[0])) {
+      errors.push(`test/${f}: expect() inside a conditional — assert presence explicitly instead:\n    ${m[0].slice(0, 80)}`);
+    }
+  }
+}
+
 if (errors.length) { console.error(errors.map(e => `✗ ${e}`).join('\n')); process.exit(1); }
 console.log(`✓ content valid: ${skillDirs.length} skills, ${agentFiles.length} agents`);