refactor(joinir): Extract legacy binding path to routing_legacy_binding.rs

Phase 179-A Step 2: Separate LoopFrontendBinding JSON construction logic into dedicated module for better organization. Changes: - New file: routing_legacy_binding.rs (223 lines) - routing.rs: cf_loop_joinir_impl() simplified to 15 lines (delegates to legacy path) - Routing now clearly separates pattern-based vs. legacy binding paths Benefits: - Clear separation of concerns (pattern router vs. legacy whitelist) - routing.rs reduced from 364 to 146 lines (60% reduction) - Legacy path isolated for future deprecation
2025-12-08 18:36:13 +09:00
parent 7a01ffe522
commit 95f3aa429e
25 changed files with 626 additions and 755 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -565,25 +565,6 @@ src/runner/modes/common_util/resolve/strip.rs  # コード生成

 **🎯 完成状態**: ChatGPT実装で`using nyashstd`完全動作中！

-## 📝 Update (2025-09-24) 🎉 Phase 15実行器統一化戦略確定！
- ✅ **Phase 15.5-B-2 MIRビルダー統一化完了**（約40行特別処理削除）
- ✅ **Rust VM現状調査完了**（Task先生による詳細分析）
-  - **712行の高品質実装**（vs PyVM 1074行）
-  - **MIR14完全対応**、Callee型実装済み
-  - **gdb/lldbデバッグ可能**、型安全設計
- ✅ **実行器戦略確定: Rust VM + LLVM 2本柱**
-  - **Rust VM**: 開発・デバッグ・検証用
-  - **LLVM**: 本番・最適化・配布用
-  - **レガシーインタープリター**: 完全アーカイブ（~1,500行削減）
-  - **PyVM**: 段階的保守化（マクロシステム等）
- ✅ **MIRインタープリターバグ修正**（feature gate問題解決）
- ✅ **スモークテスト作り直し計画確定**（プラグインBox仕様＋2実行器マトリックス検証）
- ✅ **MIR Call命令統一Phase 3.1-3.3完了**
-  - **統一メソッド**: `emit_unified_call()`実装済み
-  - **環境変数制御**: `NYASH_MIR_UNIFIED_CALL=1`で切り替え可能
-  - **削減見込み**: 7,372行 → 5,468行（**26%削減**）
-  - **6種類→1種類**: Call/BoxCall/PluginInvoke/ExternCall/NewBox/NewClosure → **MirCall**
-
 ## 🧪 テストスクリプト参考集（既存のを活用しよう！）
 ```bash
 # 基本的なテスト
@ -600,322 +581,6 @@ NYASH_MIR_UNIFIED_CALL=1 ./target/release/nyash --dump-mir test_simple_call.hako
 NYASH_MIR_UNIFIED_CALL=1 ./target/release/nyash --emit-mir-json test.json test.hako
 ```

