@mmerterden/multi-agent-pipeline 12.7.0 → 12.9.0

package/pipeline/scripts/smoke-work-summary.sh

@@ -1,163 +0,0 @@
-#!/usr/bin/env bash
-# smoke-work-summary.sh  -  v7.1.0
-#
-# Verifies the Phase 7 Work Summary renderer contract:
-#   1. Missing state + no flags → exit 2 (caller should skip section)
-#   2. Full state fixture → renders header, scope, review, phases
-#   3. Scope section marks ✅ for done tasks and ⏳ for pending
-#   4. Review outcome suppressed when all buckets empty
-#   5. Phase tick strip uses correct marks (completed ✅ · in_progress ▶ · skipped ⏭)
-#   6. Post-hoc invocation with --branch + --base-branch (no state file) still renders header
-#   7. prefs schema exposes reportContent.workSummary toggle
-#   8. channels.md documents the Work Summary option
-#
-# Exit 0 all pass, 1 any failure.
-
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-RENDER="$ROOT/pipeline/scripts/render-work-summary.sh"
-SCHEMA="$ROOT/pipeline/schemas/prefs.schema.json"
-CHANNELS_DOC="$ROOT/pipeline/commands/multi-agent/channels/SKILL.md"
-
-pass=0; fail=0; failures=()
-record_pass() { pass=$((pass + 1)); printf '  \033[0;32mPASS\033[0m %s\n' "$1"; }
-record_fail() { fail=$((fail + 1)); failures+=("$1"); printf '  \033[0;31mFAIL\033[0m %s\n' "$1"; }
-
-printf '→ smoke-work-summary (v7.1.0): Phase 7 Work Summary renderer contract\n'
-
-# --- 1: missing state → exit 2 ---
-tmp=$(mktemp -d); pushd "$tmp" >/dev/null
-set +e
-bash "$RENDER" GHOST-1 >/dev/null 2>&1
-rc=$?
-set -e
-if [ "$rc" = "2" ]; then
-  record_pass "exit 2 when no state + no flags"
-else
-  record_fail "expected exit 2 for empty state (got $rc)"
-fi
-popd >/dev/null; rm -rf "$tmp"
-
-# --- 2-5: full fixture ---
-tmp=$(mktemp -d); pushd "$tmp" >/dev/null
-mkdir -p .worktrees/PROJ-2001
-cat > .worktrees/PROJ-2001/agent-state.json <<'JSON'
-{"taskId":"PROJ-2001","branch":"feature/PROJ-2001-checkout-v2","baseBranch":"develop","prNumber":"#256",
- "planTodos":[
-   {"id":"T1","title":"Add checkout acceptance tests","status":"done"},
-   {"id":"T2","title":"Wire CheckoutViewModel","status":"done"},
-   {"id":"T3","title":"Optimize cart recomposition","status":"deferred"}
- ],
- "reviewConsensus":{
-   "accepted":[{"severity":"blocking","file":"ViewModel.swift","line":42,"issue":"race","fix":"lock","reviewer":"opus"}],
-   "deferred":[],
-   "rejected":[{"finding":{"severity":"suggestion","file":"x.swift","line":0,"issue":"style","reviewer":"sonnet"},"reason":"style-only"}],
-   "approved":false
- }}
-JSON
-cat > .worktrees/PROJ-2001/phase-tracker.json <<'JSON'
-{"taskId":"PROJ-2001","phases":{
-  "0":{"status":"completed"},"1":{"status":"completed"},"2":{"status":"completed"},
-  "3":{"status":"completed"},"4":{"status":"completed"},"5":{"status":"skipped"},
-  "6":{"status":"completed"},"7":{"status":"in_progress"}
-}}
-JSON
-out=$(bash "$RENDER" PROJ-2001)
-popd >/dev/null; rm -rf "$tmp"
-
-if grep -q '^### Work Summary' <<< "$out" && \
-   grep -q 'PROJ-2001' <<< "$out" && \
-   grep -q 'feature/PROJ-2001-checkout-v2' <<< "$out" && \
-   grep -q '#256' <<< "$out"; then
-  record_pass "renders task header with jira+branch+base+PR"
-else
-  record_fail "task header missing fields"
-fi
-
-if grep -q '✅ T1' <<< "$out" && grep -q '✅ T2' <<< "$out"; then
-  record_pass "scope marks done tasks with ✅"
-else
-  record_fail "done tasks not marked ✅ (output: $(echo "$out" | head -20))"
-fi
-
-# deferred is not "done"  -  should get ⏳
-if grep -qE '⏳ T3' <<< "$out"; then
-  record_pass "scope marks non-done tasks with ⏳"
-else
-  record_fail "non-done tasks not marked ⏳"
-fi
-
-if grep -q '1 accepted · 0 deferred · 1 rejected · approved=false' <<< "$out"; then
-  record_pass "review outcome line matches triage counts"
-else
-  record_fail "review outcome line wrong (expected '1 accepted · 0 deferred · 1 rejected · approved=false')"
-fi
-
-if grep -q '0 Init ✅' <<< "$out" && \
-   grep -q '5 Test ⏭' <<< "$out" && \
-   grep -q '7 Report ▶' <<< "$out"; then
-  record_pass "phase tick strip renders correct marks"
-else
-  record_fail "phase tick marks incorrect"
-fi
-
-# --- 4b: review outcome suppressed when empty ---
-tmp=$(mktemp -d); pushd "$tmp" >/dev/null
-mkdir -p .worktrees/PROJ-2002
-cat > .worktrees/PROJ-2002/agent-state.json <<'JSON'
-{"taskId":"PROJ-2002","branch":"fix/PROJ-2002","baseBranch":"main",
- "planTodos":[{"id":"T1","title":"tiny fix","status":"done"}],
- "reviewConsensus":{"accepted":[],"deferred":[],"rejected":[],"approved":true}}
-JSON
-out=$(bash "$RENDER" PROJ-2002)
-popd >/dev/null; rm -rf "$tmp"
-
-if ! grep -q '#### Review outcome' <<< "$out"; then
-  record_pass "review outcome hidden when all buckets empty"
-else
-  record_fail "review outcome should be hidden when empty"
-fi
-
-# --- 6: post-hoc flags, no state ---
-tmp=$(mktemp -d); pushd "$tmp" >/dev/null
-out=$(bash "$RENDER" POST-HOC-1 --branch "bugfix/post-hoc" --base-branch develop 2>&1 || true)
-popd >/dev/null; rm -rf "$tmp"
-if grep -q '^### Work Summary' <<< "$out" && grep -q 'POST-HOC-1' <<< "$out"; then
-  record_pass "post-hoc flags render header without state"
-else
-  record_fail "post-hoc invocation should still render header"
-fi
-
-# --- 7: prefs schema ---
-if jq -e '.properties.global.properties.reportContent.properties.workSummary.default == false' "$SCHEMA" >/dev/null 2>&1; then
-  record_pass "prefs schema exposes reportContent.workSummary (default false)"
-else
-  record_fail "prefs schema missing reportContent.workSummary"
-fi
-
-# --- 8: channels.md docs ---
-if grep -q '### Work Summary' "$CHANNELS_DOC" && \
-   grep -q 'Yapılan iş özeti' "$CHANNELS_DOC" && \
-   grep -q 'Work summary generation' "$CHANNELS_DOC"; then
-  record_pass "channels.md documents Work Summary content option + menu row + generation spec"
-else
-  record_fail "channels.md missing Work Summary docs"
-fi
-
-# --- 9: v7.1.1 preview-first flow documented ---
-if grep -q 'Step 3a' "$CHANNELS_DOC" && \
-   grep -q 'summary-first' "$CHANNELS_DOC" && \
-   grep -q 'auto-tick' "$CHANNELS_DOC"; then
-  record_pass "channels.md documents v7.1.1 preview-before-select flow"
-else
-  record_fail "channels.md missing Step 3a summary-first flow docs"
-fi
-
-printf '\n══ work-summary smoke: %d passed, %d failed ══\n' "$pass" "$fail"
-if [ "$fail" -gt 0 ]; then
-  printf '\nFailures:\n'
-  for m in "${failures[@]}"; do printf '  - %s\n' "$m"; done
-  exit 1
-fi
-exit 0

