docs: Major cleanup of ONGOING_TASKS.md and architectural knowledge preservation

CLEANUP ACHIEVEMENT: Reduced ONGOING_TASKS.md from 1549 lines to 128 lines (92% reduction)

ONGOING_TASKS.md CHANGES:
- Removed all completed/resolved items (infinite loop, climb tree, string-to-dictionary fixes, etc.)
- Eliminated extensive debugging logs and outdated investigation details
- Focused on active work: Localization Architecture with clear phase breakdown
- Added current system status showing all major bugs resolved
- Streamlined to actionable items only

ARCHITECTURE.md ENHANCEMENTS:
- Added comprehensive "Compiler Architecture Lessons Learned" section
- Preserved critical architectural insights from resolved bugs:
  * Circular Reference Prevention patterns (object tree integrity)
  * HashMap→IndexMap Determinism Impact (function ordering effects)
  * String Parameter Passing constraints (two-phase processing)
  * Z-Machine Opcode Form Instability (form-sensitive conflicts)
  * Builtin Pseudo-Method Detection (property vs compiler builtin distinction)
  * Expression Control Flow Optimization (jump elimination techniques)
  * Development Methodology Insights (debugging and testing strategies)

DOCUMENTATION ORGANIZATION:
- Clean separation: Active tasks (ONGOING_TASKS.md) vs Architectural knowledge (ARCHITECTURE.md)
- Historical context preserved in proper documentation structure
- No valuable technical insights lost during cleanup

IMMEDIATE NEXT STEPS:
- Phase 1: AST Extensions for localization system ready to implement
- Phase 5: Builtin Function Message Integration pending
- All major bugs resolved, system in stable production state

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

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

Author: skeptomai

ONGOING_TASKS.md

@@ -1288,6 +1288,122 @@ Main Loop (ID 9000)
 
 This modular architecture provides a robust, maintainable foundation for a complete Z-Machine interpreter with excellent game compatibility, clean code organization, and clear separation of concerns across functional domains.
 
