diff --git a/docs/development/current/main/phase161_progress.md b/docs/development/current/main/phase161_progress.md
new file mode 100644
index 00000000..33c65cff
--- /dev/null
+++ b/docs/development/current/main/phase161_progress.md
@@ -0,0 +1,354 @@
+# Phase 161 Progress Summary
+
+**Status**: 🎯 **PHASE 161 DESIGN COMPLETE** - Ready for implementation (Task 4)
+
+**Current Date**: 2025-12-04
+**Phase Objective**: Port JoinIR/MIR analysis from Rust to .hako Analyzer infrastructure
+**Strategy**: Complete design first, implement incrementally with validation at each stage
+
+---
+
+## Completed Tasks (✅)
+
+### Task 1: JSON Format Inventory ✅
+**Deliverable**: `phase161_joinir_analyzer_design.md` (1,009 lines)
+
+**Completed**:
+- ✅ Complete MIR JSON v1 schema documentation (14 instruction types)
+- ✅ JoinIR JSON v0 schema documentation (CPS-style format)
+- ✅ PHI/Loop/If identification methods with full algorithms
+- ✅ Type hint propagation 4-iteration algorithm
+- ✅ 3 representative JSON snippets (if_select_simple, min_loop, skip_ws)
+- ✅ 5-stage implementation checklist
+- ✅ Recommendation: **Prioritize MIR JSON v1** over JoinIR
+
+**Key Finding**: MIR JSON v1 is the primary target due to:
+- Unified Call instruction (simplifies implementation)
+- CFG integration (Phase 155)
+- Better for .hako implementation
+
+---
+
+### Task 2: Analyzer Box Design ✅
+**Deliverable**: `phase161_analyzer_box_design.md` (250 lines)
+
+**Completed**:
+- ✅ Defined 3 analyzer Boxes with clear responsibilities:
+  - **JsonParserBox**: Low-level JSON parsing (reusable)
+  - **MirAnalyzerBox**: Primary MIR v1 analysis
+  - **JoinIrAnalyzerBox**: JoinIR v0 conversion layer
+
+- ✅ 7 core analyzer methods for MirAnalyzerBox:
+  - `validateSchema()`: Verify MIR structure
+  - `summarize_function()`: Function-level metadata
+  - `list_instructions()`: All instructions with types
+  - `list_phis()`: PHI detection
+  - `list_loops()`: Loop detection with CFG
+  - `list_ifs()`: Conditional branch detection
+  - `propagate_types()`: Type inference system
+  - `reachability_analysis()`: Dead code detection
+
+- ✅ Key algorithms documented:
+  - PHI detection: Pattern matching on `op == "phi"`
+  - Loop detection: CFG backward edge analysis
+  - If detection: Branch+merge identification
+  - Type propagation: 4-iteration convergence
+
+- ✅ Design principles applied:
+  - 箱化 (Boxification): Each box single responsibility
+  - 境界作成 (Clear Boundaries): No intermingling of concerns
+  - Fail-Fast: Errors immediate, no silent failures
+  - 遅延シングルトン: On-demand computation + caching
+
+---
+
+### Task 3: Representative Function Selection ✅
+**Deliverable**: `phase161_representative_functions.md` (250 lines)
+
+**Completed**:
+- ✅ Selected 5 representative functions covering all patterns:
+
+  1. **if_simple** (⭐ Simple)
+     - Tests: Branch detection, if-merge, single PHI
+     - Expected: 1 PHI, 1 Branch, 1 If structure
+     - File: `local_tests/phase161/rep1_if_simple.hako` ✅
+
+  2. **loop_simple** (⭐ Simple)
+     - Tests: Loop detection, back edge, loop-carried PHI
+     - Expected: 1 Loop, 1 PHI at header, backward edge
+     - File: `local_tests/phase161/rep2_loop_simple.hako` ✅
+
+  3. **if_loop** (⭐⭐ Medium)
+     - Tests: Nested if/loop, multiple PHI, complex control flow
+     - Expected: 1 Loop, 1 If (nested), 3 PHI total
+     - File: `local_tests/phase161/rep3_if_loop.hako` ✅
+
+  4. **loop_break** (⭐⭐ Medium)
+     - Tests: Loop with multiple exits, break resolution
+     - Expected: 1 Loop with 2 exits, 1 If (for break)
+     - File: `local_tests/phase161/rep4_loop_break.hako` ✅
+
+  5. **type_prop** (⭐⭐ Medium)
+     - Tests: Type propagation, type inference, PHI chains
+     - Expected: All types consistent, 4-iteration convergence
+     - File: `local_tests/phase161/rep5_type_prop.hako` ✅
+
+- ✅ Created test infrastructure:
+  - 5 minimal .hako test files (all created locally)
+  - `local_tests/phase161/README.md` with complete testing guide
+  - Expected analyzer outputs documented for each
+
+**Note**: Test files stored in `local_tests/phase161/` (not committed due to .gitignore, but available for development)
+
+---
+
+## Architecture Overview
+
+### Data Flow (Phase 161 Complete Design)
+
+```
+Rust MIR JSON (input)
+    ↓
+    ├─→ MirAnalyzerBox (primary path)
+    │   ├─→ validateSchema()
+    │   ├─→ summarize_function()
+    │   ├─→ list_instructions()
+    │   ├─→ list_phis()
+    │   ├─→ list_loops()
+    │   ├─→ list_ifs()
+    │   ├─→ propagate_types()
+    │   └─→ reachability_analysis()
+    │
+    └─→ JoinIrAnalyzerBox (compatibility)
+        ├─→ convert_to_mir()
+        └─→ MirAnalyzerBox (reuse)
+
+Analysis Results (output)
+```
+
+### Box Responsibilities
+
+| Box | Lines | Responsibilities | Methods |
+|-----|-------|-----------------|---------|
+| JsonParserBox | ~150 | Low-level JSON parsing | get(), getArray(), getString(), getInt(), getBool() |
+| MirAnalyzerBox | ~500-600 | MIR semantic analysis | 7 core + 3 debug methods |
+| JoinIrAnalyzerBox | ~100 | JoinIR compatibility | convert_to_mir(), validate_schema() |
+
+---
+
+## Implementation Roadmap (Phases 161-2 through 161-5)
+
+### Phase 161-2: Basic MirAnalyzerBox Structure
+**Scope**: Get basic parsing working on simple patterns
+**Focus**: rep1_if_simple and rep2_loop_simple
+**Deliverables**:
+- [ ] JsonParserBox implementation (JSON→MapBox/ArrayBox)
+- [ ] MirAnalyzerBox.birth() (parse MIR JSON)
+- [ ] validateSchema() (verify structure)
+- [ ] summarize_function() (basic metadata)
+- [ ] list_instructions() (iterate blocks)
+- [ ] Unit tests for rep1 and rep2
+
+**Success Criteria**:
+- Can parse MIR JSON test files
+- Can extract function metadata
+- Can list all instructions in order
+- rep1_if_simple and rep2_loop_simple passing
+
+**Estimated Effort**: 3-5 days
+
+---
+
+### Phase 161-3: PHI/Loop/If Detection
+**Scope**: Advanced control flow analysis
+**Focus**: rep3_if_loop
+**Deliverables**:
+- [ ] list_phis() implementation
+- [ ] list_loops() implementation (CFG-based)
+- [ ] list_ifs() implementation (merge detection)
+- [ ] Algorithm correctness tests
+- [ ] Validation on all 5 representatives
+
+**Success Criteria**:
+- All 5 representatives produce correct analysis
+- PHI detection complete and accurate
+- Loop detection handles back edges
+- If detection identifies merge blocks
+
+**Estimated Effort**: 4-6 days
+
+---
+
+### Phase 161-4: Type Propagation
+**Scope**: Type hint system
+**Focus**: rep5_type_prop
+**Deliverables**:
+- [ ] Type extraction from instructions
+- [ ] 4-iteration propagation algorithm
+- [ ] Type map generation
+- [ ] Type conflict detection
+- [ ] Full validation
+
+**Success Criteria**:
+- Type map captures all ValueIds
+- No type conflicts detected
+- Propagation converges in ≤4 iterations
+- rep5_type_prop validation complete
+
+**Estimated Effort**: 2-3 days
+
+---
+
+### Phase 161-5: Analysis Features & Integration
+**Scope**: Extended functionality
+**Focus**: Production readiness
+**Deliverables**:
+- [ ] reachability_analysis() implementation
+- [ ] Debug dump methods (dump_function, dump_cfg)
+- [ ] Performance optimization (caching)
+- [ ] CLI wrapper script (joinir_analyze.sh)
+- [ ] Final integration tests
+
+**Success Criteria**:
+- All analyzer methods complete
+- Dead code detection working
+- Performance acceptable
+- CLI interface ready for Phase 162
+
+**Estimated Effort**: 3-5 days
+
+---
+
+## Key Algorithms Reference
+
+### PHI Detection Algorithm
+```
+For each block in function:
+  For each instruction in block:
+    If instruction.op == "phi":
+      Extract destination ValueId
+      For each [value, from_block] in instruction.incoming:
+        Record PHI merge point
+      Mark block as PHI merge block
+```
+
+### Loop Detection Algorithm (CFG-based)
+```
+Build adjacency list from CFG
+For each block B:
+  For each successor S in B:
+    If S's block_id < B's block_id:
+      Found backward edge B → S
+      S is loop header
+      Find all blocks in loop via DFS from S
+      Record loop structure
+```
+
+### If Detection Algorithm
+```
+For each block B with Branch instruction:
+  condition = branch.condition (ValueId)
+  true_block = branch.targets[0]
+  false_block = branch.targets[1]
+
+  For each successor block S:
+    If S has PHI with incoming from both true AND false:
+      S is the merge block
+      Record if structure
+```
+
+### Type Propagation Algorithm
+```
+Initialize: type_map[v] = v.hint (from Const/Compare/BinOp)
+Iterate 4 times:  // Maximum iterations
+  For each PHI instruction:
+    incoming_types = [type_map[v] for each [v, _] in phi.incoming]
+    type_map[phi.dest] = merge_types(incoming_types)
+
+  For each BinOp/Compare/etc:
+    Propagate operand types to result
+
+Exit when convergence or max iterations reached
+```
+
+---
+
+## Testing Strategy
+
+### Unit Level (Phase 161-2)
+- Rep1 and Rep2 basic functionality
+- JSON parsing correctness
+- Schema validation
+
+### Integration Level (Phase 161-3)
+- All 5 representatives end-to-end
+- Each analyzer method validation
+- Cross-representative consistency
+
+### System Level (Phase 161-5)
+- CLI interface testing
+- Performance profiling
+- Integration with Phase 162
+
+---
+
+## Design Decisions Documented
+
+1. **Two Analyzer Boxes**: Separate concerns enable cleaner design
+2. **JsonParserBox Extraction**: Reusability across analyzers
+3. **MIR v1 Primary**: Simpler unified Call instruction
+4. **4-Iteration Type Propagation**: Empirically proven sufficient
+5. **Fail-Fast Semantics**: No silent failures or fallbacks
+
+---
+
+## Blockers / Risks
+
+**None identified** - All design complete, ready for implementation
+
+---
+
+## Next Steps
+
+### Immediate (Task 4)
+1. Create basic JsonParserBox skeleton in .hako
+2. Implement MIR JSON→MapBox parser
+3. Implement summarize_function() and list_instructions()
+4. Validate on rep1_if_simple and rep2_loop_simple
+5. Commit Phase 161-2 implementation
+
+### Short Term
+1. Implement PHI/loop/if detection (Phase 161-3)
+2. Validate on all 5 representatives
+3. Implement type propagation (Phase 161-4)
+4. Create CLI wrapper (Phase 161-5)
+
+### Medium Term
+1. Phase 162: JoinIR lowering in .hako (using MirAnalyzerBox)
+2. Phase 163: Integration with existing compiler infrastructure
+3. Phase 164: Performance optimization
+
+---
+
+## Documents Reference
+
+| Document | Purpose | Status |
+|----------|---------|--------|
+| phase161_joinir_analyzer_design.md | JSON format inventory | ✅ Committed |
+| phase161_analyzer_box_design.md | Box architecture | ✅ Committed |
+| phase161_representative_functions.md | Function selection | ✅ Committed |
+| local_tests/phase161/ | Test suite | ✅ Created locally |
+
+---
+
+## Summary
+
+**Phase 161 Design is Complete!**
+
+All analysis boxes are architected, all algorithms documented, all test cases selected and created. The design follows Nyash principles (箱化, 境界作成, Fail-Fast) and is ready for Phase 161-2 implementation.
+
+**Recommendation**: Begin with Phase 161-2 implementation focused on basic JSON parsing and rep1/rep2 validation.
+
+---
+
+**Status**: 🚀 Ready for Phase 161 Task 4 - Basic MirAnalyzerBox Implementation