package/pipeline/scripts/smoke-workflow-audit.sh

@@ -1,101 +0,0 @@
-#!/usr/bin/env bash
-#
-# smoke-workflow-audit.sh  -  security + correctness audit of
-# `.github/workflows/` with the two dedicated external linters:
-#
-#   - zizmor      GitHub Actions security auditor (template injection,
-#                 credential persistence, cache poisoning, unpinned actions,
-#                 excessive permissions, ...). Runs offline, no network.
-#   - actionlint  workflow correctness linter (expression syntax, matrix
-#                 typos, shellcheck of run: blocks, ...).
-#
-# Any finding from either tool fails the smoke.
-#
-# WHY THIS IS STRICT BY DEFAULT
-#
-# Until now a missing binary produced a SKIP and the smoke exited 0, so it
-# reported "0 passed, 0 failed, 2 skipped" on the dev machine AND on the CI
-# runner - neither had the tools. ci-lite.yml justified not installing them by
-# saying to run the smoke locally "where the tools exist", but they did not
-# exist there either. The audit had therefore never run anywhere, while
-# appearing as a green step. When it was finally run it found nine real issues,
-# one of them high severity (a dependency cache restored into the job that
-# signs and publishes the release tarball).
-#
-# So the failure mode is inverted: absent tooling is a failure, and skipping is
-# something you opt into deliberately and locally.
-#
-#   brew install zizmor actionlint            # macOS
-#   pipx install zizmor && go install github.com/rhysd/actionlint/cmd/actionlint@latest
-#
-# WORKFLOW_AUDIT_ALLOW_MISSING=1 downgrades a missing binary back to a SKIP for
-# a local run. It is ignored when CI is set: CI installs both, pinned, and a
-# runner that cannot must fail loudly rather than pass quietly.
-#
-# Structural baseline checks that need no external binary live in
-# smoke-ci-workflows.sh - this smoke is the deeper, tool-backed layer.
-#
-# Exit codes: 0=pass, 1=findings or missing tooling, 2=workflows missing
-
-set -uo pipefail
-
-REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-WF_DIR="$REPO_ROOT/.github/workflows"
-
-[ -d "$WF_DIR" ] || { echo "FAIL: .github/workflows/ missing"; exit 2; }
-
-# In CI the escape hatch does not apply, whatever the environment says.
-ALLOW_MISSING="${WORKFLOW_AUDIT_ALLOW_MISSING:-0}"
-[ -n "${CI:-}" ] && ALLOW_MISSING=0
-
-PASS=0
-FAIL=0
-SKIPPED=0
-pass() { PASS=$((PASS + 1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL + 1)); echo "  ✗ $1"; }
-skip() { SKIPPED=$((SKIPPED + 1)); echo "  ↷ SKIP: $1"; }
-
-# A tool that is not installed is a failure unless a local run opted out.
-missing_tool() {
-  local tool="$1" install="$2"
-  if [ "$ALLOW_MISSING" = "1" ]; then
-    skip "$tool not on PATH, WORKFLOW_AUDIT_ALLOW_MISSING=1 ($install)"
-  else
-    fail "$tool not on PATH - the audit cannot run ($install)"
-  fi
-}
-
-# ──────────────────────────────────────────────────────────────────────────
-echo "→ 1. zizmor (security audit, offline)"
-if command -v zizmor >/dev/null 2>&1; then
-  # Flag names shifted across zizmor releases (--offline vs --no-online-audits);
-  # probe --help so the smoke works with whichever is installed.
-  HELP=$(zizmor --help 2>&1 || true)
-  OFFLINE_FLAG="--offline"
-  echo "$HELP" | grep -q -- '--offline' || OFFLINE_FLAG="--no-online-audits"
-  if OUT=$(zizmor "$WF_DIR" --min-severity medium "$OFFLINE_FLAG" 2>&1); then
-    pass "zizmor: no findings at medium+ severity"
-  else
-    fail "zizmor reported findings (medium+ severity)"
-    echo "$OUT" | sed 's/^/    /'
-  fi
-else
-  missing_tool zizmor "brew install zizmor"
-fi
-
-# ──────────────────────────────────────────────────────────────────────────
-echo "→ 2. actionlint (workflow correctness)"
-if command -v actionlint >/dev/null 2>&1; then
-  if OUT=$(cd "$REPO_ROOT" && actionlint 2>&1); then
-    pass "actionlint: no findings"
-  else
-    fail "actionlint reported findings"
-    echo "$OUT" | sed 's/^/    /'
-  fi
-else
-  missing_tool actionlint "brew install actionlint"
-fi
-
-echo ""
-echo "══ smoke-workflow-audit: $PASS passed, $FAIL failed, $SKIPPED skipped ══"
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0