+## Compiler Architecture Lessons Learned
+
+### Critical Bug Pattern: Circular Reference Prevention
+
+**Date**: November 12-13, 2025
+**Issue**: Container iteration infinite loops caused by circular sibling references
+**Root Cause**: Phase 2 object tree processing created objects with `sibling=self` instead of `sibling=0`
+
+**Key Insight**: Object containment systems require explicit circular reference detection:
+```rust
+// WRONG: Can create circular references
+self.write_to_object_space(obj_offset + 5, parent_child)?;
+
+// CORRECT: Check for existing correct placement first
+if parent_child == obj_num {
+    // Object already correctly positioned, no updates needed
+} else if parent_child == 0 {
+    // Parent has no children - make this object the first child
+    self.write_to_object_space(parent_offset + 6, obj_num)?;
+} else {
+    // Insert at beginning of sibling chain with circularity prevention
+    self.write_to_object_space(obj_offset + 5, parent_child)?;
+    self.write_to_object_space(parent_offset + 6, obj_num)?;
+}
+```
+
+**Prevention**: Always verify object tree integrity during Phase 2 processing and prevent self-referencing sibling chains.
+
+### HashMap→IndexMap Determinism Impact
+
+**Date**: November 12, 2025
+**Issue**: Deterministic builds required HashMap→IndexMap migration, which unexpectedly affected function ordering
+**Impact**: Identical source code produced different runtime behavior due to function address changes
+
+**Key Insight**: Function ordering changes can affect Z-Machine branch offset calculations:
+- Function addresses changed due to deterministic iteration order
+- Branch offset calculations depend on absolute addresses in bytecode
+- Identical IR logic can produce different runtime behavior when addresses shift
+
+**Architectural Decision**: Function ordering stability is critical for reproducible builds. IndexMap provides deterministic ordering at the cost of requiring careful verification of address-dependent code.
+
+### String Parameter Passing Architectural Constraint
+
+**Date**: November 6, 2025
+**Issue**: Z-Machine has no native string parameter support, but games need direction strings
+**Challenge**: Original design constraint prohibited string literals as function parameters
+
+**Solution Architecture**:
+1. **Two-Phase Processing**: Collect string info during operand building, process after instruction emission
+2. **Layout-Based Addressing**: Use `InstructionLayout.operand_location` for precise address calculation
+3. **Type Differentiation**: Direction strings (dictionary addresses) vs display strings (packed addresses)
+
+**Key Lesson**: When instruction emission affects addressing, always use layout information rather than manual calculation.
+
+**Critical Bug Pattern**:
+```rust
+// WRONG: Manual calculation (off-by-one errors)
+let operand_location = self.code_address + 1 + operands.len() * 2;
+
+// CORRECT: Layout-based (exact addressing)
+let layout = self.emit_instruction_typed(...);
+let operand_location = layout.operand_location.unwrap() + (index * 2);
+```
+
+### Z-Machine Opcode Form Instability
+
+**Date**: October 2025
+**Issue**: Same opcode number means different instructions across forms (Long/Variable)
+**Example**: Opcode 0x0D = `store` (Long form) vs `output_stream` (Variable form)
+
+**Root Cause**: Form determination in `emit_instruction` automatically switches forms based on operand constraints, but doesn't account for semantic differences.
+
+**Critical Pattern**:
+```rust
+// When LargeConstant > 255, form switches from Long to Variable
+// but opcode 0x0D changes meaning from 'store' to 'output_stream'
+emit_instruction(0x0D, [Variable(dest), LargeConstant(300)]) // BROKEN
+```
+
+**Prevention Strategy**: Add compile-time validation for form-sensitive opcodes to catch semantic conflicts before code generation.
+
+### Builtin Pseudo-Method Detection
+
+**Date**: October 9, 2025
+**Issue**: Method calls with property checks incorrectly skipped builtin pseudo-methods
+**Root Cause**: IR generator applied property check pattern to compiler-provided functions
+
+**Key Insight**: Distinguish between property-based methods and compiler builtins:
+```rust
+// Property-based methods (check if object has custom implementation)
+if property_exists { call_custom() } else { call_default() }
+
+// Builtin pseudo-methods (direct compiler functions)
+call_builtin() // No property check needed
+```
+
+**Detection Strategy**: Use pattern matching on method names to bypass property lookup for known compiler builtins (`get_exit`, `empty`, `none`).
+
+### Complex Expression Control Flow Optimization
+
+**Achievement**: 66% reduction in redundant jumps (32 → 11) through IR pattern optimization
+**Technique**: Eliminate `Jump { end_label }` when else branch is empty
+
+**Remaining Pattern**: LoadImmediate instructions don't emit Z-code, causing offset-2 jumps that convert to NOPs
+**Decision**: Accept current state - remaining NOPs are harmless and rare
+
+### Development Methodology Insights
+
+**Debugging Lesson**: When debugging execution failures, instrument actual execution path first, not binary analysis
+**Effective**: Trace instruction decode → execution flow to find missing execution
+**Ineffective**: Examining bytecode with hex dumps and guessing intent
+
+**Architecture Documentation**: Always document root causes and prevention strategies for systematic bugs - they tend to recur in similar forms.
+
+**Testing Strategy**: Verify semantic correctness, not just syntactic validity. Complex bugs often produce valid bytecode that executes incorrectly.
+
 ## IR Generation for Builtin Pseudo-Methods (October 9, 2025)
 
 ### The Problem

docs/ARCHITECTURE.md

@@ -3247,23 +3247,24 @@ impl IrGenerator {
                     source_info
                 );
 