-## 🚀 よく使う実行コマンド（忘れやすい）
-
-### 🎯 基本実行方法
-```bash
-# VMバックエンド（デフォルト、高速）
-./target/release/nyash program.hako
-./target/release/nyash --backend vm program.hako
-
-# LLVMバックエンド（最適化済み）
-./target/release/nyash --backend llvm program.hako
-
-# プラグインテスト（LLVM）
-./target/release/nyash --backend llvm program.hako
-
-# プラグイン無効（デバッグ用）
-NYASH_DISABLE_PLUGINS=1 ./target/release/nyash program.hako
-```
-
-### 🔧 テスト・スモークテスト
-```bash
-# コアスモーク（プラグイン無効）
-./tools/jit_smoke.sh
-
-# LLVMスモーク
-./tools/llvm_smoke.sh
-
-# ラウンドトリップテスト
-./tools/ny_roundtrip_smoke.sh
-
-# Stage-2 PHIスモーク（If/Loop PHI合流）
-./tools/ny_parser_stage2_phi_smoke.sh
-
-# Stage-2 Bridgeスモーク（算術/比較/短絡/if）
-./tools/ny_stage2_bridge_smoke.sh
-
-# プラグインスモーク（オプション）
-NYASH_SKIP_TOML_ENV=1 ./tools/smoke_plugins.sh
-
-# using/namespace E2E（要--enable-using）
-./tools/using_e2e_smoke.sh
-```
-
-### 🐛 デバッグ用環境変数
-```bash
-# 詳細診断
-NYASH_CLI_VERBOSE=1 ./target/release/nyash program.hako
-
-# JSON IR出力
-NYASH_DUMP_JSON_IR=1 ./target/release/nyash program.hako
-
-# MIR出力（重要！）
-NYASH_DUMP_MIR=1 ./target/release/nyash program.hako
-NYASH_VM_DUMP_MIR=1 ./target/release/nyash program.hako  # VM実行時
-./target/release/nyash --dump-mir program.hako            # フラグ版
-
-# PyVMデバッグ
-NYASH_PYVM_DEBUG=1 ./target/release/nyash program.hako
-
-# パーサー無限ループ対策
-./target/release/nyash --debug-fuel 1000 program.hako
-
-# プラグインなし実行
-NYASH_DISABLE_PLUGINS=1 ./target/release/nyash program.hako
-
-# LLVMプラグイン実行（method_id使用）
-./target/release/nyash --backend llvm program.hako
-
-# Python/llvmliteハーネス使用（開発中）
-NYASH_LLVM_USE_HARNESS=1 ./target/release/nyash program.hako
-
-# 🚀 **Phase 15.5統一Call完全動作確認済み設定** (2025-09-24)
-# ❌ モックルート回避 - 実際のLLVMハーネス使用
-NYASH_MIR_UNIFIED_CALL=1 NYASH_DISABLE_PLUGINS=1 NYASH_ENTRY_ALLOW_TOPLEVEL_MAIN=1 NYASH_LLVM_USE_HARNESS=1 NYASH_LLVM_OBJ_OUT=/tmp/output.o ./target/release/nyash --backend llvm program.hako
-
-# 🔧 Python側で統一Call処理（llvmlite直接実行）
-cd src/llvm_py && NYASH_MIR_UNIFIED_CALL=1 ./venv/bin/python llvm_builder.py input.json -o output.o
-```
-
-## 🔍 MIRデバッグ出力完全ガイド（必読！）
-
-### 🎯 **確実にMIRを出力する方法**（優先順）
-
-```bash
-# 1️⃣ 最も確実: CLIフラグ使用
-./target/release/nyash --dump-mir program.hako
-./target/release/nyash --dump-mir --mir-verbose program.hako  # 詳細版
-
-# 2️⃣ VM実行時のMIR出力
-NYASH_VM_DUMP_MIR=1 ./target/release/nyash program.hako
-
-# 3️⃣ JSON形式でファイル出力
-./target/release/nyash --emit-mir-json debug.json program.hako
-cat debug.json | jq .  # 整形表示
-
-# 4️⃣ PyVM用JSON（自動生成）
-NYASH_VM_USE_PY=1 ./target/release/nyash program.hako
-cat tmp/nyash_pyvm_mir.json | jq .
-```
-
-### 📋 **MIR関連環境変数一覧**
-
-| 環境変数 | 用途 | 出力先 |
-|---------|-----|-------|
-| `NYASH_VM_DUMP_MIR=1` | VM実行前MIR出力 | stderr |
-| `NYASH_DUMP_JSON_IR=1` | JSON IR出力 | stdout |
-| `NYASH_CLI_VERBOSE=1` | 詳細診断（MIR含む） | stderr |
-| `NYASH_DEBUG_MIR_PRINTER=1` | MIRプリンターデバッグ | stderr |
-
-### 🚨 **MIRが出力されない時のチェックリスト**
-1. ✅ `--dump-mir` フラグを使用（最も確実）
-2. ✅ `--backend vm` を明示的に指定
-3. ✅ `NYASH_DISABLE_PLUGINS=1` でプラグイン干渉を排除
-4. ✅ `NYASH_CLI_VERBOSE=1` で詳細情報取得
-
-### 💡 **実用的デバッグフロー**
-```bash
-# Step 1: 基本MIR確認
-./target/release/nyash --dump-mir gemini_test_case.hako
-
-# Step 2: 詳細MIR + エフェクト情報
-./target/release/nyash --dump-mir --mir-verbose --mir-verbose-effects gemini_test_case.hako
-
-# Step 3: VM実行時の挙動確認
-NYASH_VM_DUMP_MIR=1 NYASH_CLI_VERBOSE=1 ./target/release/nyash gemini_test_case.hako
-
-# Step 4: JSON形式で詳細解析
-./target/release/nyash --emit-mir-json mir.json gemini_test_case.hako
-jq '.functions[0].blocks' mir.json  # ブロック構造確認
-```
-
-## 📝 Update (2025-09-23) 🚀 ChatGPT5 Pro設計革命Phase 1完全実装成功！
-
-### ✅ **MIR Callee型革新 - シャドウイングバグから設計革命への昇華**
-**51日間AI協働開発言語の新たな画期的成果！**
-
-#### 🎯 **Phase 1実装完了項目**
-1. **✅ Callee列挙型導入**: `Global/Method/Value/Extern`の型安全解決システム
-2. **✅ Call命令拡張**: `callee: Option<Callee>`で破壊的変更なし段階移行
-3. **✅ 型安全関数解決**: `resolve_call_target()`でコンパイル時解決確立
-4. **✅ ヘルパー外出し**: `call_resolution.rs`で再利用可能ユーティリティ作成
-5. **✅ 完全互換性**: 既存コード破壊ゼロ、全テスト通過確認済み
-
-#### 🏆 **技術的革新内容**
-```rust
-// 🔥 革新前（問題構造）
-Call { func: ValueId /* "print"文字列 */ }  // 実行時解決→シャドウイング脆弱性
-
-// ✨ 革新後（型安全）
-enum Callee {
-    Global(String),                          // nyash.builtin.print
-    Method { box_name, method, receiver },   // box.method()
-    Value(ValueId),                          // 第一級関数保持
-    Extern(String),                          // C ABI統合
-}
-Call { func: ValueId, callee: Option<Callee> }  // 段階移行で破壊的変更なし
-```
-
-#### 📊 **Phase 15目標への直接寄与**
- **🎯 コード削減見込み**: Phase 1のみで1,500行（目標7.5%）、全Phase完了で4,500行（22.5%）
- **🛡️ シャドウイング問題**: 根本解決（実行時→コンパイル時解決）
- **⚡ using system統合**: built-in namespace完全連携
- **🔍 デバッグ向上**: MIR可読性・警告システム確立
-
-#### 🤖 **AI協働開発の真価発揮**
- **ChatGPT5 Pro**: 表面修正→根本設計革新への圧倒的洞察力
- **Claude**: 段階実装・互換性保持・テスト戦略の確実な実行
- **共創効果**: 一人+AI協働による51日間言語開発の世界記録級成果
-
-#### 🚀 **実装成果ファイル**
- `src/mir/instruction.rs`: Callee型定義・Call命令拡張
- `src/mir/builder/call_resolution.rs`: 型安全解決ユーティリティ
- `src/mir/builder/builder_calls.rs`: resolve_call_target()実装
- `docs/development/architecture/mir-callee-revolution.md`: 設計文書
- `docs/private/roadmap2/phases/phase-15/mir-callee-implementation-roadmap.md`: 実装計画
-
-#### 📋 **次のステップ（Phase 2-3）**
- **Phase 2**: HIR導入（コンパイル時名前解決）
- **Phase 3**: 明示的スコープ（`::print`, `Box::method`）
- **VM実行器対応**: 型安全実行の実装
-
---
-
-## 📝 Update (2025-09-23) ✅ MIR Callee型革命100%完了！
- 🎉 **MIR Call命令革新Phase 1完了！** ChatGPT5 Pro設計のCallee型実装
-  - **実装内容**: Callee enum（Global/Method/Value/Extern）追加
-  - **VM実行器**: Call命令のCallee対応完全実装
-  - **MIRダンプ**: call_global/call_method等の明確表示
-  - **後方互換性**: Option<Callee>で段階移行実現
- 🚀 **MIR Call統一計画決定！** ChatGPT5 Pro A++案採用
-  - **現状**: 6種類のCall系命令が乱立（Call/BoxCall/PluginInvoke/ExternCall等）
-  - **解決**: 1つのMirCallに統一（receiverをCalleeに含む革新設計）
-  - **移行計画**: 3段階（構造定義→ビルダー→実行器）で安全移行
-  - **ドキュメント**: [call-instructions-current.md](docs/reference/mir/call-instructions-current.md)作成
- ✅ **PHIバグ根本解決完了！** Exit PHI生成実装でループ後の変数値が正しく伝播
-  - **技術的成果**: たった3箇所の修正で根本解決
-  - **コミット済み**: `e5c0665` でリモートに反映
- 🎯 **改行処理TokenCursor戦略決定！** 3段階実装戦略で改善中
-
-## 📝 Update (2025-09-23) 🎉 改行処理革命Phase 1-2完全達成！skip_newlines()根絶成功！
- ✅ **skip_newlines()完全根絶達成！** 48箇所→0箇所（100%削除完了）
-  - **Phase 2-A**: match_expr.rsから6箇所削除（27%削減達成）
-  - **Phase 2-B**: Box宣言系から14箇所削除（56%削減達成）
-  - **Phase 2-C**: 文処理系から9箇所削除（75%削減達成）
-  - **Phase 2-D**: メンバー宣言系から5箇所削除（90%削減達成）
-  - **Phase 2-E**: 残存検証で手動呼び出し0確認（100%根絶完了）
- 🧠 **Smart advance()システム完全動作確認！**
-  - **深度追跡**: 括弧内改行自動処理で手動呼び出し不要
-  - **コンテキスト認識**: match式・オブジェクトリテラルで完璧動作
-  - **OR pattern対応**: `1 | 2 => "found"`等の複雑パターン完全対応
-  - **環境変数制御**: デフォルトで有効、NYASH_SMART_ADVANCE=1で制御可能
- 🔬 **重大バグ発見・修正の副次成果！**
-  - **MIR compiler bug**: OR patternでInteger/Bool処理不備を発見・修正
-  - **根本原因**: `exprs_peek.rs`でString型以外の型が未対応だった
-  - **完全修正**: 全LiteralValue型（Integer/Bool/Float/Null/Void）対応で根治
-  - **テスト検証**: `test_match_debug_or.hako`等で完全動作確認
- 🚀 **革命的効果達成！**
-  - **保守性向上**: 改行処理一元管理で新構文追加時の改行忘れ根絶
-  - **開発体験向上**: パーサーエラー激減、直感的な改行記述が可能
-  - **システム安定化**: 手動呼び出し散在による不整合が完全解消
-  - **AI協働成功**: ChatGPT戦略+Claude実装+深い考察で完璧達成
- 🎯 **次世代への道筋**: Phase 3 TokenCursor実装でさらなる改行処理完璧化準備完了
-
-## 📝 Update (2025-09-22) 🎯 Phase 15 JITアーカイブ完了＆デバッグ大進展！
- ✅ **JIT/Craneliftアーカイブ完了！** Phase 15集中開発のため全JIT機能を安全にアーカイブ
- 🔧 **コンパイルエラー全解決！** JITスタブ作成でビルド成功、開発環境復活
- 🐛 **empty args smoke test 90%解決！** `collect_prints()`の位置インクリメントバグ修正
- 📊 **デバッグ手法確立！** 詳細トレース出力で問題を段階的に特定する手法完成
- ⚡ **次の一歩**: ArrayBox戻り値問題解決でテスト完全クリア予定
- 🎯 **AI協働デバッグ**: Claude+ChatGPT修正+系統的トレースの完璧な連携実現
- 📋 詳細: JITアーカイブは `archive/jit-cranelift/` に完全移動、復活手順も完備
-
-## 📝 Update (2025-09-22) 🎯 Phase 15 重要バグ発見＆根本原因解明完了！
- ✅ **using systemパーサー問題完全解決！** `NYASH_RESOLVE_FIX_BRACES=1`でブレースバランス自動修正
- 🆕 **JSON Native実装を導入！** 別Claude Code君の`feature/phase15-nyash-json-native`から`apps/lib/json_native/`取り込み完了
- 🔧 **ChatGPTの統合実装承認！** JSON読み込み処理統合は正しい方向性、技術的に高度
- 🐛 **重大バグ完全解明！**
-  - **問題**: `collect_prints`メソッドで`break`の後のコードが実行されずnullを返す
-  - **根本原因判明**: `src/mir/loop_builder.rs`の`do_break()`が`switch_to_unreachable_block_with_void()`を呼び、break後のコードをunreachableとマーク
-  - **MIR解析結果**: 
-    - Block 1394, 1407: 直接Block 1388（null return）にジャンプ
-    - Block 1730: 正常なArrayBox return
-    - レジスタ2: `new ArrayBox()`、レジスタ751: `const 0`（null）
-  - **デバッグ環境変数**: `NYASH_DUMP_JSON_IR=1`, `NYASH_PYVM_DEBUG=1`でMIR/PyVM詳細追跡可能
-  - **一時解決策**: `break`→`finished = 1`フラグに置き換え（根治が必要）
- 📊 **現在の状況**:
-  - using systemパーサーエラー: ✅ 完全解決
-  - collect_prints()根本原因: ✅ loop_builder.rs特定完了
-  - JSON Native: 📦 取り込み済み（match式互換性の課題あり）
- 🎯 **技術成果**: 
-  - PyVM内蔵Box（ArrayBox等）の早期リターンバグ修正
-  - MIR JSON解析によるbreak/continue制御フロー問題の完全解明
-  - loop_builder.rsのdo_break()修正が必要（次のタスク）
- 🚀 **Phase 15セルフホスティング**: MIRレベルの問題も特定済み、修正準備完了！
-
-## 📝 Update (2025-09-18) 🌟 Property System革命達成！
- ✅ **Property System革命完了！** ChatGPT5×Claude×Codexの協働により、stored/computed/once/birth_once統一構文完成！
- 🚀 **Python→Nyash実行可能性飛躍！** @property/@cached_property→Nyash Property完全マッピング実現！
- ⚡ **性能革命**: Python cached_property→10-50x高速化（LLVM最適化）
- 🎯 **All or Nothing**: Phase 10.7でPython transpilation、フォールバック無し設計
- 📚 **完全ドキュメント化**: README.md導線、実装戦略、技術仕様すべて完備
- 🗃️ **アーカイブ整理**: 古いphaseファイル群をarchiveに移動、導線クリーンアップ完了
- 📋 詳細: [Property System仕様](docs/development/proposals/unified-members.md) | [Python統合計画](docs/private/roadmap2/phases/phase-10.7/)
-
-## 📝 Update (2025-09-24) ✅ 改行処理革命Phase 2-B完了！実用レベル到達
- 🎯 **改行処理革命Phase 2-B完了！** Box宣言系ファイルから14箇所のskip_newlines()完全削除
-  - **削除実績**: 48→35→21箇所（41%削減達成！）
-  - **対象ファイル**: fields.rs(9箇所)、box_definition.rs(3箇所)、static_box.rs(2箇所)
-  - **テスト結果**: OR付きmatch式、複数行宣言、Box定義すべて完璧動作✅
- ✅ **Smart advance()実用化成功！** 深度追跡で自動改行処理が完璧に機能
-  - **環境変数**: `NYASH_SMART_ADVANCE=1`で完全制御、`NYASH_DISABLE_PLUGINS=1`推奨
-  - **対応構文**: match式OR（`1 | 2`）、複数行パターン、Box宣言すべて対応
- 🔧 **ORパターンバグも同時修正！** exprs_peek.rsでInteger/Boolean型マッチング実装
-  - **修正前**: `1 | 2 => "found"`が動作せず（String型のみサポート）
-  - **修正後**: 全リテラル型（Integer/Bool/Float/Null/Void）完全対応✅
- 📊 **改行処理戦略の段階的成果**:
-  - **Phase 0**: Quick Fix ✅ 完了（即効性）
-  - **Phase 1**: Smart advance() ✅ 基本実装完了（大幅改善）
-  - **Phase 2-A**: match式系統 ✅ 完了（6箇所削除）
-  - **Phase 2-B**: Box宣言系統 ✅ 完了（14箇所削除、41%削減）
-  - **Phase 2-C**: 次の目標（更なる削減へ）
- 🎉 **技術的成果**: 手動スキップ依存からコンテキスト認識自動処理への移行成功
- 📚 **改行処理戦略ドキュメント**: [skip-newlines-removal-plan.md](docs/development/strategies/skip-newlines-removal-plan.md)
- 🚀 **次のタスク**: Phase 2-C実装→残り21箇所の系統的削除継続
-
-## 📝 Update (2025-09-23) ✅ フェーズS実装完了！break制御フロー根治開始
- ✅ **フェーズS完了！** PHI incoming修正+終端ガード徹底→重複処理4箇所統一
- 🔧 **新ユーティリティ**: `src/mir/utils/control_flow.rs`で制御フロー処理統一化
- 📊 **AI協働成果**: task+Gemini+codex+ChatGPT Pro最強分析→段階的実装戦略確立
- 🎯 **次段階**: フェーズM(PHI一本化)→数百行削減でPhase 15目標達成へ
- 📚 **戦略**: [break-control-flow-strategy.md](docs/development/strategies/break-control-flow-strategy.md)
- 💾 **アーカイブ**: codex高度解決策を`archive/codex-solutions/`に保存
-
-## 📝 Update (2025-09-14) 🎉 セルフホスティング大前進！
- ✅ Python LLVM実装が実用レベル到達！（esc_dirname_smoke, min_str_cat_loop, dep_tree_min_string全てPASS）
- 🚀 **Phase 15.3開始！** NyashコンパイラMVP実装が`apps/selfhost-compiler/`でスタート！
- ✅ JSON v0 Bridge完成 - If/Loop PHI生成実装済み（ChatGPT実装）
- 🔧 Python MVPパーサーStage-2完成 - local/if/loop/call/method/new対応
- 📚 peek式の再発見 - when→peekに名前変更、ブロック/値/文すべて対応済み
- 🧠 箱理論でSSA構築を簡略化（650行→100行）- 論文執筆完了
- 🤝 AI協働の知見を論文化 - 実装駆動型学習の重要性を実証
- 🎉 **面白事件ログ収集完了！** 41個の世界記録級事件を記録 → [CURRENT_TASK.md#面白事件ログ](CURRENT_TASK.md#🎉-面白事件ログ---ai協働開発45日間の奇跡41事例収集済み)
- 🎯 **LoopForm戦略決定**: PHIは逆Lowering時に自動生成（Codex推奨）
- 📋 詳細: [Phase 15 README](docs/private/roadmap2/phases/phase-15/README.md)
-
-### 🚀 新発見：プラグイン全方向ビルド戦略
-```bash
-# 同じソースから全形式生成！
-plugins/filebox/
-├── filebox.so     # 動的版（開発用）
-├── filebox.o      # 静的リンク用
-└── filebox.a      # アーカイブ版
-
-# 単一EXE生成可能に！
-clang main.o filebox.o pathbox.o libnyrt.a -o nyash_static.exe
-```
-
 ## ⚡ 重要な設計原則

 ### 🏗️ Everything is Box
@ -1151,10 +816,10 @@ Read docs/reference/  # まずドキュメント（API/言語仕様の入口）
 **設計書がすぐ見つからない問題を解決！**

 ### 🏗️ **アーキテクチャ核心**
- **[名前空間・using system](docs/reference/language/using.md)** ⭐超重要 - ドット記法・スコープ演算子・Phase 15.5計画
+- **[JoinIR アーキテクチャ](docs/development/current/main/joinir-architecture-overview.md)** ⭐超重要 - Loop/If/ExitLine/Boundary/PHI の全体図
+- **[名前空間・using system](docs/reference/language/using.md)** - ドット記法・スコープ演算子・Phase 15.5計画
 - **[MIR Callee革新](docs/development/architecture/mir-callee-revolution.md)** - 関数呼び出し型安全化・シャドウイング解決
 - **[構文早見表](docs/quick-reference/syntax-cheatsheet.md)** - 基本構文・よくある間違い
- **[Control Flow モジュール化](#-control_flow-モジュール構造-2025-12-05完了)** - 1,632行→17モジュール完全分離

 ### 📋 **Phase 15.5重要資料**
 - **[Core Box統一計画](docs/private/roadmap2/phases/phase-15.5/README.md)** - builtin vs plugin問題
@ -1166,50 +831,11 @@ Read docs/reference/  # まずドキュメント（API/言語仕様の入口）
 - **[プラグインシステム](docs/reference/plugin-system/)** - プラグイン開発ガイド
 - **[Phase 15 INDEX](docs/private/roadmap2/phases/phase-15/INDEX.md)** - 現在進捗

-### 🗂️ **control_flow モジュール構造** (2025-12-05完了)
-
-**元の状態**: 単一ファイル 1,632行 (2025-12-04時点で312行まで削減済み)
-**現在の状態**: 17モジュール 2,129行 (50%の行数削減達成！)
-
-**ディレクトリ構造**:
-```
-src/mir/builder/control_flow/
-├── mod.rs                              (187行) - メインエントリーポイント
-├── debug.rs                            (23行)  - デバッグユーティリティ
-├── utils.rs                            (53行)  - ヘルパー関数
-├── exception/                                  - 例外処理
-│   ├── mod.rs                          (36行)
-│   ├── try_catch.rs                    (146行)
-│   └── throw.rs                        (41行)
-└── joinir/                                     - JoinIR統合
-    ├── mod.rs                          (10行)
-    ├── routing.rs                      (343行) - パターンルーティング
-    ├── patterns/                               - ループパターン
-    │   ├── mod.rs                      (10行)
-    │   ├── pattern1_minimal.rs         (156行)
-    │   ├── pattern2_with_break.rs      (127行)
-    │   └── pattern3_with_if_phi.rs     (149行)
-    └── merge/                                  - MIRマージ
-        ├── mod.rs                      (223行)
-        ├── block_allocator.rs          (70行)
-        ├── value_collector.rs          (90行)
-        ├── instruction_rewriter.rs     (405行)
-        └── exit_phi_builder.rs         (60行)
-```
-
-**モジュール化フェーズ**:
- Phase 1: Debug utilities (debug.rs)
- Phase 2: Pattern lowerers (joinir/patterns/)
- Phase 3: JoinIR routing (joinir/routing.rs)
- Phase 4: Merge implementation (joinir/merge/)
- Phase 5: Exception handling (exception/)
- Phase 6: Utility functions (utils.rs)
- Phase 7: Documentation and cleanup
-
-**設計哲学**:
- 委譲パターン: mod.rsがエントリーポイント、サブモジュールが実装
- 関心の分離: 各モジュールが単一の責務を持つ
- テスト容易性: モジュール分割により単体テスト可能
+### 🗂️ **control_flow モジュール構造**
+**17モジュール分割完了** - `src/mir/builder/control_flow/` 参照
+- `joinir/patterns/` - Pattern1-4ループ処理
+- `joinir/merge/` - MIRマージ処理
+- `exception/` - try/catch/throw処理

 ## 🔧 開発サポート

@ -1233,87 +859,10 @@ NYASH_CLI_VERBOSE=1         # 詳細診断
 NYASH_DUMP_JSON_IR=1        # JSON IR出力
 ```

-### 🧬 Phase 25 Numeric Core 開発ワークフロー（推奨）
-
-**numeric_core / AotPrep のデバッグは必ず `dev_numeric_core_prep.sh` を使用！**
-
+### 🐍 Python LLVM バックエンド
+**場所**: `/src/llvm_py/` - llvmliteベースのMIR14→LLVM変換（2000行程度）
 ```bash
-# 基本的な使い方
-tools/dev_numeric_core_prep.sh your_case.hako out.json 2> dev.log
-
-# ログを確認
-cat dev.log | grep -E "\[aot/numeric_core\]|\[prep:\]"
-```
-
-**環境変数**:
- `NYASH_AOT_NUMERIC_CORE=1` - numeric_core パス有効化（自動設定）
- `NYASH_AOT_NUMERIC_CORE_TRACE=1` - 詳細ログ出力（自動設定）
- `HAKO_APPLY_AOT_PREP=1` - AotPrep パイプライン有効化（自動設定）
-
-**期待されるログ出力**:
-```
-[aot/numeric_core] type table size: 4
-[aot/numeric_core] copy-prop MatI64: r2 → r6
-[aot/numeric_core] phi-prop MatI64: r7
-[aot/numeric_core] transformed BoxCall(MatI64, mul_naive) → Call(NyNumericMatI64.mul_naive)
-```
-
-**トラブルシューティング**:
- ログが見えない → `hakorune_emit_mir.sh` のログ転送確認
- 変換されない → 型テーブルに MatI64 が登録されているか確認
- STRICT mode エラー → Pre-AotPrep 段階での誤検出（無効化推奨）
-
-### 🤖 AI相談
-```bash
-# Gemini CLIで相談
-gemini -p "Nyashの実装で困っています..."
-
-# Codex実行
-codex exec "質問内容"
-```
-
-### 🐍 Python LLVM バックエンド (実用レベル到達！)
-**場所**: `/src/llvm_py/`
-
-llvmliteベースのLLVMバックエンド実装。箱理論により650行→100行の簡略化を実現！
-Rust/inkwellの複雑さを回避して、シンプルに2000行程度でMIR14→LLVM変換を実現。
-
-⚠️ **重要**: **JIT/Craneliftは現在まともに動作しません！**
- ビルドは可能（`cargo build --release --features cranelift-jit`）
- 実行は不可（内部実装が未完成）
- **Python LLVMルートとPyVMのみが現在の開発対象です**
-
-#### 実行方法
-```bash
-cd src/llvm_py
-python3 -m venv venv
-./venv/bin/pip install llvmlite
-./venv/bin/python llvm_builder.py test_minimal.json -o output.o
-```
-
-#### 実装済み命令
- ✅ const, binop, jump, branch, ret, compare
- ✅ phi, call, boxcall, externcall  
- ✅ typeop, newbox, safepoint, barrier
- ✅ loopform (実験的)
-
-**利点**: シンプル、高速プロトタイピング、llvmliteの安定性
-**用途**: PHI/SSA検証、LoopForm実験、LLVM IR生成テスト
-
-### 🔄 Codex非同期ワークフロー（並列作業）
-```bash
-# 基本実行（同期）
-./tools/codex-async-notify.sh "タスク内容" codex
-
-# デタッチ実行（即座に戻る）
-CODEX_ASYNC_DETACH=1 ./tools/codex-async-notify.sh "タスク" codex
-
-# 並列制御（最大2つ、重複排除）
-CODEX_MAX_CONCURRENT=2 CODEX_DEDUP=1 CODEX_ASYNC_DETACH=1 \
-  ./tools/codex-async-notify.sh "Phase 15タスク" codex
-
-# 実行中のタスク確認
-pgrep -af 'codex.*exec'
+cd src/llvm_py && ./venv/bin/python llvm_builder.py test.json -o output.o
 ```

 ### 💡 アイデア管理（docs/development/proposals/ideas/ フォルダ）
--- a/CURRENT_TASK.md
+++ b/CURRENT_TASK.md
@ -87,11 +87,19 @@
        → **バグ修正**: Trim pattern の loop_var_name 上書き問題、InstructionRewriter の latch_incoming 設定問題。

 - 今後 1〜2 フェーズの TODO（JoinIR 周りのサマリ）
-  - [ ] **Phase 177: JsonParser `_parse_string` 本体の JoinIR 適用**
-        - Phase 176 の multi-carrier 対応を前提に、実際の `_parse_string` ループを P2+P5 で通す。
-        - 期待: pos + result の 2 キャリアが正しく更新される。
-        - エスケープ処理（`\"`）は Phase 178+ で対応。
-  - [ ] Phase 178+: JsonParser `_parse_array` / `_parse_object` など、残りの複雑ループを順次 P1–P5 の組み合わせで吸収していく。
+  - [x] **Phase 177: Multi-carrier PHI 接続修正** ✅ (2025-12-08)
+        - Task 177-STRUCT-1: CarrierVar に join_id 追加
+        - Task 177-STRUCT-2: carrier_order で順序保持（LoopHeaderPhiInfo）
+        - **成果**: Int テスト成功（sum=3）、index mismatch 問題解決
+  - [x] **Phase 178: LoopUpdateAnalyzer string 検出** ✅ (2025-12-08)
+        - Task 178-1: UpdateRhs 拡張（StringLiteral, Other 追加）
+        - Task 178-2: analyze_rhs 分岐拡張（string/method call 検出）
+        - Task 178-3: Pattern2/4 can_lower で string 拒否（Fail-Fast）
+        - Task 178-4: Legacy fallback コメント修正（LoopBuilder 削除済み反映）
+        - **成果**: String loop は明示的エラー、numeric loop は正常動作維持
+        - **注意**: グローバルテスト 79 件失敗は Phase 178 以前からの既知問題（別途対応）
+  - [ ] Phase 179+: JsonParser `_parse_array` / `_parse_object` など、残りの複雑ループを順次 P1–P5 の組み合わせで吸収していく。
+        - String 連結ループは Phase 178 で Fail-Fast 化されたため、JoinIR string emit 対応が先に必要。

 ---

--- a/docs/development/current/main/joinir-architecture-overview.md
+++ b/docs/development/current/main/joinir-architecture-overview.md
@ -40,6 +40,19 @@ JoinIR ラインで守るべきルールを先に書いておくよ：
   - JoinIR が対応していないループパターン / if パターンは、必ず `[joinir/freeze]` 等で明示的にエラーにする。
   - LoopBuilder 等へのサイレントフォールバックは禁止。

+7. **Param の役割（ParamRole）を分ける**
+   - JoinIR 側で扱うパラメータは概念的に 3 種類に分かれる：
+     - 条件専用（Condition param）: 継続条件や break 条件だけに使う値
+     - キャリア（Carrier param）: ループ状態（pos/result など）として更新される値
+     - 式結果（Expr param）: ループが式として返す値
+   - ExitLine / Header PHI / InstructionRewriter は **Carrier param だけ** を対象にし、Condition/Expr param は上書きしない。
+   - 現状は ConditionBinding/ExitMeta/JoinFragmentMeta で役割を区別しており、将来 ParamRole enum として明示する予定。
+
+8. **LoopHeader PHI dst は予約領域（上書き禁止）**
+   - LoopHeaderPhiBuilder が生成したヘッダ PHI の dst ValueId は「現在のループ値」の SSOT として扱い、  
+     BoundaryInjector や InstructionRewriter が `Copy` などで二度書きすることを禁止する。
+   - merge ラインでは「ヘッダ PHI dst に対する新しい定義が出てきたら debug モードで panic する」ことで契約違反を早期検出する。
+
 ---

 ## 2. 主な箱と責務
--- a/docs/development/current/main/loop_pattern_space.md
+++ b/docs/development/current/main/loop_pattern_space.md
@ -33,9 +33,9 @@
 | P2: Break      | `joinir_min_loop.hako`       | 単純    | 条件付きbreak | なし            | なし    | Outer      | 単一     |
 | P3: If‑PHI     | `loop_if_phi.hako`           | 単純    | なし         | なし            | if‑PHI | Outer      | 条件付き |
 | P4: Continue   | `loop_continue_pattern4`     | 単純    | なし         | 条件付きcont    | なし    | Outer      | 単一     |
-| P5: Trim‑like* | `TrimTest.trim`（設計中）    | 単純    | 条件付きbreak | なし            | なし    | BodyLocal  | 単一     |
+| P5: Trim‑like* | `TrimTest.trim`（設計中）    | 単純    | 条件付きbreak | なし            | なし    | BodyLocal  | 複数     |

-\*P5 は Phase 171 時点では「検出＋安全性判定」まで。実際の JoinIR lower は Phase 172 以降の仕事。
+\*P5 は Phase 171 時点では「検出＋安全性判定」までだったが、Phase 172–176 で Trim / `_skip_whitespace` / `_parse_string` 最小版について JoinIR→MIR lower と複数キャリア更新まで実装済み。

 ここまでで：

@ -209,4 +209,3 @@ loop (i < n) {
  JsonParserBox / Trim 系ループのインベントリと、どの Pattern に入るかの観測ログ。
 - `phase171-pattern5-loop-inventory.md`  
  Trim/JsonParser 向け Pattern5（LoopBodyLocal 条件）設計の進捗。
-
--- a/docs/development/current/main/phase178-string-detection.md
+++ b/docs/development/current/main/phase178-string-detection.md
@ -0,0 +1,71 @@
+# Phase 178: LoopUpdateAnalyzer String Detection
+
+## Summary
+
+Phase 178 extends `LoopUpdateAnalyzer` to detect string/complex carrier updates,
+enabling Fail-Fast behavior for unsupported patterns.
+
+## Changes
+
+### 1. UpdateRhs Enum Extension (`loop_update_analyzer.rs`)
+
+Added two new variants:
+- `StringLiteral(String)` - for `result = result + "x"` patterns
+- `Other` - for method calls and complex expressions
+
+### 2. analyze_rhs Extension
+
+Extended to detect:
+- String literals: `ASTNode::Literal { value: LiteralValue::String(_) }`
+- Method calls: `ASTNode::MethodCall { .. }`
+- Other complex expressions: `ASTNode::Call`, `ASTNode::BinaryOp`, etc.
+
+### 3. Pattern 2/4 can_lower Updates
+
+Both `pattern2_with_break.rs` and `pattern4_with_continue.rs` now check for
+string/complex updates in `can_lower()` and return `false` if detected.
+
+This triggers a clear error message instead of silent incorrect behavior.
+
+### 4. Legacy Fallback Comment Fixes
+
+Updated misleading comments about "legacy fallback" - LoopBuilder was removed
+in Phase 187-2 and all loops must use JoinIR.
+
+## Behavior
+
+When a loop contains string concatenation like:
+```nyash
+loop(i < limit) {
+    result = result + "x"  // String update
+    i = i + 1
+}
+```
+
+Phase 178 now produces a clear error:
+```
+[pattern2/can_lower] Phase 178: String/complex update detected, rejecting Pattern 2 (unsupported)
+[ERROR] MIR compilation error: [joinir/freeze] Loop lowering failed:
+JoinIR does not support this pattern, and LoopBuilder has been removed.
+```
+
+## Test Results
+
+- P1 (simple while): OK
+- P2 (break + int carriers): OK
+- P4 (continue + multi-carrier): OK
+- String loops: Fail-Fast with clear error
+
+## Known Issues
+
+- **79 global test failures**: Pre-existing issue, NOT caused by Phase 178
+  - Confirmed by `git stash` test - failures exist in HEAD~1
+  - Tracked separately from Phase 178
+
+## Future Work
+
+To support string loops, either:
+1. Add JoinIR instructions for string concatenation (Option A)
+2. Process loop body statements in MIR alongside JoinIR control flow (Option B)
+
+Phase 178 provides the detection foundation for future string support.
--- a/src/mir/builder/control_flow/joinir/merge/exit_line/reconnector.rs
+++ b/src/mir/builder/control_flow/joinir/merge/exit_line/reconnector.rs
@ -79,6 +79,13 @@ impl ExitLineReconnector {
        carrier_phis: &BTreeMap<String, ValueId>,
        debug: bool,
    ) -> Result<(), String> {
+        // Phase 177-STRUCT: Always log for debugging
+        eprintln!(
+            "[DEBUG-177/reconnect] ExitLineReconnector: {} exit bindings, {} carrier PHIs",
+            boundary.exit_bindings.len(),
+            carrier_phis.len()
+        );
+
        // Early return for empty exit_bindings
        if boundary.exit_bindings.is_empty() {
            if debug {
@ -110,12 +117,11 @@ impl ExitLineReconnector {
            // Update variable_map with PHI dst
            if let Some(&phi_value) = phi_dst {
                if let Some(var_vid) = builder.variable_map.get_mut(&binding.carrier_name) {
-                    if debug {
-                        eprintln!(
-                            "[cf_loop/joinir/exit_line] ExitLineReconnector: Updated variable_map['{}'] {:?} → {:?} (PHI dst)",
-                            binding.carrier_name, var_vid, phi_value
-                        );
-                    }
+                    // Phase 177-STRUCT: Always log for debugging
+                    eprintln!(
+                        "[DEBUG-177/reconnect] Updated variable_map['{}'] {:?} → {:?}",
+                        binding.carrier_name, *var_vid, phi_value
+                    );
                    *var_vid = phi_value;
                } else if debug {
                    eprintln!(
--- a/src/mir/builder/control_flow/joinir/merge/exit_phi_builder.rs
+++ b/src/mir/builder/control_flow/joinir/merge/exit_phi_builder.rs
@ -74,12 +74,11 @@ pub(super) fn build_exit_phi(

            carrier_phis.insert(carrier_name.clone(), phi_dst);

-            if debug {
-                eprintln!(
-                    "[cf_loop/joinir]   Exit block PHI (carrier '{}'): {:?} = phi {:?}",
-                    carrier_name, phi_dst, inputs
-                );
-            }
+            // DEBUG-177: Always log exit block PHI creation for carrier debugging
+            eprintln!(
+                "[DEBUG-177] Exit block PHI (carrier '{}'): {:?} = phi {:?}",
+                carrier_name, phi_dst, inputs
+            );
        }

        func.add_block(exit_block);
--- a/src/mir/builder/control_flow/joinir/merge/instruction_rewriter.rs
+++ b/src/mir/builder/control_flow/joinir/merge/instruction_rewriter.rs
@ -604,12 +604,11 @@ pub(super) fn merge_and_rewrite(
                                        carrier_inputs.entry(binding.carrier_name.clone())
                                            .or_insert_with(Vec::new)
                                            .push((new_block_id, phi_dst));
-                                        if debug {
-                                            eprintln!(
-                                                "[cf_loop/joinir] Phase 33-16: Using header PHI dst {:?} for carrier '{}'",
-                                                phi_dst, binding.carrier_name
-                                            );
-                                        }
+                                        // DEBUG-177: Always log carrier collection
+                                        eprintln!(
+                                            "[DEBUG-177] Phase 33-16: Collecting carrier '{}': from {:?} using header PHI {:?}",
+                                            binding.carrier_name, new_block_id, phi_dst
+                                        );
                                    }
                                }
                            }
--- a/src/mir/builder/control_flow/joinir/merge/loop_header_phi_builder.rs
+++ b/src/mir/builder/control_flow/joinir/merge/loop_header_phi_builder.rs
@ -84,6 +84,8 @@ impl LoopHeaderPhiBuilder {
                latch_incoming: None,
            },
        );
+        // Phase 177-STRUCT-2: Record insertion order
+        info.carrier_order.push(loop_var_name.to_string());

        if debug {
            eprintln!(
@ -103,6 +105,8 @@ impl LoopHeaderPhiBuilder {
                    latch_incoming: None,
                },
            );
+            // Phase 177-STRUCT-2: Record insertion order
+            info.carrier_order.push(name.clone());

            if debug {
                eprintln!(
--- a/src/mir/builder/control_flow/joinir/merge/loop_header_phi_info.rs
+++ b/src/mir/builder/control_flow/joinir/merge/loop_header_phi_info.rs
@ -29,6 +29,14 @@ pub struct LoopHeaderPhiInfo {
    /// of this carrier during loop iteration.
    pub carrier_phis: BTreeMap<String, CarrierPhiEntry>,

+    /// Phase 177-STRUCT-2: Carrier names in insertion order
+    ///
+    /// Preserves the order in which carriers were added (matches exit_bindings order).
+    /// Used for index-based matching with loop_step params.
+    ///
+    /// Order: [loop_var, carrier1, carrier2, ...]
+    pub carrier_order: Vec<String>,
+
    /// Expression result PHI dst (if loop is used as expression)
    ///
    /// For Pattern 2 (joinir_min_loop), this is the same as the loop
@ -55,10 +63,25 @@ impl LoopHeaderPhiInfo {
        Self {
            header_block,
            carrier_phis: BTreeMap::new(),
+            carrier_order: Vec::new(),
            expr_result_phi: None,
        }
    }

+    /// Phase 177-STRUCT-2: Get carrier name at index (in insertion order)
+    ///
+    /// Used for matching loop_step params by index.
+    pub fn get_carrier_at_index(&self, idx: usize) -> Option<&str> {
+        self.carrier_order.get(idx).map(|s| s.as_str())
+    }
+
+    /// Phase 177-STRUCT-2: Get PHI entry at index (in insertion order)
+    pub fn get_entry_at_index(&self, idx: usize) -> Option<&CarrierPhiEntry> {
+        self.carrier_order
+            .get(idx)
+            .and_then(|name| self.carrier_phis.get(name))
+    }
+
    /// Get the PHI dst for a carrier variable
    pub fn get_carrier_phi(&self, name: &str) -> Option<ValueId> {
        self.carrier_phis.get(name).map(|e| e.phi_dst)
--- a/src/mir/builder/control_flow/joinir/merge/mod.rs
+++ b/src/mir/builder/control_flow/joinir/merge/mod.rs
@ -340,12 +340,11 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
            }

            // Map loop_step's parameters
-            if debug {
-                eprintln!(
-                    "[cf_loop/joinir] Phase 33-21: function_params keys: {:?}",
-                    function_params.keys().collect::<Vec<_>>()
-                );
-            }
+            // DEBUG-177: Always log function_params keys to diagnose multi-carrier issue
+            eprintln!(
+                "[DEBUG-177] Phase 33-21: function_params keys: {:?}",
+                function_params.keys().collect::<Vec<_>>()
+            );
            if function_params.get(loop_step_func_name).is_none() {
                eprintln!(
                    "[cf_loop/joinir] WARNING: function_params.get('{}') returned None. Available keys: {:?}",
@ -354,32 +353,56 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
                );
            }
            if let Some(loop_step_params) = function_params.get(loop_step_func_name) {
-                if debug {
-                    eprintln!(
-                        "[cf_loop/joinir] Phase 33-21: loop_step ({}) params: {:?}",
-                        loop_step_func_name, loop_step_params
-                    );
-                }
-                // Map loop_step's parameters to header PHI dsts
-                // loop_step params: [i_param, carrier1_param, ...]
-                // carrier_phis: [("i", entry), ("sum", entry), ...]
-                for (idx, (carrier_name, entry)) in phi_info.carrier_phis.iter().enumerate() {
-                    if let Some(&loop_step_param) = loop_step_params.get(idx) {
-                        // Phase 177-3: Don't override condition_bindings
-                        if condition_binding_ids.contains(&loop_step_param) {
+                // DEBUG-177: Always log loop_step params
+                eprintln!(
+                    "[DEBUG-177] Phase 33-21: loop_step ({}) params: {:?}",
+                    loop_step_func_name, loop_step_params
+                );
+                // Phase 177-FIX: Process loop_step params but skip if already mapped
+                //
+                // We use a name-based approach: for each carrier_phi, check if
+                // its join_value was already set in Phase 177-3-B (body-only carriers).
+                // Only process loop_step params for carriers NOT already handled.
+                for loop_step_param in loop_step_params {
+                    // Phase 177-3: Don't override condition_bindings
+                    if condition_binding_ids.contains(loop_step_param) {
+                        eprintln!(
+                            "[DEBUG-177] Phase 177-FIX: Skipping condition_binding {:?}",
+                            loop_step_param
+                        );
+                        continue;
+                    }
+                    // Find which carrier this param belongs to by matching join_value
+                    // Check if this param was already handled by Phase 177-3-B
+                    let already_mapped = boundary.condition_bindings.iter().any(|cb| {
+                        cb.join_value == *loop_step_param &&
+                        phi_info.carrier_phis.iter().any(|(name, _)| name == &cb.name)
+                    });
+                    if already_mapped {
+                        eprintln!(
+                            "[DEBUG-177] Phase 177-FIX: Skipping {:?} (already mapped by Phase 177-3-B)",
+                            loop_step_param
+                        );
+                        continue;
+                    }
+                    // Phase 177-STRUCT-2: Use carrier_order for index-based matching
+                    //
+                    // Problem: BTreeMap iterates in alphabetical order, but JoinIR
+                    // generates params in exit_bindings order.
+                    //
+                    // Solution: Use carrier_order (Vec<String>) which preserves insertion order.
+                    if let Some(param_idx) = loop_step_params.iter().position(|p| p == loop_step_param) {
+                        // Map params[i] to carrier_order[i]
+                        if let (Some(carrier_name), Some(entry)) = (
+                            phi_info.get_carrier_at_index(param_idx),
+                            phi_info.get_entry_at_index(param_idx),
+                        ) {
                            eprintln!(
-                                "[cf_loop/joinir] Phase 177-3: Skipping override for condition_binding {:?} ('{}')",
-                                loop_step_param, carrier_name
+                                "[DEBUG-177] Phase 177-STRUCT-2: REMAP loop_step param[{}] {:?} → {:?} (carrier '{}')",
+                                param_idx, loop_step_param, entry.phi_dst, carrier_name
                            );
-                            continue;
+                            remapper.set_value(*loop_step_param, entry.phi_dst);
                        }
-                        if debug {
-                            eprintln!(
-                                "[cf_loop/joinir] Phase 33-21: REMAP loop_step param {:?} → {:?} ('{}')",
-                                loop_step_param, entry.phi_dst, carrier_name
-                            );
-                        }
-                        remapper.set_value(loop_step_param, entry.phi_dst);
                    }
                }
            }
@ -403,10 +426,15 @@ pub(in crate::mir::builder) fn merge_joinir_mir_blocks(
                        );
                    }
                }
-                for (idx, (carrier_name, entry)) in phi_info.carrier_phis.iter().enumerate() {
+                // Phase 177-STRUCT-2: Use carrier_order for deterministic iteration
+                for (idx, carrier_name) in phi_info.carrier_order.iter().enumerate() {
                    if carrier_name == loop_var_name {
                        continue;
                    }
+                    let entry = match phi_info.carrier_phis.get(carrier_name) {
+                        Some(e) => e,
+                        None => continue,
+                    };
                    let join_value_id = ValueId(idx as u32);
                    // Phase 177-3: Don't override condition_bindings
                    if !condition_binding_ids.contains(&join_value_id) {
--- a/src/mir/builder/control_flow/joinir/mod.rs
+++ b/src/mir/builder/control_flow/joinir/mod.rs
@ -8,5 +8,6 @@

 pub(in crate::mir::builder) mod patterns;
 pub(in crate::mir::builder) mod routing;
+pub(in crate::mir::builder) mod routing_legacy_binding;
 pub(in crate::mir::builder) mod merge;
 pub(in crate::mir::builder) mod trace;
--- a/src/mir/builder/control_flow/joinir/patterns/common_init.rs
+++ b/src/mir/builder/control_flow/joinir/patterns/common_init.rs
@ -102,6 +102,7 @@ impl CommonPatternInitializer {
                carriers.push(CarrierVar {
                    name: var_name.clone(),
                    host_id: var_id,
+                    join_id: None, // Phase 177-STRUCT-1
                });
            }
        }
--- a/src/mir/builder/control_flow/joinir/patterns/exit_binding.rs
+++ b/src/mir/builder/control_flow/joinir/patterns/exit_binding.rs
@ -205,6 +205,7 @@ mod tests {
            vec![CarrierVar {
                name: "sum".to_string(),
                host_id: ValueId(10),
+                join_id: None,
            }],
        );

@ -243,10 +244,12 @@ mod tests {
                CarrierVar {
                    name: "printed".to_string(),
                    host_id: ValueId(11),
+                    join_id: None,
                },
                CarrierVar {
                    name: "sum".to_string(),
                    host_id: ValueId(10),
+                    join_id: None,
                },
            ],
        );
@ -288,6 +291,7 @@ mod tests {
            vec![CarrierVar {
                name: "sum".to_string(),
                host_id: ValueId(10),
+                join_id: None,
            }],
        );

@ -315,6 +319,7 @@ mod tests {
            vec![CarrierVar {
                name: "sum".to_string(),
                host_id: ValueId(10),
+                join_id: None,
            }],
        );

@ -342,6 +347,7 @@ mod tests {
            vec![CarrierVar {
                name: "sum".to_string(),
                host_id: ValueId(10),
+                join_id: None,
            }],
        );

@ -372,6 +378,7 @@ mod tests {
            vec![CarrierVar {
                name: "sum".to_string(),
                host_id: ValueId(10),
+                join_id: None,
            }],
        );

--- a/src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs
+++ b/src/mir/builder/control_flow/joinir/patterns/pattern2_with_break.rs
@ -10,12 +10,58 @@ use super::trim_pattern_lowerer::TrimPatternLowerer;
 /// Phase 194: Detection function for Pattern 2
 ///
 /// Phase 192: Updated to structure-based detection
+/// Phase 178: Added string carrier rejection (unsupported by Pattern 2)
+/// Phase 187-2: No legacy fallback - rejection means error
 ///
 /// Pattern 2 matches:
 /// - Pattern kind is Pattern2Break (has break, no continue)
+/// - No string/complex carrier updates (JoinIR doesn't support string concat)
 pub fn can_lower(_builder: &MirBuilder, ctx: &super::router::LoopPatternContext) -> bool {
    use crate::mir::loop_pattern_detection::LoopPatternKind;
-    ctx.pattern_kind == LoopPatternKind::Pattern2Break
+    use crate::mir::join_ir::lowering::loop_update_analyzer::{LoopUpdateAnalyzer, UpdateExpr, UpdateRhs};
+    use crate::mir::join_ir::lowering::carrier_info::CarrierVar;
+    use crate::mir::ValueId;
+
+    // Basic pattern check
+    if ctx.pattern_kind != LoopPatternKind::Pattern2Break {
+        return false;
+    }
+
+    // Phase 178: Check for string/complex carrier updates
+    // Create dummy carriers from body assignment targets for analysis
+    let dummy_carriers: Vec<CarrierVar> = ctx.body.iter().filter_map(|node| {
+        match node {
+            crate::ast::ASTNode::Assignment { target, .. } => {
+                if let crate::ast::ASTNode::Variable { name, .. } = target.as_ref() {
+                    Some(CarrierVar {
+                        name: name.clone(),
+                        host_id: ValueId(0),  // Dummy
+                        join_id: None,
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }).collect();
+
+    let updates = LoopUpdateAnalyzer::analyze_carrier_updates(ctx.body, &dummy_carriers);
+
+    // Check if any update is string/complex
+    for update in updates.values() {
+        if let UpdateExpr::BinOp { rhs, .. } = update {
+            match rhs {
+                UpdateRhs::StringLiteral(_) | UpdateRhs::Other => {
+                    eprintln!("[pattern2/can_lower] Phase 178: String/complex update detected, rejecting Pattern 2 (unsupported)");
+                    return false;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    true
 }

 /// Phase 194: Lowering function for Pattern 2
--- a/src/mir/builder/control_flow/joinir/patterns/pattern4_carrier_analyzer.rs
+++ b/src/mir/builder/control_flow/joinir/patterns/pattern4_carrier_analyzer.rs
@ -271,14 +271,17 @@ mod tests {
                CarrierVar {
                    name: "i".to_string(),
                    host_id: ValueId(1),
+                    join_id: None,
                },
                CarrierVar {
                    name: "sum".to_string(),
                    host_id: ValueId(2),
+                    join_id: None,
                },
                CarrierVar {
                    name: "M".to_string(),
                    host_id: ValueId(3),
+                    join_id: None,
                },
            ],
            trim_helper: None,
--- a/src/mir/builder/control_flow/joinir/patterns/pattern4_with_continue.rs
+++ b/src/mir/builder/control_flow/joinir/patterns/pattern4_with_continue.rs
@ -39,6 +39,8 @@ use super::super::trace;
 /// Phase 194+: Detection function for Pattern 4
 ///
 /// Phase 192: Updated to use pattern_kind for consistency
+/// Phase 178: Added string carrier rejection (unsupported by Pattern 4)
+/// Phase 187-2: No legacy fallback - rejection means error
 ///
 /// Pattern 4 matches loops with continue statements.
 ///
@ -54,12 +56,55 @@ use super::super::trace;
 ///
 /// 1. **Must have continue**: `ctx.has_continue == true`
 /// 2. **No break statements**: `ctx.has_break == false` (for simplicity in Pattern 4)
+/// 3. **Phase 178**: No string/complex carrier updates (JoinIR doesn't support string concat)
 ///
-/// If both conditions are met, Pattern 4 is detected.
+/// If all conditions are met, Pattern 4 is detected.
 pub fn can_lower(_builder: &MirBuilder, ctx: &super::router::LoopPatternContext) -> bool {
-    // Phase 192: Use pattern_kind for consistency with other patterns
    use crate::mir::loop_pattern_detection::LoopPatternKind;
-    ctx.pattern_kind == LoopPatternKind::Pattern4Continue
+    use crate::mir::join_ir::lowering::loop_update_analyzer::{LoopUpdateAnalyzer, UpdateExpr, UpdateRhs};
+    use crate::mir::join_ir::lowering::carrier_info::CarrierVar;
+    use crate::mir::ValueId;
+
+    // Basic pattern check
+    if ctx.pattern_kind != LoopPatternKind::Pattern4Continue {
+        return false;
+    }
+
+    // Phase 178: Check for string/complex carrier updates
+    // Create dummy carriers from body assignment targets for analysis
+    let dummy_carriers: Vec<CarrierVar> = ctx.body.iter().filter_map(|node| {
+        match node {
+            crate::ast::ASTNode::Assignment { target, .. } => {
+                if let crate::ast::ASTNode::Variable { name, .. } = target.as_ref() {
+                    Some(CarrierVar {
+                        name: name.clone(),
+                        host_id: ValueId(0),  // Dummy
+                        join_id: None,
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }).collect();
+
+    let updates = LoopUpdateAnalyzer::analyze_carrier_updates(ctx.body, &dummy_carriers);
+
+    // Check if any update is string/complex
+    for update in updates.values() {
+        if let UpdateExpr::BinOp { rhs, .. } = update {
+            match rhs {
+                UpdateRhs::StringLiteral(_) | UpdateRhs::Other => {
+                    eprintln!("[pattern4/can_lower] Phase 178: String/complex update detected, rejecting Pattern 4 (unsupported)");
+                    return false;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    true
 }

 /// Phase 33-19: Lowering function for Pattern 4
--- a/src/mir/builder/control_flow/joinir/patterns/router.rs
+++ b/src/mir/builder/control_flow/joinir/patterns/router.rs
@ -184,9 +184,10 @@ pub fn route_loop_pattern(
        }
    }

-    // No pattern matched - fall through to legacy path
+    // No pattern matched - return None (caller will handle error)
+    // Phase 187-2: Legacy LoopBuilder removed, all loops must use JoinIR
    if ctx.debug {
-        trace::trace().debug("route", &format!("No pattern matched for function '{}', falling back to legacy", ctx.func_name));
+        trace::trace().debug("route", &format!("No pattern matched for function '{}'", ctx.func_name));
    }
    Ok(None)
 }
--- a/src/mir/builder/control_flow/joinir/routing.rs
+++ b/src/mir/builder/control_flow/joinir/routing.rs
@ -8,8 +8,9 @@ use super::trace;
 impl MirBuilder {
    /// Phase 49: Try JoinIR Frontend for mainline integration
    ///
-    /// Returns `Ok(Some(value))` if the current function should use JoinIR Frontend,
-    /// `Ok(None)` to fall through to the legacy LoopBuilder path.
+    /// Returns `Ok(Some(value))` if the loop is successfully lowered via JoinIR,
+    /// `Ok(None)` if no JoinIR pattern matched (unsupported loop structure).
+    /// Phase 187-2: Legacy LoopBuilder removed - all loops must use JoinIR.
    ///
    /// # Phase 49-4: Multi-target support
    ///
@ -116,22 +117,9 @@ impl MirBuilder {

    /// Phase 49-3: JoinIR Frontend integration implementation
    ///
-    /// # Pipeline
-    /// 1. Build Loop AST → JSON v0 format (with "defs" array)
-    /// 2. AstToJoinIrLowerer::lower_program_json() → JoinModule
-    /// 3. convert_join_module_to_mir_with_meta() → MirModule
-    /// 4. Merge MIR blocks into current_function
-    ///
-    /// # Phase 49-4 Note
-    ///
-    /// JoinIR Frontend expects a complete function definition with:
-    /// - local variable initializations
-    /// - loop body
-    /// - return statement
-    ///
-    /// Since cf_loop only has access to the loop condition and body,
-    /// we construct a minimal JSON v0 wrapper with function name "simple"
-    /// to match the JoinIR Frontend's expected pattern.
+    /// Routes loop compilation through either:
+    /// 1. Pattern-based router (Phase 194+) - preferred for new patterns
+    /// 2. Legacy binding path (Phase 49-3) - for whitelisted functions only
    pub(in crate::mir::builder) fn cf_loop_joinir_impl(
        &mut self,
        condition: &ASTNode,
@ -139,222 +127,19 @@ impl MirBuilder {
        func_name: &str,
        debug: bool,
    ) -> Result<Option<ValueId>, String> {
-        use super::super::super::loop_frontend_binding::LoopFrontendBinding;
-        use crate::mir::join_ir::frontend::{AstToJoinIrLowerer, JoinFuncMetaMap};
-        use crate::mir::join_ir_vm_bridge::convert_join_module_to_mir_with_meta;
-        use crate::mir::types::ConstValue;
-        use crate::mir::MirInstruction;
-        use crate::r#macro::ast_json::ast_to_json;
-
        // Phase 194: Use table-driven router instead of if/else chain
-        // This makes adding new patterns trivial - just add an entry to LOOP_PATTERNS table
        use super::patterns::{route_loop_pattern, LoopPatternContext};

        let ctx = LoopPatternContext::new(condition, body, &func_name, debug);
        if let Some(result) = route_loop_pattern(self, &ctx)? {
-            // Phase 195: Use unified trace
            trace::trace().routing("router", func_name, "Pattern router succeeded");
            return Ok(Some(result));
        }

-        // Phase 195: Use unified trace
-        trace::trace().routing("router", func_name, "Pattern router found no match, continuing to legacy path");
+        // Phase 187-2: Pattern router failed, try legacy whitelist
+        trace::trace().routing("router", func_name, "Pattern router found no match, trying legacy whitelist");

-        // Phase 50: Create appropriate binding based on function name
-        let binding = match func_name {
-            "JsonTokenizer.print_tokens/0" => LoopFrontendBinding::for_print_tokens(),
-            "ArrayExtBox.filter/2" => LoopFrontendBinding::for_array_filter(),
-            _ => {
-                // Phase 195: Use unified trace
-                trace::trace().routing("router", func_name, "No binding defined, falling back");
-                return Ok(None);
-            }
-        };
-
-        // Phase 195: Use unified trace
-        trace::trace().debug(
-            "router",
-            &format!(
-                "Using binding for '{}': counter={}, acc={:?}, pattern={:?}",
-                func_name, binding.counter_var, binding.accumulator_var, binding.pattern
-            ),
-        );
-
-        // Step 1: Convert condition and body to JSON
-        let condition_json = ast_to_json(condition);
-        let mut body_json: Vec<serde_json::Value> = body.iter().map(|s| ast_to_json(s)).collect();
-
-        // Phase 50: Rename variables in body (e.g., "out" → "acc" for filter)
-        binding.rename_body_variables(&mut body_json);
-
-        // Phase 50: Generate Local declarations from binding
-        let (i_local, acc_local, n_local) = binding.generate_local_declarations();
-
-        // Phase 52/56: Build params from external_refs
-        // Instance methods need `me`, static methods need their parameters (arr, pred, etc.)
-        let mut params: Vec<serde_json::Value> = Vec::new();
-
-        // Phase 52: Add 'me' for instance methods
-        if binding.needs_me_receiver() {
-            // Phase 195: Use unified trace
-            trace::trace().debug("router", "Adding 'me' to params (instance method)");
-            params.push(serde_json::json!("me"));
-        }
-
-        // Phase 56: Add external_refs as parameters (arr, pred for filter)
-        for ext_ref in &binding.external_refs {
-            // Skip "me" and "me.*" as they're handled above
-            if ext_ref == "me" || ext_ref.starts_with("me.") {
-                continue;
-            }
-            // Phase 195: Use unified trace
-            trace::trace().debug("router", &format!("Adding '{}' to params (external_ref)", ext_ref));
-            params.push(serde_json::json!(ext_ref));
-        }
-
-        // Step 2: Construct JSON v0 format with "defs" array
-        // The function is named "simple" to match JoinIR Frontend's pattern matching
-        // Phase 50: Include i/acc/n Local declarations to satisfy JoinIR Frontend expectations
-        let program_json = serde_json::json!({
-            "defs": [
-                {
-                    "name": "simple",
-                    "params": params,
-                    "body": {
-                        "type": "Block",
-                        "body": [
-                            // Phase 50: Inject i/acc/n Local declarations
-                            i_local,
-                            acc_local,
-                            n_local,
-                            {
-                                "type": "Loop",
-                                "cond": condition_json,  // JoinIR Frontend expects "cond" not "condition"
-                                "body": body_json
-                            },
-                            // Return the accumulator (or null for side-effect loops)
-                            {
-                                "type": "Return",
-                                "value": { "kind": "Variable", "name": "acc" }
-                            }
-                        ]
-                    }
-                }
-            ]
-        });
-
-        // Phase 195: Use unified trace
-        trace::trace().debug(
-            "router",
-            &format!(
-                "Generated JSON v0 for {}: {}",
-                func_name,
-                serde_json::to_string_pretty(&program_json).unwrap_or_default()
-            ),
-        );
-
-        // Step 3: Lower to JoinIR
-        // Phase 49-4: Use catch_unwind for graceful fallback on unsupported patterns
-        // The JoinIR Frontend may panic if the loop doesn't match expected patterns
-        // (e.g., missing variable initializations like "i must be initialized")
-        let join_module = {
-            let json_clone = program_json.clone();
-            let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                let mut lowerer = AstToJoinIrLowerer::new();
-                lowerer.lower_program_json(&json_clone)
-            }));
-
-            match result {
-                Ok(module) => module,
-                Err(e) => {
-                    // Extract panic message for debugging
-                    let panic_msg = if let Some(s) = e.downcast_ref::<&str>() {
-                        s.to_string()
-                    } else if let Some(s) = e.downcast_ref::<String>() {
-                        s.clone()
-                    } else {
-                        "unknown panic".to_string()
-                    };
-
-                    // Phase 195: Use unified trace
-                    trace::trace().debug(
-                        "router",
-                        &format!(
-                            "JoinIR lowering failed for {}: {}, falling back to legacy",
-                            func_name, panic_msg
-                        ),
-                    );
-                    // Return None to fall back to legacy LoopBuilder
-                    return Ok(None);
-                }
-            }
-        };
-        // Phase 49-3 MVP: Use empty meta map (full if-analysis is Phase 40+ territory)
-        let join_meta = JoinFuncMetaMap::new();
-
-        // Phase 195: Use unified trace
-        trace::trace().joinir_stats(
-            "router",
-            join_module.functions.len(),
-            join_module
-                .functions
-                .values()
-                .map(|f| f.body.len())
-                .sum(),
-        );
-
-        // Step 4: Convert JoinModule to MIR
-        let mir_module = convert_join_module_to_mir_with_meta(&join_module, &join_meta)
-            .map_err(|e| format!("JoinIR→MIR conversion failed: {}", e.message))?;
-
-        // Phase 195: Use unified trace for MIR module stats
-        if trace::trace().is_joinir_enabled() {
-            trace::trace().debug(
-                "router",
-                &format!("MirModule has {} functions", mir_module.functions.len()),
-            );
-            for (name, func) in &mir_module.functions {
-                trace::trace().debug(
-                    "router",
-                    &format!(
-                        "  - {}: {} blocks, entry={:?}",
-                        name,
-                        func.blocks.len(),
-                        func.entry_block
-                    ),
-                );
-                // Phase 189: Debug - show block contents
-                for (block_id, block) in &func.blocks {
-                    trace::trace().blocks(
-                        "router",
-                        &format!("Block {:?}: {} instructions", block_id, block.instructions.len()),
-                    );
-                    for (i, inst) in block.instructions.iter().enumerate() {
-                        trace::trace().instructions("router", &format!("[{}] {:?}", i, inst));
-                    }
-                    if let Some(ref term) = block.terminator {
-                        trace::trace().instructions("router", &format!("terminator: {:?}", term));
-                    }
-                }
-            }
-        }
-
-        // Step 5: Merge MIR blocks into current_function
-        // For Phase 49-3, we'll use a simplified approach:
-        // - Add generated blocks to current_function
-        // - Jump from current_block to the entry of generated loop
-        // - The loop exit becomes the new current_block
-        // Phase 188-Impl-3: Pass None for boundary (legacy path without boundary)
-        // Phase 189: Discard exit PHI result (legacy path doesn't need it)
-        let _ = self.merge_joinir_mir_blocks(&mir_module, None, debug)?;
-
-        // Return void for now (loop doesn't have a meaningful return value in this context)
-        let void_val = self.next_value_id();
-        self.emit_instruction(MirInstruction::Const {
-            dst: void_val,
-            value: ConstValue::Void,
-        })?;
-
-        Ok(Some(void_val))
+        // Delegate to legacy binding path (routing_legacy_binding.rs)
+        self.cf_loop_joinir_legacy_binding(condition, body, func_name, debug)
    }
 }
--- a/src/mir/builder/control_flow/joinir/routing_legacy_binding.rs
+++ b/src/mir/builder/control_flow/joinir/routing_legacy_binding.rs
@ -0,0 +1,215 @@
+//! Legacy LoopFrontendBinding path (Phase 49-3)
+//!
+//! This module contains the legacy JSON v0 construction logic for specific
+//! whitelisted functions (print_tokens, array_filter) that use the old
+//! LoopFrontendBinding system.
+//!
+//! Phase 194+ uses the pattern-based router instead. This legacy path is
+//! kept for backward compatibility with existing whitelist entries.
+
+use crate::ast::ASTNode;
+use crate::mir::builder::MirBuilder;
+use crate::mir::ValueId;
+use super::trace;
+
+impl MirBuilder {
+    /// Phase 49-3: Legacy JoinIR Frontend integration via LoopFrontendBinding
+    ///
+    /// This implements the old JSON v0 construction path for whitelisted functions.
+    /// New patterns should use the pattern router instead (route_loop_pattern).
+    ///
+    /// # Pipeline
+    /// 1. Build Loop AST → JSON v0 format (with "defs" array)
+    /// 2. AstToJoinIrLowerer::lower_program_json() → JoinModule
+    /// 3. convert_join_module_to_mir_with_meta() → MirModule
+    /// 4. Merge MIR blocks into current_function
+    pub(in crate::mir::builder) fn cf_loop_joinir_legacy_binding(
+        &mut self,
+        condition: &ASTNode,
+        body: &[ASTNode],
+        func_name: &str,
+        debug: bool,
+    ) -> Result<Option<ValueId>, String> {
+        use super::super::super::loop_frontend_binding::LoopFrontendBinding;
+        use crate::mir::join_ir::frontend::{AstToJoinIrLowerer, JoinFuncMetaMap};
+        use crate::mir::join_ir_vm_bridge::convert_join_module_to_mir_with_meta;
+        use crate::mir::types::ConstValue;
+        use crate::mir::MirInstruction;
+        use crate::r#macro::ast_json::ast_to_json;
+
+        // Phase 50: Create appropriate binding based on function name
+        let binding = match func_name {
+            "JsonTokenizer.print_tokens/0" => LoopFrontendBinding::for_print_tokens(),
+            "ArrayExtBox.filter/2" => LoopFrontendBinding::for_array_filter(),
+            _ => {
+                trace::trace().routing("router", func_name, "No legacy binding defined, falling back");
+                return Ok(None);
+            }
+        };
+
+        trace::trace().debug(
+            "router",
+            &format!(
+                "Using legacy binding for '{}': counter={}, acc={:?}, pattern={:?}",
+                func_name, binding.counter_var, binding.accumulator_var, binding.pattern
+            ),
+        );
+
+        // Step 1: Convert condition and body to JSON
+        let condition_json = ast_to_json(condition);
+        let mut body_json: Vec<serde_json::Value> = body.iter().map(|s| ast_to_json(s)).collect();
+
+        // Phase 50: Rename variables in body (e.g., "out" → "acc" for filter)
+        binding.rename_body_variables(&mut body_json);
+
+        // Phase 50: Generate Local declarations from binding
+        let (i_local, acc_local, n_local) = binding.generate_local_declarations();
+
+        // Phase 52/56: Build params from external_refs
+        let mut params: Vec<serde_json::Value> = Vec::new();
+
+        // Phase 52: Add 'me' for instance methods
+        if binding.needs_me_receiver() {
+            trace::trace().debug("router", "Adding 'me' to params (instance method)");
+            params.push(serde_json::json!("me"));
+        }
+
+        // Phase 56: Add external_refs as parameters (arr, pred for filter)
+        for ext_ref in &binding.external_refs {
+            if ext_ref == "me" || ext_ref.starts_with("me.") {
+                continue;
+            }
+            trace::trace().debug("router", &format!("Adding '{}' to params (external_ref)", ext_ref));
+            params.push(serde_json::json!(ext_ref));
+        }
+
+        // Step 2: Construct JSON v0 format with "defs" array
+        let program_json = serde_json::json!({
+            "defs": [
+                {
+                    "name": "simple",
+                    "params": params,
+                    "body": {
+                        "type": "Block",
+                        "body": [
+                            // Phase 50: Inject i/acc/n Local declarations
+                            i_local,
+                            acc_local,
+                            n_local,
+                            {
+                                "type": "Loop",
+                                "cond": condition_json,
+                                "body": body_json
+                            },
+                            // Return the accumulator
+                            {
+                                "type": "Return",
+                                "value": { "kind": "Variable", "name": "acc" }
+                            }
+                        ]
+                    }
+                }
+            ]
+        });
+
+        trace::trace().debug(
+            "router",
+            &format!(
+                "Generated JSON v0 for {}: {}",
+                func_name,
+                serde_json::to_string_pretty(&program_json).unwrap_or_default()
+            ),
+        );
+
+        // Step 3: Lower to JoinIR with panic catch
+        let join_module = {
+            let json_clone = program_json.clone();
+            let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                let mut lowerer = AstToJoinIrLowerer::new();
+                lowerer.lower_program_json(&json_clone)
+            }));
+
+            match result {
+                Ok(module) => module,
+                Err(e) => {
+                    let panic_msg = if let Some(s) = e.downcast_ref::<&str>() {
+                        s.to_string()
+                    } else if let Some(s) = e.downcast_ref::<String>() {
+                        s.clone()
+                    } else {
+                        "unknown panic".to_string()
+                    };
+
+                    trace::trace().debug(
+                        "router",
+                        &format!(
+                            "JoinIR lowering failed for {}: {} (unsupported pattern)",
+                            func_name, panic_msg
+                        ),
+                    );
+                    return Ok(None);
+                }
+            }
+        };
+
+        let join_meta = JoinFuncMetaMap::new();
+
+        trace::trace().joinir_stats(
+            "router",
+            join_module.functions.len(),
+            join_module
+                .functions
+                .values()
+                .map(|f| f.body.len())
+                .sum(),
+        );
+
+        // Step 4: Convert JoinModule to MIR
+        let mir_module = convert_join_module_to_mir_with_meta(&join_module, &join_meta)
+            .map_err(|e| format!("JoinIR→MIR conversion failed: {}", e.message))?;
+
+        // Debug MIR module if trace enabled
+        if trace::trace().is_joinir_enabled() {
+            trace::trace().debug(
+                "router",
+                &format!("MirModule has {} functions", mir_module.functions.len()),
+            );
+            for (name, func) in &mir_module.functions {
+                trace::trace().debug(
+                    "router",
+                    &format!(
+                        "  - {}: {} blocks, entry={:?}",
+                        name,
+                        func.blocks.len(),
+                        func.entry_block
+                    ),
+                );
+                for (block_id, block) in &func.blocks {
+                    trace::trace().blocks(
+                        "router",
+                        &format!("Block {:?}: {} instructions", block_id, block.instructions.len()),
+                    );
+                    for (i, inst) in block.instructions.iter().enumerate() {
+                        trace::trace().instructions("router", &format!("[{}] {:?}", i, inst));
+                    }
+                    if let Some(ref term) = block.terminator {
+                        trace::trace().instructions("router", &format!("terminator: {:?}", term));
+                    }
+                }
+            }
+        }
+
+        // Step 5: Merge MIR blocks into current_function
+        // Phase 188-Impl-3: Pass None for boundary (whitelist path without boundary tracking)
+        let _ = self.merge_joinir_mir_blocks(&mir_module, None, debug)?;
+
+        // Return void
+        let void_val = self.next_value_id();
+        self.emit_instruction(MirInstruction::Const {
+            dst: void_val,
+            value: ConstValue::Void,
+        })?;
+
+        Ok(Some(void_val))
+    }
+}
--- a/src/mir/builder/control_flow/mod.rs
+++ b/src/mir/builder/control_flow/mod.rs
@ -84,9 +84,9 @@ impl super::MirBuilder {
    ///
    /// # Phase 49: JoinIR Frontend Mainline Integration
    ///
-    /// This is the unified entry point for all loop lowering. Specific functions
-    /// are routed through JoinIR Frontend instead of the traditional LoopBuilder path
-    /// when enabled via dev flags (Phase 49) or Core policy (Phase 80):
+    /// This is the unified entry point for all loop lowering. All loops are processed
+    /// via JoinIR Frontend (Phase 187-2: LoopBuilder removed).
+    /// Specific functions are enabled via dev flags (Phase 49) or Core policy (Phase 80):
    ///
    /// - Core ON (`joinir_core_enabled()`): print_tokens / ArrayExt.filter はまず JoinIR Frontend を試す
    /// - Dev フラグ（既存）:
@ -121,8 +121,9 @@ impl super::MirBuilder {

    /// Phase 49: Try JoinIR Frontend for mainline integration
    ///
-    /// Returns `Ok(Some(value))` if the current function should use JoinIR Frontend,
-    /// `Ok(None)` to fall through to the legacy LoopBuilder path.
+    /// Returns `Ok(Some(value))` if the loop is successfully lowered via JoinIR,
+    /// `Ok(None)` if no JoinIR pattern matched (unsupported loop structure).
+    /// Phase 187-2: Legacy LoopBuilder removed - all loops must use JoinIR.
    ///
    /// # Phase 49-4: Multi-target support
    ///
--- a/src/mir/join_ir/lowering/carrier_info.rs
+++ b/src/mir/join_ir/lowering/carrier_info.rs
@ -14,8 +14,16 @@ use std::collections::HashMap;
 pub struct CarrierVar {
    /// Variable name (e.g., "sum", "printed")
    pub name: String,
-    /// Host ValueId for this variable
+    /// Host ValueId for this variable (MIR側)
    pub host_id: ValueId,
+    /// Phase 177-STRUCT: JoinIR側でこのキャリアを表すValueId
+    ///
+    /// ヘッダPHIのdstや、exitで使う値を記録する。
+    /// これにより、index ベースのマッチングを名前ベースに置き換えられる。
+    ///
+    /// - `Some(vid)`: Header PHI生成後にセットされる
+    /// - `None`: まだPHI生成前、または該当なし
+    pub join_id: Option<ValueId>,
 }

 /// Complete carrier information for a loop
@ -77,6 +85,7 @@ impl CarrierInfo {
            .map(|(name, &id)| CarrierVar {
                name: name.clone(),
                host_id: id,
+                join_id: None, // Phase 177-STRUCT-1: Set by header PHI generation
            })
            .collect();

@ -133,6 +142,7 @@ impl CarrierInfo {
            carriers.push(CarrierVar {
                name,
                host_id,
+                join_id: None, // Phase 177-STRUCT-1: Set by header PHI generation
            });
        }

@ -432,6 +442,7 @@ mod tests {
        CarrierVar {
            name: name.to_string(),
            host_id: ValueId(id),
+            join_id: None, // Phase 177-STRUCT-1
        }
    }

--- a/src/mir/join_ir/lowering/loop_update_analyzer.rs
+++ b/src/mir/join_ir/lowering/loop_update_analyzer.rs
@ -38,10 +38,20 @@ pub enum UpdateExpr {
 }

 /// Right-hand side of update expression
+///
+/// Phase 178: Extended to detect string updates for multi-carrier loops.
+/// The goal is "carrier detection", not full semantic understanding.
 #[derive(Debug, Clone)]
 pub enum UpdateRhs {
+    /// Numeric constant: count + 1
    Const(i64),
+    /// Variable reference: sum + i
    Variable(String),
+    /// Phase 178: String literal: result + "x"
+    StringLiteral(String),
+    /// Phase 178: Other expression (method call, complex expr)
+    /// Used to detect "carrier has an update" without understanding semantics
+    Other,
 }

 pub struct LoopUpdateAnalyzer;
@ -157,6 +167,9 @@ impl LoopUpdateAnalyzer {
    }

    /// Analyze right-hand side of update expression
+    ///
+    /// Phase 178: Extended to detect string updates.
+    /// Goal: "carrier has update" detection, not semantic understanding.
    fn analyze_rhs(node: &ASTNode) -> Option<UpdateRhs> {
        match node {
            // Constant: count + 1
@ -165,11 +178,24 @@ impl LoopUpdateAnalyzer {
                ..
            } => Some(UpdateRhs::Const(*n)),

-            // Variable: sum + i
+            // Phase 178: String literal: result + "x"
+            ASTNode::Literal {
+                value: LiteralValue::String(s),
+                ..
+            } => Some(UpdateRhs::StringLiteral(s.clone())),
+
+            // Variable: sum + i (also handles: result + ch)
            ASTNode::Variable { name, .. } => {
                Some(UpdateRhs::Variable(name.clone()))
            }

+            // Phase 178: Method call or other complex expression
+            // e.g., result + s.substring(pos, end)
+            ASTNode::Call { .. }
+            | ASTNode::MethodCall { .. }
+            | ASTNode::BinaryOp { .. }
+            | ASTNode::UnaryOp { .. } => Some(UpdateRhs::Other),
+
            _ => None,
        }
    }
@ -218,6 +244,7 @@ mod tests {
        let carriers = vec![CarrierVar {
            name: "count".to_string(),
            host_id: crate::mir::ValueId(0),
+            join_id: None, // Phase 177-STRUCT-1
        }];

        let updates = LoopUpdateAnalyzer::analyze_carrier_updates(&body, &carriers);
--- a/src/mir/join_ir/lowering/loop_with_break_minimal.rs
+++ b/src/mir/join_ir/lowering/loop_with_break_minimal.rs
@ -180,6 +180,16 @@ fn emit_carrier_update(
                        )
                    })?
                }
+                // Phase 178: String updates detected but not lowered to JoinIR yet
+                // The Rust MIR path handles string concatenation
+                // For JoinIR: just pass through the carrier param (no JoinIR update)
+                UpdateRhs::StringLiteral(_) | UpdateRhs::Other => {
+                    eprintln!(
+                        "[joinir/pattern2] Phase 178: Carrier '{}' has string/complex update - skipping JoinIR emit, using param passthrough",
+                        carrier.name
+                    );
+                    return Ok(carrier_param);  // Pass-through: no JoinIR update
+                }
            };

            // Allocate result ValueId
@ -737,6 +747,7 @@ mod tests {
            CarrierVar {
                name: name.to_string(),
                host_id: ValueId(host_id),
+                join_id: None, // Phase 177-STRUCT-1
            }
        }

--- a/src/mir/join_ir/lowering/loop_with_continue_minimal.rs
+++ b/src/mir/join_ir/lowering/loop_with_continue_minimal.rs
@ -387,6 +387,24 @@ pub fn lower_loop_with_continue_minimal(
                                const_1
                            }
                        }
+                        // Phase 178: String updates detected but not lowered to JoinIR yet
+                        // Skip JoinIR update - use Select passthrough to keep carrier_merged defined
+                        UpdateRhs::StringLiteral(_) | UpdateRhs::Other => {
+                            eprintln!(
+                                "[loop_with_continue_minimal] Phase 178: Carrier '{}' has string/complex update - skipping BinOp, using Select passthrough",
+                                carrier_name
+                            );
+                            // Emit Select with same values: carrier_merged = Select(_, carrier_param, carrier_param)
+                            // This is effectively a passthrough (no JoinIR update)
+                            loop_step_func.body.push(JoinInst::Select {
+                                dst: carrier_merged,
+                                cond: continue_cond,  // Condition doesn't matter when both values are same
+                                then_val: carrier_param,
+                                else_val: carrier_param,
+                                type_hint: None,
+                            });
+                            continue;  // Skip the BinOp and normal Select below
+                        }
                    }
                }
                UpdateExpr::Const(n) => {