package/pipeline/scripts/smoke-worktree-path-convention.sh

@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-#
-# smoke-worktree-path-convention.sh
-#
-# Asserts the pipeline never creates worktrees outside `{projectRoot}/{worktreeBasePath}/{taskId}`.
-# Per `feedback_worktree_path_convention.md`:
-#   - Worktree is ALWAYS under the project root, NEVER under $HOME directly.
-#   - Default basePath is `.worktrees`, override via `prefs.global.worktreeBasePath`.
-#   - Multi-repo tasks: each repo gets its own independent worktree under that repo's root.
-#
-# This is a static-analysis lint, not a runtime probe. It greps the pipeline
-# source for forbidden worktree paths in shell scripts, markdown contracts,
-# and orchestrator command files. A behavioural check (live `git worktree list`)
-# is out of scope  -  that would require a real run.
-
-set -euo pipefail
-
-SELF_DIR=$(cd "$(dirname "$0")" && pwd)
-PIPELINE_ROOT=$(cd "$SELF_DIR/.." && pwd)
-
-cd "$PIPELINE_ROOT"
-
-FAIL=0
-
-# Forbidden patterns: any worktree path that lives under $HOME directly,
-# or uses repo-name--taskId style outside a project root.
-declare -a FORBIDDEN=(
-  '\$HOME/\.worktrees'                      # $HOME/.worktrees/foo  -  wrong (must be under projectRoot)
-  '~/\.worktrees'                            # ~/.worktrees/foo  -  same
-  '\$HOME/[a-zA-Z0-9_-]+--[a-zA-Z0-9_-]+'   # $HOME/repo--taskid pattern
-  '~/[a-zA-Z0-9_-]+--[a-zA-Z0-9_-]+'        # ~/repo--taskid pattern
-  'git worktree add.*\$HOME/[^.]'           # `git worktree add $HOME/something`
-  'git worktree add.*~/[^/]'                # `git worktree add ~/something`
-)
-
-# In-scope files: shell + markdown phase contracts + orchestrator skills.
-TARGETS=(
-  "scripts/*.sh"
-  "scripts/*.mjs"
-  "lib/*.sh"
-  "commands/multi-agent/SKILL.md"
-  "commands/multi-agent/*.md"
-  "multi-agent-refs/*.md"
-  "multi-agent-refs/phases/*.md"
-  "skills/shared/core/multi-agent/SKILL.md"
-)
-
-# Allowlist file paths  -  reference docs that mention the wrong pattern only
-# to teach the rule are tagged with `# allow: worktree-bad-example` annotation
-# on the offending line.
-for pattern in "${FORBIDDEN[@]}"; do
-  for glob in "${TARGETS[@]}"; do
-    while IFS= read -r match; do
-      [ -z "$match" ] && continue
-      file="${match%%:*}"
-      # Allow lines that are rule-explanation examples (annotated).
-      if echo "$match" | grep -q '# allow: worktree-bad-example'; then continue; fi
-      # Allow this very smoke gate's own forbidden-pattern array.
-      case "$file" in
-        */smoke-worktree-path-convention.sh) continue ;;
-        */feedback_worktree_path_convention.md) continue ;;
-      esac
-      echo "FAIL [smoke-worktree-path-convention]: forbidden worktree path in $file"
-      echo "  $match"
-      FAIL=$((FAIL + 1))
-    done < <(grep -rEn "$pattern" "pipeline/$glob" 2>/dev/null || true)
-  done
-done
-
-# Positive assertion: phase-0-init.md MUST mention the convention text.
-PHASE0="multi-agent-refs/phases/phase-0-init.md"
-if [ -f "pipeline/$PHASE0" ]; then
-  if ! grep -qE 'projectRoot.*worktreeBasePath|\.worktrees/.*taskId' "pipeline/$PHASE0"; then
-    echo "FAIL [smoke-worktree-path-convention]: phase-0-init.md must document {projectRoot}/{worktreeBasePath}/{taskId} convention"
-    FAIL=$((FAIL + 1))
-  fi
-fi
-
-if [ "$FAIL" -gt 0 ]; then
-  echo ""
-  echo "smoke-worktree-path-convention: $FAIL violation(s)."
-  echo "Worktree path contract: {projectRoot}/{worktreeBasePath default .worktrees}/{taskId}. Never under \$HOME directly. See feedback_worktree_path_convention.md."
-  exit 1
-fi
-
-echo "smoke-worktree-path-convention: ok"