-                let container_object = self.variable_sources.get(&iterable_temp).and_then(
-                    |source| {
-                        if let VariableSource::ObjectTreeRoot(container_id) = source {
-                            log::error!(
+                let container_object =
+                    self.variable_sources
+                        .get(&iterable_temp)
+                        .and_then(|source| {
+                            if let VariableSource::ObjectTreeRoot(container_id) = source {
+                                log::error!(
                                 "🔍 FOR_LOOP_DEBUG: Found ObjectTreeRoot source! Container ID = {}",
                                 container_id
                             );
-                            Some(*container_id)
-                        } else {
-                            log::error!(
-                                "🔍 FOR_LOOP_DEBUG: Found non-ObjectTreeRoot source: {:?}",
-                                source
-                            );
-                            None
-                        }
-                    },
-                );
+                                Some(*container_id)
+                            } else {
+                                log::error!(
+                                    "🔍 FOR_LOOP_DEBUG: Found non-ObjectTreeRoot source: {:?}",
+                                    source
+                                );
+                                None
+                            }
+                        });
 
                 if let Some(container_id) = container_object {
                     log::error!(

killed-troll.sav

@@ -0,0 +1,63 @@
+# Mini Zork Comprehensive Test Protocol Report
+
+**Generated:** Wed Nov 12 16:19:45 PST 2025
+**Project:** infocom
+**Git Commit:** 7c0c37b
+
+## Test Configuration
+
+- **Debug Game:** 
+- **Release Game:** 
+- **Game Commands:** 11 commands (open mailbox → quit)
+- **Expected Final Score:** 7
+- **Expected Final Moves:** 4
+
+## Test Results
+
+### udebug interpreter debug game
+
+**Status:** ✅ PASSED
+- **Final Score:** 7
+- **Final Moves:** 4
+- **Success Indicators:** 4/4
+
+### udebug interpreter release game
+
+**Status:** ✅ PASSED
+- **Final Score:** 7
+- **Final Moves:** 4
+- **Success Indicators:** 4/4
+
+### urelease interpreter debug game
+
+**Status:** ✅ PASSED
+- **Final Score:** 7
+- **Final Moves:** 4
+- **Success Indicators:** 4/4
+
+### urelease interpreter release game
+
+**Status:** ✅ PASSED
+- **Final Score:** 7
+- **Final Moves:** 4
+- **Success Indicators:** 4/4
+
+## Overall Results
+
+**Tests Passed:** 4/4
+**Overall Status:** ✅ ALL TESTS PASSED
+
+🎉 **COMPREHENSIVE TEST PROTOCOL SUCCESSFUL**
+
+All build combinations (debug/release compiler × debug/release interpreter) completed
+successfully with expected gameplay outcomes. The codebase is functioning correctly
+across all tested configurations.
+
+## Files Generated
+
+- **Raw Outputs:** `*_output.txt` files with complete game session logs
+- **Clean Outputs:** `*_clean.txt` files with ANSI codes stripped
+- **Test Summaries:** `*_summary.txt` files with key metrics
+- **Game Files:** Debug and release compiled game files
+
+All files are located in: `/Users/cb/Projects/infocom-testing-old/infocom/tests/protocol_results_20251112_161909`

src/grue_compiler/ir.rs

@@ -0,0 +1 @@
+/Users/cb/Projects/infocom-testing-old/infocom/tests/mini_zork_debug_20251112_161909.z3

tests/mini_zork_debug_20251112_161909.z3

@@ -0,0 +1,27 @@
+DORK I: The Last Great Empire
+Copyright (c) 2025 Grue Games. All rights reserved.
+ZORK is a registered trademark of Infocom, Inc.
+DORK is .... not
+Revision 1 / Serial number 8675309
+   
+You are standing in an open field west of a white house, with a boarded front door.
+There is a small mailbox here.
+> 7                                                                             Score: 0 Moves: 08The a small mailbox contains:
+  leaflet
+> 7                                                                             Score: 0 Moves: 08Took leaflet.
+> 7                                                                             Score: 2 Moves: 08"WELCOME TO DORK!
+
+DORK is a game of adventure, danger, and low cunning. In it you will explore some of the most amazing territory ever seen by mortals. No computer should be without one!"
+> 7                                                                             Score: 2 Moves: 08You are facing the north side of a white house. There is no door here, and all the windows are boarded up. To the north a narrow path winds through the trees.
+> 7                                                                             Score: 2 Moves: 18This is a path winding through a dimly lit forest. The path heads north-south here. One particularly large tree with some low branches stands at the edge of the path.
+There is tree here.
+> 7                                                                             Score: 2 Moves: 28You are about 10 feet above the ground nestled among some large branches. The nearest branch above you is above your reach.
+There is a bird's nest here with a jewel-encrusted egg visible inside.
+> 7                                                                             Score: 2 Moves: 38You are the proud owner of a very special egg.. Is it ticking?
+> 7                                                                             Score: 7 Moves: 38This is a path winding through a dimly lit forest. The path heads north-south here. One particularly large tree with some low branches stands at the edge of the path.
+There is tree here.
+> 7                                                                             Score: 7 Moves: 48Your score is 7
+> 7                                                                             Score: 7 Moves: 48You are carrying:
+  jewel-encrusted egg
+  leaflet
+> 7                                                                             Score: 7 Moves: 48Are you sure you want to quit? (y/n) > 7                                                                             Score: 7 Moves: 48