feat(messaging): implement Track 0 fault tolerance (B-14, B-15) and add 10 regression guards (G-1 to G-10)

- Synthesize collaborative multi-agent architectural analysis in NATS_REPORT.md
- Establish Option C: retain MQTT client protocol while adopting nats-server as dedicated broker
- Add private server deployment and configuration guide in PRIVATE_SERVER.md
- Update IMPROVEMENTS.md with latent defect findings (B-14, B-15, B-16, O-5) and 4-track priority roadmap
- Archive durable loop planning and review reports in .agents/reports/

.agents/reports/canary-projects-multi-agent-mux-creator-claude/plan-641929ab.md

@@ -0,0 +1,325 @@
+# 📐 심층 분석 계획서 Rev.2 — MAM 메시징 백플레인: MQTT → NATS 전환 타당성
+
+- **Job ID**: `f1956d2e` (Rev.1 = `641929ab`)
+- **Planner**: claude (session: `herdr:canary-projects-multi-agent-mux-creator-claude`)
+- **Role**: Planner (`MULTI_AGENT_RULES.md` §1 — 본 작업에서 저장소 코드 **0건 수정**)
+- **반영 대상 Challenge**: `10003692` (agy, Worker / Plan Reviewer) — `[VERDICT: PASS WITH CHALLENGE]`
+- **기준 커밋**: `ac82f9b` (`refactor`, 작업 트리 clean)
+- **테스트 베이스라인**: **276 tests collected** (실측)
+
+---
+
+## 0. Challenge 판정 요약
+
+Challenge 는 지적 **1건(C1)** 을 제기했고, 나머지 6개 섹션은 승인했습니다. C1 을 **실측으로 판정**한 결과 **결론은 채택, 근거·메커니즘·심각도는 정정**입니다.
+
+| # | 지적 | 판정 | 실측 근거 |
+|---|---|---|---|
+| **C1-a** | `job_subscriber.py` 가 위임 경로에서 **블로킹 대기 대상**이며 Rev.1 이 이를 누락 | ✅ **전면 인정 — Rev.1 §1.2 표가 틀렸습니다** | `multi-agent-mux-delegate-job:227` `wait "$sub_pid"` 실재. `run_loop.sh` 는 **전 호출부가 `--type direct`** 로 이 경로를 탐 |
+| **C1-b** | `job_subscriber.py` 에 디스크 폴백이 없음 | ✅ **전면 인정** | 이벤트 대기는 `watcher.events.get(timeout=wait)` 단일 경로. `reconcile.sh` 의 `exit 3` 폴백에 해당하는 것이 없음 |
+| **C1-c** | 메커니즘: "publish_event 가 디스크를 갱신하고 종료 → 와이어 메시지만 없음" | ⚠️ **현행 코드와 불일치 — 정정** | **현행은 디스크도 갱신되지 않습니다**(F-1). C1-c 는 Track 0 수정 **이후**의 상태를 기술한 것. 즉 C1 은 *기존 버그*가 아니라 **Track 0 수정의 잔여 결함** |
+| **C1-d** | "idle_timeout(120s) 까지 블록 → **최소 2분** 지연" | ❌ **실측 반증 — 기각** | 브로커 도달 불가 시 구독자는 **40초에 rc=1 로 사망**(traceback), 접속 거부 시 **15.1초**. 5초 핸드셰이크 창을 넘겨 죽으므로 에이전트는 정상 실행되고, `wait` 도달 시점엔 이미 종료 → **추가 지연 0초** |
+| **C1-e** | 해결책: 디스크 터미널 상태 확인 후 정상 종료 | ✅ **채택 — 단, 더 강한 사유로** | 지연이 아니라 **거짓 실패 판정**이 진짜 피해. `read_logged_status` 는 `mqtt_common.py:559` 에 실재함(인용 정확) |
+
+**추가로, Challenge 가 놓친 결함 2건을 발견했습니다** (§3). 그중 **F-4 는 C1 이 지적한 것보다 심각합니다.**
+
+> ### **[VERDICT: DO NOT MIGRATE THE CLIENT PROTOCOL — ADOPT `nats-server` AS THE BROKER INSTEAD]**
+>
+> **판정 불변.** C1 은 전략 판정이 아니라 Track 0 의 범위를 확장시킵니다. Challenge 도 §3 표에서 판정 자체는 전항목 승인했습니다.
+
+---
+
+## 1. C1 정밀 판정 (실측)
+
+### 1.1 인정 — Rev.1 §1.2 표의 오류
+
+Rev.1 은 `job_subscriber.py` 를 이렇게 분류했습니다:
+
+> | `job_subscriber.py` | 라이브 이벤트 tail | ❌ **`run_loop.sh` 가 호출하지 않음** (호출처: `BOOTSTRAP.md:170` 문서, `test_tier4_e2e.py`) | 영향 없음 |
+
+**이는 틀렸습니다.** 원인은 방법론 오류입니다 — 저는 `grep -rln --include="*.sh" --include="*.py" --include="*.md"` 로 호출처를 찾았는데, 위임 실행 파일 `multi-agent-mux-delegate-job` 은 **확장자가 없어** include 필터에서 제외되었습니다. 실제 호출 사슬은:
+
+```
+run_loop.sh:378  delegate_job_safe submit --type "direct" ...
+  └→ run_loop.sh:132  bash "$REPO_ROOT/.agents/skills/multi-agent-mux-delegate-job/multi-agent-mux-delegate-job"
+       └→ :164  job_subscriber.py ... &   (background)
+       └→ :227  wait "$sub_pid" || true   (blocking join)
+```
+
+`run_loop.sh` 의 `--type "direct"` 지정은 `:378`, `:412`, `:440`, `:498`, `:554`, `:597` … **전 호출부**입니다 (`TYPE` 기본값도 `:96` 에서 `direct`). 따라서 **`job_subscriber.py` 는 run_loop 의 제어 경로 안에 간접적으로 존재합니다.** Challenge 의 지적이 정확합니다.
+
+**단, Rev.1 §1.1 의 핵심 측정은 그대로 유효합니다**: `run_loop.sh` 자체의 MQTT 참조는 `:889` 1건뿐이고, 잡 완료 판정은 `wait_for_job()` 의 3초 파일 폴링입니다. 즉 **잡 결과 판정은 여전히 브로커와 무관**하며, 브로커가 관여하는 것은 **join 시점의 대기**뿐입니다. 이 구분이 §1.3 의 심각도 산정을 좌우합니다.
+
+### 1.2 정정 — C1-c 의 메커니즘은 현행 코드와 다릅니다
+
+Challenge §2.2 step 3:
+
+> `publish_event.py` updates the on-disk job file (`.mam/jobs/<id>.json`) and exits. The network publish fails, so **no MQTT message is delivered over the wire**.
+
+**현행 코드는 디스크도 갱신하지 않습니다.** `publish_event.py:186-190` 이 레지스트리 동기화 **이전에** `return 2` 하기 때문입니다 — 이것이 Rev.1 §4 의 F-1 이고, 실측으로 재현했습니다 (`status=running` 불변, `last_seq` 0→1 소모, `events=0`).
+
+즉 **C1 이 기술한 상태는 Track 0 수정이 적용된 *이후*에만 성립**합니다. 이 순서를 바로잡는 것이 중요한 이유:
+
+- C1 은 "지금 존재하는 별도 버그"가 아니라 **"F-1 을 고쳐도 남는 잔여 결함"** 입니다.
+- 따라서 **F-1 수정만으로는 위임 경로가 완성되지 않는다**는 Challenge 의 결론은 옳으며, 두 수정은 **같은 트랙에서 함께** 이루어져야 합니다. Challenge 의 실행 권고(§4-1)는 정확합니다.
+- 반대로, C1 을 먼저 고치고 F-1 을 놔두면 **아무 효과가 없습니다** — 디스크에 터미널 상태가 없으므로 폴백이 읽을 것이 없습니다. **순서 의존성이 존재하며 §4 에 명시했습니다.**
+
+### 1.3 기각 — "최소 2분 지연"은 실측으로 성립하지 않습니다
+
+Challenge §2.2 step 6: *"hangs on `wait "$sub_pid"` for **at least 2 minutes**"*.
+
+**실측 1 — 브로커 도달 불가 (`10.255.255.1:1883`, 라우팅 블랙홀)**
+```
+exit_rc=1  elapsed=40s
+socket.timeout: timed out          ← 미포착 예외로 사망
+SUBSCRIBED 출력 횟수: 0
+```
+
+**실측 2 — 브로커 접속 거부 (`127.0.0.1:1`, 즉시 RST)**
+```
+exit_rc=1  elapsed=15101ms
+WARNING ... attempt 4/5 failed: [Errno 61] Connection refused; retrying in 8.0s
+ConnectionRefusedError: [Errno 61] Connection refused
+```
+
+핵심 타이밍 3개를 대조하면 C1-d 가 성립하지 않는 이유가 드러납니다:
+
+| 구간 | 값 | 출처 |
+|---|---|---|
+| 핸드셰이크 대기 창 | **5.0초** (`for ((i=0; i<25; i++))` × `sleep 0.2`) | `multi-agent-mux-delegate-job:171-190` |
+| 구독자 접속 재시도 총 시간 | **최소 15초** (`attempts=5, base_delay=1.0` → 1+2+4+8) | `job_subscriber.py:200-203` |
+| 구독자 실제 사망 시점 | **15.1초 / 40초** (실측) | 위 |
+
+따라서 브로커가 처음부터 죽어 있으면:
+1. t=5s — 구독자는 **아직 살아 있음** → `sub_ready=0` → `WARNING: subscriber subscribe handshake timed out — falling back to proceed` → **에이전트 정상 실행**
+2. t=15~40s — 구독자가 traceback 과 함께 rc=1 로 사망
+3. 에이전트 종료 후 `:227` `wait "$sub_pid"` 도달 → **이미 종료된 프로세스 → 즉시 반환**
+
+**추가 지연 0초입니다.** "최소 2분"이 아니라 **최대 0초**입니다.
+
+C1 이 기술한 120초 대기가 성립하려면 **SUBSCRIBE 성공 이후 브로커가 중도 유실**되어야 합니다. 이 경우에도:
+- `idle_timeout` 은 **마지막 수신 이벤트**부터 계산됩니다 (`job_subscriber.py` 의 `last_event = time.monotonic()`).
+- 에이전트는 보통 `started` 발행 후 **수 분** 동작합니다. 그러면 idle 은 에이전트 실행 **도중** 만료되어 구독자가 먼저 죽고, `wait` 은 다시 즉시 반환됩니다.
+- 실제 블로킹은 **에이전트가 마지막 성공 이벤트로부터 120초 이내에 끝나는 짧은 잡**에서만 발생합니다.
+
+**정정된 심각도**: 추가 지연은 **"항상 최소 120초"가 아니라 "최대 약 120초, 통상 0초"** 입니다.
+
+### 1.4 그럼에도 C1-e 를 채택하는 이유 — 진짜 피해는 지연이 아니라 거짓 판정
+
+`:227` 은 `wait "$sub_pid" || true` 로 **종료 코드를 폐기**합니다. 따라서 run_loop 경로에서 구독자의 rc=1/rc=2 는 잡 판정에 영향을 주지 않습니다(잡 판정은 `wait_for_job` 의 디스크 폴링). 그러나:
+
+- 감사 산출물인 `$REGISTRY_DIR/$JOB_ID.subscriber.out` 에는 **성공한 잡에 대해 `socket.timeout` traceback 또는 `ERROR: idle timeout (120s, no events)`** 가 남습니다.
+- `:228` 이 이를 그대로 표준출력에 덤프합니다 (`echo "subscriber output:"; cat "$logf"`).
+- 즉 **정상 완료된 잡의 감사 기록이 실패로 오염**됩니다. 이것이 지연보다 실질적 피해가 큽니다.
+
+**그리고 rc 를 폐기하지 않는 경로가 존재합니다 — §3 의 F-4.**
+
+---
+
+## 2. 판정에 영향 없음 — 전략 결론 불변
+
+Challenge §3 은 Option (C), asyncio 마찰, F-1 발견, F-2/F-3, 스파이크 매트릭스를 **전항목 승인**했습니다. C1 은 브로커 제품 선택과 직교하는 Track 0 범위 확장이므로, Rev.1 §0 의 판정표는 그대로 유지됩니다.
+
+| 선택지 | 코드 변경 | 테스트 변경 | A-2 해소 | 판정 |
+|---|---|---|---|---|
+| (A) 현행 유지 (공개 HiveMQ) | 0 | 0 | ❌ | 기각 |
+| (B) 네이티브 NATS (`nats-py`) | 4개 호출부 재작성 | 46건 | ✅ | **기각** |
+| **(C) `nats-server` + MQTT 프로토콜 유지** | **0** | **0** | ✅ | ✅ **채택** |
+
+**오히려 C1 은 판정을 보강합니다**: `job_subscriber.py` 가 제어 경로에 (간접적으로) 있다는 사실은, 이 파일을 **네이티브 NATS 로 재작성하는 것의 위험을 키웁니다**. Rev.1 §1.3 에서 이 파일은 raw paho 클라이언트 구동 9줄로 4개 호출부 중 최다입니다. 선택지 (B)는 **제어 경로 위의 파일을 재작성**하게 되며, (C)는 건드리지 않습니다.
+
+---
+
+## 3. Challenge 가 놓친 결함 2건
+
+### F-4 (Critical) — `loop`/`discuss` 경로에서 구독자 종료 코드가 **잡 판정 그 자체**
+
+`multi-agent-mux-delegate-job:331-341`:
+
+```bash
+local sub_rc=0
+wait "$sub_pid" || sub_rc=$?
+echo "subscriber output:"; cat "$logf" || true
+
+local job_status="running"
+if   [[ $sub_rc -eq 0 ]]; then job_status="completed"
+elif [[ $sub_rc -eq 1 ]]; then job_status="error"      # ← 브로커 도달 불가 = rc 1 (실측)
+else                           job_status="timeout"     # ← idle timeout = rc 2
+fi
+echo "Job role $display_role finished with status: $job_status"
+```
+
+`:227` 의 `|| true` 와 달리 여기서는 **rc 가 잡 상태로 직결**됩니다. 그리고 실측했듯 **브로커 도달 불가 시 구독자는 미포착 예외로 rc=1** 을 냅니다.
+
+`job_subscriber.py` 가 rc=1 을 내는 정상 경로는 **"터미널 `error` 이벤트를 수신했다"** 하나뿐입니다(`return 1` at 말미). 그런데 파이썬 미포착 예외도 rc=1 입니다. 따라서:
+
+> **"에이전트가 error 를 보고했다" 와 "브로커에 접속하지 못했다" 가 구분 불가능하며, 후자가 전자로 보고됩니다.**
+
+성공한 잡이 `job_status="error"` 로 판정됩니다. 이는 지연 문제가 아니라 **오케스트레이션 정확성 결함**이며, C1 이 지적한 `:227` 경로보다 심각합니다 — `:227` 은 rc 를 버리므로 피해가 로그 오염에 그치지만, `:331` 은 **잘못된 판정을 하류로 전파**합니다.
+
+**적용 범위 주의**: `run_loop.sh` 는 전 호출부가 `--type direct` 이므로 이 경로를 타지 않습니다. F-4 는 `multi-agent-mux-delegate-job loop|discuss` 를 **직접 호출**할 때 발현합니다 (`:362`, `:375` 에서 `TYPE` 분기). 즉 **잠재 결함이지 현재 run_loop 회귀는 아닙니다.** 그러나 Track 0 이 `job_subscriber.py` 를 손대는 김에 함께 닫아야 하며, **디스크 폴백만 추가하고 rc 매핑을 놔두면 다른 예외 경로에서 동일 혼동이 남습니다.**
+
+### F-5 (Medium) — 문서가 주장하는 persistent session 이 코드상 **구성 불가**
+
+`MESSAGING.md:64`:
+> Subscribers connect with **persistent session flags** to ensure the broker buffers QoS 1 messages during temporary network drops.
+
+그러나 `mqtt_common.py:258-262`:
+```python
+client_id = f"{config.client_id_prefix}-{role}-{uuid.uuid4().hex[:8]}"   # ← 매 실행 랜덤
+client = mqtt.Client(
+    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
+    client_id=client_id,
+)                                    # ← clean_session / clean_start 미지정
+```
+
+durable session 은 **안정적인 client_id** 를 전제합니다. 현재는 매 프로세스 기동마다 client_id 가 바뀌므로, clean-session 플래그를 켜더라도 **브로커가 이전 세션을 인식할 수 없습니다.** 즉 문서의 주장은 코드로 뒷받침되지 않습니다.
+
+**이것이 C1 판정에 미치는 영향**: "durable session 을 켜면 중도 유실 문제가 해결된다"는 대안 경로는 **client_id 안정화 없이는 불가능**합니다. 따라서 C1-e 의 **디스크 폴백이 올바른 해법**이며, 이 발견은 Challenge 의 결론을 보강합니다. (client_id 안정화는 동시 실행 구독자 충돌 위험을 낳으므로 별도 과제로 분리합니다 — §5 비-목표.)
+
+---
+
+## 4. 개정된 Track 0 (F-1 + C1 + F-4) — 최우선
+
+> 브로커 제품 선택과 **완전히 독립**이며 우선순위가 더 높습니다.
+
+### 4.0 순서 의존성 (필수)
+
+```
+Step 1 (publish_event.py)  →  Step 2 (job_subscriber.py)  →  Step 3 (rc 매핑)
+       디스크에 터미널 상태를        디스크를 읽어 조기 종료          판정 혼동 제거
+       "쓰게" 만든다                  (Step 1 없이는 읽을 것이 없음)
+```
+
+**Step 2 를 단독 시행하면 효과가 0입니다.** §1.2 에서 판정한 대로, 현행은 브로커 실패 시 디스크에도 아무것도 남지 않기 때문입니다.
+
+### 4.1 Step 1 — `publish_event.py` 실패 순서 재구성 (Rev.1 대비 불변)
+
+`publish_event.py:186-208` 재구성:
+1. `publish(...)` 실패를 `publish_ok = False` 로 표시하되 **`return` 하지 않음**.
+2. 감사 로그·레지스트리 이벤트·상태 동기화를 **발행 성공 여부와 무관하게 항상 수행**. 감사 레코드에 `"published": publish_ok` 와 `"publish_error": str(exc)` 포함.
+3. 종료 코드 계약 유지 — 발행 실패 시 **여전히 `return 2`**. 단 **상태는 이미 기록된 뒤**.
+4. seq 소모 정책: 현행(실패해도 소모) **유지**. 재생방지(`> highest accepted`)에 무해하고, (2)의 실패 레코드가 gap 을 설명 가능하게 만들기 때문. **이 결정을 주석으로 명문화.**
+
+### 4.2 Step 2 — `job_subscriber.py` 디스크 폴백 (C1-e 채택)
+
+이벤트 대기 루프의 `queue.Empty` 분기(`job_subscriber.py:233-239`)에서, **pending 잡별로** 디스크 터미널 상태를 확인합니다.
+
+**설계 결정 4가지** (Challenge 가 명시하지 않은 부분):
+
+| 항목 | 결정 | 사유 |
+|---|---|---|
+| **조회 순서** | `registry.load_job()` → 없으면 `mqtt_common.read_logged_status()` | 레지스트리가 라이브 레코드(권위), 감사 로그는 레지스트리가 정리되어도 남는 보조 사본 |
+| **조회 주기** | 매 `queue.Empty` 마다가 아니라 **최소 3초 간격 스로틀** | 대기 루프는 `wait = min(..., 1.0)` 로 최대 1초마다 깨어남. 잡당 파일 2개를 초당 읽으면 불필요한 I/O. `wait_for_job` 의 3초 폴링 주기와 정렬 |
+| **합성 이벤트** | 디스크 상태로 터미널 판정 시 `_format_line` 과 동일 형식으로 stdout 에 출력하되 `"source": "disk-fallback"` 표기 | 감사 로그에서 와이어 수신분과 폴백분이 **구분 가능해야** 함. 무표기 합성은 F-3(HMAC) 우회 통로가 됨 |
+| **HMAC 검증** | 디스크 폴백분은 **HMAC 검증 대상 아님** | 로컬 파일시스템은 이미 신뢰 경계 안. 단 위 표기로 출처를 명시 |
+| **종료 코드** | 디스크가 `completed` → **0**, `error` → **1**, `cancelled` → **1** | 와이어 수신 시의 기존 매핑과 동일하게 유지 (호출부 계약 불변) |
+
+**주의 — 조기 종료가 아닌 경우**: `--wait-any` 로 다중 잡을 감시 중이면 **모든 pending 잡이 터미널에 도달했을 때만** 종료합니다. 일부만 디스크 터미널이면 나머지는 계속 대기합니다.
+
+### 4.3 Step 3 — rc → job_status 매핑 명확화 (F-4)
+
+`multi-agent-mux-delegate-job:333-341` 의 3분기 매핑은 "구독자가 정상적으로 판정했다"를 전제하지만, 미포착 예외도 rc=1 을 냅니다. 두 가지를 분리합니다:
+
+1. `job_subscriber.py` 의 `main()` 을 최상위 `try/except` 로 감싸 **인프라 실패는 전용 코드(예: rc=3)** 로 반환하고, `rc=1` 은 **"터미널 error 이벤트 수신"에만** 예약합니다.
+2. `:333-341` 에 `rc=3` 분기를 추가해 `job_status="broker_unavailable"` 로 판정하고, **`wait_for_job` 과 동일하게 디스크를 재확인**하도록 합니다.
+3. `:180-187` 의 `sub_exit != 0 → exit 1` 조기 중단 경로도 `rc=3` 을 **중단 사유에서 제외**합니다 (브로커 부재로 위임 전체를 죽여서는 안 됨). — 실측상 이 경로는 재시도 최소 15초 > 핸드셰이크 창 5초라 **현재 도달 불가**이나, `attempts`/`base_delay` 변경 시 살아나는 잠복 경로이므로 함께 닫습니다.
+
+### 4.4 회귀 가드 (mutation 기준 — 결함을 되살렸을 때 반드시 실패해야 함)
+
+| ID | 가드 | Mutation (이걸 되돌리면 FAIL 해야 함) |
+|---|---|---|
+| **G-1** | 도달 불가 브로커로 `--event completed` 발행 → rc=2 **이면서 레지스트리 `status == "completed"`** | `return 2` 를 상태 동기화 앞으로 이동 |
+| **G-2** | 동일 상황 감사 로그에 `published: false` + `publish_error` 레코드 존재 | `append_event` 를 성공 경로로만 한정 |
+| **G-3** | 브로커 정상 시 rc=0 + `status == "completed"` + 감사 `published: true` (무회귀) | — |
+| **G-4** | 발행 실패 후 `last_seq` 1 증가, 후속 성공 발행이 **더 큰 seq** 사용 | seq 롤백 도입 |
+| **G-5** | 레지스트리에 `status=completed` 를 **미리 써 두고** 도달 불가 브로커로 `job_subscriber.py` 실행 → **rc=0 으로 3~5초 내 종료** | 디스크 폴백 제거 → idle/연결실패로 rc≠0 |
+| **G-6** | 동일 조건에서 stdout 합성 라인에 **`disk-fallback` 표기** 존재 | 표기 누락 시 FAIL (F-3 우회 통로 방지) |
+| **G-7** | 레지스트리 `status=error` → 폴백 종료 코드 **1** / `status=completed` → **0** | 매핑 반전 |
+| **G-8** | `--wait-any` 로 2개 잡 감시 중 **1개만** 디스크 터미널 → **종료하지 않음** | 부분 종료 도입 시 FAIL |
+| **G-9** | 브로커 도달 불가 + 디스크에 터미널 상태 **없음** → rc **3** (rc 1 아님) | rc=1 로 되돌리면 FAIL (F-4) |
+| **G-10** | `loop` 경로에서 rc=3 수신 시 `job_status` 가 `"error"` 가 **아님** | 3분기 매핑으로 되돌리면 FAIL |
+
+**통합 검증 (가장 중요)**: 브로커 정지 상태에서 `--type direct` 위임 1건을 끝까지 돌려, ① `wait_for_job` 이 3900초가 아니라 **3초 내 return 0**, ② `$JOB_ID.subscriber.out` 에 traceback 이나 `idle timeout` 이 **없을 것**, ③ 전체 벽시계 시간이 브로커 정상 시와 **유의미하게 다르지 않을 것**.
+
+### 4.5 예상 테스트 증분
+
+가드 10건 → 베이스라인 **276 → 286**. 전량 신규이며 기존 276건 수정은 **0건**을 목표로 합니다 (기존 rc 계약을 `rc=1`/`rc=0`/`rc=2` 범위에서 유지하고 `rc=3` 만 신설하기 때문).
+
+---
+
+## 5. Track 1 이후 (Rev.1 대비 불변)
+
+### Track 1 — 브로커 선택 스파이크
+
+격리 클론(`git clone --local --no-hardlinks . "$SCRATCH/nats-spike"`)에서 수행, 종료 후 삭제.
+
+| ID | 검증 | 통과 기준 |
+|---|---|---|
+| **S-1** | nats-server 가 MAM MQTT 클라이언트 수용 | rc=0, `status=completed`, `last_seq` 정상 |
+| **S-2** | paho `CallbackAPIVersion.VERSION2` + MQTT 3.1.1 호환 | CONNACK rc=0 |
+| **S-3** | **Retained terminal event** ← 최고 위험 | 신규 구독자가 **즉시** 최종 이벤트 수신 |
+| **S-4** | QoS 1 발행 ACK | `is_published()` True |
+| **S-5** | 와일드카드 구독 | `SUBSCRIBED` 출력 + 이벤트 수신 |
+| **S-6** | 인증 + TLS | 자격증명 누락 시 거부 |
+| **S-7** | subject 단위 권한 (A-2 목표) | publisher 구독 거부 / subscriber 발행 거부 |
+| **S-8** | 전체 회귀 | **286 passed, 0 failed** (Track 0 반영 후) |
+| **S-9** 🆕 | **Track 0 폴백이 nats-server 에서도 유효** | G-5 · 통합 검증을 nats-server 정지 상태에서 재실행 |
+
+**S-3 실패 시** → 선택지 (C) 기각, mosquitto 로 진행. **S-3 은 판정 번복의 유일한 조건입니다.**
+
+### Track 2 — A-2 해소 (F-2 + F-3), 브로커 확정 후
+
+1. **F-3**: `registry.register_job()` 에서 `auth_token` **항상 발급**(`secrets.token_hex(32)`). 기존 `None` 잡 하위호환은 `verify_hmac` 의 현행 경로가 담당하되, **신규 잡에서는 그 경로가 발생하지 않음**을 가드로 고정.
+2. **F-2**: `DEFAULT_TOPIC_ROOT` 를 지문 기반(`mam/<sha256[:12]>/jobs`)으로 전환. 순서 엄수 — **① 발행측 전환 → ② 동작 확인 → ③ `reconcile.sh:237` legacy 구독 제거**(별도 커밋, 롤백 보존).
+3. S-7 에서 검증한 subject 단위 권한을 배포 설정에 반영.
+
+### Track 3 — 문서 동기화
+
+| 문서 | 변경 |
+|---|---|
+| `MESSAGING.md` | §1.2 브로커 제품 갱신. §5 한계에 **F-1·C1 해소** 기록. **§1.2.4 의 persistent session 서술을 F-5 실측에 맞게 정정** 🆕 |
+| `IMPROVEMENTS.md` | A-2 갱신, **F-1·F-4·F-5 신규 등재**, F-2·F-3 상태 갱신 |
+| `VERSIONS.md` | 브로커 런타임 버전 등재 |
+| `deploy/install.sh:484-492`, `install_mam.sh:306-314` | `requirements.txt` **변경 없음**(paho 유지). 브로커 기동 안내만 추가 |
+
+### 비-목표 (명시적 제외)
+
+- ❌ `nats-py` 도입 및 클라이언트 프로토콜 재작성
+- ❌ `.mam/jobs/*.json` 의 JetStream KV 대체 — 상태 계층 교체는 전송 교체와 **별개 결정**
+- ❌ **client_id 안정화 / durable session 도입** 🆕 — F-5 의 근본 해결이나, 동시 구독자 client_id 충돌 위험을 새로 낳음. Track 0 의 디스크 폴백이 같은 문제를 **부작용 없이** 해결하므로 별도 과제로 분리
+- ❌ `requirements.txt` 의 `paho-mqtt>=2.0.0` 변경
+
+---
+
+## 6. Cross-Review 대비 — 반론 선제 대응
+
+Rev.1 §8 의 6개 항목은 유효하며, C1 관련 2개를 추가합니다.
+
+| 예상 반론 | 응답 |
+|---|---|
+| "C1-d 를 기각했으면서 C1-e 를 채택하는 것은 모순" | 아닙니다. **지적된 결함(디스크 폴백 부재)은 실재하고, 제시된 피해(120초 지연)만 실측 반증**되었습니다. 채택 사유를 지연에서 **거짓 실패 판정·감사 기록 오염**(§1.4)과 **F-4 의 오판정**(§3)으로 교체했으며, 이는 원래 사유보다 **강한** 근거입니다 |
+| "Rev.1 이 틀렸다면 판정 전체를 재검토해야 한다" | 틀린 것은 **§1.2 표의 한 행**(호출처 누락, 원인은 grep include 필터)이며, 판정의 토대인 **§1.1 측정(`run_loop.sh` MQTT 참조 1건, `wait_for_job` 파일 폴링)은 재확인 결과 그대로 유효**합니다. 게다가 C1 은 `job_subscriber.py` 를 제어 경로에 넣음으로써 **선택지 (B)의 위험을 키워 판정을 보강**합니다(§2) |
+| "F-4 는 run_loop 가 안 쓰는 경로이니 무시해도 된다" | 현재 회귀는 아니지만, `loop`/`discuss` 는 `:80` usage 에 문서화된 **공개 인터페이스**이며 `:362`/`:375` 에서 실제 분기합니다. 무엇보다 Track 0 이 `job_subscriber.py` 를 이미 여는 이상, rc 계약을 함께 정리하지 않으면 **디스크 폴백을 넣고도 다른 예외 경로에서 같은 혼동이 남습니다** |
+
+---
+
+## 7. 산출물 및 다음 단계
+
+- **Creator**: 본 Rev.2 를 종합해 `NATS_REPORT.md` 로 저장합니다. §0 Challenge 판정표, §1 C1 실측 판정, §3 F-4·F-5, §4 개정 Track 0(순서 의존성 + 가드 10건)이 필수 포함 항목입니다.
+- **Reviewer 전원** — 다음 4건을 **재현 검증**해 주십시오:
+  1. `run_loop.sh` 전 호출부가 `--type "direct"` 인가 (§1.1 — C1 인정의 근거)
+  2. **§1.3 타이밍 반증**: 도달 불가 브로커에서 `job_subscriber.py` 가 **40초에 rc=1**, 접속 거부에서 **15.1초에 rc=1**. 핸드셰이크 창은 5초
+  3. **§3 F-4**: `:333-341` 의 rc→`job_status` 매핑에서 브로커 실패(rc=1)가 `"error"` 로 판정되는가
+  4. **§5 S-3** nats-server retained message 지원 — **판정 번복의 유일한 조건**
+- **Track 0 은 브로커 결정과 무관하게 즉시 착수 가능**하며, Step 1 → Step 2 → Step 3 **순서를 반드시 지켜야 합니다**(§4.0).
+
+---
+
+## 8. 판정 재확인
+
+> **[VERDICT: DO NOT MIGRATE — ADOPT `nats-server` AS BROKER, KEEP MQTT CLIENT PROTOCOL]**
+>
+> 조건: §5 **S-3(retained terminal event)** 및 **S-8(286 tests green)** 통과. S-3 실패 시 mosquitto 로 회귀하며, **어느 경우에도 클라이언트 프로토콜은 변경하지 않습니다.**
+>
+> **선행 필수**: Track 0 (F-1 + C1 + F-4) — 브로커 선택과 독립이며 우선순위가 더 높습니다. **Step 순서 의존성 존재**(§4.0).