package/pipeline/scripts/smoke-wrapper-preservation.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-# smoke-wrapper-preservation.sh  -  local-only alias wrappers must survive install/update.
-#
-# Local-only wrappers (frontmatter `local-only: true`) live ONLY under
-# ~/.claude/commands/multi-agent/ (never in pipeline/, never synced). install
-# wipes that namespace before copying from pipeline; without the snapshot+restore
-# carve-out in install/claude.mjs installCommands, wrappers are destroyed on every
-# run. This asserts they survive a second install.
-
-set -uo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(cd "$HERE/../.." && pwd)"
-INSTALL_JS="$ROOT/install.js"
-
-PASS=0; FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-TMP="$(mktemp -d)"
-trap 'rm -rf "$TMP"' EXIT
-
-echo "→ 1. first install lays down the namespace"
-if HOME="$TMP" node "$INSTALL_JS" --claude >/dev/null 2>&1; then
-  pass "install --claude (1st) exited 0"
-else
-  fail "install --claude (1st) failed"
-  echo "══ wrapper-preservation smoke: $PASS passed, $FAIL failed ══"; exit 1
-fi
-
-WRAP_DIR="$TMP/.claude/commands/multi-agent/zz-wrapper-probe"
-mkdir -p "$WRAP_DIR"
-cat > "$WRAP_DIR/SKILL.md" <<'EOF'
----
-description: "probe local-only wrapper"
-allowed-tools: Skill
-local-only: true
----
-Use the Skill tool to invoke `some-plugin:some-skill`.
-EOF
-[ -f "$WRAP_DIR/SKILL.md" ] && pass "seeded a local-only wrapper" || fail "could not seed wrapper"
-
-echo ""
-echo "→ 2. second install must PRESERVE the wrapper"
-if HOME="$TMP" node "$INSTALL_JS" --claude >/dev/null 2>&1; then
-  pass "install --claude (2nd) exited 0"
-else
-  fail "install --claude (2nd) failed"
-fi
-if [ -f "$WRAP_DIR/SKILL.md" ] && grep -q '^local-only: true' "$WRAP_DIR/SKILL.md"; then
-  pass "local-only wrapper survived re-install"
-else
-  fail "local-only wrapper was DESTROYED by re-install (carve-out regressed)"
-fi
-
-echo ""
-echo "→ 3. a normal (non-local-only) stray dir is still wiped"
-STRAY="$TMP/.claude/commands/multi-agent/zz-stray-probe"
-mkdir -p "$STRAY"; printf -- '---\ndescription: "stray"\n---\n' > "$STRAY/SKILL.md"
-HOME="$TMP" node "$INSTALL_JS" --claude >/dev/null 2>&1
-if [ -f "$STRAY/SKILL.md" ]; then
-  fail "non-local-only stray survived (wipe too weak)"
-else
-  pass "non-local-only stray correctly wiped"
-fi
-
-echo ""
-echo "══ wrapper-preservation smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ]

