refactor(normalization): Phase 135 P0 - Extend plan to zero post-loop assigns

Generalize NormalizationPlan suffix detection to accept zero post-loop assignments:

Goal: Improve entry point consistency by allowing `loop + assign* + return` (N >= 0)

Implementation:
- Modified plan_box.rs detection logic (only file changed)
- Removed `post_assign_count >= 1` requirement
- Unified Phase 131 (loop + return) and Phase 132-133 (loop + assign+ + return) paths

Changes:
- src/mir/builder/control_flow/normalization/plan_box.rs:
  - Removed assignment count constraint
  - Unified pattern detection: `loop + assign* + return` (N >= 0)
- apps/tests/phase135_loop_true_break_once_post_empty_return_min.hako (new fixture)
- tools/smokes/v2/profiles/integration/apps/phase135_*.sh (new smoke tests)

Pattern support:
- Phase 131/135: loop + return only (consumed: 2, post_assign_count: 0) ✅
- Phase 132: loop + 1 assign + return (consumed: 3, post_assign_count: 1) ✅
- Phase 133: loop + N assigns + return (consumed: 2+N, post_assign_count: N) ✅

Design principles maintained:
- **Minimal change**: Only plan_box.rs modified (execute_box unchanged)
- **SSOT**: Detection logic centralized in plan_box.rs
- **Box-First**: Responsibility separation preserved (Plan/Execute)

Test results:
- Unit tests (plan_box): 9/9 PASS (2 new tests added)
- Phase 135 VM/LLVM EXE: PASS (exit code 1)
- Phase 131 regression: 2/2 PASS (path now unified)
- Phase 133 regression: 2/2 PASS
- cargo test --lib: PASS

Benefits:
- Unified entry point for all loop + post patterns
- Easier maintenance (single detection logic)
- Future extensibility (easy to add new patterns)
- Clear separation of Phase 131 and Phase 132-135 paths

Default behavior unchanged: Dev-only guard maintained

Related: Phase 135 normalization pattern consistency improvement

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

apps/tests/phase135_loop_true_break_once_post_empty_return_min.hako

@@ -0,0 +1,28 @@
+// Phase 135 P0: loop(true) break-once with post 0 assigns + return
+//
+// Purpose: Test loop(true) { <assign>* ; break } + return (0 assignments)
+// Expected output: 1
+//
+// Structure:
+//   x = 0         // pre-loop init
+//   loop(true) {  // condition is Bool literal true
+//       x = 1     // body assignment
+//       break     // break at end
+//   }
+//   return x      // direct return (NO post-loop assignments)
+//
+// Difference from Phase 131:
+//   Phase 131: loop only (no return)
+//   Phase 135: loop + return (0 post assignments)
+
+static box Main {
+    main() {
+        local x
+        x = 0
+        loop(true) {
+            x = 1
+            break
+        }
+        return x
+    }
+}

docs/development/current/main/10-Now.md

@@ -1,5 +1,35 @@
 # Self Current Task — Now (main)
 
+## 2025-12-18：Phase 135 P0 完了 ✅
+
+**Phase 135 P0: Normalization Plan Suffix Detection Generalization**
+- 目的: NormalizationPlanBox の suffix 検出を一般化し、post-loop assign が 0 回でも OK に
+- 背景:
+  - Phase 133 までは `loop + assign+ + return`（assign 1回以上必須）
+  - Phase 131 は `loop` のみ（return なし）
+  - ギャップ: `loop + return`（0 assign）が別経路
+- 改善:
+  - `loop + assign* + return`（N >= 0 assignments）を統一パターンとして検出
+  - Phase 131 と Phase 132-133 を `LoopWithPost { post_assign_count }` enum で統一
+  - Phase 131 (loop-only, no return) は `PlanKind::LoopOnly` として独立維持
+- 実装:
+  - `src/mir/builder/control_flow/normalization/plan_box.rs`（検出ロジック修正のみ）
+  - `post_assign_count >= 1` チェックを削除 → `>= 0` を許容
+  - `execute_box.rs` は変更なし（既存ロジックが 0 assigns を自然にサポート）
+- Fixture: `apps/tests/phase135_loop_true_break_once_post_empty_return_min.hako`（期待: exit code 1）
+- Smoke tests:
+  - `phase135_loop_true_break_once_post_empty_return_vm.sh` PASS
+  - `phase135_loop_true_break_once_post_empty_return_llvm_exe.sh` PASS
+- Regression:
+  - Phase 131: 2/2 PASS（VM + LLVM EXE）
+  - Phase 133: 2/2 PASS（VM + LLVM EXE）
+- Unit tests: 9/9 PASS（plan_box module）
+- 設計原則:
+  - **最小変更**: plan_box.rs の検出条件のみ変更
+  - **SSOT 維持**: 検出ロジックは plan_box.rs に集約
+  - **Box-First**: PlanBox（what）と ExecuteBox（how）の責任分離維持
+- 入口: `src/mir/builder/control_flow/normalization/README.md`（Phase 135 セクション追加）
+
 ## 2025-12-18：Phase 133 完了 ✅
 
 **Phase 133: loop(true) break-once + multiple post-loop assigns（dev-only）**