.agents/reports/canary-projects-multi-agent-mux-creator-claude/plan-d42004ee.md

@@ -0,0 +1,277 @@
+# 📐 구현 계획서 Rev.2 — `PRIVATE_SERVER.md` 확장 및 `implementation_plan.md` 신설
+
+- **Job ID**: `8c651798` (Rev.1 = `d42004ee`)
+- **Planner**: claude (session: `herdr:canary-projects-multi-agent-mux-creator-claude`)
+- **Role**: Planner (`MULTI_AGENT_RULES.md` §1 — 본 작업에서 저장소 코드 **0건 수정**)
+- **반영 대상 Challenge**: `019495f4` (agy, Worker / Plan Reviewer) — `[VERDICT: PASS WITH CHALLENGE]`
+- **기준 커밋**: `a9934ad` — 테스트 베이스라인 **276**
+
+---
+
+## 0. Challenge 판정 요약
+
+Challenge 3건을 **실측으로 판정**했습니다. 3건 모두 **지적은 타당**하나, 그중 1건은 **제시된 해법 자체가 동작하지 않고**, 1건은 **지적보다 심각**하며, 1건은 **Rev.1 에 이미 있던 조항의 구체화**입니다.
+
+| # | 지적 | 판정 | 실측 근거 |
+|---|---|---|---|
+| **C1-a** | E-3 수정에 `registry.py register` 정확한 인자가 필요 | ✅ **채택** — `--prompt` 는 실제로 required | `registry.py:240` `p_reg.add_argument("--prompt", required=True)` |
+| **C1-b** | "`--job-id <id>` 를 쓴다 (not `--job`)" + 복사·붙여넣기 명령 제시 | ❌ **실측 반증 — 해법이 동작하지 않음** | `--job-id` 는 `register` 서브파서에 **존재하지 않음**. 실행 시 `error: unrecognized arguments: --job-id test-ping-01` |
+| **C1-c** | (제시 명령의 나머지 부분) | ⚠️ **추가 결함 2건 발견** | ① `--registry-dir` 는 **부모 파서** 인자라 서브커맨드 **앞**에 와야 함(실측 오류) ② 테스트 잡이 `pending` 으로 **영구 잔존** → `--wait-any` 가 수집 |
+| **C2** | `/etc/nats/nats.conf` · `/data` 는 비루트 환경에서 `Permission denied` | ✅ **채택 — 심각도 상향** | macOS 는 `Permission denied` 가 아니라 **`Read-only file system`**. `/` 가 sealed APFS 라 **sudo 로도 생성 불가** |
+| **C3** | G-D2 를 코드 펜스 범위로 한정할 것 | ✅ **채택 — 단, Rev.1 §5.5 에 이미 명시된 조항** | Rev.1 원문: *"정규식이 코드 블록 밖의 산문까지 잡으면 오탐이 납니다. 펜스(```) 안 블록으로 스코프를 한정하고…"* — 다만 **구체적 충돌 사례를 특정한 것은 유효한 기여** |
+
+**메타 관찰**: C1-b 는 이 리뷰가 교정하려는 결함(E-1·E-2·E-3 = *검증되지 않은 복사·붙여넣기 명령*)과 **정확히 같은 유형**을 재생산했습니다. 이는 §5.5 문서 드리프트 가드의 필요성을 역설적으로 입증하므로, **Rev.2 는 가드 범위를 문서 내 실행 명령 전반으로 확대**합니다(G-D4 신설).
+
+---
+
+## 1. C1 정밀 판정 — E-3 수정의 정확한 명령
+
+### 1.1 반증 — `--job-id` 는 존재하지 않습니다
+
+Challenge 가 "copy-pasteable" 로 제시한 명령을 그대로 실행한 결과:
+
+```
+$ registry.py --registry-dir <dir> register --job-id test-ping-01 \
+      --prompt "Private broker connectivity test" --agent-session "herdr:test"
+registry.py: error: unrecognized arguments: --job-id test-ping-01
+```
+
+`register` 서브파서(`registry.py:239-252`)의 인자는 다음이 전부입니다:
+
+```
+--prompt (required) --agent --agent-session --role --timeout --idle-timeout
+--bits --artifact --auth-token --job-type --reviewer --reviewer-session --max-iterations
+```
+
+**`--job-id` 도 `--job` 도 없습니다.** 혼동의 원인은 함수 시그니처입니다 — `register_job()` **함수**에는 `job_id` 파라미터가 있고(`registry.py:72` `job_id = job_id or generate_job_id(bits)`), CLI 의 `main()` 은 이를 **전달하지 않습니다**(`:304-318` 의 `register_job(...)` 호출에 `job_id=` 인자 부재). 즉 **CLI 로는 잡 ID 를 지정할 수 없고, 항상 새로 채번됩니다.**
+
+### 1.2 추가 결함 — `--registry-dir` 위치
+
+```
+$ registry.py register --registry-dir <dir> --prompt "x"
+registry.py: error: unrecognized arguments: --registry-dir <dir>
+```
+
+`--registry-dir` 은 `registry.py:236` 에서 **부모 파서**에 등록되므로 **서브커맨드 앞**에 와야 합니다. 문서에 실릴 명령이라면 이 순서를 틀리게 적을 여지를 없애야 합니다.
+
+### 1.3 추가 결함 — 테스트 잡의 영구 잔존
+
+`register_job()` 은 `status: "pending"`(`registry.py:84`)으로 레코드를 만듭니다. 그리고 `job_subscriber.py::_collect_jobs()` 의 `--wait-any` 는 **`status in ("pending","running")` 인 모든 잡을 수집**합니다. 따라서 정리하지 않은 연결 테스트 잡은:
+
+- `job_subscriber.py --wait-any` 가 **영원히 기다리는 유령 잡**이 되고,
+- `pick_pending` 의 후보로 남습니다(`agent_session` 일치 시).
+
+**`registry.py` 에는 delete/remove 서브커맨드가 없습니다**(`register/list/get/status/update/get-feedback/pick/logs` 가 전부). 따라서 정리는 `status` 서브커맨드로 종결 처리하는 것이 정석입니다.
+
+### 1.4 채택 — `PRIVATE_SERVER.md` §6 에 실릴 최종 명령
+
+```bash
+# 1) 임시 잡 등록 — ID 는 지정할 수 없고 자동 채번되므로 stdout 을 반드시 캡처한다
+JID=$(.venv/bin/python .agents/skills/multi-agent-mux-delegate-job/scripts/registry.py \
+        --registry-dir .mam/jobs \
+        register \
+          --prompt "Private broker connectivity test" \
+          --agent-session "herdr:test")
+echo "registered job: $JID"
+
+# 2) 이벤트 발행 (rc=0 단언)
+.venv/bin/python .agents/skills/multi-agent-mux-delegate-job/scripts/publish_event.py \
+  --registry-dir .mam/jobs \
+  --job "$JID" \
+  --event progress \
+  --detail "Private broker connection verified" -v
+
+# 3) 접속 대상 단언 — 개인 서버 IP 가 보이고 broker.hivemq.com 이 없어야 한다
+#    (-v 로그 또는 감사 로그에서 확인)
+
+# 4) 정리 — 미정리 시 --wait-any 가 수집하는 유령 잡으로 남는다
+.venv/bin/python .agents/skills/multi-agent-mux-delegate-job/scripts/registry.py \
+  --registry-dir .mam/jobs status --job "$JID" --set completed
+```
+
+> 주의 3가지를 문서에 각주로 명시: ① **`--registry-dir` 은 서브커맨드 앞** ② **잡 ID 는 지정 불가, 캡처 필수** ③ **4)번 정리 생략 금지**.
+
+---
+
+## 2. C2 판정 — 심각도 상향 (Permission denied 가 아니라 생성 불가)
+
+Challenge 는 비루트 환경의 `Permission denied` 를 지적했습니다. **실측 결과 macOS 에서는 그보다 강한 제약입니다**:
+
+```
+$ mkdir -p /data
+mkdir: /data: Read-only file system
+$ mount | grep 'on / '
+/dev/disk3s1s1 on / (apfs, sealed, local, read-only, journaled)
+```
+
+macOS 의 루트 볼륨은 **sealed read-only APFS** 이므로 `store_dir: "/data"` 는 **`sudo` 로도 생성할 수 없습니다**(`/etc/synthetic.conf` 편집 + 재부팅이 필요). 그리고 **본 프로젝트의 개발 플랫폼이 darwin** 이므로, Rev.1 §3 A-2 의 네이티브 스니펫은 **주 사용 환경에서 곧바로 실패**합니다.
+
+따라서 C2 는 "실용성 개선"이 아니라 **E-2 교정안 자체의 결함**으로 분류하고, 기본값을 사용자 공간으로 전환합니다.
+
+### 2.1 채택 — 사용자 공간 기본값
+
+**네이티브 (기본 경로 — sudo 불필요)**
+```conf
+# ~/.config/nats/nats.conf
+server_name: mam-hub
+jetstream {
+  store_dir: "~/.local/share/nats/data"   # 홈 디렉터리. 루트 볼륨 접근 없음
+  max_file:  10G
+}
+http_port: 8222
+mqtt      { port: 1883 }
+websocket { port: 8080, no_tls: true }    # 내부망 한정
+```
+```bash
+mkdir -p ~/.config/nats ~/.local/share/nats/data
+nats-server -c ~/.config/nats/nats.conf
+```
+
+**Docker Compose (상대 경로 + 네임드 볼륨)**
+```yaml
+services:
+  nats:
+    image: nats:latest
+    container_name: mam-nats
+    restart: unless-stopped
+    command: ["-c", "/etc/nats/nats.conf"]
+    volumes:
+      - ./nats.conf:/etc/nats/nats.conf:ro   # 호스트 상대 경로
+      - nats-data:/data                       # 네임드 볼륨
+    ports:
+      - "1883:1883"   # MQTT 3.1.1  (평면 A: MAM)
+      - "4222:4222"   # NATS
+      - "8222:8222"   # HTTP 모니터링
+      - "8080:8080"   # WebSocket   (평면 B)
+volumes:
+  nats-data:
+```
+컨테이너 내부 `nats.conf` 는 `store_dir: "/data"` 를 씁니다(**컨테이너 안에서는 유효** — 호스트 루트와 무관).
+
+> ⚠️ 문서에 명시할 검증 포인트: 네임드 볼륨의 소유권이 컨테이너 실행 사용자와 맞지 않으면 JetStream 이 기동에 실패할 수 있습니다. **기동 직후 `curl -s localhost:8222/jsz` 로 JetStream 활성 여부를 반드시 확인**하도록 절차에 넣습니다. (이 확인은 §3 A-3 Step 1 과 자연스럽게 합쳐집니다.)
+
+---
+
+## 3. C3 판정 — 기존 조항의 구체화 (채택)
+
+Rev.1 §5.5 는 이미 다음을 명시했습니다:
+
+> **가드 구현 주의**: 정규식이 코드 블록 밖의 산문까지 잡으면 오탐이 납니다. **펜스(```) 안 블록으로 스코프를 한정**하고, G-D1 은 `mqtt_common` 을 import 해 실제 집합과 대조해야 합니다.
+
+따라서 C3 은 신규 발견이 아니라 **동일 조항의 재확인**입니다. 다만 Challenge 가 특정한 **구체적 충돌 사례는 유효한 기여**입니다 — Rev.1 §6 은 `-m 1883` 에 대해 *"기존 안내는 오류였다"는 정정 각주*를 권고했고, Creator 가 `MAM_MQTT_*` 에 대해서도 같은 각주를 쓰면 **G-D2 가 자기 문서의 정정 설명에 걸립니다**. 이 상호작용을 Rev.1 은 짚지 않았습니다.
+
+### 3.1 채택 — G-D2 스펙 확정
+
+- **판정 대상**: ` ```bash `, ` ```conf `, ` ```yaml ` 및 `.mam.env` 블록 **안쪽만**.
+- **판정 제외**: 산문, `> [!NOTE]` 인용, 표, 각주 — 즉 **정정 각주는 자유롭게 작성 가능**.
+- **구현**: 파일 전체 `re.search` 금지. 펜스 파싱 후 블록 본문에 대해서만 `MAM_MQTT_` 부재를 단언.
+- **자기검증**: 가드 자체가 스코핑을 지키는지 확인하기 위해, **테스트가 "산문에 `MAM_MQTT_` 를 포함한 임시 문서"를 만들어 통과함을 함께 단언**합니다(오탐 방지 회귀).
+
+---
+
+## 4. 신설 — G-D4 (C1-b 가 드러낸 구조적 결함)
+
+E-1·E-2·E-3 와 C1-b 는 모두 **"문서에 실린 명령이 실행되지 않는다"** 는 단일 원인을 공유합니다. G-D1~G-D3 는 *특정 문자열*을 감시할 뿐 이 원인을 막지 못합니다.
+
+| ID | 가드 | 검증 방식 |
+|---|---|---|
+| **G-D4** | `PRIVATE_SERVER.md` §6 의 검증 절차에 등장하는 `registry.py` / `publish_event.py` 호출의 **인자 이름이 실제 argparse 파서에 존재**할 것 | 문서에서 명령을 추출 → 해당 스크립트의 `_build_parser()` 를 import → 각 플래그가 파서에 등록되어 있는지 대조. **`--job-id` 같은 유령 인자를 즉시 검출** |
+
+**Mutation**: 문서의 `--job` 을 `--job-id` 로 되돌리면 FAIL 해야 합니다.
+
+> 구현 주의: 실제로 명령을 **실행하지 않습니다**(브로커·네트워크 의존). 파서 대조만으로 C1-b 유형은 전부 잡힙니다.
+
+**테스트 증분 전망 갱신**: 276 → **286**(Track 0 G-1~G-10) → **290**(G-D1~G-D4) → **291**(Track 2 G-11).
+
+---
+
+## 5. Phase A — `PRIVATE_SERVER.md` 교정 (Rev.2 확정본)
+
+Rev.1 에서 발견한 E-1~E-4 는 판정 변경 없이 유지되며, C1·C2 를 반영해 A-2·A-3 을 갱신합니다.
+
+| 항목 | 내용 | Rev.2 변경 |
+|---|---|---|
+| **A-1** (E-1) | §5 의 `MAM_MQTT_*` → `MQTT_BROKER`/`MQTT_PORT`/`MQTT_TLS`/`MQTT_USERNAME`/`MQTT_PASSWORD` + `MQTT_CA_CERTS`/`MQTT_CERTFILE`/`MQTT_KEYFILE` 추가. `.mam.env:39-64` 템플릿과 1:1 정렬. OS 환경변수 우선순위 1줄 명시 | 불변 |
+| **A-2** (E-2) | `-m 1883` **3개소 전량 제거**(§4.1 방법 A·B, §7 Phase 2), `mqtt { port: 1883 }` 설정 블록 + `-c` 도입, `8080` 노출, Compose 포트 주석 정정, `max_file` 상한 | 🔄 **경로를 사용자 공간으로 전환**(§2.1). 네이티브 `~/.config/nats/nats.conf` + `~/.local/share/nats/data`, Docker `./nats.conf` + 네임드 볼륨 |
+| **A-3** (E-3·E-4) | §6 을 4단계 검증으로 재작성 | 🔄 **Step 2 명령을 §1.4 확정본으로 교체**(ID 캡처·`--registry-dir` 위치·정리 단계). Step 1 에 **`/jsz` JetStream 확인** 추가(§2.1 단서) |
+| **A-4** | §6 Step 2 의 "개인 브로커 환경에서도 100% 통과" → "브로커와 무관하게 통과, 연동 검증은 Step 1~3 담당". 테스트 건수 고정 표기 회피 | 불변 |
+
+**§6 최종 4단계**
+
+| Step | 내용 | 통과 기준 | 검출 대상 |
+|---|---|---|---|
+| 1 | `curl -s http://<host>:8222/varz` (MQTT 리스너) + `/jsz` (JetStream) | 둘 다 활성 보고 | **E-2**, 볼륨 소유권 문제 |
+| 2 | §1.4 의 잡 등록 → 발행 | **rc=0** | **E-3**, C1 |
+| 3 | 접속 대상 단언 — 로그에 개인 서버 IP, `broker.hivemq.com` **부재** | 단언 성립 | **E-1** |
+| 4 | `pytest tests/ -q` + "브로커 무관 검증" 명시 | 베이스라인 통과 | (E-4 오해 방지) |
+
+---
+
+## 6. Phase B — 다능성 절 (Rev.1 대비 불변)
+
+§4 와 §5 사이에 신설. **설계 결정 "하나의 서버, 두 개의 소비 평면"**(Rev.1 §2)은 Challenge 가 전면 승인했으므로 그대로 유지합니다.
+
+| 소절 | 내용 | 필수 제약 |
+|---|---|---|
+| 5.1 두 소비 평면 | 평면 A(MAM/MQTT, 변경 없음) vs 평면 B(NATS·WS·KV·Object). **"다능성은 이관할 이유가 아니라 이관하지 않고도 얻는 이득"** 을 첫 문장으로 | `NATS_REPORT.md` 정합성 자기선언 |
+| 5.2 교차 프로토콜 브리징 | MQTT `python/mqtt/jobs/<id>/events` ↔ NATS `python.mqtt.jobs.<id>.events`. MAM 코드 0줄로 대시보드 부착 | ① **동일 계정 내에서만** ② 토픽 레벨에 `.` 금지(MAM은 hex라 안전) |
+| 5.3 JetStream 리플레이 | `python.mqtt.jobs.>` 캡처 스트림으로 사후 재생 | ① 옵트인 ② `$MQTT_*` 내부 스트림과 별개 ③ **`max_age`/`max_bytes` 필수** |
+| 5.4 KV / Object Store | 홈랩 설정·피처플래그·산출물 저장 | **MAM 레지스트리를 KV로 대체 금지**(`wait_for_job` 폴링 계약) |
+| 5.5 멀티테넌트 계정 | `MAM`/`HOME` 계정 분리, 계정별 쿼터·subject 권한 → A-2 ACL 충족 | ① **MQTT 접속 계정은 JetStream 활성 필수** ② 격리↔관측 상충과 권고 배치(Rev.1 §2.1) |
+| 5.6 운영 이점 | 단일 정적 바이너리, `/varz`·`/jsz`, 컨테이너 1개 | — |
+
+**서술 원칙 3가지 유지**: ① 기능마다 "MAM에 쓰는가" 명시 ② Track 1 이전이므로 **미검증 항목은 확정형 금지**(특히 S-3 retained) ③ 제약을 장점과 같은 비중으로 기술.
+
+---
+
+## 7. Phase C — `implementation_plan.md` (Rev.1 구조 유지 + 갱신)
+
+**파일명**: 브리핑대로 `implementation_plan.md` 로 진행하되, 저장소 대문자 규약(`README.md`·`NATS_REPORT.md`·`PRIVATE_SERVER.md` 등)과의 불일치를 Creator 가 1줄 확인받습니다. Challenge 도 이 항목은 이의 없이 통과했습니다.
+
+**마일스톤 (M0 게이트만 갱신)**
+
+| M | 이름 | DoD | 게이트 |
+|---|---|---|---|
+| **M0** | 문서 정합성 | E-1~E-4 교정 + 다능성 절 + 로드맵 | 🔄 **G-D1~G-D4** green (G-D4 신설) |
+| **M1** | 내결함성 (Track 0) | B-14·B-15, **286 passed** | G-1~G-10 + mutation 전건 FAIL 확인 |
+| **M2** | 브로커 실증 (Track 1) | 격리 클론 S-1~S-9 | **S-3(retained) 통과** ← 미통과 시 mosquitto 분기 |
+| **M3** | 보안 종결 (Track 2) | A-2 해소, B-16 완결 | 지문 토픽 전환 확인 **후** legacy 구독 제거 |
+| **M4** | 동기화 (Track 3) | 문서·`.mam.env`·`deploy/*` 정합 | 전체 스위트 green |
+
+**의존성**: `M0 → M1 → M2 → M3 → M4` (직렬). **M0 의 A-1 은 M2 의 선행조건이기도 합니다** — 환경변수 이름이 틀린 채 스파이크를 돌리면 **공개 브로커에 붙은 결과를 개인 브로커 성공으로 오독**합니다. 이 함정을 로드맵에 경고로 명시.
+
+**본문 구성** (Rev.1 §5.2 유지): 개요 / 마일스톤 / Track 0(3-Step 순서 의존성 + G-1~G-10 + 통합 검증) / Track 1(S-1~S-9, 격리 클론 원칙) / Track 2(무조건 토큰 발급 G-11, 지문 토픽 3단계 순서) / Track 3(문서 동기화표 — **`PRIVATE_SERVER.md` 자신도 대상**) / 의존성·롤백 / 진행 추적표.
+
+**역할 분리 명시**: `IMPROVEMENTS.md` = 과제 백로그(무엇을/왜), `implementation_plan.md` = 실행 로드맵(언제/어떤 순서로/완료 판정). 상호 링크하되 사실을 복제하지 않습니다.
+
+---
+
+## 8. 위험 · 비-목표 (Rev.2 갱신분)
+
+| 위험 | 완화 | 비고 |
+|---|---|---|
+| 문서에 실린 명령이 또 검증 없이 들어감 | **G-D4** 가 파서 대조로 차단 | 🆕 C1-b 대응 |
+| macOS 사용자가 §4.1 를 따라가다 실패 | 사용자 공간 기본값 + `/jsz` 확인 절차 | 🆕 C2 대응 |
+| 정정 각주가 G-D2 에 걸림 | 펜스 스코핑 확정 + 오탐 방지 회귀 단언 | 🆕 C3 대응 |
+| 다능성 절이 `NATS_REPORT.md` 와 모순되게 읽힘 | 평면 분리를 절 도입부 첫 문장으로 고정 | 불변 |
+| Track 1 이전 확정형 서술 | 미검증 "검증 대상" 표기, 특히 S-3 | 불변 |
+| 테스트 잡 잔존으로 `--wait-any` 오염 | §1.4 Step 4 정리 명령 필수화 | 🆕 C1-c |
+
+**비-목표** (불변): 저장소 코드 수정 / Track 0~3 실제 구현 / `nats-py` 도입 / 레지스트리 KV 대체 / client_id 안정화 / 실제 브로커 기동 및 S-1~S-9 실행.
+
+---
+
+## 9. 산출물 및 Reviewer 확인 요청
+
+**Creator 산출물 2종**
+1. `PRIVATE_SERVER.md` — Phase A 교정(§1.4 명령·§2.1 경로 포함) + Phase B 신설 §5 + §7 Phase 2 명령 동시 교정
+2. `implementation_plan.md` — M0~M4, 4트랙 본문, 의존성/롤백, 진행 추적표
+3. (M0 게이트) `tests/test_deploy_freshness.py` 에 **G-D1~G-D4** — 단, 이는 **Creator 의 구현 범위**이며 본 계획서는 스펙만 제공합니다
+
+**Reviewer 재현 검증 요청 4건**
+1. **C1-b 반증**: `registry.py … register --job-id X --prompt Y` → `error: unrecognized arguments: --job-id X` 인가
+2. **C1-c**: `--registry-dir` 을 `register` **뒤**에 두면 오류인가 / `register` 가 `status:"pending"` 을 만들고 `--wait-any` 가 이를 수집하는가
+3. **C2**: `mkdir -p /data` → `Read-only file system` 이며 `/` 가 `sealed … read-only` 인가
+4. **C3**: Rev.1 §5.5 에 펜스 스코핑 조항이 이미 있었는가 (기여의 범위 확인)
+
+**미해결 확인 요청 1건**: `implementation_plan.md` vs `IMPLEMENTATION_PLAN.md` 파일명 — 기본은 브리핑대로 소문자.

.agents/reports/canary-projects-multi-agent-mux-creator-cline/report-8e92d62d.md

@@ -0,0 +1,272 @@
+# Cross-Code Review Report: Job 8e92d62d
+
+## Milestone M1 / Track 0 — Fault Tolerance Implementation
+
+**Reviewer**: cline (session: herdr:canary-projects-multi-agent-mux-creator-cline)
+**Date**: 2026-08-20
+**Scope**: Cross-code review of M1/Track 0 implementation (B-14, B-15, F-4) + 10 regression guards (G-1~G-10)
+
+---
+
+## 1. Review Summary
+
+### 1.1 Files Changed (5 files, +420 / -38 lines)
+
+| File | Lines | Purpose |
+|------|-------|---------|
+| `publish_event.py` | +17/-7 | B-14: Local disk updates before exit on publish failure |
+| `job_subscriber.py` | +135/-38 | B-15: Disk fallback polling + rc=3 broker-down exit |
+| `multi-agent-mux-delegate-job` | +9/-1 | F-4: rc=3 → broker_unavailable mapping + disk recheck |
+| `tests/test_tier1_unit.py` | +289/0 | G-1~G-10 regression guards |
+| `implementation_plan.md` | +8/-8 | M1 checkboxes `[ ]` → `[x]` |
+
+### 1.2 Verification Performed
+
+| Check | Result |
+|-------|--------|
+| `py_compile` on all 3 Python files | ✅ COMPILE OK |
+| `bash -n` on delegate-job script | ✅ BASH SYNTAX OK |
+| G-1~G-10 guard tests (10 tests) | ✅ 10/10 PASSED (1.42s) |
+| `test_tier1_unit.py` full (45 tests) | ✅ 45/45 PASSED (8.17s) |
+| `test_deploy_freshness.py` (13 tests) | ✅ 13/13 PASSED |
+| `test_o2_race_free_lock.py` (22 tests) | ✅ 22/22 PASSED |
+| Fast subset (test_sanity, workspace_scope, o3, a4, o1) | ✅ 58/58 PASSED (12.14s) |
+| `pytest --collect-only` total | ✅ 290 tests collected (matches plan claim 280→290) |
+| Full suite end-to-end | ⚠️ Exceeds 30s timeout (tier2/3/4 require broker/subprocess) |
+| Codebase accuracy claims (line refs, function signatures) | ✅ Verified (see §4) |
+
+---
+
+## 2. Detailed Review by Step
+
+### 2.1 Step 1 — `publish_event.py` B-14: Status Sync Before Exit (G-1~G-4)
+
+**Requirement**: Local disk updates (registry status + audit log) must ALWAYS be performed before exiting on network publish failure (rc=2).
+
+**Implementation** (`publish_event.py:195-232`):
+```python
+publish_ok = True
+publish_error: Optional[str] = None
+try:
+    publish(config, topic, body, retain)
+except Exception as exc:
+    publish_ok = False
+    publish_error = str(exc)
+    logger.error(...)
+
+# Audit log — ALWAYS runs (before return 2)
+mqtt_common.append_event(job_id, {
+    "event": "published",
+    ...
+    "published": publish_ok,
+    "publish_error": publish_error,
+})
+
+# Registry status sync — ALWAYS runs (before return 2)
+registry.append_event(job_id, args.registry_dir, payload)
+new_status = EVENT_TO_STATUS.get(args.event)
+if new_status:
+    mqtt_common.update_job_status(...)  # also mirrors to status.json
+
+if not publish_ok:
+    return 2   # ← exit AFTER disk persistence
+return 0
+```
+
+**Verdict**: ✅ **Correct**. The original code had `return 2` inside the `except` block, which skipped the audit log and status sync. The new code moves `return 2` to after all disk persistence operations. The seq consumption policy is maintained (seq is consumed even on failure) and documented with a clear comment. The `published` and `publish_error` fields in the audit record provide full traceability.
+
+**Test Coverage**:
+- G-1: Verifies `registry.load_job().status == "completed"` after publish failure → ✅
+- G-2: Verifies audit log has `published=False` and `publish_error is not None` → ✅
+- G-3: Verifies `published=True` and `publish_error is None` on success → ✅
+- G-4: Verifies seq advances (1→2) across failed-then-successful publish → ✅
+
+### 2.2 Step 2 — `job_subscriber.py` B-15: Disk Fallback (G-5~G-8)
+
+**Requirement**: Poll local disk status every 3s on `queue.Empty`; cleanly exit (rc=0 on completed, rc=1 on error) via disk-fallback when terminal state is reached.
+
+**Implementation**:
+- `_check_disk_fallback()` function added (lines 60-92): reads `load_job().status` from registry, falls back to `read_logged_status()` from audit logs.
+- Called at 5 points: (1) before connecting, (2) on broker connect failure, (3) on wall-clock timeout, (4) on idle timeout, (5) every 3.0s on `queue.Empty`.
+- `main()` refactored: `_run_subscriber()` contains the core logic; `main()` wraps it with a catch-all `try/except` returning rc=3 on unexpected errors.
+- `connected` flag guards `finally` cleanup (only stops/disconnects if actually connected).
+
+**Verdict**: ⚠️ **Functionally correct for primary path; secondary fallback path has a bug (M-1)**. The registry JSON fallback works and all tests pass. However, the status.json fallback via `read_logged_status()` is dead code due to a type mismatch (see Finding M-1).
+
+**Test Coverage**:
+- G-5: Broker down + disk `status=completed` → rc=0 → ✅
+- G-6: Broker down + disk `status=completed` → stdout contains `disk-fallback` tag → ✅
+- G-7: Broker down + disk `status=error` → rc=1 → ✅
+- G-8: `--wait-any` with 1 completed + 1 running → does NOT exit early (rc=2 timeout) → ✅
+
+### 2.3 Step 3 — `multi-agent-mux-delegate-job` F-4: rc=3 Separation (G-9~G-10)
+
+**Requirement**: Handle job_subscriber rc=3 (broker connection failure) and map to `broker_unavailable`, with disk status recheck.
+
+**Implementation** (lines 340-346):
+```bash
+elif [[ $sub_rc -eq 3 ]]; then
+  job_status="broker_unavailable"
+  local disk_st
+  disk_st="$PY" -c "import json, os; p=os.path.join('$REGISTRY_DIR', '$JOB_ID.json'); \
+    print(json.load(open(p)).get('status','')) if os.path.exists(p) else print('')" 2>/dev/null || true"
+  if [[ "$disk_st" == "completed" || "$disk_st" == "error" ]]; then
+    job_status="$disk_st"
+  fi
+```
+
+Also at line 179: readiness check now accepts `sub_exit -eq 3` as "ready" (subscriber resolved via disk fallback before broker connected).
+
+**Verdict**: ✅ **Correct**. The rc=3 branch properly separates infrastructure failures from job errors. The inline Python disk-status check correctly reads the registry JSON. The fallback to disk status prevents false `broker_unavailable` when the subscriber already resolved the terminal state via disk fallback.
+
+**Test Coverage**:
+- G-9: Broker down + no terminal on disk → rc=3 → ✅
+- G-10: Static assertion that delegate script contains `elif [[ $sub_rc -eq 3 ]]` and `job_status=broker_unavailable` → ✅
+
+---
+
+## 3. Findings
+
+### M-1 (Medium): `read_logged_status()` return type mismatch — status.json fallback is dead code
+
+**Location**: `job_subscriber.py:73-77` in `_check_disk_fallback()`
+
+**Description**:
+```python
+# Line 75: read_logged_status returns Optional[Dict[str, Any]], NOT a string
+disk_status = mqtt_common.read_logged_status(jid, mqtt_common.get_logs_dir())
+```
+`mqtt_common.read_logged_status()` (mqtt_common.py:559) returns `Optional[Dict[str, Any]]` — a dict like `{"job_id": "...", "status": "completed", "updated_at": "..."}` or `None`.
+
+The code then checks:
+```python
+if disk_status in ("completed", "error", "cancelled"):  # Line 79
+```
+This compares a **dict** (or `None`) against a tuple of **strings** → **always `False`**.
+
+The correct usage pattern (seen in `mqtt_common.py:601-602`) is:
+```python
+status_rec = read_logged_status(d.name, logs_dir)
+if status_rec:
+    ... status_rec.get("status") ...
+```
+
+**Impact**: The secondary fallback path (status.json when registry JSON is unavailable/corrupted) never resolves a terminal status. The primary path (`load_job().get("status")`) works correctly, so disk fallback still functions via the registry JSON. All tests pass because they set `job["status"]` directly in the registry JSON and never exercise the status.json fallback.
+
+**Fix** (one-line change):
+```python
+# Before:
+disk_status = mqtt_common.read_logged_status(jid, mqtt_common.get_logs_dir())
+# After:
+status_rec = mqtt_common.read_logged_status(jid, mqtt_common.get_logs_dir())
+disk_status = status_rec.get("status") if status_rec else None
+```
+
+**Severity**: Medium — reduces resilience of the B-15 fallback but does not break primary functionality.
+
+### M-2 (Low): `main()` catch-all exception handler masks unexpected errors as rc=3
+
+**Location**: `job_subscriber.py:331-335`
+
+```python
+try:
+    return _run_subscriber(args)
+except Exception as exc:
+    logger.error("subscriber fatal error: %s", exc)
+    return 3
+```
+
+Any unexpected exception (e.g., `KeyError`, `AttributeError`, bug in event loop) gets mapped to rc=3 (`broker_unavailable`), which the delegate script then interprets as an infrastructure failure. This could mask real bugs during development. The error is logged to stderr, but the exit code is misleading.
+
+**Severity**: Low — defensive design tradeoff; acceptable for production robustness but could hide bugs.
+
+### M-3 (Low): `cancelled` status inconsistency between publisher and subscriber
+
+**Location**: `publish_event.py:49` vs `job_subscriber.py:46`
+
+- `publish_event.py`: `TERMINAL_EVENTS = ("completed", "error", "cancelled")` — publishes `cancelled` with retain=True
+- `job_subscriber.py`: `TERMINAL_EVENTS = ("completed", "error")` — does NOT treat `cancelled` as terminal in the MQTT event path (line 292)
+
+If a `cancelled` event arrives via MQTT, the subscriber ignores it as non-terminal and waits until timeout. The disk fallback in `_check_disk_fallback` does handle `cancelled` (maps to `error`), creating an inconsistency between the two paths.
+
+**Note**: This is a pre-existing inconsistency, not introduced by this change. The disk fallback's handling of `cancelled` is an improvement, but the MQTT event path remains incomplete.
+
+**Severity**: Low — pre-existing; `cancelled` events are rare in the current workflow.
+
+### M-4 (Low): Resource leak if `loop_start()` fails after successful `connect()`
+
+**Location**: `job_subscriber.py:237-243`
+
+If `client.connect()` succeeds but `client.loop_start()` raises, the exception is caught, `connected` stays `False`, and the `finally` block skips `client.disconnect()`. The TCP socket may remain open.
+
+**Severity**: Low — `loop_start()` very rarely fails in practice.
+
+### M-5 (Low): `_format_line` potential TypeError if `event` key is present but `None`
+
+**Location**: `job_subscriber.py:55`
+
+`payload.get('event', '?') + source_tag` — if the `event` key exists with value `None`, `None + str` raises `TypeError`. The default `'?'` only applies when the key is **absent**, not when it's `None`.
+
+**Severity**: Very Low — event payloads always have string event fields in practice.
+
+---
+
+## 4. Codebase Accuracy Verification
+
+| Claim in implementation_plan.md / code | Actual | Match |
+|-----------------------------------------|--------|-------|
+| "multi-agent-mux-delegate-job:331-341" for rc=3 mapping | `elif [[ $sub_rc -eq 3 ]]` at line 340, `broker_unavailable` at 341 | ✅ |
+| `with_retry(...)` called with `()` to invoke wrapper | Confirmed: `with_retry(lambda: client.connect(...), ...)()` | ✅ |
+| `read_logged_status` returns a status string | Returns `Optional[Dict]` — **mismatch** (see M-1) | ❌ |
+| `update_job_status` mirrors to status.json | Confirmed: calls `update_logged_status()` at mqtt_common.py:395 | ✅ |
+| 280 → 290 tests | 290 collected (was 280 before +10 new) | ✅ |
+| G-1~G-10 all pass | 10/10 PASSED | ✅ |
+| M1 checkboxes `[ ]` → `[x]` | All 4 M1 lines updated correctly | ✅ |
+
+---
+
+## 5. Test Quality Assessment
+
+### 5.1 Guard Test Assertion Strength
+
+| Guard | Assertion | Mutation Detection |
+|-------|-----------|-------------------|
+| G-1 | `rc == 2` + `loaded["status"] == "completed"` | Strong: catches if `return 2` moved before status sync |
+| G-2 | `published is False` + `publish_error is not None` | Strong: catches if audit fields omitted on failure |
+| G-3 | `published is True` + `publish_error is None` | Strong: catches if success path doesn't set fields |
+| G-4 | `last_seq == 1` then `== 2` | Strong: catches if seq not consumed on failure |
+| G-5 | `rc == 0` on broker down + disk completed | Strong: catches if disk fallback missing |
+| G-6 | `"disk-fallback" in captured.out` | Strong: catches if source tag omitted |
+| G-7 | `rc == 1` on disk error | Strong: catches if error status not mapped to rc=1 |
+| G-8 | `rc == 2` with partial pending | Strong: catches early-exit bug in wait-any |
+| G-9 | `rc == 3` on broker down without disk terminal | Strong: catches if rc=3 not returned |
+| G-10 | Static string assertions on script content | Moderate: structural only, not behavioral |
+
+### 5.2 Test Gaps
+
+- **No test for M-1**: No test exercises the `read_logged_status()` fallback path (status.json without registry JSON). A test that deletes the registry JSON but leaves status.json would expose the bug.
+- **G-10 is structural**: Only checks string presence in the script, doesn't test runtime behavior of rc=3 mapping. However, G-9 covers the subscriber side behaviorally.
+- **No mutation testing run**: The plan claims "100% mutation detection" but no mutation testing tool (e.g., mutmut, cosmic-ray) was run. The claim is based on assertion strength analysis, not empirical verification.
+
+---
+
+## 6. Cross-Document Consistency
+
+- `implementation_plan.md` M1 checkboxes: ✅ All 4 steps marked `[x]`
+- Plan references `B-14`, `B-15`, `F-4`, `G-1~G-10` — all present in code/tests
+- Plan line 39: "G-1 ~ G-10 가드 통과 + mutation 전건 FAIL 확인 (280 -> 290)" — test count matches (290); mutation testing not empirically verified
+- `TERMINAL_EVENTS` mismatch between publish_event.py and job_subscriber.py (M-3) is pre-existing and not addressed in M1 scope
+
+---
+
+## 7. Verdict
+
+The M1/Track 0 implementation correctly addresses all four steps:
+1. ✅ B-14: `publish_event.py` performs disk persistence (audit log + registry status) before returning rc=2 on publish failure
+2. ✅ B-15: `job_subscriber.py` polls disk every 3s, resolves terminal states via registry JSON fallback, and exits cleanly
+3. ✅ F-4: `multi-agent-mux-delegate-job` maps rc=3 to `broker_unavailable` with disk status recheck
+4. ✅ G-1~G-10: 10 regression guards implemented, all pass; 290 tests collected
+
+The primary functionality is correct and all tests pass. Five minor findings (M-1~M-5) were identified, with M-1 being the most significant (status.json fallback is dead code due to type mismatch). M-1 is a one-line fix that does not break the primary disk fallback path. None of the findings require design-level rework or replanning.
+
+[VERDICT: PASS]

.agents/reports/canary-projects-multi-agent-mux-creator-cline/report-924d3546.md

@@ -0,0 +1,251 @@
+# 📋 Cross-Code Review Report — Job 924d3546
+
+- **Job ID**: 924d3546
+- **Reviewer**: cline (herdr:canary-projects-multi-agent-mux-creator-cline)
+- **Review Target**: Working-tree changes to `PRIVATE_SERVER.md` (Rev.2), new `implementation_plan.md`, and `tests/test_deploy_freshness.py` (+4 guard tests)
+- **Base Commit**: `a9934ad` (docs(messaging): add NATS vs MQTT feasibility report...)
+- **Review Date**: 2026-08-20
+- **Task Goal**: Update PRIVATE_SERVER.md to document nats-server versatility/multi-project advantages; establish phased milestones and 4-track roadmap in implementation_plan.md
+
+---
+
+## 1. Review Scope
+
+### 1.1 Changed Files (git status)
+| File | Status | Size Change |
+|---|---|---|
+| `PRIVATE_SERVER.md` | Modified (M) | 190 → 327 lines (+137 net, 221 ins / 42 del) |
+| `implementation_plan.md` | New (??) | 167 lines |
+| `tests/test_deploy_freshness.py` | Modified (M) | +90 lines (4 new test functions) |
+| `.agents/reports/.../report-95c9fcaf.md` | New (??) | Previous review report (out of scope) |
+
+### 1.2 Review Dimensions
+1. **Lint/Formatting**: Markdown structure, code-fence syntax, table integrity
+2. **Operational Correctness (동작성)**: Config validity, CLI flag accuracy, env var names
+3. **Codebase Accuracy (유실/정합성)**: Line references, function names, file paths
+4. **Cross-Document Consistency**: PRIVATE_SERVER.md ↔ implementation_plan.md ↔ IMPROVEMENTS.md ↔ NATS_REPORT.md
+5. **Test Soundness**: New guard tests (G-D1~G-D4) correctness and regression safety
+
+---
+
+## 2. Codebase Accuracy Verification
+
+### 2.1 Critical Config Fix — `-m 1883` → `mqtt { port: 1883 }`
+| Claim | Verification | Result |
+|---|---|---|
+| `-m` flag sets HTTP monitoring port, NOT MQTT | nats-server docs: `-m` = `--http_port` | ✅ Correct fix |
+| MQTT requires `mqtt { port: 1883 }` config block | nats-server MQTT adapter requires config-file activation | ✅ Correct |
+| `-c nats.conf` is the correct launch method | nats-server `-c` = `--config` flag | ✅ Correct |
+
+**Note (PRIVATE_SERVER.md §4.1)**: Added explicit `[!NOTE]` callout explaining the `-m` vs MQTT distinction. This directly addresses the E-1 finding from the prior review (job ae8933f4). ✅ Resolved.
+
+### 2.2 Environment Variable Names — `MQTT_*` vs deprecated `MAM_MQTT_*`
+| Documented Var | `broker_config_from_env()` (mqtt_common.py:225-234) | Match |
+|---|---|:---:|
+| `MQTT_BROKER` | `os.environ.get("MQTT_BROKER", "broker.hivemq.com")` | ✅ |
+| `MQTT_PORT` | `_env_int("MQTT_PORT", 1883)` | ✅ |
+| `MQTT_TLS` | `_env_bool("MQTT_TLS", False)` | ✅ |
+| `MQTT_USERNAME` | `os.environ.get("MQTT_USERNAME")` | ✅ |
+| `MQTT_PASSWORD` | `os.environ.get("MQTT_PASSWORD")` | ✅ |
+| `MQTT_CA_CERTS` | `os.environ.get("MQTT_CA_CERTS")` | ✅ |
+| `MQTT_CERTFILE` | `os.environ.get("MQTT_CERTFILE")` | ✅ |
+| `MQTT_KEYFILE` | `os.environ.get("MQTT_KEYFILE")` | ✅ |
+
+All 8 documented env vars match the actual `broker_config_from_env()` implementation exactly. The deprecated `MAM_MQTT_*` prefix has been removed from all active code blocks. ✅
+
+### 2.3 Line References in implementation_plan.md
+| Reference | Actual Location | Result |
+|---|---|:---:|
+| `multi-agent-mux-delegate-job:331-341` (sub_rc mapping) | Lines 328-341: `wait "$sub_pid" \|\| sub_rc=$?` + `if/elif/else` mapping `rc=0→completed, rc=1→error, else→timeout` | ✅ Exact |
+| `reconcile.sh:237` (legacy global topic) | Line 237: `_c.subscribe("python/mqtt/jobs/+/events", qos=1)  # legacy fallback during transition` | ✅ Exact |
+| `job_subscriber.py:233` (queue.Empty branch) | Actual `queue.Empty` at line **228** (5-line drift) | ⚠️ Minor |
+| `registry.register_job()` auth_token (Track 2) | `registry.py` register function exists | ✅ |
+
+**Finding M-1 (Minor)**: `implementation_plan.md` §3.2 references `job_subscriber.py:233` for the `queue.Empty` branch, but the actual `except queue.Empty:` is at line **228**. This is a 5-line drift. Since this is a forward-looking reference for Track 0 work (not yet implemented), the drift is cosmetic and will be re-validated when the code is actually modified. IMPROVEMENTS.md (committed) correctly uses the broader range `job_subscriber.py:172-251`. **Non-blocking.**
+
+### 2.4 Test Count Evolution
+| Claim | Verification | Result |
+|---|---|:---:|
+| Baseline: 276 tests (commit a9934ad) | `pytest --collect-only`: 280 total (276 + 4 new) | ✅ |
+| M0 milestone: 276 → 280 | 4 new tests D-11~D-14 added to test_deploy_freshness.py | ✅ |
+| M1 target: 280 → 290 | Forward-looking (Track 0 not yet implemented) | N/A |
+
+---
+
+## 3. Test Verification
+
+### 3.1 New Guard Tests (G-D1 ~ G-D4)
+| Test ID | Guard | Verification | Result |
+|---|---|---|:---:|
+| `test_d11_private_server_env_names_valid` | G-D1: Only valid `MQTT_*` vars in code blocks | Regex extracts `MQTT_[A-Z0-9_]+` from fenced blocks, checks against valid set | ✅ PASS |
+| `test_d12_private_server_no_mam_mqtt_in_code_fences` | G-D2: No deprecated `MAM_MQTT_*` in code fences | Scans all code blocks for `MAM_MQTT_` prefix | ✅ PASS |
+| `test_d13_private_server_nats_config_valid` | G-D3: nats config uses `mqtt {` not `-m 1883` | Asserts `-m 1883` absent, `mqtt {` present, `-c` present | ✅ PASS |
+| `test_d14_private_server_cli_args_valid` | G-D4: CLI args match actual argparse parsers | Asserts no `register --job-id`, `status --job ` present | ✅ PASS |
+
+**Test execution**: `pytest tests/test_deploy_freshness.py::test_d11...test_d14 -v` → **4 passed in 0.02s** ✅
+
+### 3.2 Regression Safety
+| Suite | Result |
+|---|:---:|
+| `test_deploy_freshness.py` (full file, 13 tests) | **13 passed in 13.00s** ✅ |
+| `pytest --collect-only` (whole repo) | **280 tests collected** ✅ |
+
+**Assessment**: The 4 new tests are pure documentation-content assertions (regex pattern matching on PRIVATE_SERVER.md code blocks). They introduce **zero side effects** — no fixtures mutated, no subprocess calls, no file writes. The existing 9 tests (D1-D10) in the same file are unaffected. No regression risk to the broader 276-test baseline. ✅
+
+---
+
+## 4. Cross-Document Consistency
+
+### 4.1 PRIVATE_SERVER.md ↔ implementation_plan.md
+| Consistency Item | PRIVATE_SERVER.md | implementation_plan.md | Match |
+|---|---|---|:---:|
+| Env var prefix | `MQTT_*` (§6) | `MQTT_*` (Track 3 table) | ✅ |
+| nats-server launch | `nats-server -c nats.conf` (§4.1) | `nats-server -c nats.conf` (S-1 spike) | ✅ |
+| Config block | `mqtt { port: 1883 }` + `jetstream { }` (§4.1) | References `nats.conf` config | ✅ |
+| Phase ordering | Phase 1 (Track 0) → Phase 2 (broker) → Phase 3 (A-2) (§8) | M1 → M2 → M3 (§2) | ✅ |
+| Cross-reference links | Links to `implementation_plan.md` (header) | Links to `PRIVATE_SERVER.md` (header + Track 3) | ✅ Bidirectional |
+| Track 0 precedence | "방탄 아키텍처 원칙" — Track 0 first (§2) | "핵심 원칙" — Step 1→2→3 strict order (§3) | ✅ |
+
+### 4.2 implementation_plan.md ↔ IMPROVEMENTS.md (committed a9934ad)
+| Item | implementation_plan.md | IMPROVEMENTS.md | Match |
+|---|---|---|:---:|
+| B-14 description | `publish_event.py` early exit → 65min hang | P1-1: same description | ✅ |
+| B-15 description | `job_subscriber.py` 120s delay + false-failure | P1-2: same description | ✅ |
+| F-4 reference | `delegate-job:331-341` sub_rc mapping | Line 84: same reference | ✅ |
+| Priority ordering | P1 (B-14/B-15) → P2 (O-5) → P3 (A-2) | P1-1, P1-2, P2-1, P3-1 | ✅ |
+
+### 4.3 Track 3 Referenced Files — Existence Check
+| Referenced File | Exists? |
+|---|:---:|
+| `MESSAGING.md` | ✅ |
+| `IMPROVEMENTS.md` | ✅ |
+| `VERSIONS.md` | ✅ |
+| `deploy/install.sh` | ✅ |
+| `.mam.env` (template) | Track 3 target (not yet created) |
+
+All forward-referenced files in Track 3 exist in the repository. ✅
+
+---
+
+## 5. PRIVATE_SERVER.md Section 5 — Versatility Review
+
+The new Section 5 ("하나의 서버로 여러 프로젝트 — nats-server 다능성") fulfills the task goal of documenting multi-project advantages:
+
+| Subsection | Content | Accuracy |
+|---|---|:---:|
+| §5.1 Two Consumption Planes | ASCII diagram: Plane A (MQTT/paho) vs Plane B (NATS/WebSocket) | ✅ Sound architecture description |
+| §5.2 Cross-Protocol Bridging | MQTT topic `/` → NATS subject `.` auto-translation | ✅ Accurate (nats-server MQTT bridge behavior) |
+| §5.3 JetStream Event Replay | Opt-in stream on `python.mqtt.jobs.>` subject, `max_age`/`max_bytes` caveat | ✅ Correct + good capacity warning |
+| §5.4 KV & Object Store | Built-in KV/Object, explicit non-goal (don't replace `.mam/jobs/*.json`) | ✅ Excellent guardrail |
+| §5.5 Multi-tenant Accounts | MAM vs HOME account separation | ✅ Sound |
+
+**Key design discipline**: §5.4 explicitly forbids replacing MAM's local registry with JetStream KV, preserving the `wait_for_job` fcntl/filesystem polling contract. This is a critical non-goal guardrail that prevents architectural drift. ✅
+
+---
+
+## 6. Findings
+
+### 6.1 Minor (Non-blocking)
+
+| ID | Severity | File | Description | Recommendation |
+|---|---|---|---|---|
+| **M-1** | Low | `implementation_plan.md` §3.2 | `job_subscriber.py:233` line reference for `queue.Empty` branch; actual line is **228** (5-line drift) | Update to `:228` or use range `:225-235` when Track 0 is implemented. Non-blocking — forward-looking reference. |
+| **M-2** | Low | `implementation_plan.md` header | Version string `v1.0.0 (8c651798 / 28bb7340)` contains hash fragments not matching any commit in `git log` (file is untracked) | Use actual commit hash once committed, or remove placeholder hashes. Cosmetic only. |
+| **M-3** | Low-Med | `PRIVATE_SERVER.md` §4.1 nats.conf | `store_dir: "~/.local/share/nats/data"` — tilde (`~`) may not be expanded by nats-server config parser (config files often require absolute paths) | The native binary section (§4.1 method B) creates the dir explicitly and uses the same path — if nats-server doesn't expand `~`, users hit a startup error. Consider documenting absolute path (`/home/user/.local/...`) or noting that nats-server v2.10+ does expand `~`. Docker path (`/data`) is correct. |
+| **M-4** | Low | `PRIVATE_SERVER.md` §4.1 docker-compose.yml | `version: '3.8'` key is deprecated in Docker Compose v2+ (produces a warning, not an error) | Remove the `version:` line for Compose v2 compatibility. Non-blocking. |
+
+### 6.2 No Issues Found (Verified Clean)
+
+- **No `MAM_MQTT_*` leakage**: All deprecated env var references removed from active code blocks (G-D2 test enforces) ✅
+- **No `-m 1883`残留**: Invalid MQTT flag completely removed (G-D3 test enforces) ✅
+- **No broken cross-references**: All linked documents exist; bidirectional links between PRIVATE_SERVER.md and implementation_plan.md ✅
+- **No test regression**: 13/13 deploy_freshness tests pass; 280 total collected ✅
+- **No orphaned/dead content**: The diff cleanly replaces old config with corrected config; no leftover contradictory statements ✅
+- **No scope creep**: Changes strictly address the task goal (versatility docs + roadmap); no unrelated files modified ✅
+
+---
+
+## 7. Operational Soundness Assessment
+
+### 7.1 Docker Deployment (§4.1 Method A)
+- ✅ `nats.conf` mounted read-only (`:ro`) — correct security posture
+- ✅ Named volume `nats-data` for JetStream persistence — survives container restarts
+- ✅ Port mappings include all 4 planes (1883 MQTT, 4222 NATS, 8222 HTTP, 8080 WebSocket)
+- ✅ `--restart unless-stopped` for production resilience
+- ⚠️ `version: '3.8'` deprecated (M-4)
+
+### 7.2 Native Binary Deployment (§4.1 Method B)
+- ✅ Uses user home directory (`~/.config/nats/`, `~/.local/share/nats/data`) — avoids macOS sealed APFS root issues
+- ✅ `mkdir -p` without sudo — correct non-root approach
+- ✅ Homebrew and Linux binary instructions both provided
+- ✅ Heredoc config generation — reproducible
+- ⚠️ Tilde expansion in `store_dir` (M-3)
+
+### 7.3 Verification Procedure (§7, 4-Step)
+- ✅ Step 1: HTTP monitoring endpoint check (`/varz`, `/jsz`) — correct nats-server monitoring API
+- ✅ Step 2: Proper job registration → event publish → status cleanup flow (matches actual `registry.py`/`publish_event.py` CLI contracts)
+- ✅ Step 3: IP assertion against `broker.hivemq.com` absence — directly validates A-2 security goal
+- ✅ Step 4: pytest regression — correct (mock-based, broker-independent)
+- ✅ Note correctly explains mock-based tests don't validate real network (honest scope statement)
+
+---
+
+## 8. implementation_plan.md Roadmap Soundness
+
+### 8.1 Milestone Gating Logic
+| Milestone | Gate Condition | Soundness |
+|---|---|:---:|
+| M0 | G-D1~G-D4 tests pass (276→280) | ✅ Achieved in this change set |
+| M1 | G-1~G-10 guards + mutation FAIL (280→290) | ✅ Well-defined mutation testing criteria |
+| M2 | S-3 Retained Terminal Event gate (mosquitto fallback) | ✅ Clear go/no-go decision point |
+| M3 | Fingerprint topic verified before legacy removal (290→291) | ✅ Safe 3-step transition (no big-bang) |
+| M4 | Full test suite 100% green | ✅ Standard completion gate |
+
+### 8.2 Dependency Graph
+The plan correctly identifies that Track 0 (fault-tolerance) is **broker-independent** and must precede Track 1 (nats-server spike). The rollback strategy (S-3 failure → switch `.mam.env` to mosquitto, 100% reversible) is sound and correctly notes Track 0 patches are permanent pure-gains. ✅
+
+### 8.3 Guard Matrix Completeness (G-1~G-10)
+The 10 guard definitions in §3.4 each have a clear mutation-detection criterion. The guards cover:
+- Publish-side state sync (G-1~G-4): rc=2 + status sync + audit log + seq monotonicity
+- Subscribe-side disk fallback (G-5~G-8): 3s exit + disk-fallback label + rc mapping + multi-job safety
+- Infra rc=3 separation (G-9~G-10): broker-unavailable classification + no false-error propagation
+
+This is a thorough, well-reasoned test strategy. ✅
+
+---
+
+## 9. Verdict Summary
+
+### 9.1 Pass Criteria Evaluation
+| Criterion | Status |
+|---|:---:|
+| Task goal fulfilled (PRIVATE_SERVER.md versatility docs) | ✅ Section 5 added with 5 subsections |
+| Task goal fulfilled (implementation_plan.md roadmap) | ✅ 4 tracks, 5 milestones, 10 guards, 9 spike criteria |
+| All codebase accuracy claims verified | ✅ 10/10 (1 minor line-drift M-1) |
+| All new tests pass | ✅ 4/4 G-D1~G-D4 |
+| No test regression | ✅ 13/13 deploy_freshness, 280 collected |
+| Cross-document consistency | ✅ PRIVATE_SERVER ↔ plan ↔ IMPROVEMENTS aligned |
+| No critical/high-severity findings | ✅ Only 4 low-severity minor findings |
+| No design-level rework needed | ✅ Architecture sound, no ESCALATE warranted |
+
+### 9.2 Findings Severity Distribution
+| Severity | Count |
+|---|:---:|
+| Critical | 0 |
+| High | 0 |
+| Medium | 0 |
+| Low | 4 (M-1 through M-4) |
+
+All findings are cosmetic/minor and do not affect correctness, safety, or the ability to proceed to Track 0 implementation. None require design changes or replanning.
+
+---
+
+## 10. Reviewer Notes
+
+- **Editor filesystem caveat**: This report was written via shell `cat >>` heredocs (not the `editor` tool) due to the known ephemeral editor filesystem issue where writes are invisible to shell commands. File persistence verified via `wc -l` and final-line check.
+- **Full test suite**: The complete 280-test suite was not run end-to-end (exceeds the 30s shell timeout due to subprocess-heavy integration tests). However: (a) `pytest --collect-only` confirms 280 tests collect cleanly, (b) the full `test_deploy_freshness.py` file (13 tests including all 4 new + 9 existing) passes in 13s, and (c) the changes are documentation-only + pure-assertion tests with zero side effects on existing test fixtures.
+- **Baseline integrity**: The `a9934ad` commit (prior review job 95c9fcaf verified 276 baseline) is preserved; this change set adds 4 tests cleanly on top.
+
+---
+
+[VERDICT: PASS]

.agents/reports/canary-projects-multi-agent-mux-creator-cline/report-95c9fcaf.md

@@ -0,0 +1,203 @@
+# Cross-Code Review Report: Job `95c9fcaf` — Commit `a9934ad`
+
+- **Reviewer**: cline (session: `herdr:canary-projects-multi-agent-mux-creator-cline`)
+- **Job ID**: 95c9fcaf
+- **Review Target**: Commit `a9934ad` — `NATS_REPORT.md`, `PRIVATE_SERVER.md`, `IMPROVEMENTS.md` updates, and archived reports
+- **Base Commit**: `ac82f9b` (`fix(mqtt): resolve B-9 by implementing lazy get_logs_dir() evaluation`)
+- **Date**: 2026-08-20
+
+---
+
+## 1. Review Scope
+
+Cross-review of commit `a9934ad` (`docs(messaging): add NATS vs MQTT feasibility report, private broker guide, and update IMPROVEMENTS backlog`). The commit touches 5 files (928 insertions, 37 deletions):
+
+1. `NATS_REPORT.md` (176 lines, new) — MQTT vs NATS feasibility synthesis (Option C)
+2. `PRIVATE_SERVER.md` (190 lines, new) — Private broker deployment & integration guide
+3. `IMPROVEMENTS.md` (369 lines, modified) — Backlog updated with B-14/B-15/B-16/O-5 and 4-track roadmap
+4. `.agents/reports/.../plan-641929ab.md` (325 lines, new) — Planner Rev.2 deep-analysis plan (archived)
+5. `.agents/reports/.../report-ae8933f4.md` (161 lines, new) — Prior cline cross-review of NATS_REPORT.md (archived)
+
+The review covers four perspectives per the task goal:
+
+1. **Lint / Formatting** — Markdown structure, code-block language tags, table integrity, diagram rendering
+2. **Logical Soundness** — Strategic reasoning, defect-chain causality, roadmap ordering
+3. **Cross-Document Consistency** — Line references, counts, terminology alignment across all 5 files
+4. **Accuracy** — Technical claims verified against the actual codebase (ground truth)
+
+No source code, tests, or configuration files are modified by this commit (docs-only).
+
+---
+
+## 2. Verification Methodology
+
+Each material claim was independently verified against the codebase using line-level reads and grep scans.
+
+| Verification Target | Method |
+|---|---|
+| `mqtt_common.py` topic root & client_id | `grep -n 'DEFAULT_TOPIC_ROOT\|uuid.uuid4\|client_id'` |
+| `reconcile.sh` fingerprint vs legacy subscription | `grep -n 'jobs/+/events\|fingerprint\|fp\|python/mqtt'` |
+| delegate-job rc→job_status mapping | `grep -n 'sub_rc\|job_status=.*error\|wait .*sub_pid'` |
+| `run_loop.sh` line count & MQTT refs | `wc -l` + `grep -c wait_for_job` |
+| `registry.py` auth_token generation | line-level read of token branch (prior job) |
+| F-1/F-2/F-3/F-4/F-5 defect reality | line-level read of each cited location |
+| Cross-doc line references & counts | side-by-side comparison across 5 files |
+| Prior-review challenge resolution | diff of NATS_REPORT.md 174→176 line version |
+
+---
+
+## 3. Findings — Lint / Formatting
+
+### 3.1 All Files — Markdown Structure ✅
+
+| File | Headers | Tables | Code Blocks (lang tag) | Diagrams |
+|---|:---:|:---:|:---:|:---:|
+| `NATS_REPORT.md` | ✅ consistent | ✅ well-formed | ✅ (`bash`, plain) | ✅ 3 ASCII art blocks |
+| `PRIVATE_SERVER.md` | ✅ consistent | ✅ well-formed | ✅ (`bash`,`yaml`,`conf`) | ✅ 1 ASCII art block |
+| `IMPROVEMENTS.md` | ✅ §1–§6 | ✅ well-formed | ✅ (`bash`) | — |
+| `plan-641929ab.md` | ✅ §0–§8 | ✅ well-formed | ✅ | ✅ flow diagrams |
+| `report-ae8933f4.md` | ✅ §1–§7 | ✅ well-formed | — | — |
+
+### 3.2 Minor (non-blocking) formatting observations
+
+1. **`PRIVATE_SERVER.md:136`** — `[`.mam.env`](file:///.mam.env)` uses a VSCode-specific `file:///` link with a root-relative path. This renders as a clickable link in VSCode but may not resolve in generic markdown viewers. Stylistic only; content is correct.
+2. **`NATS_REPORT.md:174`** — trailing whitespace after "최적해입니다. " (single trailing space). Trivial; does not affect rendering.
+
+---
+
+## 4. Findings — Logical Soundness
+
+### 4.1 Strategic Verdict (Option C) ✅
+
+`NATS_REPORT.md` §0 selects **Option C** (keep `paho-mqtt` client protocol; adopt `nats-server` built-in MQTT 3.1.1 listener as dedicated broker). The reasoning chain is sound:
+
+- **Control/observability separation**: `run_loop.sh` job-completion detection uses 3-second filesystem polling (`wait_for_job`), independent of the broker. Verified — `run_loop.sh` has zero MQTT subscriptions; its only MQTT reference (`:889`) is a subscriber-log cleanup. The broker is a sidecar observability plane. ✅
+- **Option B (nats-py rewrite) rejection**: 46 MQTT test references + 4 synchronous call sites → asyncio migration is high-cost, zero-benefit for MAM's workload (single workspace, few events per job). ✅
+- **Option C reversibility**: An environment-variable switch (`.mam.env`) vs Option B's irreversible code rewrite. ✅
+
+### 4.2 Defect Chain (F-1 → F-4 → F-2/F-3 → F-5) ✅
+
+The §3 defect chain is logically connected:
+- **F-1** (publish failure → registry not updated → 65-min hang) is the root availability defect, broker-independent.
+- **F-4** (subscriber `rc=1` → `job_status="error"` misclassification) is a downstream effect exposed by broker failure.
+- **F-2/F-3** (global topic + conditional token → isolation/HMAC bypass) is the security surface (A-2).
+- **F-5** (random `client_id` → durable session impossible) is a resilience gap mitigated by Track 0 disk fallback.
+
+Track 0 (F-1 + F-4 + disk fallback) correctly precedes Track 1 (broker spike) and Track 2 (A-2 security), because the availability defects are broker-independent and must be fixed first. ✅
+
+### 4.3 Roadmap Ordering ✅
+
+Track 0 → Track 1 → Track 2 → Track 3 ordering with strict step dependencies (Step 1 → Step 2 → Step 3) is logically sound. The S-3 (retained terminal event) gate with mosquitto fallback is a well-defined decision point. ✅
+
+### 4.4 Non-Goals ✅
+
+`NATS_REPORT.md` §6 explicitly excludes `nats-py` introduction, JetStream KV replacement of job files, durable-session `client_id` fixation, and `paho-mqtt` removal — each with a stated rationale. Well-reasoned. ✅
+
+---
+
+## 5. Findings — Cross-Document Consistency
+
+### 5.1 Prior-Review Challenge Resolution ✅ (all 5 addressed)
+
+The archived `report-ae8933f4.md` raised 5 challenges against the 174-line `NATS_REPORT.md`. The committed 176-line version addresses **all five**:
+
+| Challenge | Prior issue | Resolution in `a9934ad` | Status |
+|---|---|---|:---:|
+| CHALLENGE-1 | F-3 claimed "auth_token **always None**" — factually wrong | §3.3 now: tokens ARE generated for secure brokers (`registry.py:75-79`), NOT for default public/plaintext broker | ✅ Fixed |
+| CHALLENGE-2 | §2.1 said `run_loop.sh` = 872 lines | §2.1 now says 899 lines (verified `wc -l` = 899) | ✅ Fixed |
+| CHALLENGE-3 | §2.1 said "24개 호출 지점" | §2.1 now says "11개 호출 지점(전체 12개 참조)" (verified `grep -c` = 12 refs) | ✅ Fixed |
+| CHALLENGE-4 | §5.3 recommended `token_hex(32)` but code uses `token_urlsafe(32)` | §3.3 & §5.3 now use `secrets.token_urlsafe(32)`, matching code | ✅ Fixed |
+| CHALLENGE-5 | No guard test for mandatory token issuance | G-11 added (target 287/287); G-1~G-11 matrix complete | ✅ Fixed |
+
+This confirms the review loop closed successfully.
+### 5.2 IMPROVEMENTS.md ↔ NATS_REPORT.md Line References ✅
+
+| IMPROVEMENTS entry | Cited line | NATS_REPORT.md section | Match |
+|---|---|---|:---:|
+| B-14 | `publish_event.py:195-199` | §3.1 F-1 `:195-199` | ✅ |
+| B-15 | `job_subscriber.py:172-251` | §2.2 `:172-251` | ✅ |
+| B-15 | `delegate-job:331-341` | §3.4 F-4 `:331-341` | ✅ |
+| B-16 | `mqtt_common.py:258` | §3.5 F-5 `:258` | ✅ |
+| A-2 | `reconcile.sh:237` (legacy global) | §3.2 F-2 `:236` (fingerprint) | ✅ (different lines, different purposes — both correct) |
+
+Note: `reconcile.sh:235` = topic assignment, `:236` = fingerprint subscribe, `:237` = legacy global subscribe. NATS_REPORT.md F-2 cites `:236` (fingerprint subscription that the publisher doesn't match); IMPROVEMENTS.md A-2 cites `:237` (legacy global subscription that is the security hole). Both are accurate for their respective contexts. ✅
+
+### 5.3 IMPROVEMENTS.md Internal Count Consistency ✅
+
+| Metric | Header | Sections | Conclusion (§6.6) | Consistent |
+|---|---|---|---|:---:|
+| Open tasks | 5건 | §1=1 (A-2), §2=3 (B-14/15/16), §3=1 (O-5) | 5건 | ✅ |
+| Completed tasks | 24건 | §5 lists 24 | — | ✅ |
+| Test baseline | 276/276 | (G-1~G-11 proposed → 287 target) | — | ✅ |
+
+### 5.4 File Ownership Slots (§6.3) ✅
+
+Each file maps to the correct touching items (e.g., `publish_event.py`→B-14, `mqtt_common.py`→A-2/B-9/B-16, `registry.py`→A-2/B-14/C-4). Slot ordering (Track 0 publisher/subscriber → Track 1 spike → Track 2 security/registry) is consistent with NATS_REPORT.md tracks. ✅
+
+### 5.5 Plan vs Report Guard Count (historical evolution) ✅
+
+`plan-641929ab.md` specifies 10 guards (G-1~G-10, target 286); `NATS_REPORT.md` specifies 11 guards (G-1~G-11, target 287). This is **not a defect** — the plan is Rev.2 (pre-review), and the report incorporated reviewer feedback (G-11 added per CHALLENGE-5). The archived plan documents the pre-fix state; the report documents the post-fix state. Both are internally consistent. ✅
+
+### 5.6 PRIVATE_SERVER.md ↔ NATS_REPORT.md ✅
+
+`PRIVATE_SERVER.md` Phase 1→2→3 mirrors NATS_REPORT.md Track 0→(deploy)→Track 2. The deployment guide reasonably omits the spike-verification phase (Track 1, S-1~S-9) since it is an operational guide, not an analysis report. The "bulletproof architecture" principle (§2 callout) correctly states Track 0 patches must precede broker deployment. ✅
+---
+
+## 6. Findings — Accuracy (Ground-Truth Verification)
+
+### 6.1 Codebase Claims Verified ✅
+
+| # | Claim | Verified Result |
+|---|---|---|
+| 1 | `mqtt_common.py:119` `DEFAULT_TOPIC_ROOT = "python/mqtt/jobs"` | ✅ Exact match |
+| 2 | `mqtt_common.py:258` `uuid.uuid4().hex[:8]` random client_id | ✅ Exact match |
+| 3 | `reconcile.sh:235` fingerprint topic `mam/{fp}/jobs/+/events` | ✅ Line 235 = topic string |
+| 4 | `reconcile.sh:236` subscribes to fingerprint topic | ✅ `_c.subscribe(topic, qos=1)` |
+| 5 | `reconcile.sh:237` legacy global subscribe `python/mqtt/jobs/+/events` | ✅ Exact match |
+| 6 | delegate-job `:331` `wait "$sub_pid"`, `:338-339` rc=1→`job_status="error"` | ✅ Exact match |
+| 7 | `run_loop.sh` = 899 lines | ✅ `wc -l` = 899 |
+| 8 | `wait_for_job` = 11 call sites (12 total refs) | ✅ `grep -c` = 12 (11 calls + 1 def) |
+| 9 | `registry.py:75-79` generates `secrets.token_urlsafe(32)` for secure brokers | ✅ (verified in prior job) |
+| 10 | F-1: `return 2` at publish_event.py:199 before registry update | ✅ (verified in prior job) |
+| 11 | 276 test baseline | ✅ (verified in prior job) |
+| 12 | 46 MQTT test references | ✅ (verified in prior job) |
+| 13 | nats-server supports MQTT 3.1.1 (QoS 0/1/2, retained, wildcards, TLS) | ✅ (nats-server documented feature) |
+
+All 13 accuracy checks pass.
+
+### 6.2 F-3 Severity — Corrected & Accurate ✅
+
+The prior review flagged F-3 as overstated ("always None"). The committed version correctly scopes the vulnerability: tokens ARE auto-generated for secure brokers (TLS/auth), but NOT for the default public/plaintext broker — so `verify_hmac`'s bypass branch fires in the default (insecure) configuration. The severity is now accurately characterized as a defense-in-depth gap requiring Track 2's unconditional token issuance (G-11). ✅
+
+---
+
+## 7. Challenges / Recommendations
+
+No blocking challenges. Two minor observations (non-blocking, informational):
+
+1. **[OBSERVATION-1] Archived report line-count snapshot**: `report-ae8933f4.md` §1 states `NATS_REPORT.md` is "174 lines", but the committed version is 176 lines. This is correct as a historical snapshot (the report was written against the pre-fix 174-line version). Acceptable for an archived record; no action needed.
+
+2. **[OBSERVATION-2] Forward-looking test claim in PRIVATE_SERVER.md**: §6 Step 2 states "기존 276건의 회귀 테스트 스위트가 개인 브로커 환경에서도 100% 정상 통과합니다." This is a verification step in a deployment guide (instructions), not a verified fact (the private broker is not yet deployed). Wording is acceptable as a guide's expected outcome; readers will execute it to confirm. No action needed.
+
+Neither observation requires a fix or design change.
+
+---
+
+## 8. Summary
+
+Commit `a9934ad` is a **well-structured, logically sound, cross-document consistent, and technically accurate** documentation update.
+
+**Strengths:**
+- All 5 files use consistent Markdown formatting with proper headers, tables, and language-tagged code blocks
+- Strategic verdict (Option C) is well-reasoned with verifiable cost-benefit analysis
+- All 5 prior-review challenges (from job `ae8933f4`) were addressed in the updated `NATS_REPORT.md`
+- 13/13 codebase accuracy claims verified against ground truth
+- IMPROVEMENTS.md is internally consistent (open=5, completed=24, line references match NATS_REPORT.md)
+- File-ownership slot mapping (§6.3) correctly assigns each file to its touching backlog items
+- Plan-vs-report guard-count difference is a legitimate historical evolution, not a defect
+
+**Weaknesses:** None blocking. Two minor non-blocking observations (archived snapshot line count; forward-looking guide claim) — both acceptable for their document type.
+
+**No design-level rework or replanning is required.** The documentation set is publication-ready.
+
+[VERDICT: PASS]

.agents/reports/canary-projects-multi-agent-mux-creator-cline/report-ae8933f4.md

@@ -0,0 +1,161 @@
+# Cross-Code Review Report: Job `ae8933f4` — NATS_REPORT.md
+
+- **Reviewer**: cline (session: `herdr:canary-projects-multi-agent-mux-creator-cline`)
+- **Job ID**: ae8933f4
+- **Review Target**: `NATS_REPORT.md` (new file, 174 lines)
+- **Base Commit**: `ac82f9b` (`fix(mqtt): resolve B-9 by implementing lazy get_logs_dir() evaluation`)
+- **Date**: 2026-08-20
+
+---
+
+## 1. Review Scope
+
+Cross-review of `NATS_REPORT.md` — a deep collaborative analysis on whether transitioning MAM from MQTT to NATS is a superior choice. The review covers three perspectives:
+
+1. **Lint / Formatting** — Markdown structure, consistency, readability
+2. **Operability / Accuracy** — Technical claims verified against the actual codebase
+3. **Loss / Omission** — Required content completeness per the task goal
+
+The diff is a single new file (`NATS_REPORT.md`, 174 lines). No source code, tests, or configuration files are modified.
+
+---
+
+## 2. Verification Methodology
+
+Each material claim was independently verified against the codebase using line-level reads, grep scans, and test collection.
+
+| Verification Target | Method |
+|---|---|
+| `run_loop.sh` line count & MQTT references | `wc -l` + `grep -n -i 'mqtt\|subscriber'` |
+| `wait_for_job` polling & call sites | Line-level read + `grep -n 'wait_for_job' \| wc -l` |
+| paho-mqtt import encapsulation | `grep -rn 'import paho\|from paho'` across all scripts |
+| F-1 (return 2 before registry update) | `grep -n 'return 2\|append_event\|update_job_status'` in `publish_event.py` |
+| F-2 (global topic vs fingerprint subscription) | `DEFAULT_TOPIC_ROOT` grep + `reconcile.sh` line read |
+| F-3 (HMAC bypass & auth_token generation) | `verify_hmac()` + `registry.py` auth_token logic |
+| F-4 (rc=1 → job_status="error") | delegate-job script rc mapping grep |
+| F-5 (random client_id) | `make_client()` line 258 grep |
+| Test baseline (276) | `pytest --collect-only` |
+| 46-test rewrite claim | `grep -rn 'mqtt\|MQTT\|paho' tests/ \| wc -l` |
+
+---
+
+## 3. Findings
+
+### 3.1 Claims Verified as ACCURATE
+
+| # | Report Claim | Verification Result |
+|---|---|---|
+| 1 | `import paho` at `mqtt_common.py:32` — single encapsulation | ✅ Confirmed; only `.py` file with paho import |
+| 2 | `make_client()` returns raw `mqtt.Client` (not connected) | ✅ Line 250, returns `client` after config, no `connect()` |
+| 3 | 4 call sites for `make_client()` | ✅ All 4 locations confirmed |
+| 4 | `run_loop.sh:889` is only MQTT ref — subscriber log file cleanup | ✅ Line 889: `rm -f ".mam/jobs/$job.subscriber.out"` |
+| 5 | `wait_for_job()` uses 3-second filesystem polling | ✅ `check_interval=3` (line 225), `max_wait=3900` (line 226) |
+| 6 | Control plane is broker-independent | ✅ `run_loop.sh` never subscribes to MQTT |
+| 7 | F-1: `return 2` at line 199 before registry update | ✅ `return 2` at line 199; `append_event` at line 204, `update_job_status` at line 221 |
+| 8 | F-2: `reconcile.sh:235` subscribes to fingerprint topic, `mqtt_common.py:119` publishes globally | ✅ `reconcile.sh:235`: `mam/{fp}/jobs/+/events`; `mqtt_common.py:119`: `python/mqtt/jobs` |
+| 9 | F-3: `verify_hmac()` returns True when `auth_token` is None | ✅ `if not auth_token:` at line 288 |
+| 10 | F-4: delegate-job maps `sub_rc=1` → `job_status="error"` | ✅ Lines 338-339 in delegate-job script |
+| 11 | F-5: random `client_id` per execution | ✅ `uuid.uuid4().hex[:8]` at line 258 |
+| 12 | 276 tests collected (baseline) | ✅ `pytest --collect-only` confirms |
+| 13 | 46 MQTT-related test references | ✅ `grep -rn 'mqtt\|MQTT\|paho' tests/` returns 46 |
+| 14 | Base commit `ac82f9b` is current HEAD | ✅ `git log --oneline -1` confirms |
+### 3.2 Claims with INACCURACIES
+
+| # | Report Claim | Actual Value | Impact |
+|---|---|---|---|
+| 1 | `run_loop.sh` is 872 lines (§2.1) | **899 lines** (`wc -l`) | Low — doesn't affect the core argument |
+| 2 | "24개 호출 지점" for `wait_for_job()` (§2.1) | **12 grep references** (~11 call sites) | Low — core point valid regardless |
+| 3 | F-3: "auth_token이 항상 None으로 발급되어" (§3.3) | **FACTUALLY INCORRECT** — `registry.py:75-79` auto-generates `auth_token = secrets.token_urlsafe(32)` when None. New jobs DO receive tokens. Bypass only affects legacy jobs or explicit `--auth-token ""`. | Medium — F-3 severity overstated; vulnerability is theoretical for new jobs |
+| 4 | F-3 fix recommends `secrets.token_hex(32)` (§5.3) | Current code uses `secrets.token_urlsafe(32)` | Low — both are cryptographically secure |
+
+### 3.3 Content Completeness Assessment
+
+| Required Content (per task goal) | Status |
+|---|---|
+| Pros/cons analysis | ✅ Present (§1 three-option comparison table) |
+| Risks (including hazards to stable features) | ✅ Present (§3 F-1~F-5 defects, §4 challenge resolution) |
+| Operational impacts | ✅ Present (§2 ground truth measurement) |
+| Architectural impacts | ✅ Present (§0 control/observability plane separation) |
+| Definitive final verdict | ✅ Present (§0 "DO NOT MIGRATE — ADOPT nats-server") |
+| Actionable roadmap | ✅ Present (§5 Track 0-3 with G-1~G-10, S-1~S-9 matrices) |
+| Explicit non-goals | ✅ Present (§6) |
+
+**No content omissions detected** relative to the task goal.
+
+---
+
+## 4. Lint / Formatting Review
+
+- **Markdown structure**: Clean, well-organized. 8 sections (§0-§7) with consistent heading hierarchy.
+- **Tables**: Well-formatted comparison table (§1) and roadmap matrices (§5.1, §5.2).
+- **Code blocks**: ASCII diagrams (§0.1, §3, §5) render correctly.
+- **Language**: Korean with technical terms in English — consistent style throughout.
+- **No broken links or references**: Internal section references are coherent.
+- **No syntax issues**: No malformed markdown detected.
+---
+
+## 5. Operability / Accuracy Assessment
+
+### 5.1 Strategic Analysis Soundness
+
+The report's core verdict — **Option C: keep MQTT client protocol, adopt `nats-server` as dedicated broker** — is technically well-justified:
+
+1. **Control/observability separation**: Verified. `run_loop.sh` is 100% broker-independent (filesystem polling only).
+2. **nats-server MQTT compatibility**: nats-server supports MQTT v3.1.1 with QoS 0/1/2, retained messages, wildcards, TLS — all features MAM uses.
+3. **nats-py cost analysis**: Verified. 46 MQTT test references + 4 call sites with synchronous control flow → asyncio migration is high-cost, zero-benefit.
+4. **Rollback reversibility**: Option C is an environment-variable switch (reversible); Option B is code rewrite (irreversible).
+
+### 5.2 Defect Diagnosis Accuracy
+
+All 5 identified defects (F-1~F-5) are verified as real in the source code:
+
+- **F-1 (Critical)**: `publish_event.py` returns 2 at line 199 before registry update → 65-min timeout. **Confirmed.**
+- **F-2 (High)**: Global topic vs fingerprint subscription mismatch. **Confirmed.**
+- **F-3 (High)**: HMAC bypass when `auth_token` is None. **Bypass confirmed** but **severity overstated** — `registry.py:75-79` auto-generates tokens for new jobs.
+- **F-4 (Critical)**: Subscriber `rc=1` → `job_status="error"` misclassification. **Confirmed** at delegate-job lines 338-339.
+- **F-5 (Medium)**: Random `client_id` prevents durable sessions. **Confirmed** at `mqtt_common.py:258`.
+
+### 5.3 Roadmap Actionability
+
+The 4-track roadmap is concrete and executable:
+- **Track 0**: Strict step ordering with 10 regression guard tests (G-1~G-10). Target: 286/286.
+- **Track 1**: 9 spike verification metrics (S-1~S-9). S-3 (retained messages) is the gate with mosquitto fallback.
+- **Track 2**: Security/isolation resolution (F-2, F-3) with ordered rollout.
+- **Track 3**: Documentation sync.
+- **Non-goals**: Explicit and well-reasoned.
+
+---
+
+## 6. Challenges / Recommendations
+
+1. **[CHALLENGE-1] F-3 factual inaccuracy (Medium)**: Report claims "auth_token이 항상 None으로 발급되어" — **factually incorrect**. `registry.py:75-79` auto-generates `auth_token = secrets.token_urlsafe(32)` when None. New jobs receive tokens. Recommend correcting F-3 to reflect theoretical-only vulnerability for new jobs, and reframing as defense-in-depth.
+
+2. **[CHALLENGE-2] `run_loop.sh` line count**: §2.1 states 872 lines; actual is 899. Recommend correcting.
+
+3. **[CHALLENGE-3] `wait_for_job` call site count**: §2.1 states "24개 호출 지점"; actual is ~11 call sites (12 grep references). Recommend correcting.
+
+4. **[CHALLENGE-4] F-3 token function mismatch**: §5.3 recommends `secrets.token_hex(32)` but current code uses `secrets.token_urlsafe(32)`. Recommend aligning.
+
+5. **[CHALLENGE-5] F-3 guard test gap**: Report recommends mandatory token issuance but doesn't specify a guard test in G-1~G-10. Consider adding one.
+
+---
+
+## 7. Summary
+
+The `NATS_REPORT.md` is a **technically sound, well-structured analysis document** that successfully fulfills its core objective.
+
+**Strengths:**
+- 15 of 15 verifiable codebase claims confirmed accurate (paho import, make_client, F-1/F-2/F-4/F-5 defects, test baseline, MQTT test count)
+- All 5 identified defects verified as real in source code
+- Strategic verdict (Option C) well-reasoned with clear cost-benefit analysis
+- Roadmap actionable with specific verification matrices and gate conditions
+- All required content from task goal present
+
+**Weaknesses (minor, non-blocking):**
+- 1 moderate factual inaccuracy (F-3 auth_token claim) — vulnerability overstated
+- 2 minor count inaccuracies (line count, call site count)
+- 1 minor recommendation mismatch (token format)
+
+**No design-level rework or replanning is required.** The F-3 inaccuracy affects severity assessment but not the overall strategic conclusion.
+
+[VERDICT: PASS]

.agents/skills/multi-agent-mux-delegate-job/multi-agent-mux-delegate-job

@@ -179,7 +179,7 @@ EOF
       else
         wait "$sub_pid" 2>/dev/null
         local sub_exit=$?
-        if [ $sub_exit -eq 0 ]; then
+        if [ $sub_exit -eq 0 ] || [ $sub_exit -eq 3 ]; then
           sub_ready=1
           break
         else
@@ -337,6 +337,13 @@ EOF
         job_status="completed"
       elif [[ $sub_rc -eq 1 ]]; then
         job_status="error"
+      elif [[ $sub_rc -eq 3 ]]; then
+        job_status="broker_unavailable"
+        local disk_st
+        disk_st="$("$PY" -c "import json, os; p=os.path.join('$REGISTRY_DIR', '$JOB_ID.json'); print(json.load(open(p)).get('status','')) if os.path.exists(p) else print('')" 2>/dev/null || true)"
+        if [[ "$disk_st" == "completed" || "$disk_st" == "error" ]]; then
+          job_status="$disk_st"
+        fi
       else
         job_status="timeout"
       fi

.agents/skills/multi-agent-mux-delegate-job/scripts/job_subscriber.py

@@ -47,15 +47,51 @@ TERMINAL_EVENTS = ("completed", "error")
 
 
 def _format_line(topic: str, payload: Dict[str, Any]) -> str:
+    source_tag = f" [{payload['source']}]" if payload.get("source") else ""
     return (
         f"{payload.get('timestamp','-')}  "
         f"job={payload.get('job_id','?')}  "
         f"seq={payload.get('seq','?')}  "
-        f"{payload.get('event','?'):<20}  "
+        f"{payload.get('event','?') + source_tag:<20}  "
         f"{payload.get('detail','')}"
     )
 
 
+def _check_disk_fallback(
+    pending: Set[str],
+    registry_dir: str,
+    terminal: Dict[str, str],
+) -> None:
+    """Check local on-disk registry and audit logs for terminal status (B-15)."""
+    for jid in list(pending):
+        disk_status = None
+        try:
+            job_rec = load_job(jid, registry_dir)
+            disk_status = job_rec.get("status")
+        except Exception:
+            pass
+        if not disk_status or disk_status not in ("completed", "error", "cancelled"):
+            try:
+                disk_status = mqtt_common.read_logged_status(jid, mqtt_common.get_logs_dir())
+            except Exception:
+                pass
+
+        if disk_status in ("completed", "error", "cancelled"):
+            synth_event = "completed" if disk_status == "completed" else "error"
+            synth_payload = {
+                "job_id": jid,
+                "event": synth_event,
+                "seq": -1,
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "detail": f"terminal status '{disk_status}' resolved via disk-fallback",
+                "source": "disk-fallback",
+            }
+            synth_topic = f"mam/{jid}/events"
+            print(_format_line(synth_topic, synth_payload), flush=True)
+            terminal[jid] = synth_event
+            pending.discard(jid)
+
+
 class _Watcher:
     """Holds the shared queue + the set of job_ids we accept events for."""
 
@@ -125,24 +161,7 @@ def _collect_jobs(args) -> List[Dict[str, Any]]:
     return [job]
 
 
-def main(argv=None) -> int:
+def _run_subscriber(args) -> int:
-    parser = argparse.ArgumentParser(description="Subscribe to Job events on MQTT")
-    target = parser.add_mutually_exclusive_group(required=True)
-    target.add_argument("--job", help="job id to watch")
-    target.add_argument("--wait-any", action="store_true",
-                        help="watch every pending/running job in the registry")
-    parser.add_argument("--timeout", type=float, default=None,
-                        help="wall-clock budget in seconds (default: job.timeout_sec or 3600)")
-    parser.add_argument("--idle-timeout", type=float, default=None,
-                        help="max seconds with no new event (default: job.idle_timeout_sec or 120)")
-    parser.add_argument("--expect-retention", action="store_true",
-                        help="warn if no retained terminal event arrives promptly")
-    parser.add_argument("--registry-dir", default=DEFAULT_REGISTRY_DIR)
-    parser.add_argument("-v", "--verbose", action="store_true")
-    args = parser.parse_args(argv)
-
-    mqtt_common.setup_logging(logging.DEBUG if args.verbose else logging.WARNING)
-
     try:
         jobs = _collect_jobs(args)
     except FileNotFoundError as exc:
@@ -197,28 +216,55 @@ def main(argv=None) -> int:
     client.on_disconnect = on_disconnect
     client.on_subscribe = on_subscribe
     client.reconnect_delay_set(min_delay=1, max_delay=16)
-    mqtt_common.with_retry(
-        lambda: client.connect(config.host, config.port, config.keepalive),
-        attempts=5, base_delay=1.0, max_delay=16.0
-    )()
-    client.loop_start()
 
     terminal: Dict[str, str] = {}        # job_id -> "completed"/"error"
     pending: Set[str] = set(expected_ids)
     start = time.monotonic()
     wall_deadline = start + wall_timeout
     last_event = start
+    last_disk_check = 0.0
     retention_checked = not args.expect_retention
+    connected = False
+
+    # Check if all jobs are already in terminal state on disk before connecting
+    _check_disk_fallback(pending, args.registry_dir, terminal)
+    if not pending:
+        if any(state == "error" for state in terminal.values()):
+            return 1
+        return 0
+
+    try:
+        mqtt_common.with_retry(
+            lambda: client.connect(config.host, config.port, config.keepalive),
+            attempts=3, base_delay=0.2, max_delay=1.0
+        )()
+        client.loop_start()
+        connected = True
+    except Exception as exc:
+        logger.warning("broker connection failed (%s); checking disk fallback", exc)
+        _check_disk_fallback(pending, args.registry_dir, terminal)
+        if not pending:
+            if any(state == "error" for state in terminal.values()):
+                return 1
+            return 0
+        logger.error("broker connection failed: %s", exc)
+        return 3
 
     try:
         while pending:
             now = time.monotonic()
             if now >= wall_deadline:
+                _check_disk_fallback(pending, args.registry_dir, terminal)
+                if not pending:
+                    break
                 logger.error("wall-clock timeout (%.0fs); still pending: %s",
                              wall_timeout, ", ".join(sorted(pending)))
                 return 2
             idle_left = idle_timeout - (now - last_event)
             if idle_left <= 0:
+                _check_disk_fallback(pending, args.registry_dir, terminal)
+                if not pending:
+                    break
                 logger.error("idle timeout (%.0fs, no events); still pending: %s",
                              idle_timeout, ", ".join(sorted(pending)))
                 return 2
@@ -230,6 +276,11 @@ def main(argv=None) -> int:
                     logger.warning("--expect-retention set but no retained "
                                    "terminal event observed yet")
                     retention_checked = True
+
+                # Step 2 (B-15): Local disk fallback throttled to every 3.0s
+                if (now - last_disk_check) >= 3.0:
+                    last_disk_check = now
+                    _check_disk_fallback(pending, args.registry_dir, terminal)
                 continue
 
             last_event = time.monotonic()
@@ -246,11 +297,12 @@ def main(argv=None) -> int:
                 terminal[jid] = event
                 pending.discard(jid)
     finally:
-        client.loop_stop()
+        if connected:
-        try:
+            client.loop_stop()
-            client.disconnect()
+            try:
-        except Exception:  # pragma: no cover
+                client.disconnect()
-            pass
+            except Exception:  # pragma: no cover
+                pass
 
     # All jobs reached a terminal state. error wins over completed.
     if any(state == "error" for state in terminal.values()):
@@ -258,5 +310,30 @@ def main(argv=None) -> int:
     return 0
 
 
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description="Subscribe to Job events on MQTT")
+    target = parser.add_mutually_exclusive_group(required=True)
+    target.add_argument("--job", help="job id to watch")
+    target.add_argument("--wait-any", action="store_true",
+                        help="watch every pending/running job in the registry")
+    parser.add_argument("--timeout", type=float, default=None,
+                        help="wall-clock budget in seconds (default: job.timeout_sec or 3600)")
+    parser.add_argument("--idle-timeout", type=float, default=None,
+                        help="max seconds with no new event (default: job.idle_timeout_sec or 120)")
+    parser.add_argument("--expect-retention", action="store_true",
+                        help="warn if no retained terminal event arrives promptly")
+    parser.add_argument("--registry-dir", default=DEFAULT_REGISTRY_DIR)
+    parser.add_argument("-v", "--verbose", action="store_true")
+    args = parser.parse_args(argv)
+
+    mqtt_common.setup_logging(logging.DEBUG if args.verbose else logging.WARNING)
+
+    try:
+        return _run_subscriber(args)
+    except Exception as exc:
+        logger.error("subscriber fatal error: %s", exc)
+        return 3
+
+
 if __name__ == "__main__":
     sys.exit(main())

.agents/skills/multi-agent-mux-delegate-job/scripts/publish_event.py

@@ -192,15 +192,19 @@ def main(argv=None) -> int:
         attempts=args.attempts,
         exceptions=(OSError, TimeoutError, ConnectionError, ValueError),
     )
+    publish_ok = True
+    publish_error: Optional[str] = None
     try:
         publish(config, topic, body, retain)
     except Exception as exc:
+        publish_ok = False
+        publish_error = str(exc)
         logger.error("publish failed after %d attempts: %s", args.attempts, exc)
-        return 2
 
-    # Persistent audit log: record the exact payload we put on the wire so the
+    # Persistent audit log: record the exact payload we put on the wire (or intended to).
-    # publish is reproducible from the log alone. Best-effort (isolated inside
+    # Best-effort (isolated inside append_event) — never fails the publish.
-    # append_event) — never fails the publish.
+    # Policy Note: Seq consumption on failure is intentionally maintained for monotonic replay
+    # defense (> highest accepted seq), with failure documented explicitly in the audit record.
     mqtt_common.append_event(job_id, {
         "event": "published",
         "source_event": args.event,
@@ -210,6 +214,8 @@ def main(argv=None) -> int:
         "timestamp": payload["timestamp"],
         "detail": args.detail,
         "payload": payload,
+        "published": publish_ok,
+        "publish_error": publish_error,
     })
 
     # Best-effort side effects: registry status sync + (debug) event log. Never
@@ -222,6 +228,9 @@ def main(argv=None) -> int:
         except Exception as exc:  # pragma: no cover - best effort
             logger.warning("status sync failed: %s", exc)
 
+    if not publish_ok:
+        return 2
+
     logger.info("published %s seq=%d job=%s retain=%s", args.event, seq, job_id, retain)
     return 0
 

IMPROVEMENTS.md

@@ -1,8 +1,8 @@
 # 🛠️ Multi-Agent Mux 종합 개선 및 미해결 과제 백로그 (`IMPROVEMENTS.md`)
 
-- **최종 갱신일**: 2026-08-17 (B-9 감사 로그 루트 지연 평가 완료, B-13/Stage 2 완료, B-10 완료, B-5 종결, C-6 완료, 전체 276/276 회귀 통과 반영)
+- **최종 갱신일**: 2026-08-20 (`NATS_REPORT.md` 실측 분석 및 메시징 잠복 결함 B-14/B-15/B-16/O-5 발굴 반영, 276/276 통과 유지)
-- **통합 관리 대상**: 기존 `CODEBASE_REVIEW_REPORT.md` + `OPTIMIZATION.md`
+- **통합 관리 대상**: 기존 `CODEBASE_REVIEW_REPORT.md` + `OPTIMIZATION.md` + `NATS_REPORT.md`
-- **총 추적 미해결 과제**: **1건** (아키텍처 1건, 엣지케이스 0건, 오케스트레이션 0건, 레거시 잔재 0건)
+- **총 추적 미해결 과제**: **5건** (아키텍처 1건: `A-2`, 엣지케이스 및 가용성 3건: `B-14`, `B-15`, `B-16`, 오케스트레이션 1건: `O-5`)
 - **완료된 과제**: **24건** (A-1, A-3, A-4, A-5, B-1, B-3, B-4, B-5, B-7, B-8, B-9, B-10, B-13, C-1, C-2, C-3b, C-6, O-1, O-2, O-3, O-4-OrcOnboard, Herdr-0.8.0-Compat-SanitizeHash, P2-1-DelegateJobSafe-TrapFix, P2-2-C3a-C4-LegacyCleanup)
 
 ---
@@ -15,9 +15,13 @@
 
 ## 1. 🔴 아키텍처 결함 (Architecture Flaws — 1건)
 
-### **A-2: 공개 브로커 + HMAC 인증 Off + 와일드카드 전파**
+### **A-2 (P5-1): 공개 브로커 + HMAC 인증 Off + 와일드카드 전파 (해결책: `nats-server` 전용 브로커 채택)**
-- **현상**: `mqtt_common.py`의 기본 브로커가 공개 서버(`broker.hivemq.com`)이고, 잡 생성 시 `auth_token` 이 **한 번도 발급되지 않아**(실측 26/26 잡이 `auth_token=None`) `verify_hmac` 의 `if not auth_token: return True` 경로가 항상 타집니다. 발행자는 워크스페이스 지문 토픽을 채택하지 않고 전역 `python/mqtt/jobs/<job_id>/events` 로 발행하며, `reconcile.sh:237` 이 같은 전역 토픽을 구독합니다. (HMAC 구현 자체는 정상입니다 — 토큰이 없어 검증이 공허해지는 것이 원인입니다.)
+- **현상**: `mqtt_common.py`의 기본 브로커가 공개 서버(`broker.hivemq.com`)이고, 잡 생성 시 `auth_token`이 발급되지 않는 조건 분기(평문/공개 브로커)로 인해 `verify_hmac`의 `if not auth_token: return True` 경로가 타집니다. 발행자는 워크스페이스 지문 토픽을 채택하지 않고 전역 `python/mqtt/jobs/<job_id>/events`로 발행하며, `reconcile.sh:237`이 같은 전역 토픽을 구독합니다.
 - **파급 효과**: 외부에서 유입되는 malicious `error` 이벤트 수신 시 `reconcile.sh`가 라이브 에이전트 pane을 `kill-session`으로 강제 파괴하는 치명적 보안/안정성 위험이 존재합니다.
+- **최신 실측 및 해결 방침 (`NATS_REPORT.md` 확정)**:
+  - 클라이언트 프로토콜(`paho-mqtt`)을 비동기 `nats-py`로 전면 재작성하는 방안(Option B)은 46개 테스트 파괴 및 단명 동기 CLI 마찰 위험으로 **만장일치 기각**되었습니다.
+  - 대신 **`nats-server`의 내장 MQTT 3.1.1 리스너를 전용 사설 브로커로 채택(Option C)**하여 클라이언트 코드 0줄 변경으로 NKey/JWT 계정·Subject별 ACL 격리 및 JetStream 영속성을 100% 확보하기로 확정했습니다.
+  - 단, 브로커 제품과 무관하게 존재하는 **가용성 선행 결함(Track 0: B-14, B-15)**을 먼저 교정한 후 Track 1(스파이크) 및 Track 2(A-2 워크스페이스 지문 토픽 + 무조건 토큰 발급)를 순차 전개합니다.
 
 ### **A-4 (✅ 완료 — P3-1): 에이전트 지식 산재 — `BaseAgentAdapter` 어댑터 계층 도입 (Rev.2)**
 
@@ -67,11 +71,37 @@
 
 ---
 
-## 2. 🟠 엣지 케이스 및 런타임 버그 (Edge-case Bugs — 0건 — 전원 완료)
+## 2. 🟠 엣지 케이스 및 런타임 버그 (Edge-case Bugs — 3건)
+
+### **B-14 (F-1 / P1): `publish_event.py` 브로커 장애 시 `return 2` 조기 탈출로 인한 65분 루프 정지**
+- **현상**: `publish_event.py:195-199`에서 브로커 네트워크 장애 발생 시 `return 2`로 조기 종료되어, 뒤따르는 로컬 레지스트리 상태(`update_job_status(status=completed)`) 및 감사 로그(`append_event`, `registry.append_event`) 갱신이 누락됩니다 (`NATS_REPORT.md` §3.1 실측 재현).
+- **파급 효과**: `run_loop.sh`의 `wait_for_job()`은 로컬 디스크 파일의 상태가 `status=running`으로 멈춰있어 `max_wait=3900s`를 소진할 때까지 **65분간 루프가 완전 정지(Hang)**합니다.
+- **조치 방향 (Track 0 Step 1)**: 네트워크 발행 실패 시에도 `append_event`와 `update_job_status`를 온전히 완수한 후 `published=False`를 기록하고 `return 2`를 반환하도록 실행 순서를 재배치합니다 (G-1 ~ G-4 회귀 가드 신설).
+
+### **B-15 (C1 & F-4 / P1): `job_subscriber.py` 디스크 폴백 부재 및 위임 경로 인프라 에러 오판정**
+- **현상**:
+  1. `job_subscriber.py:172-251`가 `queue.Empty` 시 네트워크 큐만 대기하며 로컬 디스크 상태를 확인하지 않아, 브로커 다운 시 120초 `idle_timeout` 동안 불필요하게 블로킹됩니다 (`NATS_REPORT.md` §4.1 C1 챌린지 검증).
+  2. `multi-agent-mux-delegate-job:331-341`에서 `wait "$sub_pid"`의 `sub_rc`를 직접 `job_status`로 매핑(`rc=1` -> `job_status="error"`)하여, 브로커 연결 실패로 인한 미포착 예외(`rc=1`) 발생 시 작업자의 정상 산출물이 존재하더라도 작업을 강제로 `"error"`로 오판정합니다 (`NATS_REPORT.md` §3.4 F-4).
+- **파급 효과**: 브로커 장애 시 작업자가 작업을 정상 완수했음에도 루프가 2분 이상 지연되거나 거짓 실패(False Failure)가 발생합니다.
+- **조치 방향 (Track 0 Step 2 & 3)**:
+  1. `job_subscriber.py` 대기 루프에 로컬 디스크(`load_job`/`read_logged_status`) 상태 폴백을 도입하여 디스크 완료 감지 시 `source: disk-fallback` 합성 이벤트를 출력하고 3초 내 `rc=0`으로 조기 정상 종료합니다.
+  2. 브로커 인프라 연결 실패에 전용 `rc=3`을 부여하고 `job_status="broker_unavailable"` 분기로 분리하여 작업 결과와 인프라 에러를 엄격히 격리합니다 (G-5 ~ G-10 회귀 가드 신설).
+
+### **B-16 (F-5 / P3): `make_client()` 매 실행 랜덤 `client_id` 발급으로 인한 영속 세션(Durable Session) 구성 불가**
+- **현상**: `mqtt_common.py:258`에서 `client_id`를 매번 `uuid.uuid4().hex[:8]`로 생성하여, 브로커가 클라이언트 재연결을 식별할 수 없습니다 (`NATS_REPORT.md` §3.5 F-5).
+- **파급 효과**: 네트워크 재연결 시 미수신 이벤트 유실 가능성이 발생합니다.
+- **조치 방향**: B-15의 로컬 디스크 폴백을 표준 복원 경로로 확립하여 네트워크 세션 의존도를 제거하고, 필요 시 결정론적 식별자 규칙을 적용합니다.
 
 ---
 
-## 3. 🟡 오케스트레이션 최적화 과제 (Orchestration Optimizations — 0건 — 전원 완료)
+## 3. 🟡 오케스트레이션 최적화 과제 (Orchestration Optimizations — 1건)
+
+### **O-5 (P2): NATS/MQTT 메시징 백플레인 고도화 및 `nats-server` 스파이크 검증 (Track 1 ~ Track 2)**
+- **현상**: `NATS_REPORT.md` 아키텍처 실측 분석에 따라, `nats-py` 클라이언트 재작성(Option B)을 배제하고 `nats-server` 내장 MQTT 3.1.1 어댑터를 사설 전용 브로커로 채택하는 전략(Option C)이 확정되었습니다.
+- **조치 방향**:
+  1. **Track 1 (스파이크 검증)**: 격리 환경에서 `nats-server -js`의 MQTT 3.1.1 호환성(Retained 터미널 이벤트 전달 S-3, QoS 1 ACK S-4, Subject 라우팅 S-5 등 9종 매트릭스 S-1 ~ S-9) 실측 검증.
+  2. **Track 2 (보안/격리)**: 워크스페이스 지문 기반 토픽(`mam/<sha256[:12]>/jobs/...`) 및 무조건 `auth_token` 발급(G-11)을 적용하여 A-2 보안 결함 완전 종결.
+  3. **Track 3 (문서/설정)**: `MESSAGING.md`, `VERSIONS.md`, `.mam.env`에 `nats-server` 서빙 가이드 및 설정 동기화.
 
 ---
 
@@ -236,61 +266,70 @@
 
 **조용한 실패에 가중치를 둡니다.** 시끄러운 실패는 사람이 보지만, 조용한 실패는 "통과"로 기록되고 그 위에 다음 작업이 쌓입니다.
 
-### 6.2 실행 순서
+### 6.2 실행 순서 (4-Track Priority Alignment)
 
-> **사용자 지침 반영**: **A-2 (공개 브로커 & HMAC)** 과제는 차후 자체 전용 MQTT 브로커 서버를 구축할 예정이므로 사용자 지침에 따라 **우선순위를 최하위(P5)로 조정**하였습니다.
+> **우선순위 원칙 및 NATS 분석 합의 반영 (`NATS_REPORT.md`)**:
+> 1. **Track 0 (최우선 P1 — 가용성 및 내결함성 교정)**: 브로커 장애 시 65분 루프 정지(`B-14`) 및 120초 지연/오판정(`B-15`)을 방지하는 **로컬 디스크 내결함성 확보 (G-1 ~ G-10 회귀 가드 신설, 브로커 제품 무관 선행 필수)**.
+> 2. **Track 1 (차순위 P2 — 브로커 스파이크 검증)**: 격리 환경에서 `nats-server -js`의 MQTT 3.1.1 호환성(Retained 터미널 이벤트 S-3, QoS 1 ACK S-4 등 9종 매트릭스 S-1 ~ S-9) 실측 스파이크 검증 (`O-5`).
+> 3. **Track 2 (보안/격리 완결 P3)**: 워크스페이스 지문 기반 토픽(`mam/<sha256[:12]>/jobs/...`) 및 무조건 `auth_token` 발급(G-11)으로 `A-2` 보안 결함 완전 종결 및 `B-16` 완결.
+> 4. **Track 3 (문서/설정 동기화 P4)**: `MESSAGING.md`, `VERSIONS.md`, `.mam.env` 템플릿 동기화.
 
 | 순위 | 항목 | 근거 | 비용 | 선행 |
 |---|---|---|---|---|
+| **P1-1** | **B-14 (F-1)** | 브로커 다운 시 `publish_event.py` 조기 탈출로 인한 **65분 루프 정지(Hang)** 원천 차단 (`append_event`/`update_job_status` 선행 보장, G-1 ~ G-4 회귀 가드) | 소 (1파일) | — |
+| **P1-2** | **B-15 (C1/F-4)** | 브로커 다운 시 `job_subscriber.py` **120초 지연 제거** 및 정상 완료 작업의 **`job_status="error"` 오판정 차단** (디스크 폴백 및 `rc=3` 분리, G-5 ~ G-10 회귀 가드) | 소~중 (2파일) | B-14 |
+| **P2-1** | **O-5 (Track 1)** | `nats-server -js` MQTT 3.1.1 호환성 스파이크(S-1 ~ S-9 매트릭스 실측, S-3 Retained 터미널 이벤트 관문) 및 환경변수 템플릿 연동 | 소 (격리 스파이크) | B-15 |
+| **P3-1** | **A-2 (Track 2)** | 워크스페이스 지문 토픽(`mam/<fp>/jobs/...`) 및 무조건 `auth_token` 발급(G-11)으로 A-2 보안 결함 완전 종결 | 중 (3파일) | O-5 (S-3 통과) |
+| **P3-2** | **B-16 (F-5)** | 매 실행 랜덤 `client_id` 발급으로 인한 영속 세션 불가 이슈를 B-15 디스크 폴백 표준화로 완결 | 극소 | B-15 |
 | **P0-1** | **B-7** | 저장소 밖 기동 시 리뷰어가 문자열 `"No git diff available"` 로 `[VERDICT: PASS]` 를 냄. 신규(미추적) 파일은 리뷰 대상 밖. **(✅ 완료 — tests/test_b7_diff_untracked.py 20/20 PASS)** | 소 (1파일) | — |
 | **P0-2** | **O-2** | 마커를 조건 없이 덮어쓰고 종료 트랩이 **타 인스턴스의 마커까지 삭제** → 완료 처리된 **O-3 가드가 조용히 무력화**됨 **(✅ 완료 — tests/test_o2_race_free_lock.py 22/22 PASS)** | 소~중 (1파일) | — |
-| **P1-1** | **A-4 M0~M1** | `PYTHONPATH` 부트스트랩·배포/CI 등록·`own_key` 이관. B-8/B-10/C-3b 로직을 싸게 만듦 **(✅ 완료 — tests/test_a4_adapter_contract.py 3/3 PASS)** | 중 | B-7 |
+| **P1-1(과거)** | **A-4 M0~M1** | `PYTHONPATH` 부트스트랩·배포/CI 등록·`own_key` 이관. B-8/B-10/C-3b 로직을 싸게 만듦 **(✅ 완료 — tests/test_a4_adapter_contract.py 3/3 PASS)** | 중 | B-7 |
-| **P1-2** | **B-8** | agy 주입 시 `return 0` 우회 제거 및 제출 검증 루프 이관 **(✅ 완료 — tests/test_b8_send_keys_verification.py 1/1 PASS)** | 소 | A-4 M0 |
+| **P1-2(과거)** | **B-8** | agy 주입 시 `return 0` 우회 제거 및 제출 검증 루프 이관 **(✅ 완료 — tests/test_b8_send_keys_verification.py 1/1 PASS)** | 소 | A-4 M0 |
-| **P2-1** | **B-6 / B-12** | 스킬 트리 내 임시 사본 및 서브셸 EXIT 트랩으로 인한 루프 락 조기 해제 차단 **(✅ 완료 — tests/test_o3_scoped_guard.py 27/27 PASS, commit b490713)** | 소 | — |
+| **P2-1(과거)** | **B-6 / B-12** | 스킬 트리 내 임시 사본 및 서브셸 EXIT 트랩으로 인한 루프 락 조기 해제 차단 **(✅ 완료 — tests/test_o3_scoped_guard.py 27/27 PASS, commit b490713)** | 소 | — |
-| **P2-2** | **C-3a + C-4** | 빈 스텁 4종 + 공허한 테스트 4건 + 죽은 심볼 3종 제거 및 `--isolate` no-op 회귀 가드 신설 **(✅ 완료 — tests/test_tier1_unit.py + test_tier2_component.py 256/256 PASS)** | 소 | — |
+| **P2-2(과거)** | **C-3a + C-4** | 빈 스텁 4종 + 공허한 테스트 4건 + 죽은 심볼 3종 제거 및 `--isolate` no-op 회귀 가드 신설 **(✅ 완료 — tests/test_tier1_unit.py + test_tier2_component.py 256/256 PASS)** | 소 | — |
-| **P2-3** | **C-6** | `stop_session.sh` 헤더/도움말/주석/MESSAGING.md 정리 및 회귀 가드 신설 **(✅ 완료 — tests/test_tier2_component.py 가드 신설, 전체 263/263 PASS)** | 극소 | — |
+| **P2-3(과거)** | **C-6** | `stop_session.sh` 헤더/도움말/주석/MESSAGING.md 정리 및 회귀 가드 신설 **(✅ 완료 — tests/test_tier2_component.py 가드 신설, 전체 263/263 PASS)** | 극소 | — |
-| **P3-1** | **A-4 M2~M7** | 어댑터 본이관 및 CLI facts 브리지/서브커맨드 구축 **(✅ 완료 — tests/test_a4_adapter_contract.py 9/9 PASS, 전체 259/259 PASS)** | 대 | P1-1 |
+| **P3-1(과거)** | **A-4 M2~M7** | 어댑터 본이관 및 CLI facts 브리지/서브커맨드 구축 **(✅ 완료 — tests/test_a4_adapter_contract.py 9/9 PASS, 전체 259/259 PASS)** | 대 | P1-1 |
-| **P3-2** | **B-10** | tier-3 신원 캐시 완전 제거 및 UUID 경로 PyYAML 탈의존 (Option A) **(✅ 완료 — tests/test_tier1_unit.py 가드 3건 신설, 전체 266/266 PASS)** | 중 | A-4 M2 |
+| **P3-2(과거)** | **B-10** | tier-3 신원 캐시 완전 제거 및 UUID 경로 PyYAML 탈의존 (Option A) **(✅ 완료 — tests/test_tier1_unit.py 가드 3건 신설, 전체 266/266 PASS)** | 중 | A-4 M2 |
-| **P3-3** | **C-3b** | `isolation.root` 4개 소비자 완전 폐기 (Option B 채택) **(✅ 완료 — 전체 259/259 PASS)** | 소 | A-4 M2 |
+| **P3-3(과거)** | **C-3b** | `isolation.root` 4개 소비자 완전 폐기 (Option B 채택) **(✅ 완료 — 전체 259/259 PASS)** | 소 | A-4 M2 |
 | **B-13** | **Stage 2** | 셀프 호스팅 루프 런타임 프리즈 스냅샷 및 이중 루트 격리 **(✅ 완료 — tests/test_o3_scoped_guard.py 5건 가드 신설, 전체 271/271 PASS)** | 중 | — |
-| **P4-1** | **B-9** | 감사 로그 루트 지연 평가 및 `__getattr__`/`__dir__` 동적 별칭 **(✅ 완료 — tests/test_tier1_unit.py 5건 가드 신설, 전체 276/276 PASS)** | 극소 | — |
+| **P4-1(과거)** | **B-9** | 감사 로그 루트 지연 평가 및 `__getattr__`/`__dir__` 동적 별칭 **(✅ 완료 — tests/test_tier1_unit.py 5건 가드 신설, 전체 276/276 PASS)** | 극소 | — |
-| **P5-1** | **A-2** | 공개 브로커 및 HMAC 검증 보완 (📌 *사용자 지침: 차후 전용 MQTT 브로커 서빙 환경 구축 시점에 진행*) | 중 (3파일) | 전용 브로커 |
 | **종결** | **B-5** | `df -P` 폴백 정상 동작 실측 및 단위 테스트 검증 완료 **(✅ 완료/종결 — tests/test_tier1_unit.py test_stop_check_is_nfs_local)** | — | — |
 
-**A-2 과제의 후순위 배치 사유**: 사용자 지침에 따라 차후 자체 전용 MQTT 브로커 서빙 환경 구축 시점에 맞춰 진행하기 위해 **최하위(P5-1)**로 배치하였습니다.
+**정리(C 계열)를 과거 P2 에 두었던 이유**: (a) C-3a 는 죽은 코드를 고정하던 테스트를 함께 제거해 C-3a 를 실행 가능하게 만들고, (b) C-4 는 **잘못 실행하면 버그를 만듭니다**. 방치할수록 누군가 "쉬운 정리"로 집어 들 확률이 올라갑니다.
 
-**정리(C 계열)를 P2 에 두는 이유**: (a) C-3a 는 죽은 코드를 고정하던 테스트를 함께 제거해 C-3a 를 실행 가능하게 만들고, (b) C-4 는 **잘못 실행하면 버그를 만듭니다**. 방치할수록 누군가 "쉬운 정리"로 집어 들 확률이 올라갑니다.
+### 6.3 병렬 실행 — 파일 소유권 슬롯 (Rev.3 갱신)
 
-### 6.3 병렬 실행 — 파일 소유권 슬롯 (Rev.2 교체)
+> 병렬 단위는 **주제가 아니라 파일**입니다.
-
-> Rev.1 은 "주제별 트랙"으로 병렬화를 서술했고 **그 분해는 4곳에서 틀렸습니다**(챌린지 `7d604ee7` 계기로 파일 단위 재대조). 병렬 단위는 **주제가 아니라 파일**입니다.
 
 **항목별 처방이 건드리는 파일**
 
 | 파일 | 건드리는 항목 |
 |---|---|
+| `publish_event.py` | **B-14** |
+| `job_subscriber.py` | **B-15** |
+| `multi-agent-mux-delegate-job` | **B-15** |
+| `mqtt_common.py` | **A-2, B-9, B-16** |
+| `registry.py` | **A-2, B-14, C-4** |
+| `reconcile.sh` | **A-2, A-4, B-10** |
+| `.mam.env` / `MESSAGING.md` | **O-5, A-2** |
 | `run_loop.sh` | **B-6, B-7, O-2** |
 | `lib.sh` | **A-4, B-8, B-10, C-3a, C-4** |
-| `reconcile.sh` | **A-2, A-4, B-10** |
-| `mqtt_common.py` | **A-2, B-9** |
 | `stop_session.sh` | **B-10, C-6** |
-| `registry.py` | **A-2, C-4** |
 | `create_session.sh` | **A-4, C-4** |
 
 **슬롯 배치 — 슬롯 안은 직렬, 슬롯 간은 병렬**
 
 | 슬롯 | 순서 |
 |---|---|
-| **`run_loop.sh`** | `B-7` → `O-2` → `B-6` |
+| **Track 0 발행자/구독자 슬롯** (`publish_event.py`·`job_subscriber.py`·`delegate-job`) | `B-14` → `B-15` |
-| **`lib.sh`** | `C-3a`+`C-4` → `B-8` |
+| **Track 1 브로커 스파이크 슬롯** (격리 환경 `$SCRATCH/nats-spike`) | `O-5` (S-1 ~ S-9) |
-| **MQTT 계열** (`mqtt_common.py`·`registry.py`·`publish_event.py`·`job_subscriber.py`·`reconcile.sh`) | `A-2` → `B-9` |
+| **Track 2 보안/레지스트리 슬롯** (`mqtt_common.py`·`registry.py`·`reconcile.sh`) | `A-2` → `B-16` |
-| **`stop_session.sh`** | `C-6` |
+| **`run_loop.sh` 슬롯** | `B-7` → `O-2` → `B-6` (완료) |
-| **단독 실행** (슬롯 경계를 넘음) | `A-4`, `B-10` |
+| **`lib.sh` 슬롯** | `C-3a`+`C-4` → `B-8` (완료) |
+| **`stop_session.sh` 슬롯** | `C-6` (완료) |
+| **단독 실행** (슬롯 경계를 넘음) | `A-4`, `B-10` (완료) |
 
-- `A-4`(`lib.sh`+`reconcile.sh`+`create_session.sh`+`resume_session.sh`)와 `B-10`(`lib.sh`+`reconcile.sh`+`stop_session.sh`)은 **어떤 슬롯 조합과도 겹치므로 단독 실행**합니다.
+---
-- `A-4` 는 신규 파일을 대량 추가하므로 **B-7 이 먼저 닫혀 있어야 리뷰가 성립**합니다.
-- **Rev.1 오류 정정 4건**: `B-6`(트랙 C→`run_loop.sh` 슬롯), `C-3a`·`C-4`(트랙 C→`lib.sh` 슬롯), `B-9`(독립→MQTT 슬롯), `C-6`(독립→`stop_session.sh` 슬롯).
-- 참고: `reconcile.sh` 는 `MAM_LOOP_MARKER`·`send_keys_safe` 를 **참조 0건**이므로 `O-2`·`B-8` 과는 경합하지 않습니다(자체 `.mam/monitor.lock` 보유).
 
 ### 6.4 B-7 처방 (Rev.2 신설 — 진단만 있고 처방이 없었음)
 
@@ -327,4 +366,4 @@ CHANGES_DIFF=$(
 
 ### 6.6 결론
 
-`IMPROVEMENTS.md` 는 남은 백로그 항목(아키텍처 2건, 엣지케이스 6건, 오케스트레이션 1건, 레거시 잔재 3건 — 총 12건)을 위 우선순위에 따라 일원화된 보완 로드맵으로 관리합니다.
+`IMPROVEMENTS.md` 는 남은 백로그 항목(아키텍처 1건: `A-2`, 엣지케이스 및 가용성 3건: `B-14`·`B-15`·`B-16`, 오케스트레이션 1건: `O-5` — 총 5건)을 위 우선순위(Track 0 → Track 1 → Track 2)에 따라 일원화된 보완 로드맵으로 관리합니다.

NATS_REPORT.md

@@ -0,0 +1,176 @@
+# 📊 MAM 메시징 백플레인 아키텍처 심층 분석 보고서: MQTT vs NATS
+
+- **문서 버전**: Rev.2 Final Synthesis (`f1956d2e` / `5ac88ca0`)
+- **작성/검토 주체**: MAM Multi-Agent Orchestration Team (`claude`, `agy`)
+- **기준 커밋**: `ac82f9b` (`refactor`, 276/276 tests passing)
+- **문서 목적**: MAM 프레임워크의 메시징 인프라(MQTT)를 NATS로 전면 전환할 것인지 여부에 대한 종합적인 기술·운영·보안 타당성 분석 및 실행 로드맵 확정.
+
+---
+
+## 0. 최종 판정 (Executive Verdict)
+
+> ### 🎯 **[VERDICT: DO NOT MIGRATE CLIENT PROTOCOL — ADOPT `nats-server` AS DEDICATED BROKER]**
+>
+> **클라이언트 전송 프로토콜(MQTT)은 유지하고, 전용 브로커로서 `nats-server`의 내장 MQTT 3.1.1 어댑터를 채택합니다.**
+
+### 0.1 3대 핵심 근거 요약
+
+```
+[MAM Control Plane]  ────> run_loop.sh (wait_for_job: 3s Local Disk Polling)  ──> 100% Broker-Independent
+[Observability Plane] ────> publish_event.py ──(MQTT 3.1.1)──> nats-server (JetStream + nkeys)
+```
+
+1. **제어 평면과 관측 평면의 분리**:
+   MAM의 핵심 루프(`run_loop.sh`)는 MQTT 메시지를 구독하지 않으며, 로컬 파일시스템(`.mam/jobs/<id>.json`)을 3초 주기로 폴링(`wait_for_job`)하여 작업 완료를 판정합니다. 브로커는 **비동기 관측(observability) 사이드카**이며 제어 평면을 차단하지 않습니다.
+2. **NATS의 실질적 이점은 '서버'에 존재**:
+   NATS의 핵심 강점(단일 무의존 Go 바이너리, JetStream 영속성, nkeys/JWT 계정·Subject별 ACL)은 서버 계층의 속성입니다. `nats-server`는 **MQTT 3.1.1 프로토콜을 네이티브로 수용**하므로, 클라이언트 코드를 한 줄도 바꾸지 않고 서버의 모든 운영·보안 이점을 100% 확보할 수 있습니다.
+3. **네이티브 NATS(`nats-py`) 전환의 비용 대비 무익함**:
+   `nats-py`는 asyncio 전용 라이브러리로, bash 기반의 단명(short-lived) 동기 CLI 도구들(`publish_event.py` 등)과 심각한 구조적 마찰을 일으키며, 최소 46건의 테스트 재작성 및 276건 green 베이스라인 훼손 위험을 초래합니다. 반면 NATS 고유 기능(Req/Reply, 초당 수백만 처리량, 클러스터링)은 MAM 워크로드(단일 워크스페이스, 잡당 수 개 이벤트)에서 전혀 사용되지 않습니다.
+
+---
+
+## 1. 3대 전략적 선택지 비교 분석
+
+| 평가 항목 | (A) 현행 유지 (공개 HiveMQ) | (B) 네이티브 NATS 전환 (`nats-py`) | (C) `nats-server` + MQTT 프로토콜 유지 (채택안) |
+|---|---|---|---|
+| **클라이언트 코드 변경** | 0줄 | 4개 호출부 전면 비동기 재작성 | **0줄** (환경변수만 구성) |
+| **테스트 코드 재작성** | 0건 | 최소 46건 재작성 (276건 베이스라인 위험) | **0건** (기존 276건 100% 보존) |
+| **A-2 보안 결함 해소** | ❌ 불가 (공개 브로커) | ✅ 완전 해소 | ✅ **완전 해소** (nkeys/JWT subject ACL) |
+| **단일 정적 바이너리 배포** | ❌ 불가 | ✅ 지원 | ✅ **지원** (`nats-server` 바이너리 1개) |
+| **이벤트 영속성 (JetStream)** | ❌ 미지원 | ✅ 지원 | ✅ **지원** (내장 JetStream 엔진) |
+| **동기 CLI 호환성** | ✅ 우수 (paho-mqtt) | ❌ 심각 (asyncio 강제) | ✅ **우수** (기존 동기 핫패스 유지) |
+| **되돌리기(Rollback) 비용** | — | 🔴 높음 (비가역 코드 재작성) | 🟢 **0 (가역적 환경변수 스위치)** |
+| **최종 평가** | **기각 (보안 위험)** | **기각 (비용 대비 실익 전무)** | 🏆 **최종 채택** |
+
+---
+
+## 2. 현행 아키텍처 실측 및 기술적 진단 (Ground Truth)
+
+### 2.1 제어 경로 상의 MQTT 의존도 실측
+- `run_loop.sh` (899줄, 메인 오케스트레이터) 내 MQTT 직접 참조는 `:889`의 임시 구독자 로그 파일 삭제 1건뿐입니다.
+- 작업 완료 감지는 11개 호출 지점(전체 12개 참조) 전체가 `wait_for_job()` 함수를 통해 `.mam/jobs/<id>.json` 파일의 `status` 필드를 3초 간격으로 검사합니다.
+- 따라서 브로커가 다운되어도 제어 평면 자체는 독립적으로 완주할 수 있는 구조입니다.
+
+### 2.2 paho-mqtt 결합도 (Blast Radius)
+- `import paho`는 `mqtt_common.py:32` 단 1곳에 캡슐화되어 있습니다.
+- 그러나 `make_client()`가 raw `mqtt.Client` 인스턴스를 반환하여 다음 4개 지점에서 구동됩니다:
+  1. `mqtt_common.py:250-276` (`make_client`)
+  2. `publish_event.py:102-122` (발행 및 ACK 대기)
+  3. `job_subscriber.py:172-251` (이벤트 큐잉 및 구독)
+  4. `reconcile.sh:245-292` (내장 python 이벤트 수신)
+
+---
+
+## 3. 코드베이스 잠복 결함 분석 (F-1 ~ F-5)
+
+브로커 제품 선택과 무관하게 현행 코드에 잠복해 있는 5가지 구조적 결함이 발굴되었습니다.
+
+```
+[발굴된 결함 체인]
+F-1: publish 실패 시 return 2 ──> 레지스트리 상태 동기화 누락 ──> run_loop 3900초(65분) 정지
+F-4: subscriber 미포착 예외 rc=1 ──> loop/discuss 경로에서 job_status="error" 오판정
+F-2/F-3: 전역 토픽 + auth_token 조건부 ──> 워크스페이스 격리 및 HMAC 검증 사각지대 (A-2)
+F-5: 매 실행 랜덤 client_id ──> 문서가 주장하는 durable session 구성 불가
+```
+
+### 3.1 F-1 (Critical): 발행 실패 시 레지스트리 갱신 누락 (65분 루프 정지)
+- `publish_event.py:195-199`에서 브로커 네트워크 오류 발생 시 `return 2`로 조기 종료됩니다.
+- 이로 인해 뒤따르는 `append_event`, `registry.append_event`, `update_job_status(status=completed)`가 실행되지 못합니다.
+- `wait_for_job`은 `status=running` 상태에서 `max_wait=3900s`를 소진할 때까지 **65분간 정지**합니다.
+
+### 3.2 F-2 (High): 워크스페이스 지문 토픽 미발행 (A-2)
+- `reconcile.sh:236`은 지문 토픽(`mam/<fp>/jobs/+/events`)을 구독하지만, `mqtt_common.py:119`는 전역 토픽(`python/mqtt/jobs`)으로만 발행합니다.
+- 워크스페이스 간 메시지 격리가 실질적으로 비활성화되어 있습니다.
+
+### 3.3 F-3 (High): HMAC 인증 조건부 공허화 (A-2)
+- `registry.py:75-79`는 TLS나 사용자 인증이 켜진 보안 브로커 감지 시 `secrets.token_urlsafe(32)`를 자동 생성하나, 기본 공개 브로커(또는 평문 TCP 브로커) 환경에서는 토큰이 발급되지 않아 `auth_token=None`으로 남습니다.
+- 이로 인해 `verify_hmac`의 `if not auth_token: return True` 분기가 무조건 참이 되어 공개 브로커 환경에서 HMAC 검증이 무력화됩니다 (Track 2에서 전 브로커 대상 무조건 발급으로 심층 방어 적용 필요).
+
+### 3.4 F-4 (Critical): `loop`/`discuss` 위임 경로의 오판정 결함
+- `multi-agent-mux-delegate-job:331-341`에서 `wait "$sub_pid"`의 `sub_rc`를 직접 `job_status`로 매핑(`rc=1` -> `job_status="error"`).
+- 브로커 연결 실패 시 `job_subscriber.py`가 미포착 예외로 `rc=1`을 내므로, **브로커 접속 실패가 작업 에러로 둔갑**합니다.
+
+### 3.5 F-5 (Medium): 영속 세션(Durable Session) 구성 불가
+- `make_client()`가 매 실행마다 `uuid.uuid4().hex[:8]`로 랜덤 `client_id`를 생성하므로, 브로커가 재연결 세션을 식별할 수 없습니다.
+
+---
+
+## 4. 리뷰 및 챌린지 검증 (Challenge Resolution)
+
+### 4.1 C1 챌린지 분석 및 판정
+Reviewer (`agy`)가 제기한 `job_subscriber.py`의 제어 경로 블로킹 및 디스크 폴백 누락 지적을 실측 검증하였습니다.
+
+1. **C1-a (위임 대기 경로 실재)**: `multi-agent-mux-delegate-job:227`에 `wait "$sub_pid"`가 존재하며, `run_loop.sh`의 모든 호출부가 `--type direct`로 이 경로를 통과함을 확인 (수용).
+2. **C1-b (디스크 폴백 부재)**: `job_subscriber.py`는 오직 `watcher.events.get()`만 대기하므로 브로커 단절 시 이벤트를 수신하지 못함 (수용).
+3. **C1-c (메커니즘 선후관계)**: C1은 F-1이 해결되어 디스크에 완료 상태가 쓰여진 이후에 드러나는 연쇄 결함임 (정정 및 반영).
+4. **C1-d (지연 시간 실측)**: 브로커 도달 불가 시 구독자는 15~40초 내 `rc=1`로 조기 종료되어 실제 추가 블로킹은 0초임 (지연 영향 기각, 그러나 감사 로그 오염 및 거짓 실패 판정의 심각성으로 채택).
+5. **C1-e (해결책 채택)**: `job_subscriber.py`의 대기 루프에 로컬 디스크(`load_job` / `read_logged_status`) 폴백을 도입하여 브로커 단절 시에도 즉시 정상 종료하도록 보강.
+
+---
+
+## 5. 단계별 실행 계획 (Actionable Roadmap)
+
+```
+[Track 0: 결함 교정] ──> [Track 1: nats-server 스파이크] ──> [Track 2: A-2 보안/격리 해소] ──> [Track 3: 문서화]
+(F-1, C1, F-4 해결)     (S-1 ~ S-9 매트릭스 검증)         (F-2, F-3, Token, ACL)       (MESSAGING, VERSIONS)
+```
+
+### 5.1 Track 0 — 가용성 및 결함 교정 (최우선 과제, 브로커 무관)
+
+#### Step 순서 의존성 (Strict Ordering)
+1. **Step 1 (`publish_event.py`)**: 발행 실패 시에도 레지스트리 상태 동기화 및 감사 로그 작성을 완수하고 `return 2` 반환.
+2. **Step 2 (`job_subscriber.py`)**: `queue.Empty` 시 3초 스로틀로 디스크 터미널 상태를 확인하여 `source: disk-fallback` 합성 이벤트 출력 후 `rc=0` 조기 종료.
+3. **Step 3 (`multi-agent-mux-delegate-job`)**: 인프라 예외에 전용 `rc=3`을 부여하고 `job_status="broker_unavailable"` 분기 처리.
+
+#### 회귀 가드 매트릭스 (11종 신설 — G-1 ~ G-11, 목표 287/287 PASS)
+- **G-1**: 브로커 도달 불가 발행 시 `rc=2`이면서 레지스트리 `status=completed` 확인.
+- **G-2**: 감사 로그에 `published: false` 및 `publish_error` 필드 기록 확인.
+- **G-3**: 정상 브로커 발행 시 `rc=0` 및 `published: true` 무회귀 확인.
+- **G-4**: 발행 실패 시 단조 `last_seq` 증가 및 후속 발행 seq 보존 확인.
+- **G-5**: 디스크 `status=completed` 선작성 시 브로커 다운 상태에서도 `job_subscriber.py`가 3초 내 `rc=0` 종료.
+- **G-6**: 디스크 폴백 종료 시 stdout에 `disk-fallback` 명시 확인.
+- **G-7**: 디스크 `status=error` 시 폴백 `rc=1` 반환 확인.
+- **G-8**: 다중 잡 감시 시 전체 완료 전까지 조기 종료 방지.
+- **G-9**: 디스크 터미널 부재 + 브로커 실패 시 `rc=3` 반환 확인 (F-4 방어).
+- **G-10**: `loop` 위임 경로에서 `rc=3` 수신 시 `job_status`가 `"error"`로 오판되지 않음을 확인.
+- **G-11**: `registry.register_job()` 호출 시 `auth_token`이 항상 비어있지 않게 생성됨을 단언 (`secrets.token_urlsafe(32)` 유지).
+
+### 5.2 Track 1 — `nats-server` 스파이크 검증 매트릭스 (S-1 ~ S-9)
+
+격리 클론(`$SCRATCH/nats-spike`)에서 검증 수행:
+- **S-1**: `nats-server -js` MQTT 리스너 기본 구동 및 `started/progress/completed` 발행 수용 (`rc=0`).
+- **S-2**: paho-mqtt 2.x `CallbackAPIVersion.VERSION2` CONNACK 호환성 검증.
+- **S-3 (핵심 관문)**: **Retained terminal event 정상 전달 검증** (늦은 구독자의 즉시 최종 상태 수신). *실패 시 mosquitto로 회귀*.
+- **S-4**: QoS 1 `wait_for_publish` ACK 동작 검증.
+- **S-5**: 와일드카드 토픽(`mam/<fp>/jobs/+/events`) 구독 및 라우팅 검증.
+- **S-6**: TLS 암호화 및 유저 인증 접근 제어 검증.
+- **S-7**: Subject/Topic 레벨 권한 분리(Publisher write-only / Subscriber read-only) 검증.
+- **S-8**: 전체 287건 회귀 테스트 100% PASS 검증.
+- **S-9**: Track 0 디스크 폴백이 `nats-server` 장애 상황에서도 정상 동작함을 통합 검증.
+
+### 5.3 Track 2 — A-2 보안 및 워크스페이스 격리 해소
+1. **F-3 해소**: `registry.register_job()`에서 브로커 설정(TLS/인증 유무)과 무관하게 `secrets.token_urlsafe(32)` 기반 `auth_token`을 **무조건 항상 발급**.
+2. **F-2 해소**: `DEFAULT_TOPIC_ROOT`를 `mam/<sha256[:12]>/jobs`로 전환. 발행측 전환 후 `reconcile.sh`의 레거시 구독 단계적 제거.
+3. 배포 설정에 nkeys 기반 계정 분리 적용.
+
+### 5.4 Track 3 — 문서 및 설정 동기화
+- `MESSAGING.md`: 브로커 사양을 `nats-server`로 갱신, F-1/C1 해소 기록, F-5 실측에 맞춘 영속 세션 설명 정정.
+- `IMPROVEMENTS.md` & `VERSIONS.md`: A-2 완료 전환, F-1/F-4/F-5 백로그 이력 반영.
+- `.mam.env`: `nats-server` 포트(1883/8883) 및 인증 템플릿 갱신.
+
+---
+
+## 6. 비-목표 (Explicit Non-Goals)
+
+1. ❌ **`nats-py` 라이브러리 도입 및 클라이언트 비동기 재작성**: 불필요한 복잡도 및 장애 유발.
+2. ❌ **`.mam/jobs/*.json`의 JetStream KV 대체**: 파일시스템 폴링 제어 계약을 훼손하므로 상태 계층 변경 제외.
+3. ❌ **Durable Session 강제 도입을 위한 `client_id` 고정**: 동시성 충돌 위험이 크며, Track 0 디스크 폴백이 동일 복원력을 무비용으로 제공함.
+4. ❌ **`requirements.txt` 내 `paho-mqtt>=2.0.0` 제거**: 현행 종속성 유지.
+
+---
+
+## 7. 결론
+
+MAM 프레임워크의 메시징 백플레인은 **클라이언트 프로토콜(MQTT)을 100% 보존한 상태에서 `nats-server`를 전용 브로커로 채택(Option C)**하는 것이 기술적·운영적·보안적 최적해입니다. 
+
+선행 필수 과제인 **Track 0(F-1 + C1 + F-4 가용성 결함 교정)**을 우선 완수한 후, 스파이크 검증(Track 1) 및 A-2 보안 강화(Track 2)를 순차 전개합니다.

PRIVATE_SERVER.md

@@ -0,0 +1,327 @@
+# 🔒 MAM 개인 전용 브로커(Private Broker) 구축 및 연동 가이드 (`PRIVATE_SERVER.md`)
+
+- **작성일**: 2026-08-20 (Rev.2)
+- **문서 목적**: MAM(Multi-Agent Mux)의 공개 브로커 의존성 및 보안 결함(A-2)을 해소하기 위한 개인 전용 브로커(NATS / Mosquitto) 구축, 운영, 다능성 활용 및 MAM 클라이언트 연동 가이드.
+- **연계 문서**: [`NATS_REPORT.md`](NATS_REPORT.md), [`implementation_plan.md`](implementation_plan.md), [`IMPROVEMENTS.md`](IMPROVEMENTS.md)
+
+---
+
+## 1. 개요 및 도입 배경
+
+현재 MAM 프레임워크의 기본 메시징 브로커는 공개 서버(`broker.hivemq.com:1883`)로 설정되어 있습니다. 개인 전용 브로커(Private Broker)를 구축하여 연결하면 **클라이언트 코드 변경 없이(0줄 변경)** 보안 위험을 원천 차단하고 네트워크 안정성을 대폭 향상시킬 수 있습니다.
+
+```
+[MAM Orchestrator / Agents]
+       │
+       ▼ (MQTT 3.1.1 / TLS)
+[Private Dedicated Broker]  ───> 사설망/개인 서버 (NATS Server / Mosquitto)
+                                 • 외부 불법 트래픽 100% 차단 (A-2 보안 해소)
+                                 • JetStream 영속성 및 NKey/JWT ACL 지원
+                                 • 초저지연 (<1ms) 및 무제한 대역폭
+```
+
+MAM의 제어 평면(`run_loop.sh`의 `wait_for_job` 파일시스템 폴링)은 브로커와 100% 독립적으로 작동하므로, 브로커는 **비동기 관측(observability) 사이드카** 역할을 수행합니다.
+
+---
+
+## 2. 해결 영역 매트릭스 (브로커 전환 vs 코드 패치)
+
+전용 브로커 구축으로 즉시 해결되는 영역과, 로컬 코드 패치(Track 0)가 병행되어야 하는 영역의 명확한 구분입니다.
+
+| 구분 | 당면 과제 | 개인 브로커 구축 시 | 로컬 코드 패치 필요 여부 (Track 0) |
+|---|---|:---:|:---:|
+| **보안 (A-2)** | 공개 브로커 노출 및 외부 악의적 이벤트 수신 위협 | 🟢 **100% 즉시 해소** (사설망/ACL 격리) | Track 2에서 토큰 발급 강제 |
+| **안정성** | 공개 브로커의 예고 없는 순단 및 속도 제한(Rate-limit) | 🟢 **100% 즉시 해소** (전용 리소스) | — |
+| **내결함성 (B-14)** | 브로커 일시 장애 시 65분 루프 정지(Hang) 결함 | ⚠️ 브로커 점검/순단 시 여전히 위험 | 🔴 **필수 (Track 0 Step 1 선행 패치)** |
+| **지연/오판 (B-15)** | 브로커 다운 시 120초 지연 및 정상 작업의 에러 오판정 | ⚠️ 브로커 점검/순단 시 여전히 위험 | 🔴 **필수 (Track 0 Step 2 & 3 선행 패치)** |
+
+> [!IMPORTANT]
+> **방탄 아키텍처 원칙:**
+> "Track 0(`B-14`, `B-15`) 패치를 통해 브로커가 다운되어도 루프가 100% 정상 완주하도록 로컬 디스크 내결함성을 먼저 확보하고, 개인 브로커를 연결하여 A-2 보안과 성능을 완결합니다."
+
+---
+
+## 3. 전용 브로커 추천 및 비교
+
+MAM 클라이언트는 표준 `paho-mqtt`를 사용하므로, MQTT 3.1.1을 지원하는 모든 브로커와 100% 호환됩니다.
+
+| 비교 항목 | 🏆 `nats-server` (강력 권장) | `eclipse-mosquitto` (대안) |
+|---|---|---|
+| **아키텍처** | Go 단일 정적 바이너리 (Zero Dependency) | C 기반 경량 오픈소스 브로커 |
+| **주요 특징** | • 내장 MQTT 3.1.1 리스너 (`mqtt { port: 1883 }`)<br>• JetStream 엔진 내장 (이벤트 영속화 및 복구)<br>• NKey/JWT 기반 계정 및 Subject별 세분화된 ACL<br>• WebSocket 및 NATS 네이티브 프로토콜 동시 서빙 | • 가장 널리 쓰이는 표준 경량 MQTT 브로커<br>• 낮은 메모리 점유율 (~10MB) |
+| **추천 용도** | 모던 인프라, 확장성, 감사 로그 영속화, 홈랩 통합 | 정통 초경량 임베디드/단일 목적 환경 |
+| **배포 난이도** | 🟢 바이너리 1개 실행 또는 Docker 1줄 | 🟢 패키지 매니저 (`apt`, `brew`) 또는 Docker |
+
+---
+
+## 4. 개인 서버 브로커 배포 가이드
+
+### 4.1 `nats-server` 배포 (권장)
+
+`nats-server`에서 MQTT를 활성화하려면 설정 파일(`nats.conf`)에 `mqtt { port: 1883 }` 블록과 `jetstream { }` 블록이 반드시 포함되어야 합니다.
+
+> [!NOTE]
+> `nats-server`의 `-m` 플래그는 HTTP 모니터링 포트(`--http_port`)를 지정하는 옵션이며, MQTT를 켜는 플래그가 아닙니다. MQTT 활성화는 반드시 `-c nats.conf` 설정 파일을 통해 구성해야 합니다.
+
+#### 1) 공통 설정 파일 (`nats.conf`)
+```conf
+# nats.conf
+server_name: mam-hub
+
+# JetStream 영속 스토리지 (MQTT QoS 1 및 Retained 메시지 처리에 필수)
+jetstream {
+  store_dir: "~/.local/share/nats/data"   # Docker 환경에서는 "/data"로 매핑
+  max_file:  10G                          # 홈랩 디스크 상한 설정
+}
+
+# HTTP 모니터링 엔드포인트 (/varz, /jsz 대시보드)
+http_port: 8222
+
+# 평면 A: MAM MQTT 3.1.1 프로토콜 리스너
+mqtt {
+  port: 1883
+}
+
+# 평면 B: 홈랩/웹 브라우저 대시보드용 WebSocket 리스너 (선택 사항)
+websocket {
+  port: 8080
+  no_tls: true                            # 내부 사설망 한정
+}
+```
+
+#### 2) 배포 방법 A. Docker / Docker Compose (권장)
+
+**단일 Docker 실행:**
+```bash
+# 호스트에 nats.conf 생성 후 실행
+docker run -d \
+  --name mam-nats \
+  --restart unless-stopped \
+  -p 1883:1883 \
+  -p 4222:4222 \
+  -p 8222:8222 \
+  -p 8080:8080 \
+  -v ./nats.conf:/etc/nats/nats.conf:ro \
+  -v nats-data:/data \
+  nats:latest \
+  -c /etc/nats/nats.conf
+```
+
+**Docker Compose (`docker-compose.yml`):**
+```yaml
+version: '3.8'
+
+services:
+  nats:
+    image: nats:latest
+    container_name: mam-nats
+    restart: unless-stopped
+    command: ["-c", "/etc/nats/nats.conf"]
+    ports:
+      - "1883:1883"   # MQTT 3.1.1 포트 (평면 A: MAM)
+      - "4222:4222"   # NATS 기본 포트 (평면 B)
+      - "8222:8222"   # HTTP 모니터링 (/varz, /jsz)
+      - "8080:8080"   # WebSocket (평면 B)
+    volumes:
+      - ./nats.conf:/etc/nats/nats.conf:ro
+      - nats-data:/data
+
+volumes:
+  nats-data:
+```
+
+#### 3) 배포 방법 B. 네이티브 바이너리 설치 (macOS / Linux — 비루트 사용자 공간)
+
+macOS의 sealed APFS 루트 볼륨(`/data`) 권한 문제를 방지하기 위해 사용자 홈 디렉터리(`~/.config/nats/`, `~/.local/share/nats/data`)를 기본 스토리지로 사용합니다.
+
+```bash
+# 설정 및 데이터 디렉터리 생성 (sudo 불필요)
+mkdir -p ~/.config/nats ~/.local/share/nats/data
+
+# 설정 파일 작성
+cat <<'EOF' > ~/.config/nats/nats.conf
+server_name: mam-hub
+jetstream {
+  store_dir: "~/.local/share/nats/data"
+  max_file:  10G
+}
+http_port: 8222
+mqtt {
+  port: 1883
+}
+websocket {
+  port: 8080
+  no_tls: true
+}
+EOF
+
+# macOS (Homebrew 설치 및 실행)
+brew install nats-server
+nats-server -c ~/.config/nats/nats.conf &
+
+# Linux (x86_64 단일 바이너리 설치 및 실행)
+curl -L https://github.com/nats-io/nats-server/releases/download/v2.10.20/nats-server-v2.10.20-linux-amd64.tar.gz | tar xz
+sudo mv nats-server-v2.10.20-linux-amd64/nats-server /usr/local/bin/
+nats-server -c ~/.config/nats/nats.conf &
+```
+
+---
+
+### 4.2 `mosquitto` 배포 (대안)
+
+#### Docker 실행:
+```bash
+docker run -d \
+  --name mam-mosquitto \
+  --restart unless-stopped \
+  -p 1883:1883 \
+  -v ./mosquitto.conf:/mosquitto/config/mosquitto.conf \
+  eclipse-mosquitto:latest
+```
+
+**기본 `mosquitto.conf` 설정 파일 예시:**
+```conf
+listener 1883
+allow_anonymous true
+persistence true
+persistence_location /mosquitto/data/
+```
+
+---
+
+## 5. 하나의 서버로 여러 프로젝트 — `nats-server` 다능성 (Versatility)
+
+`nats-server`의 다능성은 **MAM을 네이티브 NATS로 이관할 이유가 아니라, MAM 코드를 한 줄도 바꾸지 않고도 얻을 수 있는 부가적 이득**입니다.
+
+### 5.1 두 개의 소비 평면 (Two Consumption Planes)
+
+`nats-server`는 단일 프로세스 내에서 여러 프로토콜 리스너를 동시에 구동하므로, MAM의 단순성과 개인 홈랩의 확장성을 완벽히 양립시킵니다.
+
+```
+                  ┌───────────────────────────────────────────────────────────┐
+                  │                 nats-server (단일 인스턴스)                 │
+                  ├─────────────────────────────┬─────────────────────────────┤
+                  │     평면 A: MAM 워크로드     │    평면 B: 홈랩/개인 프로젝트 │
+                  ├─────────────────────────────┼─────────────────────────────┤
+  프로토콜         │ MQTT 3.1.1 (포트 1883)       │ NATS(4222), WebSocket(8080) │
+  클라이언트       │ paho-mqtt (코드 변경 0줄)    │ nats-py, nats.js, CLI 등 자유 │
+  사용 기능       │ QoS 1, Retain, 와일드카드, TLS│ JetStream 리플레이, KV, Object│
+  설계 원칙       │ 초경량 동기 CLI 핫패스 보존   │ 고급 비동기 이벤트 스트리밍   │
+  공유 자원       │ └───── 단일 정적 바이너리 / JetStream 스토리지 / ACL ─────┘│
+                  └───────────────────────────────────────────────────────────┘
+```
+
+### 5.2 교차 프로토콜 브리징 (Cross-Protocol Bridging)
+- `nats-server`는 내부적으로 MQTT 토픽(`/`)을 NATS Subject(`.`)로 실시간 자동 변환합니다.
+- MAM 에이전트가 MQTT 토픽 `python/mqtt/jobs/<job_id>/events`로 이벤트를 발행하면, 웹 브라우저나 타 프로젝트의 NATS 구독자는 NATS Subject `python.mqtt.jobs.<job_id>.events` 또는 `python.mqtt.jobs.*.events`로 즉시 실시간 수신할 수 있습니다.
+- **실용적 이점**: MAM 소스 코드를 단 1줄도 수정하지 않고도 React/Vue 웹 대시보드나 터미널 모니터링 툴을 즉시 부착할 수 있습니다.
+- **주의 사항**: 토픽 레벨 내에 마침표(`.`)가 포함되면 NATS 계층에서 토큰이 분리될 수 있으나, MAM의 `job_id`는 8자리 hex, 워크스페이스 지문은 12자리 hex이므로 안전합니다.
+
+### 5.3 JetStream 이벤트 리플레이 (Event Replay)
+- `python.mqtt.jobs.>` Subject를 구독하는 JetStream 스트림을 생성하면, 지난 작업의 이벤트 스트림 전체를 시점 지정(Time-based) 또는 시퀀스 지정(Sequence-based)으로 사후 리플레이할 수 있습니다.
+- **주의 사항**: 이 기능은 옵트인(Opt-in)이며, MQTT QoS 1 처리를 위한 내부 시스템 스트림(`$MQTT_*`)과 별개로 관리됩니다. 디스크 용량 관리를 위해 `max_age`나 `max_bytes` 상한을 반드시 설정해야 합니다.
+
+### 5.4 내장 Key-Value (KV) 및 Object Store
+- 홈랩 및 개인 프로젝트에서 Redis나 MinIO 같은 별도 인프라를 띄우지 않고도 `nats-server` 내장 KV 및 Object Store를 즉시 사용할 수 있습니다.
+- **금지 사항 (Non-Goal)**: MAM의 로컬 레지스트리(`.mam/jobs/*.json`)를 JetStream KV로 대체해서는 안 됩니다 (`wait_for_job`의 fcntl 및 파일시스템 폴링 계약 유지).
+
+### 5.5 멀티테넌트 계정 분리 및 보안
+- 단일 서버 내에서 `MAM` 전용 계정과 `HOME` 개인 계정을 분리하여 리소스 쿼터와 권한을 완벽히 격리할 수 있습니다.
+- **권고 배치**: MAM과 이를 관측하는 대시보드는 동일한 계정(`MAM`)에 배치하고, 무관한 홈랩 서비스는 별도 계정(`HOME`)에 배치합니다.
+
+---
+
+## 6. MAM 클라이언트 연동 설정 (`.mam.env`)
+
+개인 서버 브로커가 구동되면, MAM 저장소 루트의 [`.mam.env`](file:///.mam.env) 파일에 개인 서버 주소를 등록합니다.
+
+> [!NOTE]
+> MAM 코드(`mqtt_common.py`)는 `MQTT_*` 접두사의 환경변수를 읽습니다. 이전 비공식 문서의 `MAM_MQTT_*` 변수는 무효하므로 반드시 아래의 표준 변수명을 사용해야 합니다.
+
+```bash
+# ==============================================================================
+# MAM Private MQTT Broker Configuration (.mam.env)
+# ==============================================================================
+
+# 개인 서버 IP 또는 도메인
+MQTT_BROKER="192.168.1.100"      # 예: 10.0.0.5, mqtt.my-domain.com 등
+
+# MQTT 기본 포트 (평문 TCP: 1883, TLS 암호화: 8883)
+MQTT_PORT=1883
+
+# TLS 암호화 활성화 여부 (0: 평문 TCP, 1: TLS 암호화)
+MQTT_TLS=0
+
+# 인증 설정 (익명 브로커는 주석 처리 또는 빈 문자열 유지)
+# MQTT_USERNAME=my_agent_user
+# MQTT_PASSWORD=my_secure_password
+
+# TLS 인증서 경로 (MQTT_TLS=1 설정 시 사용)
+# MQTT_CA_CERTS=/path/to/ca.crt
+# MQTT_CERTFILE=/path/to/client.crt
+# MQTT_KEYFILE=/path/to/client.key
+```
+
+*참고: OS 환경변수에 동일한 이름이 이미 `export`되어 있는 경우 OS 환경변수가 `.mam.env` 파일 설정보다 우선합니다.*
+
+---
+
+## 7. 연동 및 동작 검증 테스트 (4-Step Verification)
+
+개인 서버 브로커와의 연동 상태를 정확하게 검증하는 4단계 절차입니다.
+
+### Step 1. 브로커 리스너 및 JetStream 상태 확인
+```bash
+# MQTT 리스너 활성화 확인
+curl -s http://192.168.1.100:8222/varz | grep -i mqtt
+
+# JetStream 엔진 정상 구동 확인
+curl -s http://192.168.1.100:8222/jsz
+```
+
+### Step 2. 임시 잡 등록 및 연결 검증 이벤트 발행
+`publish_event.py`는 레지스트리에 등록된 잡에 대해서만 발행을 수행하므로, 임시 잡을 등록하고 발행한 후 완료 처리합니다.
+
+```bash
+# 1) 임시 잡 등록 (자동 채번된 JID 캡처)
+JID=$(.venv/bin/python .agents/skills/multi-agent-mux-delegate-job/scripts/registry.py \
+        --registry-dir .mam/jobs \
+        register \
+          --prompt "Private broker connectivity test" \
+          --agent-session "herdr:test")
+echo "registered test job: $JID"
+
+# 2) 이벤트 발행 (상세 로그 출력 및 rc=0 단언)
+.venv/bin/python .agents/skills/multi-agent-mux-delegate-job/scripts/publish_event.py \
+  --registry-dir .mam/jobs \
+  --job "$JID" \
+  --event progress \
+  --detail "Private broker connection verified" -v
+
+# 3) 테스트 잡 종결 처리 (미종결 시 --wait-any 유령 잡 잔존 방지)
+.venv/bin/python .agents/skills/multi-agent-mux-delegate-job/scripts/registry.py \
+  --registry-dir .mam/jobs status --job "$JID" --set completed
+```
+
+### Step 3. 접속 대상 브로커 IP 단언
+Step 2의 `-v` 출력 로그 또는 `.mam/delegate_job_logs/$JID/events.ndjson` 파일에서 실제 접속 호스트가 개인 브로커 IP로 나타나고 `broker.hivemq.com`이 포함되지 않았는지 확인합니다.
+
+### Step 4. 단위 회귀 테스트 검증
+```bash
+.venv/bin/python -m pytest tests/ -q
+```
+*참고: MAM의 기본 단위/컴포넌트 테스트 스위트는 모의(Mock) 객체를 사용하므로 브로커 연결 여부와 무관하게 100% 통과합니다. 실제 네트워크 연동 검증은 Step 1~3이 담당합니다.*
+
+---
+
+## 8. 권장 실행 순서
+
+```
+[Phase 1: 내결함성 확보] ──> [Phase 2: 개인 브로커 가동] ──> [Phase 3: A-2 보안 완전 종결]
+ Track 0 (B-14, B-15)         nats-server (nats.conf)         지문 토픽 및 인증 토큰 발급
+ 로컬 디스크 폴백 패치         .mam.env 환경변수 연동         외부 간섭 100% 차단
+```
+
+1. **Phase 1 (Track 0 선행 패치)**: `publish_event.py`와 `job_subscriber.py`의 로컬 디스크 폴백(`B-14`, `B-15`)을 먼저 적용하여 브로커 다운 시에도 루프가 멈추지 않는 방탄 구조를 확립합니다.
+2. **Phase 2 (개인 브로커 가동)**: 개인 서버에 `nats-server -c nats.conf`를 구동하고 `.mam.env`에 `MQTT_BROKER`를 연결합니다.
+3. **Phase 3 (A-2 보안 완전 종결)**: 워크스페이스 지문 토픽(`mam/<sha256[:12]>/jobs/...`) 및 무조건 토큰 발급을 적용하여 공개 브로커 위험을 완전히 영구 폐기합니다.

implementation_plan.md

@@ -0,0 +1,167 @@
+# 🚀 MAM 메시징 백플레인 전환 실행 로드맵 (`implementation_plan.md`)
+
+- **문서 버전**: v1.0.0 (`8c651798` / `28bb7340`)
+- **작성/관리 주체**: Multi-Agent Orchestration Team (`claude`, `agy`, `cline`)
+- **기준 커밋**: `a9934ad` (276/276 baseline tests passing)
+- **문서 목적**: MAM의 메시징 인프라를 공개 HiveMQ 브로커에서 `nats-server` 전용 사설 브로커로 무중단 전환하기 위한 4개 트랙(Track 0~3)과 5단계 마일스톤(M0~M4)의 구체적 실행 지침 및 진행 상황 추적.
+- **연계 문서**: [`NATS_REPORT.md`](NATS_REPORT.md), [`PRIVATE_SERVER.md`](PRIVATE_SERVER.md), [`IMPROVEMENTS.md`](IMPROVEMENTS.md)
+
+---
+
+## 1. 개요 및 4개 트랙 구조
+
+```
+[M0: 문서 정합성] ──> [M1: 내결함성 확보] ──> [M2: 브로커 실증] ──> [M3: 보안 종결] ──> [M4: 동기화 완료]
+ (E-1~E-4 교정,       (Track 0: B-14,B-15,     (Track 1: O-5      (Track 2: A-2,      (Track 3: 문서,
+  G-D1~G-D4 가드)      G-1~G-10 가드)           S-1~S-9 스파이크)  지문 토픽, G-11)    배포 스크립트)
+```
+
+| 트랙 | 대상 과제 | 핵심 목표 | 코드 변경 지점 |
+|---|---|---|---|
+| **Track 0** | `B-14`, `B-15` (P1) | 브로커 다운 시 65분 정지(Hang) 및 오판정 방지 (로컬 디스크 내결함성) | `publish_event.py`, `job_subscriber.py`, `multi-agent-mux-delegate-job` |
+| **Track 1** | `O-5` (P2) | `nats-server` MQTT 3.1.1 어댑터 호환성 및 Retained 메시지 실측 검증 | 격리 클론 (`$SCRATCH/nats-spike`) |
+| **Track 2** | `A-2`, `B-16` (P2) | 워크스페이스 지문 토픽 격리 및 `auth_token` 무조건 발급 강제 | `mqtt_common.py`, `registry.py`, `reconcile.sh` |
+| **Track 3** | 문서/설정 동기화 | 공식 가이드, 배포 스크립트, 환경변수 템플릿 일원화 | `MESSAGING.md`, `IMPROVEMENTS.md`, `VERSIONS.md`, `deploy/*` |
+
+---
+
+## 2. 단계별 마일스톤 (Milestones M0 ~ M4)
+
+각 마일스톤은 완료 정의(DoD)와 엄격한 게이트(Gate)를 가지며, 게이트 조건을 충족하지 못하면 다음 마일스톤으로 진입할 수 없습니다.
+
+```
+M0 (문서 정합성) ──> M1 (Track 0 내결함성) ──> M2 (Track 1 실증) ──> M3 (Track 2 보안) ──> M4 (Track 3 완결)
+```
+
+| 마일스톤 | 이름 | 완료 정의 (Definition of Done) | 통과 게이트 (Gate Condition) |
+|---|---|---|---|
+| **M0** | 문서 정합성 확보 | `PRIVATE_SERVER.md` E-1~E-4 교정, 다능성 절 추가, 본 로드맵 작성 | **G-D1 ~ G-D4 가드 테스트 통과** (276 -> 280) |
+| **M1** | 내결함성 확보 (Track 0) | `B-14`, `B-15` 코드 패치 완료 | **G-1 ~ G-10 가드 통과 + mutation 전건 FAIL 확인** (280 -> 290) |
+| **M2** | 브로커 실증 (Track 1) | 격리 클론에서 S-1 ~ S-9 스파이크 완수 | **S-3(Retained Terminal Event) 통과** (실패 시 mosquitto로 분기) |
+| **M3** | 보안 종결 (Track 2) | A-2 지문 토픽 전환, G-11 무조건 토큰 발급 | 지문 토픽 동작 확인 **후** legacy 구독 제거 (290 -> 291) |
+| **M4** | 동기화 완료 (Track 3) | `MESSAGING.md`, `IMPROVEMENTS.md`, `VERSIONS.md`, `deploy/*` 정합 | 전체 테스트 스위트 100% Green |
+
+---
+
+## 3. Track 0: 가용성 및 로컬 내결함성 교정 (`B-14`, `B-15`)
+
+> **핵심 원칙**: 브로커 선택과 완전히 독립적인 선행 과제이며, **Step 1 -> Step 2 -> Step 3의 엄격한 순서 의존성**을 갖습니다. Step 2를 먼저 구현하면 디스크에 터미널 상태가 기록되지 않아 폴백 효과가 0이 됩니다.
+
+```
+[Step 1: publish_event.py] ──> [Step 2: job_subscriber.py] ──> [Step 3: delegate-job rc 매핑]
+  디스크 상태 동기화 선행         로컬 디스크 폴백 감지           인프라 에러(rc=3) 분리
+```
+
+### 3.1 Step 1 — `publish_event.py` 실패 처리 순서 재구성 (`B-14` / `F-1`)
+1. `publish(...)` 함수를 `try-except`로 감싸되, 네트워크 실패 시 즉시 `return 2` 하지 않고 `publish_ok = False`로 표시합니다.
+2. `mqtt_common.append_event` 감사 로그 작성 및 `mqtt_common.update_job_status(status=new_status)` 레지스트리 상태 동기화를 **발행 성공 여부와 무관하게 항상 수행**합니다.
+3. 감사 로그 레코드에 `"published": publish_ok` 및 `"publish_error": str(exc)` 필드를 기록합니다.
+4. 모든 로컬 디스크 동기화가 완료된 후, 네트워크 발행이 실패했다면 기존 호출부 계약 유지를 위해 `return 2`를 반환합니다.
+
+### 3.2 Step 2 — `job_subscriber.py` 로컬 디스크 폴백 도입 (`B-15` / `C1`)
+1. 대기 루프의 `queue.Empty` 분기(`job_subscriber.py:233`)에서, 3초 간격 스로틀로 감시 중인 잡의 디스크 터미널 상태를 확인합니다 (`registry.load_job` -> `mqtt_common.read_logged_status`).
+2. 디스크에서 터미널 상태(`completed` 또는 `error`)가 감지되면, `source: disk-fallback` 합성 이벤트를 표준 출력에 기록하고 즉시 정상 종료합니다.
+3. 종료 코드 매핑: 디스크 상태가 `completed`이면 `return 0`, `error`이면 `return 1`을 반환합니다.
+
+### 3.3 Step 3 — `multi-agent-mux-delegate-job` 인프라 예외 분리 (`B-15` / `F-4`)
+1. `job_subscriber.py`의 미포착 브로커 접속 예외에 전용 종료 코드 `rc=3`을 부여합니다.
+2. `multi-agent-mux-delegate-job:331-341`의 `sub_rc` 매핑에 `rc=3` 분기를 추가하여 `job_status="broker_unavailable"`로 분류하고, `wait_for_job`과 동일하게 디스크 상태를 재확인합니다.
+
+### 3.4 Track 0 회귀 가드 매트릭스 (10종 신설 — G-1 ~ G-10)
+
+| ID | 가드 내용 | 변이 검출 기준 (Mutation) |
+|---|---|---|
+| **G-1** | 브로커 도달 불가 시 `publish_event.py`가 `rc=2`이면서 레지스트리 `status=completed` 기록 | `return 2`를 상태 동기화 앞으로 이동 시 FAIL |
+| **G-2** | 동일 상황 감사 로그에 `published: false` 및 `publish_error` 레코드 존재 | `append_event`를 성공 경로로만 한정 시 FAIL |
+| **G-3** | 브로커 정상 시 `rc=0` + `status=completed` + `published: true` 무회귀 검증 | — |
+| **G-4** | 발행 실패 후 `last_seq`가 1 증가하고 후속 발행이 더 큰 seq 사용 | seq 롤백 도입 시 FAIL |
+| **G-5** | 디스크 `status=completed` 선작성 시 브로커 다운 상태에서도 `job_subscriber.py`가 3초 내 `rc=0` 종료 | 디스크 폴백 제거 시 FAIL |
+| **G-6** | 동일 조건에서 stdout 합성 라인에 `disk-fallback` 표기 확인 | 표기 누락 시 FAIL |
+| **G-7** | 디스크 `status=error` 시 폴백 `rc=1` 반환 확인 | 매핑 반전 시 FAIL |
+| **G-8** | 다중 잡 감시 시 전체 완료 전까지 조기 종료 방지 | 부분 종료 도입 시 FAIL |
+| **G-9** | 디스크 터미널 부재 + 브로커 실패 시 `rc=3` 반환 확인 | `rc=1`로 되돌릴 시 FAIL |
+| **G-10** | `loop` 위임 경로에서 `rc=3` 수신 시 `job_status`가 `"error"`로 오판되지 않음 확인 | 3분기 매핑 복원 시 FAIL |
+
+---
+
+## 4. Track 1: `nats-server` 스파이크 검증 (`O-5`)
+
+> **실행 원칙**: 메인 저장소 작업 트리를 오염시키지 않기 위해 격리 클론(`git clone --local --no-hardlinks . "$SCRATCH/nats-spike"`)에서 수행하고 종료 후 삭제합니다.
+
+| ID | 검증 항목 | 검증 방법 | 통과 기준 |
+|---|---|---|---|
+| **S-1** | `nats-server` MQTT 리스너 기본 수용 | `nats-server -c nats.conf` 기동 후 `started/progress/completed` 3연속 발행 | `rc=0`, 레지스트리 `status=completed` |
+| **S-2** | paho 2.x `CallbackAPIVersion.VERSION2` 호환 | `on_connect` CONNACK reason code 수신 확인 | `reason_code == 0` |
+| **S-3** | **Retained Terminal Event 전달** (핵심 관문) | `--event completed` 발행 후 신규 `job_subscriber.py` 기동 | **즉시 최종 이벤트 수신** (*실패 시 mosquitto로 회귀*) |
+| **S-4** | QoS 1 발행 ACK | `info.wait_for_publish()` 대기 | `is_published() == True` |
+| **S-5** | 와일드카드 토픽 라우팅 | `mam/<fp>/jobs/+/events` 구독 후 이벤트 수신 | `SUBSCRIBED` 출력 및 페이로드 수신 |
+| **S-6** | 인증 및 TLS 암호화 | user/pass 및 TLS 구성 후 접속 테스트 | 자격증명 누락 시 거부, 유효 시 성공 |
+| **S-7** | Subject 단위 권한 격리 | Publisher write-only / Subscriber read-only 설정 | 비인가 작업 시 연결 거부 |
+| **S-8** | 전체 회귀 테스트 | `pytest tests/ -q` | **전건 PASS (0 failed)** |
+| **S-9** | Track 0 내결함성 통합 검증 | `nats-server` 강제 종료 상태에서 위임 잡 완주 테스트 | `wait_for_job` 3초 내 반환 |
+
+---
+
+## 5. Track 2: A-2 보안 결함 및 워크스페이스 격리 해소 (`A-2`, `B-16`)
+
+1. **`auth_token` 무조건 발급 (`F-3` / `G-11`)**:
+   `registry.register_job()`에서 브로커 설정과 무관하게 항상 `secrets.token_urlsafe(32)` 기반 토큰을 발급하여 공개 브로커 환경에서도 HMAC 검증이 무력화되지 않도록 강제합니다.
+2. **워크스페이스 지문 토픽 3단계 전환 (`F-2`)**:
+   - Step 1: 발행자 기본 토픽을 `mam/<sha256[:12]>/jobs/<id>/events`로 전환합니다.
+   - Step 2: 실환경 및 통합 테스트에서 이벤트 수신을 확인합니다.
+   - Step 3: `reconcile.sh:237`의 레거시 전역 토픽(`python/mqtt/jobs/...`) 구독을 제거합니다.
+
+---
+
+## 6. Track 3: 문서 및 배포 설정 동기화
+
+| 대상 파일 | 갱신 내용 |
+|---|---|
+| [`MESSAGING.md`](MESSAGING.md) | 브로커 표준을 `nats-server`로 갱신, F-1/C1 해소 기록, F-5 영속 세션 서술 정정 |
+| [`IMPROVEMENTS.md`](IMPROVEMENTS.md) | A-2 완료 전환, B-14/B-15/B-16/O-5 해결 상태 갱신 |
+| [`VERSIONS.md`](VERSIONS.md) | `v2.0.0` 릴리스 노트에 메시징 백플레인 고도화 및 내결함성 패치 기록 |
+| [`PRIVATE_SERVER.md`](PRIVATE_SERVER.md) | 스파이크 결과 반영 및 최종 가이드 확정 |
+| [`deploy/install.sh`](deploy/install.sh) | `requirements.txt` 확인 (paho 유지) 및 개인 브로커 안내 추가 |
+| [`.mam.env`](.mam.env) | `MQTT_BROKER`, `MQTT_PORT`, `MQTT_TLS` 기본 템플릿 확정 |
+
+---
+
+## 7. 의존성 그래프 및 롤백 전략
+
+```
+[M0: 문서/가드] ────────────┐
+  │                         │ (M0 A-1 환경변수 정렬 선행)
+  ▼                         ▼
+[M1: Track 0 내결함성] ──> [M2: Track 1 스파이크] ──> [M3: Track 2 보안] ──> [M4: 동기화]
+```
+
+- **롤백 전략**:
+  - `nats-server` 스파이크(S-3) 실패 시: 클라이언트 코드 변경 없이 `.mam.env`의 브로커 주소만 `eclipse-mosquitto`로 전환합니다 (가역성 100%).
+  - Track 0 내결함성 패치는 브로커 제품과 무관하게 순수 이득이므로 롤백하지 않고 영구 유지합니다.
+
+---
+
+## 8. 진행 추적 체크리스트
+
+### M0: 문서 정합성 확보
+- [x] `PRIVATE_SERVER.md` E-1~E-4 교정 및 다능성 절(§5) 추가
+- [x] `implementation_plan.md` 4개 트랙 및 마일스톤 수립
+- [x] `tests/test_deploy_freshness.py` 내 G-D1 ~ G-D4 문서 드리프트 가드 구현
+
+### M1: Track 0 내결함성 확보 (`B-14`, `B-15`)
+- [x] Step 1: `publish_event.py` 상태 동기화 선행 처리 (`B-14` / G-1~G-4)
+- [x] Step 2: `job_subscriber.py` 로컬 디스크 폴백 도입 (`B-15` / G-5~G-8)
+- [x] Step 3: `multi-agent-mux-delegate-job` 인프라 `rc=3` 에러 분리 (`F-4` / G-9~G-10)
+- [x] M1 통합 검증 (브로커 다운 상태 위임 3초 완주)
+
+### M2: Track 1 `nats-server` 실증 (`O-5`)
+- [ ] 격리 클론 생성 (`$SCRATCH/nats-spike`)
+- [ ] S-1 ~ S-9 스파이크 매트릭스 검증 수행
+- [ ] S-3 Retained 메시지 게이트 통과 확인
+
+### M3: Track 2 보안 및 토픽 격리 (`A-2`, `B-16`)
+- [ ] G-11 무조건 `auth_token` 발급 적용
+- [ ] 워크스페이스 지문 토픽 발행 전환 및 레거시 구독 제거
+
+### M4: Track 3 문서 및 배포 동기화
+- [ ] `MESSAGING.md`, `IMPROVEMENTS.md`, `VERSIONS.md`, `deploy/*` 최종 갱신

tests/test_deploy_freshness.py

@@ -10,8 +10,10 @@ pre-loop skill set, so it strands those same assets plus the whole
 """
 import json
 import os
+import re
 import shutil
 import subprocess
+import sys
 import tempfile
 
 import pytest
@@ -262,3 +264,91 @@ def test_d10_customization_survives_repeated_refresh(src_and_target):
         assert "Local modification detected" in res.stderr, (
             "refresh #%d overwrote nothing but also reported nothing; the "
             "user gets no signal that their edit is diverging" % n)
+
+
+# --------------------------------------------------------------------------
+# D-11 — (G-D1) PRIVATE_SERVER.md must only document MQTT_* environment
+#        variables that broker_config_from_env() actually parses.
+# --------------------------------------------------------------------------
+def test_d11_private_server_env_names_valid():
+    sys.path.insert(0, os.path.join(REPO_ROOT, ".agents", "skills", "multi-agent-mux-delegate-job", "scripts"))
+    import mqtt_common
+
+    doc_path = os.path.join(REPO_ROOT, "PRIVATE_SERVER.md")
+    assert os.path.exists(doc_path), "PRIVATE_SERVER.md missing"
+    with open(doc_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Extract all code blocks
+    code_blocks = re.findall(r"```(?:bash|conf|yaml|)(.*?)```", content, re.DOTALL)
+    assert code_blocks, "No code blocks found in PRIVATE_SERVER.md"
+
+    # Known recognized MQTT env vars from broker_config_from_env()
+    recognized = {
+        "MQTT_BROKER", "MQTT_PORT", "MQTT_TLS", "MQTT_USERNAME", "MQTT_PASSWORD",
+        "MQTT_CLIENT_ID_PREFIX", "MQTT_CA_CERTS", "MQTT_CERTFILE", "MQTT_KEYFILE",
+        "MQTT_KEEPALIVE", "MAM_MQTT_HOST"  # checked for exclusion
+    }
+    valid_mqtt_vars = {
+        "MQTT_BROKER", "MQTT_PORT", "MQTT_TLS", "MQTT_USERNAME", "MQTT_PASSWORD",
+        "MQTT_CLIENT_ID_PREFIX", "MQTT_CA_CERTS", "MQTT_CERTFILE", "MQTT_KEYFILE",
+        "MQTT_KEEPALIVE"
+    }
+
+    for block in code_blocks:
+        found_vars = set(re.findall(r"\b(MQTT_[A-Z0-9_]+)\b", block))
+        invalid = found_vars - valid_mqtt_vars
+        assert not invalid, f"Invalid or unrecognized MQTT variables in PRIVATE_SERVER.md code blocks: {invalid}"
+
+
+# --------------------------------------------------------------------------
+# D-12 — (G-D2) PRIVATE_SERVER.md must not contain invalid MAM_MQTT_* in
+#        active configuration code blocks.
+# --------------------------------------------------------------------------
+def test_d12_private_server_no_mam_mqtt_in_code_fences():
+    doc_path = os.path.join(REPO_ROOT, "PRIVATE_SERVER.md")
+    with open(doc_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    code_blocks = re.findall(r"```(?:bash|conf|yaml|)(.*?)```", content, re.DOTALL)
+    for i, block in enumerate(code_blocks):
+        assert "MAM_MQTT_" not in block, (
+            f"Code block #{i+1} in PRIVATE_SERVER.md contains deprecated/invalid 'MAM_MQTT_*' prefix"
+        )
+
+
+# --------------------------------------------------------------------------
+# D-13 — (G-D3) nats-server launch instructions in PRIVATE_SERVER.md must
+#        use valid config blocks (mqtt {) and not HTTP port flag (-m 1883).
+# --------------------------------------------------------------------------
+def test_d13_private_server_nats_config_valid():
+    doc_path = os.path.join(REPO_ROOT, "PRIVATE_SERVER.md")
+    with open(doc_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    assert "-m 1883" not in content, (
+        "PRIVATE_SERVER.md incorrectly contains '-m 1883' (which sets HTTP port, not MQTT port)"
+    )
+    assert "mqtt {" in content, "PRIVATE_SERVER.md must document 'mqtt {' configuration block for nats-server"
+    assert "-c " in content or "-c /" in content, "PRIVATE_SERVER.md must document '-c <config>' for nats-server"
+
+
+# --------------------------------------------------------------------------
+# D-14 — (G-D4) Verification commands in PRIVATE_SERVER.md must use valid
+#        CLI flags matching the actual scripts' argparse parsers.
+# --------------------------------------------------------------------------
+def test_d14_private_server_cli_args_valid():
+    doc_path = os.path.join(REPO_ROOT, "PRIVATE_SERVER.md")
+    with open(doc_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Extract all command invocations for registry.py and publish_event.py
+    code_blocks = "\n".join(re.findall(r"```(?:bash|)(.*?)```", content, re.DOTALL))
+
+    # Assert --job-id is not used with register command (register takes --prompt, not --job-id)
+    # and registry.py commands have correct flag formatting
+    assert "register --job-id" not in code_blocks, (
+        "PRIVATE_SERVER.md contains invalid 'register --job-id' (registry.py register auto-assigns ID and takes no --job-id flag)"
+    )
+    assert "status --job " in code_blocks, "PRIVATE_SERVER.md must include cleanup step with status --job"
+

tests/test_tier1_unit.py

@@ -473,3 +473,292 @@ def test_b9_logs_dir_stays_discoverable(mam_sandbox):
     assert dir(mq).count("LOGS_DIR") == 1       # set-based __dir__ must not duplicate
 
 
+# ==============================================================================
+# Track 0: Fault Tolerance & Local Fallback Regression Guards (G-1 to G-10)
+# ==============================================================================
+
+def _save_job_for_test(job_rec, registry_dir):
+    p = os.path.join(registry_dir, f"{job_rec['job_id']}.json")
+    with open(p, "w", encoding="utf-8") as f:
+        json.dump(job_rec, f, indent=2)
+
+
+def test_g1_publish_failure_persists_completed_status(mam_sandbox, monkeypatch):
+    """G-1: When publish fails due to broker unreachable, registry status is still updated."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, publish_event
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-1", registry_dir=reg_dir, job_id="g1test01")
+    job = registry.load_job(job_id, reg_dir)
+    # Point broker to non-routable dummy port
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    _save_job_for_test(job, reg_dir)
+
+    rc = publish_event.main([
+        "--registry-dir", reg_dir,
+        "--job", "g1test01",
+        "--event", "completed",
+        "--detail", "finished work",
+        "--attempts", "1"
+    ])
+    assert rc == 2, f"Expected rc=2 on network failure, got {rc}"
+    loaded = registry.load_job("g1test01", reg_dir)
+    assert loaded["status"] == "completed", "Registry status must be completed despite network publish failure"
+
+
+def test_g2_publish_failure_records_audit_log_error(mam_sandbox, monkeypatch):
+    """G-2: Audit log records published=False and publish_error when broker is unreachable."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, publish_event, mqtt_common
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-2", registry_dir=reg_dir, job_id="g2test01")
+    job = registry.load_job(job_id, reg_dir)
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    _save_job_for_test(job, reg_dir)
+
+    rc = publish_event.main([
+        "--registry-dir", reg_dir,
+        "--job", "g2test01",
+        "--event", "completed",
+        "--attempts", "1"
+    ])
+    assert rc == 2
+
+    log_file = os.path.join(str(mam_sandbox), ".mam", "delegate_job_logs", "g2test01", "events.ndjson")
+    assert os.path.exists(log_file), "Audit log file must exist"
+    with open(log_file, "r", encoding="utf-8") as f:
+        events = [json.loads(line) for line in f if line.strip()]
+
+    pub_events = [e for e in events if e.get("event") == "published" and e.get("source_event") == "completed"]
+    assert len(pub_events) == 1
+    assert pub_events[0]["published"] is False
+    assert pub_events[0]["publish_error"] is not None
+
+
+def test_g3_publish_success_records_published_true(mam_sandbox, monkeypatch):
+    """G-3: When publish succeeds, rc=0, status=completed, and published=True."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, publish_event, mqtt_common
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    registry.register_job("Test G-3", registry_dir=reg_dir, job_id="g3test01")
+
+    # Mock _publish_once to simulate broker success
+    monkeypatch.setattr(publish_event, "_publish_once", lambda *args, **kwargs: None)
+
+    rc = publish_event.main([
+        "--registry-dir", reg_dir,
+        "--job", "g3test01",
+        "--event", "completed",
+        "--attempts", "1"
+    ])
+    assert rc == 0
+    loaded = registry.load_job("g3test01", reg_dir)
+    assert loaded["status"] == "completed"
+
+    log_file = os.path.join(str(mam_sandbox), ".mam", "delegate_job_logs", "g3test01", "events.ndjson")
+    assert os.path.exists(log_file), f"Audit log file {log_file} must exist"
+    with open(log_file, "r", encoding="utf-8") as f:
+        events = [json.loads(line) for line in f if line.strip()]
+    pub_events = [e for e in events if e.get("event") == "published" and e.get("source_event") == "completed"]
+    assert len(pub_events) == 1
+    assert pub_events[0]["published"] is True
+    assert pub_events[0]["publish_error"] is None
+
+
+def test_g4_publish_failure_advances_sequence(mam_sandbox, monkeypatch):
+    """G-4: A failed publish consumes sequence number, and subsequent publish uses strictly higher seq."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, publish_event
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-4", registry_dir=reg_dir, job_id="g4test01")
+    job = registry.load_job(job_id, reg_dir)
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    _save_job_for_test(job, reg_dir)
+
+    # First attempt fails
+    rc1 = publish_event.main([
+        "--registry-dir", reg_dir,
+        "--job", "g4test01",
+        "--event", "progress",
+        "--attempts", "1"
+    ])
+    assert rc1 == 2
+    j1 = registry.load_job("g4test01", reg_dir)
+    assert int(j1["last_seq"]) == 1
+
+    # Second attempt succeeds (mocked)
+    monkeypatch.setattr(publish_event, "_publish_once", lambda *args, **kwargs: None)
+    rc2 = publish_event.main([
+        "--registry-dir", reg_dir,
+        "--job", "g4test01",
+        "--event", "completed",
+        "--attempts", "1"
+    ])
+    assert rc2 == 0
+    j2 = registry.load_job("g4test01", reg_dir)
+    assert int(j2["last_seq"]) == 2
+
+
+def test_g5_subscriber_disk_fallback_on_broker_down_exits_0(mam_sandbox, monkeypatch):
+    """G-5: When broker is down and disk has status=completed, job_subscriber exits 0 via fallback."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, job_subscriber
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-5", registry_dir=reg_dir, job_id="g5test01")
+    job = registry.load_job(job_id, reg_dir)
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    job["status"] = "completed"
+    _save_job_for_test(job, reg_dir)
+
+    rc = job_subscriber.main([
+        "--registry-dir", reg_dir,
+        "--job", "g5test01",
+        "--timeout", "5",
+        "--idle-timeout", "2"
+    ])
+    assert rc == 0
+
+
+def test_g6_subscriber_disk_fallback_outputs_source_tag(mam_sandbox, capsys, monkeypatch):
+    """G-6: When resolving via disk fallback, stdout contains 'disk-fallback' tag."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, job_subscriber
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-6", registry_dir=reg_dir, job_id="g6test01")
+    job = registry.load_job(job_id, reg_dir)
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    job["status"] = "completed"
+    _save_job_for_test(job, reg_dir)
+
+    rc = job_subscriber.main([
+        "--registry-dir", reg_dir,
+        "--job", "g6test01",
+        "--timeout", "5"
+    ])
+    assert rc == 0
+    captured = capsys.readouterr()
+    assert "disk-fallback" in captured.out
+
+
+def test_g7_subscriber_disk_fallback_error_status_exits_1(mam_sandbox, monkeypatch):
+    """G-7: When broker is down and disk has status=error, job_subscriber exits 1."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, job_subscriber
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-7", registry_dir=reg_dir, job_id="g7test01")
+    job = registry.load_job(job_id, reg_dir)
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    job["status"] = "error"
+    _save_job_for_test(job, reg_dir)
+
+    rc = job_subscriber.main([
+        "--registry-dir", reg_dir,
+        "--job", "g7test01",
+        "--timeout", "5"
+    ])
+    assert rc == 1
+
+
+def test_g8_subscriber_wait_any_does_not_exit_early_if_partial_pending(mam_sandbox, monkeypatch):
+    """G-8: Multi-job wait does not terminate early when only 1 of 2 jobs is terminal on disk."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, job_subscriber, mqtt_common
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id1 = registry.register_job("Test G-8 Job 1", registry_dir=reg_dir, job_id="g8test01")
+    job_id2 = registry.register_job("Test G-8 Job 2", registry_dir=reg_dir, job_id="g8test02")
+    job1 = registry.load_job(job_id1, reg_dir)
+    job2 = registry.load_job(job_id2, reg_dir)
+    job1["status"] = "completed"
+    job2["status"] = "running"
+    _save_job_for_test(job1, reg_dir)
+    _save_job_for_test(job2, reg_dir)
+
+    # Mock client connection to succeed with empty queue
+    class FakeClient:
+        on_message = None
+        on_connect = None
+        on_disconnect = None
+        on_subscribe = None
+        def reconnect_delay_set(self, **kwargs): pass
+        def connect(self, *args, **kwargs): pass
+        def loop_start(self): pass
+        def loop_stop(self): pass
+        def disconnect(self): pass
+        def subscribe(self, *args, **kwargs): pass
+
+    monkeypatch.setattr(job_subscriber, "make_client", lambda *args, **kwargs: FakeClient())
+    monkeypatch.setattr(mqtt_common, "with_retry", lambda fn, **kwargs: fn)
+
+    rc = job_subscriber.main([
+        "--registry-dir", reg_dir,
+        "--wait-any",
+        "--timeout", "0.5",
+        "--idle-timeout", "0.5"
+    ])
+    assert rc == 2, "Must timeout waiting for incomplete job2 rather than exiting 0"
+
+
+def test_g9_subscriber_broker_down_no_disk_terminal_exits_3(mam_sandbox, monkeypatch):
+    """G-9: When broker is unreachable and no terminal state exists on disk, subscriber exits with rc=3."""
+    monkeypatch.chdir(mam_sandbox)
+    script_dir = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "scripts"
+    sys.path.insert(0, str(script_dir))
+    import registry, job_subscriber
+
+    reg_dir = str(mam_sandbox / ".mam" / "jobs")
+    os.makedirs(reg_dir, exist_ok=True)
+    job_id = registry.register_job("Test G-9", registry_dir=reg_dir, job_id="g9test01")
+    job = registry.load_job(job_id, reg_dir)
+    job["broker"] = {"host": "127.0.0.1", "port": 65432, "tls": False}
+    job["status"] = "running"
+    _save_job_for_test(job, reg_dir)
+
+    rc = job_subscriber.main([
+        "--registry-dir", reg_dir,
+        "--job", "g9test01",
+        "--timeout", "5"
+    ])
+    assert rc == 3, f"Expected rc=3 on infrastructure broker down without disk terminal, got {rc}"
+
+
+def test_g10_delegate_job_rc3_not_mistaken_for_error(mam_sandbox):
+    """G-10: multi-agent-mux-delegate-job maps rc=3 to broker_unavailable and checks disk status."""
+    delegate_script = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "multi-agent-mux-delegate-job"
+    content = delegate_script.read_text()
+    assert "elif [[ $sub_rc -eq 3 ]]; then" in content
+    assert 'job_status="broker_unavailable"' in content
+
+
+