package/pipeline/scripts/smoke-write-state.sh

@@ -1,159 +0,0 @@
-#!/usr/bin/env bash
-# smoke-write-state.sh  -  verify write-state.mjs atomic write + merge + lock behavior.
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-WRITER="$SCRIPT_DIR/write-state.mjs"
-
-if [ ! -f "$WRITER" ]; then
-  echo "FAIL: write-state.mjs not found" >&2
-  exit 1
-fi
-
-PASS=0
-FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-TMPDIR=$(mktemp -d) || { echo "FAIL: mktemp" >&2; exit 1; }
-trap 'rm -rf "$TMPDIR"' EXIT
-
-STATE="$TMPDIR/state.json"
-
-# 1. Initial write creates file
-echo '{"currentPhase":0,"status":"in_progress"}' | node "$WRITER" "$STATE"
-if [ -f "$STATE" ] && grep -q '"currentPhase": 0' "$STATE"; then
-  pass "initial write creates file"
-else
-  fail "initial write missing/malformed"
-fi
-
-# 2. Merge preserves existing fields
-echo '{"currentPhase":3}' | node "$WRITER" "$STATE"
-if grep -q '"currentPhase": 3' "$STATE" && grep -q '"status": "in_progress"' "$STATE"; then
-  pass "merge preserves untouched fields"
-else
-  fail "merge dropped fields"
-fi
-
-# 3. Nested merge
-echo '{"phases":{"3":{"status":"done"}}}' | node "$WRITER" "$STATE"
-echo '{"phases":{"4":{"status":"in_progress"}}}' | node "$WRITER" "$STATE"
-if grep -q '"3"' "$STATE" && grep -q '"4"' "$STATE"; then
-  pass "nested merge preserves sibling keys"
-else
-  fail "nested merge overwrote sibling keys"
-fi
-
-# 4. --replace overwrites completely
-echo '{"currentPhase":7}' | node "$WRITER" --replace "$STATE"
-if ! grep -q '"status"' "$STATE" && grep -q '"currentPhase": 7' "$STATE"; then
-  pass "--replace overwrites full state"
-else
-  fail "--replace did not fully overwrite"
-fi
-
-# 5. Invalid JSON exits 1
-echo 'not-json' | node "$WRITER" "$TMPDIR/other.json" 2>/dev/null
-if [ $? -eq 1 ]; then
-  pass "invalid JSON exits 1"
-else
-  fail "invalid JSON did not exit 1"
-fi
-
-# 6. Empty stdin exits 1
-: | node "$WRITER" "$TMPDIR/empty.json" 2>/dev/null
-if [ $? -eq 1 ]; then
-  pass "empty stdin exits 1"
-else
-  fail "empty stdin did not exit 1"
-fi
-
-# 7. Missing path arg exits 3
-echo '{}' | node "$WRITER" 2>/dev/null
-if [ $? -eq 3 ]; then
-  pass "missing path exits 3"
-else
-  fail "missing path did not exit 3"
-fi
-
-# 8. Atomic  -  no .tmp leftover after success
-if ls "$TMPDIR"/.state.json.*.tmp 2>/dev/null | head -1 | grep -q .; then
-  fail "leftover .tmp file after success"
-else
-  pass "no .tmp leftover after successful write"
-fi
-
-# 9. No .lock leftover after success
-if [ -f "$STATE.lock" ]; then
-  fail "leftover .lock file after success"
-else
-  pass "no .lock leftover after successful write"
-fi
-
-# 10. Concurrent writers don't corrupt state
-#
-# Was 5 writers, which lost an update roughly one run in five on a loaded
-# machine and never on an idle one, so it read as a flaky test rather than the
-# data-loss bug it was. 20 writers puts enough writers in the acquire window to
-# make a regression show up on an idle machine too.
-STATE2="$TMPDIR/concurrent.json"
-WRITERS=20
-echo '{"counter":0}' | node "$WRITER" "$STATE2"
-for i in $(seq 1 "$WRITERS"); do
-  echo "{\"w$i\":$i}" | node "$WRITER" "$STATE2" &
-done
-wait
-MISSING=0
-for i in $(seq 1 "$WRITERS"); do
-  grep -q "\"w$i\": $i" "$STATE2" || MISSING=$((MISSING+1))
-done
-if [ "$MISSING" -eq 0 ]; then
-  pass "$WRITERS concurrent writers all persisted"
-else
-  fail "$MISSING of $WRITERS concurrent writes lost"
-fi
-
-# 11. A lock with no readable PID must not be treated as stale
-#
-# This is the exact shape of the bug above. The lock used to be created empty
-# and filled on the next line, so a writer that arrived in between read an
-# unparseable PID, called the lock stale, and deleted it while its owner was
-# still working. Both then wrote and one update vanished.
-#
-# An empty lock now has to block until the staleness window elapses, so a
-# writer given a 1s acquire budget must give up with exit 2 rather than help
-# itself to the lock.
-STATE3="$TMPDIR/emptylock.json"
-echo '{"seed":1}' | node "$WRITER" "$STATE3"
-: > "$STATE3.lock"
-LOCK_RC=0
-echo '{"stolen":true}' | WRITE_STATE_LOCK_TIMEOUT_MS=1000 WRITE_STATE_LOCK_STALE_MS=30000 \
-  node "$WRITER" "$STATE3" >/dev/null 2>&1 || LOCK_RC=$?
-if [ "$LOCK_RC" -eq 2 ] && ! grep -q '"stolen"' "$STATE3"; then
-  pass "empty lock is not stolen (exit 2, state untouched)"
-else
-  fail "empty lock was treated as stale (exit $LOCK_RC) - the live-lock race is back"
-fi
-rm -f "$STATE3.lock"
-
-# 12. A lock older than the staleness window is still reclaimed
-#
-# The counterpart to 11: refusing to reclaim an unreadable PID must not mean a
-# genuinely abandoned lock blocks forever.
-STATE4="$TMPDIR/stalelock.json"
-echo '{"seed":1}' | node "$WRITER" "$STATE4"
-: > "$STATE4.lock"
-STALE_RC=0
-echo '{"recovered":true}' | WRITE_STATE_LOCK_TIMEOUT_MS=3000 WRITE_STATE_LOCK_STALE_MS=1 \
-  node "$WRITER" "$STATE4" >/dev/null 2>&1 || STALE_RC=$?
-if [ "$STALE_RC" -eq 0 ] && grep -q '"recovered"' "$STATE4"; then
-  pass "abandoned lock past the staleness window is reclaimed"
-else
-  fail "stale lock not reclaimed (exit $STALE_RC) - writers would wedge"
-fi
-
-echo ""
-echo "══ write-state smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ] || exit 1