src/mir/builder/control_flow/normalization/README.md

@@ -87,13 +87,13 @@ pub enum PlanKind {
 
 ---
 
-## Pattern Detection (Phase 131-133)
+## Pattern Detection (Phase 131-135)
 
 ### Phase 131: Loop-Only
-- Pattern: `loop(true) { ... break }`
+- Pattern: `loop(true) { ... break }` (single statement, no return)
 - Consumed: 1 statement
 - Kind: `PlanKind::LoopOnly`
-- Example: `loop(true) { x = 1; break }; return x`
+- Example: `loop(true) { x = 1; break }`
 
 ### Phase 132: Loop + Single Post
 - Pattern: `loop(true) { ... break }; <assign>; return <expr>`
@@ -107,6 +107,14 @@ pub enum PlanKind {
 - Kind: `PlanKind::LoopWithPost { post_assign_count: N }`
 - Example: `loop(true) { x = 1; break }; x = x + 2; x = x + 3; return x`
 
+### Phase 135: Loop + Return (Zero Post Assigns) **NEW**
+- Pattern: `loop(true) { ... break }; return <expr>` (0 post-loop assignments)
+- Consumed: 2 statements (loop, return)
+- Kind: `PlanKind::LoopWithPost { post_assign_count: 0 }`
+- Example: `loop(true) { x = 1; break }; return x`
+- **Improvement**: Unifies Phase 131 and Phase 132-133 patterns under `LoopWithPost` enum
+- **Compatibility**: Phase 131 (loop-only, no return) remains as `PlanKind::LoopOnly`
+
 ---
 
 ## Contract
@@ -127,7 +135,7 @@ pub enum PlanKind {
 **Invariants**:
 - `consumed <= remaining.len()` (never consume more than available)
 - If `requires_return` is true, `remaining[consumed-1]` must be Return
-- Post-assign patterns require `consumed >= 3` (loop + assign + return minimum)
+- Post-assign patterns require `consumed >= 2` (loop + return minimum, Phase 135+)
 
 ### NormalizationExecuteBox::execute()
 
@@ -172,10 +180,13 @@ pub enum PlanKind {
 - Phase 131 pattern detection (loop-only)
 - Phase 132 pattern detection (loop + single post)
 - Phase 133 pattern detection (loop + multiple post)
+- **Phase 135 pattern detection (loop + zero post)** **NEW**
 - Return boundary detection (consumed stops at return)
+- **Return boundary with trailing statements** **NEW**
 - Non-matching patterns (returns None)
 
 ### Regression Smokes
+- **Phase 135**: `phase135_loop_true_break_once_post_empty_return_{vm,llvm_exe}.sh` **NEW**
 - Phase 133: `phase133_loop_true_break_once_post_multi_add_{vm,llvm_exe}.sh`
 - Phase 132: `phase132_loop_true_break_once_post_add_llvm_exe.sh`
 - Phase 131: `phase131_loop_true_break_once_{vm,llvm_exe}.sh`

src/mir/builder/control_flow/normalization/plan_box.rs

@@ -65,39 +65,7 @@ impl NormalizationPlanBox {
             return Ok(Some(NormalizationPlan::loop_only()));
         }
 
-        // Check if second statement is an assignment (Phase 132-133 specific)
+        // Phase 132-135: Loop + (assign*) + return
-        let has_post_assignment = matches!(&remaining[1], ASTNode::Assignment { .. });
-        if !has_post_assignment {
-            // Not a post-assignment pattern, treat as loop-only if it's just a loop
-            // (if there are other statements after the loop that aren't assignments,
-            // this is not our pattern - return None)
-            if debug {
-                trace.routing(
-                    "normalization/plan",
-                    func_name,
-                    "No post-assignment after loop, treating as loop-only",
-                );
-            }
-            return Ok(Some(NormalizationPlan::loop_only()));
-        }
-
-        // Phase 132-133: Loop + post assignments + return
-        // Minimum: loop + 1 assign + return (3 statements)
-        if remaining.len() < 3 {
-            // Has assignment after loop but no return - not a valid pattern
-            if debug {
-                trace.routing(
-                    "normalization/plan",
-                    func_name,
-                    &format!(
-                        "Loop + assignment but no return ({} statements), not a valid pattern",
-                        remaining.len()
-                    ),
-                );
-            }
-            return Ok(None);
-        }
-
         // Count consecutive assignments after the loop
         let mut post_assign_count = 0;
         for i in 1..remaining.len() {
@@ -108,32 +76,33 @@ impl NormalizationPlanBox {
             }
         }
 
-        // After assignments, we need a return statement
+        // After assignments (0 or more), we need a return statement
         let return_index = 1 + post_assign_count;
         if return_index >= remaining.len() {
-            // No return statement - cannot use post pattern
+            // No statement after assignments - not a post pattern
             if debug {
                 trace.routing(
                     "normalization/plan",
                     func_name,
                     &format!(
-                        "No return after {} assignments, not a valid post pattern",
+                        "No statement after {} assignments, not a valid post pattern",
                         post_assign_count
                     ),
                 );
             }
+            // If there's a non-assignment statement after loop but no return, treat as not a pattern
             return Ok(None);
         }
 
         let has_return = matches!(&remaining[return_index], ASTNode::Return { .. });
         if !has_return {
-            // Statement after assignments is not return - not a post pattern
+            // Statement after loop (and optional assignments) is not return - not a post pattern
             if debug {
                 trace.routing(
                     "normalization/plan",
                     func_name,
                     &format!(
-                        "Statement after {} assignments is not return, not a valid post pattern",
+                        "Statement after loop and {} assignments is not return, not a valid post pattern",
                         post_assign_count
                     ),
                 );
@@ -141,13 +110,13 @@ impl NormalizationPlanBox {
             return Ok(None);
         }
 
-        // Valid Phase 132-133 pattern: loop + N assignments + return
+        // Valid Phase 132-135 pattern: loop + N assignments (N >= 0) + return
         if debug {
             trace.routing(
                 "normalization/plan",
                 func_name,
                 &format!(
-                    "Detected Phase 132-133 pattern: loop + {} post assigns + return",
+                    "Detected Phase 132-135 pattern: loop + {} post assigns + return",
                     post_assign_count
                 ),
             );
@@ -351,4 +320,47 @@ mod tests {
         // No return means not a valid post pattern
         assert!(plan.is_none());
     }
+
+    #[test]
+    fn test_plan_block_suffix_phase135_loop_return_only() {
+        use crate::mir::builder::MirBuilder;
+
+        // Phase 135: loop + return (0 post assignments)
+        let remaining = vec![
+            make_loop(),
+            make_return("x"),
+        ];
+
+        let builder = MirBuilder::new();
+        let plan = NormalizationPlanBox::plan_block_suffix(&builder, &remaining, "test", false)
+            .expect("Should not error");
+
+        assert!(plan.is_some());
+        let plan = plan.unwrap();
+        assert_eq!(plan.consumed, 2); // loop + return
+        assert_eq!(plan.kind, PlanKind::LoopWithPost { post_assign_count: 0 });
+        assert!(plan.requires_return);
+    }
+
+    #[test]
+    fn test_plan_block_suffix_return_boundary_with_trailing() {
+        use crate::mir::builder::MirBuilder;
+
+        // Pattern with unreachable statement after return (Phase 135 variation)
+        let remaining = vec![
+            make_loop(),
+            make_return("x"),
+            make_assignment("y", 999), // Unreachable
+        ];
+
+        let builder = MirBuilder::new();
+        let plan = NormalizationPlanBox::plan_block_suffix(&builder, &remaining, "test", false)
+            .expect("Should not error");
+
+        assert!(plan.is_some());
+        let plan = plan.unwrap();
+        // Should consume only up to return (not the unreachable statement)
+        assert_eq!(plan.consumed, 2); // loop + return
+        assert_eq!(plan.kind, PlanKind::LoopWithPost { post_assign_count: 0 });
+    }
 }

tools/smokes/v2/profiles/integration/apps/phase135_loop_true_break_once_post_empty_return_llvm_exe.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Phase 135 P0: loop(true) break-once + return (0 post assigns, LLVM EXE parity)
+# Pattern: loop(true) { x = 1; break } → return x (should be 1)
+
+source "$(dirname "$0")/../../../lib/test_runner.sh"
+source "$(dirname "$0")/../../../lib/llvm_exe_runner.sh"
+export SMOKES_USE_PYVM=0
+require_env || exit 2
+
+llvm_exe_preflight_or_skip || exit 0
+
+# Phase 135 is a dev-only Normalized shadow loop case.
+# LLVM EXE emission must run with JoinIR dev/strict enabled, otherwise it will freeze.
+require_joinir_dev
+
+# Phase 135: minimal plugin set (StringBox, ConsoleBox, IntegerBox only)
+STRINGBOX_SO="$NYASH_ROOT/plugins/nyash-string-plugin/libnyash_string_plugin.so"
+CONSOLEBOX_SO="$NYASH_ROOT/plugins/nyash-console-plugin/libnyash_console_plugin.so"
+INTEGERBOX_SO="$NYASH_ROOT/plugins/nyash-integer-plugin/libnyash_integer_plugin.so"
+
+LLVM_REQUIRED_PLUGINS=(
+  "StringBox|$STRINGBOX_SO|nyash-string-plugin"
+  "ConsoleBox|$CONSOLEBOX_SO|nyash-console-plugin"
+  "IntegerBox|$INTEGERBOX_SO|nyash-integer-plugin"
+)
+LLVM_PLUGIN_BUILD_LOG="/tmp/phase135_loop_true_break_once_post_empty_return_plugin_build.log"
+llvm_exe_ensure_plugins_or_fail || exit 1
+
+INPUT_HAKO="$NYASH_ROOT/apps/tests/phase135_loop_true_break_once_post_empty_return_min.hako"
+OUTPUT_EXE="$NYASH_ROOT/tmp/phase135_loop_true_break_once_post_empty_return_llvm_exe"
+
+EXPECTED_EXIT_CODE=1
+LLVM_BUILD_LOG="/tmp/phase135_loop_true_break_once_post_empty_return_build.log"
+if llvm_exe_build_and_run_expect_exit_code; then
+  test_pass "phase135_loop_true_break_once_post_empty_return_llvm_exe: exit code matches expected (1)"
+else
+  exit 1
+fi

tools/smokes/v2/profiles/integration/apps/phase135_loop_true_break_once_post_empty_return_vm.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# Phase 135 P0: loop(true) break-once + return (0 post assigns, Normalized shadow, VM)
+#
+# Verifies that loop(true) { <assign>* ; break } + return (0 assigns) works:
+# - x = 0 → loop(true) { x = 1; break } → return x → 1
+# - Dev-only: NYASH_JOINIR_DEV=1 HAKO_JOINIR_STRICT=1
+
+source "$(dirname "$0")/../../../lib/test_runner.sh"
+export SMOKES_USE_PYVM=0
+require_env || exit 2
+
+# Phase 135 is a dev-only Normalized shadow loop case.
+require_joinir_dev
+
+PASS_COUNT=0
+FAIL_COUNT=0
+RUN_TIMEOUT_SECS=${RUN_TIMEOUT_SECS:-10}
+
+echo "[INFO] Phase 135 P0: loop(true) break-once + return (0 post assigns, Normalized shadow, VM)"
+
+# Test 1: phase135_loop_true_break_once_post_empty_return_min.hako
+echo "[INFO] Test 1: phase135_loop_true_break_once_post_empty_return_min.hako"
+INPUT="$NYASH_ROOT/apps/tests/phase135_loop_true_break_once_post_empty_return_min.hako"
+
+set +e
+OUTPUT=$(timeout "$RUN_TIMEOUT_SECS" env \
+  NYASH_DISABLE_PLUGINS=1 \
+  "$NYASH_BIN" --backend vm "$INPUT" 2>&1)
+EXIT_CODE=$?
+set -e
+
+if [ "$EXIT_CODE" -eq 124 ]; then
+  echo "[FAIL] hakorune timed out (>${RUN_TIMEOUT_SECS}s)"
+  FAIL_COUNT=$((FAIL_COUNT + 1))
+elif [ "$EXIT_CODE" -eq 1 ]; then
+  # Phase 135: expected output is exit code 1 (return value)
+  echo "[PASS] exit code verified: 1"
+  PASS_COUNT=$((PASS_COUNT + 1))
+else
+  echo "[FAIL] hakorune failed with exit code $EXIT_CODE (expected 1)"
+  echo "[INFO] output (tail):"
+  echo "$OUTPUT" | tail -n 50 || true
+  FAIL_COUNT=$((FAIL_COUNT + 1))
+fi
+
+echo "[INFO] PASS: $PASS_COUNT, FAIL: $FAIL_COUNT"
+
+if [ "$FAIL_COUNT" -eq 0 ]; then
+  test_pass "phase135_loop_true_break_once_post_empty_return_vm: All tests passed"
+  exit 0
+else
+  test_fail "phase135_loop_true_break_once_post_empty_return_vm: $FAIL_COUNT test(s) failed"
+  exit 1
+fi