chore(ipuaro): release v0.29.0

feat(ipuaro): add impact score to initial context
Add High Impact Files section to initial context showing which files are most critical based on percentage of codebase that depends on them. Changes: - Add impactScore field to FileMeta (0-100) - Add calculateImpactScore() helper function - Update MetaAnalyzer to compute impact scores - Add formatHighImpactFiles() to prompts.ts - Add includeHighImpactFiles config option (default: true) - 28 new tests (1826 total)
2025-12-28 07:16:53 +05:00 · 2025-12-05 15:44:27 +05:00 · 2025-12-05 15:43:24 +05:00 · 2025-12-05 15:12:26 +05:00 · 2025-12-05 14:38:45 +05:00 · 2025-12-05 14:20:14 +05:00
57 changed files with 8312 additions and 367 deletions
--- a/packages/guardian/docs/RESEARCH_CITATIONS.md
+++ b/packages/guardian/docs/RESEARCH_CITATIONS.md
@@ -20,6 +20,21 @@ This document provides authoritative sources, academic papers, industry standard
 12. [Aggregate Boundary Validation (DDD Tactical Patterns)](#12-aggregate-boundary-validation-ddd-tactical-patterns)
 13. [Secret Detection & Security](#13-secret-detection--security)
 14. [Severity-Based Prioritization & Technical Debt](#14-severity-based-prioritization--technical-debt)
 15. [Domain Event Usage Validation](#15-domain-event-usage-validation)
 16. [Value Object Immutability](#16-value-object-immutability)
 17. [Command Query Separation (CQS/CQRS)](#17-command-query-separation-cqscqrs)
 18. [Factory Pattern](#18-factory-pattern)
 19. [Specification Pattern](#19-specification-pattern)
 20. [Bounded Context](#20-bounded-context)
 21. [Persistence Ignorance](#21-persistence-ignorance)
 22. [Null Object Pattern](#22-null-object-pattern)
 23. [Primitive Obsession](#23-primitive-obsession)
 24. [Service Locator Anti-pattern](#24-service-locator-anti-pattern)
 25. [Double Dispatch and Visitor Pattern](#25-double-dispatch-and-visitor-pattern)
 26. [Entity Identity](#26-entity-identity)
 27. [Saga Pattern](#27-saga-pattern)
 28. [Anti-Corruption Layer](#28-anti-corruption-layer)
 29. [Ubiquitous Language](#29-ubiquitous-language)
 ---
@@ -801,22 +816,840 @@ This document provides authoritative sources, academic papers, industry standard
 ---
 ## 15. Domain Event Usage Validation
 ### Eric Evans: Domain-Driven Design (2003)
 **Original Definition:**
 - Domain Events: "Something happened that domain experts care about"
 - Events capture facts about the domain that have already occurred
 - Distinct from system events - they model business-relevant occurrences
 - Reference: [Martin Fowler - Domain Event](https://martinfowler.com/eaaDev/DomainEvent.html)
 **Book: Domain-Driven Design** (2003)
 - Author: Eric Evans
 - Publisher: Addison-Wesley Professional
 - ISBN: 978-0321125217
 - Domain Events weren't explicitly in the original book but evolved from DDD community
 - Reference: [DDD Community - Domain Events](https://www.domainlanguage.com/)
 ### Vaughn Vernon: Implementing Domain-Driven Design (2013)
 **Chapter 8: Domain Events**
 - Author: Vaughn Vernon
 - Comprehensive coverage of Domain Events implementation
 - "Model information about activity in the domain as a series of discrete events"
 - Reference: [Amazon - Implementing DDD](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 **Key Principles:**
 - Events should be immutable
 - Named in past tense (OrderPlaced, UserRegistered)
 - Contain all data needed by handlers
 - Enable loose coupling between aggregates
 ### Martin Fowler's Event Patterns
 **Event Sourcing:**
 - "Capture all changes to an application state as a sequence of events"
 - Events become the primary source of truth
 - Reference: [Martin Fowler - Event Sourcing](https://martinfowler.com/eaaDev/EventSourcing.html)
 **Event-Driven Architecture:**
 - Promotes loose coupling between components
 - Enables asynchronous processing
 - Reference: [Martin Fowler - Event-Driven](https://martinfowler.com/articles/201701-event-driven.html)
 ### Why Direct Infrastructure Calls Are Bad
 **Coupling Issues:**
 - Direct calls create tight coupling between domain and infrastructure
 - Makes testing difficult (need to mock infrastructure)
 - Violates Single Responsibility Principle
 - Reference: [Microsoft - Domain Events Design](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/domain-events-design-implementation)
 **Benefits of Domain Events:**
 - Decouples domain from side effects
 - Enables eventual consistency
 - Improves testability
 - Supports audit logging naturally
 - Reference: [Jimmy Bogard - Domain Events](https://lostechies.com/jimmybogard/2010/04/08/strengthening-your-domain-domain-events/)
 ---
 ## 16. Value Object Immutability
 ### Eric Evans: Domain-Driven Design (2003)
 **Value Object Definition:**
 - "An object that describes some characteristic or attribute but carries no concept of identity"
 - "Value Objects should be immutable"
 - When you care only about the attributes of an element, classify it as a Value Object
 - Reference: [Martin Fowler - Value Object](https://martinfowler.com/bliki/ValueObject.html)
 **Immutability Requirement:**
 - "Treat the Value Object as immutable"
 - "Don't give it any identity and avoid the design complexities necessary to maintain Entities"
 - Reference: [DDD Reference - Value Objects](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 ### Martin Fowler on Value Objects
 **Blog Post: Value Object** (2016)
 - "A small simple object, like money or a date range, whose equality isn't based on identity"
 - "I consider value objects to be one of the most important building blocks of good domain models"
 - Reference: [Martin Fowler - Value Object](https://martinfowler.com/bliki/ValueObject.html)
 **Key Properties:**
 - Equality based on attribute values, not identity
 - Should be immutable (once created, cannot be changed)
 - Side-effect free behavior
 - Self-validating (validate in constructor)
 ### Vaughn Vernon: Implementing DDD
 **Chapter 6: Value Objects**
 - Detailed implementation guidance
 - "Measures, quantifies, or describes a thing in the domain"
 - "Can be compared with other Value Objects using value equality"
 - "Completely replaceable when the measurement changes"
 - Reference: [Vaughn Vernon - Implementing DDD](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 ### Why Immutability Matters
 **Thread Safety:**
 - Immutable objects are inherently thread-safe
 - No synchronization needed for concurrent access
 - Reference: [Effective Java - Item 17](https://www.amazon.com/Effective-Java-Joshua-Bloch/dp/0134685997)
 **Reasoning About Code:**
 - Easier to understand code when objects don't change
 - No defensive copying needed
 - Simplifies caching and optimization
 - Reference: [Oracle Java Tutorials - Immutable Objects](https://docs.oracle.com/javase/tutorial/essential/concurrency/immutable.html)
 **Functional Programming Influence:**
 - Immutability is a core principle of functional programming
 - Reduces side effects and makes code more predictable
 - Reference: [Wikipedia - Immutable Object](https://en.wikipedia.org/wiki/Immutable_object)
 ---
 ## 17. Command Query Separation (CQS/CQRS)
 ### Bertrand Meyer: Original CQS Principle
 **Book: Object-Oriented Software Construction** (1988, 2nd Ed. 1997)
 - Author: Bertrand Meyer
 - Publisher: Prentice Hall
 - ISBN: 978-0136291558
 - Introduced Command Query Separation principle
 - Reference: [Wikipedia - CQS](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)
 **CQS Principle:**
 - "Every method should either be a command that performs an action, or a query that returns data to the caller, but not both"
 - Commands: change state, return nothing (void)
 - Queries: return data, change nothing (side-effect free)
 - Reference: [Martin Fowler - CommandQuerySeparation](https://martinfowler.com/bliki/CommandQuerySeparation.html)
 ### Greg Young: CQRS Pattern
 **CQRS Documents** (2010)
 - Author: Greg Young
 - Extended CQS to architectural pattern
 - "CQRS is simply the creation of two objects where there was previously only one"
 - Reference: [Greg Young - CQRS Documents](https://cqrs.files.wordpress.com/2010/11/cqrs_documents.pdf)
 **Key Concepts:**
 - Separate models for reading and writing
 - Write model (commands) optimized for business logic
 - Read model (queries) optimized for display/reporting
 - Reference: [Microsoft - CQRS Pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs)
 ### Martin Fowler on CQRS
 **Blog Post: CQRS** (2011)
 - "At its heart is the notion that you can use a different model to update information than the model you use to read information"
 - Warns against overuse: "CQRS is a significant mental leap for all concerned"
 - Reference: [Martin Fowler - CQRS](https://martinfowler.com/bliki/CQRS.html)
 ### Benefits and Trade-offs
 **Benefits:**
 - Independent scaling of read and write workloads
 - Optimized data schemas for each side
 - Improved security (separate read/write permissions)
 - Reference: [AWS - CQRS Pattern](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-data-persistence/cqrs-pattern.html)
 **Trade-offs:**
 - Increased complexity
 - Eventual consistency challenges
 - More code to maintain
 - Reference: [Microsoft - CQRS Considerations](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs#issues-and-considerations)
 ---
 ## 18. Factory Pattern
 ### Gang of Four: Design Patterns (1994)
 **Book: Design Patterns: Elements of Reusable Object-Oriented Software**
 - Authors: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (Gang of Four)
 - Publisher: Addison-Wesley
 - ISBN: 978-0201633610
 - Defines Factory Method and Abstract Factory patterns
 - Reference: [Wikipedia - Design Patterns](https://en.wikipedia.org/wiki/Design_Patterns)
 **Factory Method Pattern:**
 - "Define an interface for creating an object, but let subclasses decide which class to instantiate"
 - Lets a class defer instantiation to subclasses
 - Reference: [Refactoring Guru - Factory Method](https://refactoring.guru/design-patterns/factory-method)
 **Abstract Factory Pattern:**
 - "Provide an interface for creating families of related or dependent objects without specifying their concrete classes"
 - Reference: [Refactoring Guru - Abstract Factory](https://refactoring.guru/design-patterns/abstract-factory)
 ### Eric Evans: Factory in DDD Context
 **Domain-Driven Design** (2003)
 - Chapter 6: "The Life Cycle of a Domain Object"
 - Factories encapsulate complex object creation
 - "Shift the responsibility for creating instances of complex objects and Aggregates to a separate object"
 - Reference: [DDD Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 **DDD Factory Guidelines:**
 - Factory should create valid objects (invariants satisfied)
 - Two types: Factory for new objects, Factory for reconstitution
 - Keep creation logic out of the entity itself
 - Reference: Already in Section 10 - Domain-Driven Design
 ### Why Factories Matter in DDD
 **Encapsulation of Creation Logic:**
 - Complex aggregates need coordinated creation
 - Business rules should be enforced at creation time
 - Clients shouldn't know construction details
 - Reference: [Vaughn Vernon - Implementing DDD, Chapter 11](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 **Factory vs Constructor:**
 - Constructors should be simple (assign values)
 - Factories handle complex creation logic
 - Factories can return different types
 - Reference: [Effective Java - Item 1: Static Factory Methods](https://www.amazon.com/Effective-Java-Joshua-Bloch/dp/0134685997)
 ---
 ## 19. Specification Pattern
 ### Eric Evans & Martin Fowler
 **Original Paper: Specifications** (1997)
 - Authors: Eric Evans and Martin Fowler
 - Introduced the Specification pattern
 - "A Specification states a constraint on the state of another object"
 - Reference: [Martin Fowler - Specification](https://martinfowler.com/apsupp/spec.pdf)
 **Domain-Driven Design** (2003)
 - Chapter 9: "Making Implicit Concepts Explicit"
 - Specifications make business rules explicit and reusable
 - "Create explicit predicate-like Value Objects for specialized purposes"
 - Reference: [DDD Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 ### Pattern Definition
 **Core Concept:**
 - Specification is a predicate that determines if an object satisfies some criteria
 - Encapsulates business rules that can be reused and combined
 - Reference: [Wikipedia - Specification Pattern](https://en.wikipedia.org/wiki/Specification_pattern)
 **Three Main Uses:**
 1. **Selection**: Finding objects that match criteria
 2. **Validation**: Checking if object satisfies rules
 3. **Construction**: Describing what needs to be created
 - Reference: [Martin Fowler - Specification](https://martinfowler.com/apsupp/spec.pdf)
 ### Composite Specifications
 **Combining Specifications:**
 - AND: Both specifications must be satisfied
 - OR: Either specification must be satisfied
 - NOT: Specification must not be satisfied
 - Reference: [Refactoring Guru - Specification Pattern](https://refactoring.guru/design-patterns/specification)
 **Benefits:**
 - Reusable business rules
 - Testable in isolation
 - Readable domain language
 - Composable for complex rules
 - Reference: [Enterprise Craftsmanship - Specification Pattern](https://enterprisecraftsmanship.com/posts/specification-pattern-c-implementation/)
 ---
 ## 20. Bounded Context
 ### Eric Evans: Domain-Driven Design (2003)
 **Original Definition:**
 - "A Bounded Context delimits the applicability of a particular model"
 - "Explicitly define the context within which a model applies"
 - Chapter 14: "Maintaining Model Integrity"
 - Reference: [Martin Fowler - Bounded Context](https://martinfowler.com/bliki/BoundedContext.html)
 **Key Principles:**
 - Each Bounded Context has its own Ubiquitous Language
 - Same term can mean different things in different contexts
 - Models should not be shared across context boundaries
 - Reference: [DDD Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 ### Vaughn Vernon: Strategic Design
 **Implementing Domain-Driven Design** (2013)
 - Chapter 2: "Domains, Subdomains, and Bounded Contexts"
 - Detailed guidance on identifying and mapping contexts
 - Reference: [Vaughn Vernon - Implementing DDD](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 **Context Mapping Patterns:**
 - Shared Kernel
 - Customer/Supplier
 - Conformist
 - Anti-Corruption Layer
 - Open Host Service / Published Language
 - Reference: [Context Mapping Patterns](https://www.infoq.com/articles/ddd-contextmapping/)
 ### Why Bounded Contexts Matter
 **Avoiding Big Ball of Mud:**
 - Without explicit boundaries, models become entangled
 - Different teams step on each other's models
 - Reference: [Wikipedia - Big Ball of Mud](https://en.wikipedia.org/wiki/Big_ball_of_mud)
 **Microservices and Bounded Contexts:**
 - "Microservices should be designed around business capabilities, aligned with bounded contexts"
 - Each microservice typically represents one bounded context
 - Reference: [Microsoft - Microservices and Bounded Contexts](https://learn.microsoft.com/en-us/azure/architecture/microservices/model/domain-analysis)
 ### Cross-Context Communication
 **Integration Patterns:**
 - Never share domain models across contexts
 - Use integration events or APIs
 - Translate between context languages
 - Reference: [Microsoft - Tactical DDD](https://learn.microsoft.com/en-us/azure/architecture/microservices/model/tactical-ddd)
 ---
 ## 21. Persistence Ignorance
 ### Definition and Principles
 **Core Concept:**
 - Domain objects should have no knowledge of how they are persisted
 - Business logic remains pure and testable
 - Infrastructure concerns are separated from domain
 - Reference: [Microsoft - Persistence Ignorance](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/infrastructure-persistence-layer-design#the-persistence-ignorance-principle)
 **Wikipedia Definition:**
 - "Persistence ignorance is the ability of a class to be used without any underlying persistence mechanism"
 - Objects don't know if/how they'll be stored
 - Reference: [Wikipedia - Persistence Ignorance](https://en.wikipedia.org/wiki/Persistence_ignorance)
 ### Eric Evans: DDD and Persistence
 **Domain-Driven Design** (2003)
 - Repositories abstract away persistence details
 - Domain model should not reference ORM or database concepts
 - Reference: Already covered in Section 6 - Repository Pattern
 **Key Quote:**
 - "The domain layer should be kept clean of all technical concerns"
 - ORM annotations violate this principle
 - Reference: [Clean Architecture and DDD](https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/)
 ### Clean Architecture Alignment
 **Robert C. Martin:**
 - "The database is a detail"
 - Domain entities should not depend on persistence frameworks
 - Use Repository interfaces to abstract persistence
 - Reference: [Clean Architecture Book](https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164)
 ### Practical Implementation
 **Two-Model Approach:**
 - Domain Model: Pure business objects
 - Persistence Model: ORM-annotated entities
 - Mappers translate between them
 - Reference: [Microsoft - Infrastructure Layer](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/infrastructure-persistence-layer-design)
 **Benefits:**
 - Domain model can evolve independently of database schema
 - Easier testing (no ORM required)
 - Database can be changed without affecting domain
 - Reference: [Enterprise Craftsmanship - Persistence Ignorance](https://enterprisecraftsmanship.com/posts/persistence-ignorance/)
 ---
 ## 22. Null Object Pattern
 ### Original Pattern
 **Pattern Languages of Program Design 3** (1997)
 - Author: Bobby Woolf
 - Chapter: "Null Object"
 - Publisher: Addison-Wesley
 - ISBN: 978-0201310115
 - Reference: [Wikipedia - Null Object Pattern](https://en.wikipedia.org/wiki/Null_object_pattern)
 **Definition:**
 - "A Null Object provides a 'do nothing' behavior, hiding the details from its collaborators"
 - Replaces null checks with polymorphism
 - Reference: [Refactoring Guru - Null Object](https://refactoring.guru/introduce-null-object)
 ### Martin Fowler's Coverage
 **Refactoring Book** (1999, 2018)
 - "Introduce Null Object" refactoring
 - "Replace conditional logic that checks for null with a null object"
 - Reference: [Refactoring Catalog](https://refactoring.com/catalog/introduceNullObject.html)
 **Special Case Pattern:**
 - More general pattern that includes Null Object
 - "A subclass that provides special behavior for particular cases"
 - Reference: [Martin Fowler - Special Case](https://martinfowler.com/eaaCatalog/specialCase.html)
 ### Benefits
 **Eliminates Null Checks:**
 - Reduces cyclomatic complexity
 - Cleaner, more readable code
 - Follows "Tell, Don't Ask" principle
 - Reference: [SourceMaking - Null Object](https://sourcemaking.com/design_patterns/null_object)
 **Polymorphism Over Conditionals:**
 - Null Object responds to same interface as real object
 - Default/neutral behavior instead of null checks
 - Reference: [C2 Wiki - Null Object](https://wiki.c2.com/?NullObject)
 ### When to Use
 **Good Candidates:**
 - Objects frequently checked for null
 - Null represents "absence" with sensible default behavior
 - Reference: [Baeldung - Null Object Pattern](https://www.baeldung.com/java-null-object-pattern)
 **Cautions:**
 - Don't use when null has semantic meaning
 - Can hide bugs if misapplied
 - Reference: [Stack Overflow - Null Object Considerations](https://stackoverflow.com/questions/1274792/is-the-null-object-pattern-a-bad-practice)
 ---
 ## 23. Primitive Obsession
 ### Code Smell Definition
 **Martin Fowler: Refactoring** (1999, 2018)
 - Primitive Obsession is a code smell
 - "Using primitives instead of small objects for simple tasks"
 - Reference: [Refactoring Catalog](https://refactoring.com/catalog/)
 **Wikipedia Definition:**
 - "Using primitive data types to represent domain ideas"
 - Example: Using string for email, int for money
 - Reference: [Wikipedia - Code Smell](https://en.wikipedia.org/wiki/Code_smell)
 ### Why It's a Problem
 **Lost Type Safety:**
 - String can contain anything, Email cannot
 - Compiler can't catch domain errors
 - Reference: [Refactoring Guru - Primitive Obsession](https://refactoring.guru/smells/primitive-obsession)
 **Scattered Validation:**
 - Same validation repeated in multiple places
 - Violates DRY principle
 - Reference: [SourceMaking - Primitive Obsession](https://sourcemaking.com/refactoring/smells/primitive-obsession)
 **Missing Behavior:**
 - Primitives can't have domain-specific methods
 - Logic lives in services instead of objects
 - Reference: [Enterprise Craftsmanship - Primitive Obsession](https://enterprisecraftsmanship.com/posts/functional-c-primitive-obsession/)
 ### Solutions
 **Replace with Value Objects:**
 - Money instead of decimal
 - Email instead of string
 - PhoneNumber instead of string
 - Reference: Already covered in Section 16 - Value Object Immutability
 **Replace Data Value with Object:**
 - Refactoring: "Replace Data Value with Object"
 - Introduce Parameter Object for related primitives
 - Reference: [Refactoring - Replace Data Value with Object](https://refactoring.com/catalog/replaceDataValueWithObject.html)
 ### Common Primitive Obsession Examples
 **Frequently Misused Primitives:**
 - string for: email, phone, URL, currency code, country code
 - int/decimal for: money, percentage, age, quantity
 - DateTime for: date ranges, business dates
 - Reference: [DDD - Value Objects](https://martinfowler.com/bliki/ValueObject.html)
 ---
 ## 24. Service Locator Anti-pattern
 ### Martin Fowler's Analysis
 **Blog Post: Inversion of Control Containers and the Dependency Injection pattern** (2004)
 - Compares Service Locator with Dependency Injection
 - "With service locator the application class asks for it explicitly by a message to the locator"
 - Reference: [Martin Fowler - Inversion of Control](https://martinfowler.com/articles/injection.html)
 **Service Locator Definition:**
 - "The basic idea behind a service locator is to have an object that knows how to get hold of all of the services that an application might need"
 - Acts as a registry that provides dependencies on demand
 - Reference: [Martin Fowler - Service Locator](https://martinfowler.com/articles/injection.html#UsingAServiceLocator)
 ### Why It's Considered an Anti-pattern
 **Mark Seemann: Dependency Injection in .NET** (2011, 2nd Ed. 2019)
 - Author: Mark Seemann
 - Extensively covers why Service Locator is problematic
 - "Service Locator is an anti-pattern"
 - Reference: [Mark Seemann - Service Locator is an Anti-Pattern](https://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/)
 **Hidden Dependencies:**
 - Dependencies are not visible in constructor
 - Makes code harder to understand and test
 - Violates Explicit Dependencies Principle
 - Reference: [DevIQ - Explicit Dependencies](https://deviq.com/principles/explicit-dependencies-principle)
 **Testing Difficulties:**
 - Need to set up global locator for tests
 - Tests become coupled to locator setup
 - Reference: [Stack Overflow - Service Locator Testing](https://stackoverflow.com/questions/1557781/is-service-locator-an-anti-pattern)
 ### Dependency Injection Alternative
 **Constructor Injection:**
 - Dependencies declared in constructor
 - Compiler enforces dependency provision
 - Clear, testable code
 - Reference: Already covered in Section 6 - Repository Pattern
 **Benefits over Service Locator:**
 - Explicit dependencies
 - Easier testing (just pass mocks)
 - IDE support for navigation
 - Compile-time checking
 - Reference: [Martin Fowler - Constructor Injection](https://martinfowler.com/articles/injection.html#ConstructorInjectionWithPicocontainer)
 ---
 ## 25. Double Dispatch and Visitor Pattern
 ### Gang of Four: Visitor Pattern
 **Design Patterns** (1994)
 - Authors: Gang of Four
 - Visitor Pattern chapter
 - "Represent an operation to be performed on the elements of an object structure"
 - Reference: [Wikipedia - Visitor Pattern](https://en.wikipedia.org/wiki/Visitor_pattern)
 **Intent:**
 - "Lets you define a new operation without changing the classes of the elements on which it operates"
 - Separates algorithms from object structure
 - Reference: [Refactoring Guru - Visitor](https://refactoring.guru/design-patterns/visitor)
 ### Double Dispatch Mechanism
 **Definition:**
 - "A mechanism that dispatches a function call to different concrete functions depending on the runtime types of two objects involved in the call"
 - Visitor pattern uses double dispatch
 - Reference: [Wikipedia - Double Dispatch](https://en.wikipedia.org/wiki/Double_dispatch)
 **How It Works:**
 1. Client calls element.accept(visitor)
 2. Element calls visitor.visit(this) - first dispatch
 3. Correct visit() overload selected - second dispatch
 - Reference: [SourceMaking - Visitor](https://sourcemaking.com/design_patterns/visitor)
 ### When to Use
 **Good Use Cases:**
 - Operations on complex object structures
 - Many distinct operations needed
 - Object structure rarely changes but operations change often
 - Reference: [Refactoring Guru - Visitor Use Cases](https://refactoring.guru/design-patterns/visitor)
 **Alternative to Type Checking:**
 - Replace instanceof/typeof checks with polymorphism
 - More maintainable and extensible
 - Reference: [Replace Conditional with Polymorphism](https://refactoring.guru/replace-conditional-with-polymorphism)
 ### Trade-offs
 **Advantages:**
 - Open/Closed Principle for new operations
 - Related operations grouped in one class
 - Accumulate state while traversing
 - Reference: [GoF Design Patterns](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
 **Disadvantages:**
 - Adding new element types requires changing all visitors
 - May break encapsulation (visitors need access to element internals)
 - Reference: [C2 Wiki - Visitor Pattern](https://wiki.c2.com/?VisitorPattern)
 ---
 ## 26. Entity Identity
 ### Eric Evans: Domain-Driven Design (2003)
 **Entity Definition:**
 - "An object that is not defined by its attributes, but rather by a thread of continuity and its identity"
 - "Some objects are not defined primarily by their attributes. They represent a thread of identity"
 - Reference: [Martin Fowler - Evans Classification](https://martinfowler.com/bliki/EvansClassification.html)
 **Identity Characteristics:**
 - Unique within the system
 - Stable over time (doesn't change)
 - Survives state changes
 - Reference: [DDD Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 ### Vaughn Vernon: Identity Implementation
 **Implementing Domain-Driven Design** (2013)
 - Chapter 5: "Entities"
 - Detailed coverage of identity strategies
 - "The primary characteristic of an Entity is that it has a unique identity"
 - Reference: [Vaughn Vernon - Implementing DDD](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 **Identity Types:**
 - Natural keys (SSN, email)
 - Surrogate keys (UUID, auto-increment)
 - Domain-generated IDs
 - Reference: [Microsoft - Entity Keys](https://learn.microsoft.com/en-us/ef/core/modeling/keys)
 ### Identity Best Practices
 **Immutability of Identity:**
 - Identity should never change after creation
 - Use readonly/final fields
 - Reference: [StackExchange - Mutable Entity ID](https://softwareengineering.stackexchange.com/questions/375765/is-it-bad-practice-to-have-mutable-entity-ids)
 **Value Object for Identity:**
 - Wrap identity in Value Object (UserId, OrderId)
 - Type safety prevents mixing IDs
 - Can include validation logic
 - Reference: [Enterprise Craftsmanship - Strongly Typed IDs](https://enterprisecraftsmanship.com/posts/strongly-typed-ids/)
 **Equality Based on Identity:**
 - Entity equality should compare only identity
 - Not all attributes
 - Reference: [Vaughn Vernon - Entity Equality](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 ---
 ## 27. Saga Pattern
 ### Original Research
 **Paper: Sagas** (1987)
 - Authors: Hector Garcia-Molina and Kenneth Salem
 - Published: ACM SIGMOD Conference
 - Introduced Sagas for long-lived transactions
 - Reference: [ACM Digital Library - Sagas](https://dl.acm.org/doi/10.1145/38713.38742)
 **Definition:**
 - "A saga is a sequence of local transactions where each transaction updates data within a single service"
 - Alternative to distributed transactions
 - Reference: [Microsoft - Saga Pattern](https://learn.microsoft.com/en-us/azure/architecture/reference-architectures/saga/saga)
 ### Chris Richardson: Microservices Patterns
 **Book: Microservices Patterns** (2018)
 - Author: Chris Richardson
 - Publisher: Manning
 - ISBN: 978-1617294549
 - Chapter 4: "Managing Transactions with Sagas"
 - Reference: [Manning - Microservices Patterns](https://www.manning.com/books/microservices-patterns)
 **Saga Types:**
 1. **Choreography**: Each service publishes events that trigger next steps
 2. **Orchestration**: Central coordinator tells services what to do
 - Reference: [Microservices.io - Saga](https://microservices.io/patterns/data/saga.html)
 ### Compensating Transactions
 **Core Concept:**
 - Each step has a compensating action to undo it
 - If step N fails, compensate steps N-1, N-2, ..., 1
 - Reference: [AWS - Saga Pattern](https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-data-persistence/saga-pattern.html)
 **Compensation Examples:**
 - CreateOrder → DeleteOrder
 - ReserveInventory → ReleaseInventory
 - ChargePayment → RefundPayment
 - Reference: [Microsoft - Compensating Transactions](https://learn.microsoft.com/en-us/azure/architecture/patterns/compensating-transaction)
 ### Trade-offs
 **Advantages:**
 - Works across service boundaries
 - No distributed locks
 - Services remain autonomous
 - Reference: [Chris Richardson - Saga](https://chrisrichardson.net/post/microservices/patterns/data/2019/07/22/design-sagas.html)
 **Challenges:**
 - Complexity of compensation logic
 - Eventual consistency
 - Debugging distributed sagas
 - Reference: [Microsoft - Saga Considerations](https://learn.microsoft.com/en-us/azure/architecture/reference-architectures/saga/saga#issues-and-considerations)
 ---
 ## 28. Anti-Corruption Layer
 ### Eric Evans: Domain-Driven Design (2003)
 **Original Definition:**
 - Chapter 14: "Maintaining Model Integrity"
 - "Create an isolating layer to provide clients with functionality in terms of their own domain model"
 - Protects your model from external/legacy models
 - Reference: [DDD Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 **Purpose:**
 - "The translation layer between a new system and an external system"
 - Prevents external model concepts from leaking in
 - Reference: [Martin Fowler - Anti-Corruption Layer](https://martinfowler.com/bliki/AntiCorruptionLayer.html)
 ### Microsoft Guidance
 **Azure Architecture Center:**
 - "Implement a facade or adapter layer between different subsystems that don't share the same semantics"
 - Isolate subsystems by placing an anti-corruption layer between them
 - Reference: [Microsoft - ACL Pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer)
 **When to Use:**
 - Integrating with legacy systems
 - Migrating from monolith to microservices
 - Working with third-party APIs
 - Reference: [Microsoft - ACL When to Use](https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer#when-to-use-this-pattern)
 ### Components of ACL
 **Facade:**
 - Simplified interface to external system
 - Hides complexity from domain
 - Reference: [Refactoring Guru - Facade](https://refactoring.guru/design-patterns/facade)
 **Adapter:**
 - Translates between interfaces
 - Maps external model to domain model
 - Reference: [Refactoring Guru - Adapter](https://refactoring.guru/design-patterns/adapter)
 **Translator:**
 - Converts data structures
 - Maps field names and types
 - Handles semantic differences
 - Reference: [Evans DDD - Model Translation](https://www.domainlanguage.com/)
 ### Benefits
 **Isolation:**
 - Changes to external system don't ripple through domain
 - Domain model remains pure
 - Reference: [Microsoft - ACL Benefits](https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer)
 **Gradual Migration:**
 - Replace legacy components incrementally
 - Strangler Fig pattern compatibility
 - Reference: [Martin Fowler - Strangler Fig](https://martinfowler.com/bliki/StranglerFigApplication.html)
 ---
 ## 29. Ubiquitous Language
 ### Eric Evans: Domain-Driven Design (2003)
 **Original Definition:**
 - Chapter 2: "Communication and the Use of Language"
 - "A language structured around the domain model and used by all team members"
 - "The vocabulary of that Ubiquitous Language includes the names of classes and prominent operations"
 - Reference: [Martin Fowler - Ubiquitous Language](https://martinfowler.com/bliki/UbiquitousLanguage.html)
 **Key Principles:**
 - Shared by developers and domain experts
 - Used in code, conversations, and documentation
 - Changes to language reflect model changes
 - Reference: [DDD Reference](https://www.domainlanguage.com/wp-content/uploads/2016/05/DDD_Reference_2015-03.pdf)
 ### Why It Matters
 **Communication Benefits:**
 - Reduces translation between business and tech
 - Catches misunderstandings early
 - Domain experts can read code names
 - Reference: [InfoQ - Ubiquitous Language](https://www.infoq.com/articles/ddd-ubiquitous-language/)
 **Design Benefits:**
 - Model reflects real domain concepts
 - Code becomes self-documenting
 - Easier onboarding for new team members
 - Reference: [Vaughn Vernon - Implementing DDD](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577)
 ### Building Ubiquitous Language
 **Glossary:**
 - Document key terms and definitions
 - Keep updated as understanding evolves
 - Reference: [DDD Community - Glossary](https://thedomaindrivendesign.io/glossary/)
 **Event Storming:**
 - Collaborative workshop technique
 - Discover domain events and concepts
 - Build shared understanding and language
 - Reference: [Alberto Brandolini - Event Storming](https://www.eventstorming.com/)
 ### Common Pitfalls
 **Inconsistent Terminology:**
 - Same concept with different names (Customer/Client/User)
 - Different concepts with same name
 - Reference: [Domain Language - Building UL](https://www.domainlanguage.com/)
 **Technical Terms in Domain:**
 - "DTO", "Entity", "Repository" are technical
 - Domain should use business terms
 - Reference: [Evans DDD - Model-Driven Design](https://www.domainlanguage.com/)
 ---
 ## Conclusion
 The code quality detection rules implemented in Guardian are firmly grounded in:
-1. **Academic Research**: Peer-reviewed papers on software maintainability, complexity metrics, code quality, technical debt prioritization, and severity classification
+1. **Academic Research**: Peer-reviewed papers on software maintainability, complexity metrics, code quality, technical debt prioritization, severity classification, and distributed systems (Sagas)
 2. **Industry Standards**: ISO/IEC 25010, SonarQube rules, OWASP security guidelines, Google and Airbnb style guides
 3. **Authoritative Books**:
   - Gang of Four's "Design Patterns" (1994)
   - Bertrand Meyer's "Object-Oriented Software Construction" (1988, 1997)
   - Robert C. Martin's "Clean Architecture" (2017)
   - Vaughn Vernon's "Implementing Domain-Driven Design" (2013)
   - Chris Richardson's "Microservices Patterns" (2018)
   - Eric Evans' "Domain-Driven Design" (2003)
   - Martin Fowler's "Patterns of Enterprise Application Architecture" (2002)
   - Martin Fowler's "Refactoring" (1999, 2018)
   - Steve McConnell's "Code Complete" (1993, 2004)
-4. **Expert Guidance**: Martin Fowler, Robert C. Martin (Uncle Bob), Eric Evans, Vaughn Vernon, Alistair Cockburn, Kent Beck
+   - Joshua Bloch's "Effective Java" (2001, 2018)
   - Mark Seemann's "Dependency Injection in .NET" (2011, 2019)
   - Bobby Woolf's "Null Object" in PLoPD3 (1997)
 4. **Expert Guidance**: Martin Fowler, Robert C. Martin (Uncle Bob), Eric Evans, Vaughn Vernon, Alistair Cockburn, Kent Beck, Greg Young, Bertrand Meyer, Mark Seemann, Chris Richardson, Alberto Brandolini
 5. **Security Standards**: OWASP Secrets Management, GitHub Secret Scanning, GitGuardian best practices
 6. **Open Source Tools**: ArchUnit, SonarQube, ESLint, Secretlint - widely adopted in enterprise environments
 7. **DDD Tactical & Strategic Patterns**: Domain Events, Value Objects, Entities, Aggregates, Bounded Contexts, Anti-Corruption Layer, Ubiquitous Language, Specifications, Factories
 8. **Architectural Patterns**: CQS/CQRS, Saga, Visitor/Double Dispatch, Null Object, Persistence Ignorance
 These rules represent decades of software engineering wisdom, empirical research, security best practices, and battle-tested practices from the world's leading software organizations and thought leaders.
@@ -845,9 +1678,9 @@ These rules represent decades of software engineering wisdom, empirical research
 ---
-**Document Version**: 1.1
+**Document Version**: 2.0
-**Last Updated**: 2025-11-26
+**Last Updated**: 2025-12-04
 **Questions or want to contribute research?**
 - 📧 Email: fozilbek.samiyev@gmail.com
 - 🐙 GitHub: https://github.com/samiyev/puaros/issues
-**Based on research as of**: November 2025
+**Based on research as of**: December 2025
--- a/packages/ipuaro/CHANGELOG.md
+++ b/packages/ipuaro/CHANGELOG.md
@@ -5,6 +5,880 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [0.29.0] - 2025-12-05 - Impact Score
 ### Added
 - **High Impact Files in Initial Context (v0.29.0)**
  - New `## High Impact Files` section in initial context
  - Shows files with highest impact scores (percentage of codebase depending on them)
  - Table format with File, Impact %, and Dependents count
  - Files sorted by impact score descending
  - Default: shows top 10 files with impact score >= 5%
 - **Impact Score Computation**
  - New `impactScore: number` field in `FileMeta` (0-100)
  - Formula: `(dependents.length / (totalFiles - 1)) * 100`
  - Computed in `MetaAnalyzer.analyzeAll()` after all files analyzed
  - New `calculateImpactScore()` helper function in FileMeta.ts
 - **Configuration Option**
  - `includeHighImpactFiles: boolean` in ContextConfigSchema (default: `true`)
  - `includeHighImpactFiles` option in `BuildContextOptions`
  - Users can disable to save tokens: `context.includeHighImpactFiles: false`
 - **New Helper Function in prompts.ts**
  - `formatHighImpactFiles()` - formats high impact files table for display
 ### New Context Format
 ```
 ## High Impact Files
 | File | Impact | Dependents |
 |------|--------|------------|
 | utils/validation | 67% | 12 files |
 | types/user | 45% | 8 files |
 | services/user | 34% | 6 files |
 ```
 ### Technical Details
 - Total tests: 1826 passed (was 1798, +28 new tests)
  - 9 new tests for calculateImpactScore()
  - 14 new tests for formatHighImpactFiles() and buildInitialContext
  - 5 new tests for includeHighImpactFiles config option
 - Coverage: 97.52% lines, 91.3% branches, 98.63% functions
 - 0 ESLint errors, 3 warnings (pre-existing complexity)
 - Build successful
 ### Notes
 This completes v0.29.0 of the Graph Metrics milestone:
 - ✅ 0.27.0 - Inline Dependency Graph
 - ✅ 0.28.0 - Circular Dependencies in Context
 - ✅ 0.29.0 - Impact Score
 Next milestone: v0.30.0 - Transitive Dependencies Count
 ---
 ## [0.28.0] - 2025-12-05 - Circular Dependencies in Context
 ### Added
 - **Circular Dependencies in Initial Context (v0.28.0)**
  - New `## ⚠️ Circular Dependencies` section in initial context
  - Shows cycle chains immediately without requiring tool calls
  - Format: `- services/user → services/auth → services/user`
  - Uses same path shortening as dependency graph (removes `src/`, extensions, `/index`)
 - **Configuration Option**
  - `includeCircularDeps: boolean` in ContextConfigSchema (default: `true`)
  - `includeCircularDeps` option in `BuildContextOptions`
  - `circularDeps: string[][]` parameter to pass pre-computed cycles
  - Users can disable to save tokens: `context.includeCircularDeps: false`
 - **New Helper Function in prompts.ts**
  - `formatCircularDeps()` - formats circular dependency cycles for display
 ### New Context Format
 ```
 ## ⚠️ Circular Dependencies
 - services/user → services/auth → services/user
 - utils/a → utils/b → utils/c → utils/a
 ```
 ### Technical Details
 - Total tests: 1798 passed (was 1775, +23 new tests)
  - 12 new tests for formatCircularDeps()
  - 6 new tests for buildInitialContext with includeCircularDeps
  - 5 new tests for includeCircularDeps config option
 - Coverage: 97.48% lines, 91.13% branches, 98.63% functions
 - 0 ESLint errors, 3 warnings (pre-existing complexity in ASTParser and prompts)
 - Build successful
 ## [0.27.0] - 2025-12-05 - Inline Dependency Graph
 ### Added
 - **Dependency Graph in Initial Context (v0.27.0)**
  - New `## Dependency Graph` section in initial context
  - Shows file relationships without requiring tool calls
  - Format: `services/user: → types/user, utils/validation ← controllers/user`
  - `→` indicates files this file imports (dependencies)
  - `←` indicates files that import this file (dependents)
  - Hub files (>5 dependents) shown first
  - Files sorted by total connections (descending)
 - **Configuration Option**
  - `includeDepsGraph: boolean` in ContextConfigSchema (default: `true`)
  - `includeDepsGraph` option in `BuildContextOptions`
  - Users can disable to save tokens: `context.includeDepsGraph: false`
 - **New Helper Functions in prompts.ts**
  - `formatDependencyGraph()` - formats entire dependency graph from metas
  - `formatDepsEntry()` - formats single file's dependencies/dependents
  - `shortenPath()` - shortens paths (removes `src/`, extensions, `/index`)
 ### New Context Format
 ```
 ## Dependency Graph
 utils/validation: ← services/user, services/auth, controllers/api
 services/user: → types/user, utils/validation ← controllers/user, api/routes
 services/auth: → services/user, utils/jwt ← controllers/auth
 types/user: ← services/user, services/auth
 ```
 ### Technical Details
 - Total tests: 1775 passed (was 1754, +21 new tests)
  - 16 new tests for formatDependencyGraph()
  - 5 new tests for includeDepsGraph config option
 - Coverage: 97.48% lines, 91.07% branches, 98.62% functions
 - 0 ESLint errors, 2 warnings (pre-existing complexity in ASTParser and prompts)
 - Build successful
 ### Notes
 This completes v0.27.0 of the Graph Metrics milestone:
 - ✅ 0.27.0 - Inline Dependency Graph
 Next milestone: v0.28.0 - Circular Dependencies in Context
 ---
 ## [0.26.0] - 2025-12-05 - Rich Initial Context: Decorator Extraction
 ### Added
 - **Decorator Extraction (0.24.4)**
  - Functions now show their decorators in initial context
  - Classes now show their decorators in initial context
  - Methods show decorators per-method
  - New format: `@Controller('users') class UserController`
  - Function format: `@Get(':id') async getUser(id: string): Promise<User>`
  - Supports NestJS decorators: `@Controller`, `@Get`, `@Post`, `@Injectable`, `@UseGuards`, etc.
  - Supports Angular decorators: `@Component`, `@Injectable`, `@Input`, `@Output`, etc.
 - **FileAST.ts Enhancements**
  - `decorators?: string[]` field on `FunctionInfo`
  - `decorators?: string[]` field on `MethodInfo`
  - `decorators?: string[]` field on `ClassInfo`
 - **ASTParser.ts Enhancements**
  - `formatDecorator()` - formats decorator node to string (e.g., `@Get(':id')`)
  - `extractNodeDecorators()` - extracts decorators that are direct children of a node
  - `extractDecoratorsFromSiblings()` - extracts decorators before the declaration in export statements
  - Decorators are extracted for classes, methods, and exported functions
 - **prompts.ts Enhancements**
  - `formatDecoratorsPrefix()` - formats decorators as a prefix string for display
  - Used in `formatFunctionSignature()` for function decorators
  - Used in `formatFileSummary()` for class decorators
 ### New Context Format
 ```
 ### src/controllers/user.controller.ts
 - @Controller('users') class UserController extends BaseController
 - @Get(':id') @Auth() async getUser(id: string): Promise<User>
 - @Post() @ValidateBody() async createUser(data: UserDTO): Promise<User>
 ```
 ### Technical Details
 - Total tests: 1754 passed (was 1720, +34 new tests)
  - 14 new tests for ASTParser decorator extraction
  - 6 new tests for prompts decorator formatting
  - +14 other tests from internal improvements
 - Coverage: 97.49% lines, 91.14% branches, 98.61% functions
 - 0 ESLint errors, 2 warnings (pre-existing complexity in ASTParser and prompts)
 - Build successful
 ### Notes
 This completes the v0.24.0 Rich Initial Context milestone:
 - ✅ 0.24.1 - Function Signatures with Types
 - ✅ 0.24.2 - Interface/Type Field Definitions
 - ✅ 0.24.3 - Enum Value Definitions
 - ✅ 0.24.4 - Decorator Extraction
 Next milestone: v0.25.0 - Graph Metrics in Context
 ---
 ## [0.25.0] - 2025-12-04 - Rich Initial Context: Interface Fields & Type Definitions
 ### Added
 - **Interface Field Definitions (0.24.2)**
  - Interfaces now show their fields in initial context
  - New format: `interface User { id: string, name: string, email: string }`
  - Readonly fields marked: `interface Config { readonly version: string }`
  - Extends still supported: `interface AdminUser extends User { role: string }`
 - **Type Alias Definitions (0.24.2)**
  - Type aliases now show their definitions in initial context
  - Simple types: `type UserId = string`
  - Union types: `type Status = "pending" | "active" | "done"`
  - Intersection types: `type AdminUser = User & Admin`
  - Function types: `type Handler = (event: Event) => void`
  - Long definitions truncated at 80 characters with `...`
 - **New Helper Functions in prompts.ts**
  - `formatInterfaceSignature()` - formats interface with fields
  - `formatTypeAliasSignature()` - formats type alias with definition
  - `truncateDefinition()` - truncates long type definitions
 ### Changed
 - **FileAST.ts**
  - Added `definition?: string` field to `TypeAliasInfo` interface
 - **ASTParser.ts**
  - `extractTypeAlias()` now extracts the type definition via `childForFieldName(VALUE)`
  - Supports all type kinds: simple, union, intersection, object, function, generic, array, tuple
 - **prompts.ts**
  - `formatFileSummary()` now uses `formatInterfaceSignature()` for interfaces
  - `formatFileSummary()` now uses `formatTypeAliasSignature()` for type aliases
 ### New Context Format
 ```
 ### src/types/user.ts
 - interface User { id: string, name: string, email: string }
 - interface UserDTO { name: string, email?: string }
 - type UserId = string
 - type Status = "pending" | "active" | "done"
 - type AdminUser = User & Admin
 ```
 ### Technical Details
 - Total tests: 1720 passed (was 1702, +18 new tests)
  - 10 new tests for interface field formatting
  - 8 new tests for type alias definition extraction
 - Coverage: 97.5% lines, 91.04% branches, 98.6% functions
 - 0 ESLint errors, 1 warning (pre-existing complexity in ASTParser)
 - Build successful
 ### Notes
 This completes the second part of Rich Initial Context milestone:
 - ✅ 0.24.1 - Function Signatures with Types
 - ✅ 0.24.2 - Interface/Type Field Definitions
 - ⏳ 0.24.3 - Enum Value Definitions
 - ⏳ 0.24.4 - Decorator Extraction
 ---
 ## [0.24.0] - 2025-12-04 - Rich Initial Context: Function Signatures
 ### Added
 - **Function Signatures in Context (0.24.1)**
  - Full function signatures with parameter types and return types in initial context
  - New format: `async getUser(id: string): Promise<User>` instead of `fn: getUser`
  - Classes show inheritance: `class UserService extends BaseService implements IService`
  - Interfaces show extends: `interface AdminUser extends User, Admin`
  - Optional parameters marked with `?`: `format(value: string, options?: FormatOptions)`
 - **BuildContextOptions Interface**
  - New `includeSignatures?: boolean` option for `buildInitialContext()`
  - Controls signature vs compact format (default: `true` for signatures)
 - **Configuration**
  - Added `includeSignatures: boolean` to `ContextConfigSchema` (default: `true`)
  - Users can disable signatures to save tokens: `context.includeSignatures: false`
 ### Changed
 - **ASTParser**
  - Arrow functions now extract `returnType` in `extractLexicalDeclaration()`
  - Return type format normalized (strips leading `: `)
 - **prompts.ts**
  - New `formatFunctionSignature()` helper function
  - `formatFileSummary()` now shows full signatures by default
  - Added `formatFileSummaryCompact()` for legacy format
  - `formatFileOverview()` accepts `includeSignatures` parameter
  - Defensive handling for missing interface `extends` array
 ### New Context Format (default)
 ```
 ### src/services/user.ts
 - async getUser(id: string): Promise<User>
 - async createUser(data: UserDTO): Promise<User>
 - validateEmail(email: string): boolean
 - class UserService extends BaseService
 - interface IUserService extends IService
 - type UserId
 ```
 ### Compact Format (includeSignatures: false)
 ```
 - src/services/user.ts [fn: getUser, createUser | class: UserService | interface: IUserService | type: UserId]
 ```
 ### Technical Details
 - Total tests: 1702 passed (was 1687, +15 new tests)
  - 8 new tests for function signature formatting
  - 5 new tests for `includeSignatures` configuration
  - 1 new test for compact format
  - 1 new test for undefined AST entries
 - Coverage: 97.54% lines, 91.14% branches, 98.59% functions
 - 0 ESLint errors, 2 warnings (complexity in ASTParser and prompts)
 - Build successful
 ### Notes
 This is the first part of v0.24.0 Rich Initial Context milestone:
 - ✅ 0.24.1 - Function Signatures with Types
 - ⏳ 0.24.2 - Interface/Type Field Definitions
 - ⏳ 0.24.3 - Enum Value Definitions
 - ⏳ 0.24.4 - Decorator Extraction
 ---
 ## [0.23.0] - 2025-12-04 - JSON/YAML & Symlinks
 ### Added
 - **JSON AST Parsing**
  - Parse JSON files using `tree-sitter-json`
  - Extract top-level keys as exports for indexing
  - 2 unit tests for JSON parsing
 - **YAML AST Parsing**
  - Parse YAML files using `yaml` npm package (chosen over `tree-sitter-yaml` due to native binding compatibility issues)
  - Extract top-level keys from mappings
  - Detect root-level arrays
  - Handle parse errors gracefully
  - 6 unit tests for YAML parsing (empty, null, errors, line tracking)
 - **Symlinks Metadata**
  - Added `symlinkTarget?: string` to `ScanResult` interface
  - `FileScanner.safeReadlink()` extracts symlink targets
  - Symlinks detected during file scanning
 ### Changed
 - **ASTParser**
  - Added `parseYAML()` method using `yaml` package
  - Added `getLineFromOffset()` helper for accurate line numbers
  - Checks `doc.errors` for YAML parse errors
  - Language type now includes `"json" | "yaml"`
 ### Technical Details
 - Total tests: 1687 passed (was 1679, +8 new tests)
 - Coverage: 97.5% lines, 91.21% branches, 98.58% functions
 - 0 ESLint errors, 5 warnings (acceptable TUI complexity warnings)
 - Dependencies: Added `yaml@^2.8.2`, removed `tree-sitter-yaml`
 ### ROADMAP Update
 Verified that v0.20.0, v0.21.0 were already implemented but not documented:
 - v0.20.0: IndexProject (184 LOC, 318 LOC tests) and ExecuteTool (225 LOC) were complete
 - v0.21.0: Multiline Input, Syntax Highlighting (167 LOC, 24 tests) were complete
 - Updated ROADMAP.md to reflect actual implementation status
 ---
 ## [0.22.5] - 2025-12-02 - Commands Configuration
 ### Added
 - **CommandsConfigSchema (0.22.5)**
  - New configuration schema for command settings in `src/shared/constants/config.ts`
  - `timeout: number | null` (default: null) - global timeout for shell commands in milliseconds
  - Integrated into main ConfigSchema with `.default({})`
  - Exported `CommandsConfig` type from config module
 ### Changed
 - **RunCommandTool**
  - Added optional `config?: CommandsConfig` parameter to constructor
  - Timeout priority: `params.timeout` → `config.timeout` → `DEFAULT_TIMEOUT (30000)`
  - Updated parameter description to reflect configuration support
  - Config-based timeout enables global command timeout without per-call specification
 ### Technical Details
 - Total tests: 1679 passed (was 1657, +22 new tests)
 - New test file: `commands-config.test.ts` with 19 tests
  - Default values validation (timeout: null)
  - `timeout` nullable positive integer validation (including edge cases: zero, negative, float rejection)
  - Partial and full config merging tests
 - Updated RunCommandTool tests: 3 new tests for configuration integration
  - Config timeout behavior
  - Null config timeout fallback to default
  - Param timeout priority over config timeout
 - Coverage: 97.64% lines, 91.36% branches, 98.77% functions, 97.64% statements
 - 0 ESLint errors, 5 warnings (acceptable TUI component warnings)
 - Build successful with no TypeScript errors
 ### Notes
 This release completes the v0.22.0 Extended Configuration milestone. All items for v0.22.0 are now complete:
 - ✅ 0.22.1 - Display Configuration
 - ✅ 0.22.2 - Session Configuration
 - ✅ 0.22.3 - Context Configuration
 - ✅ 0.22.4 - Autocomplete Configuration
 - ✅ 0.22.5 - Commands Configuration
 ---
 ## [0.22.4] - 2025-12-02 - Autocomplete Configuration
 ### Added
 - **AutocompleteConfigSchema (0.22.4)**
  - New configuration schema for autocomplete settings in `src/shared/constants/config.ts`
  - `enabled: boolean` (default: true) - toggle autocomplete feature
  - `source: "redis-index" | "filesystem" | "both"` (default: "redis-index") - autocomplete source
  - `maxSuggestions: number` (default: 10) - maximum number of suggestions to display
  - Integrated into main ConfigSchema with `.default({})`
  - Exported `AutocompleteConfig` type from config module
 ### Changed
 - **useAutocomplete Hook**
  - Added optional `config?: AutocompleteConfig` parameter to `UseAutocompleteOptions`
  - Config priority: `config` → `props` → `defaults`
  - Reads `enabled` and `maxSuggestions` from config if provided
  - Falls back to prop values, then to defaults
  - Internal variables renamed: `enabled` → `isEnabled`, `maxSuggestions` → `maxSuggestionsCount`
 - **Chat Component**
  - Fixed ESLint error: removed unused `roleColor` variable in `ToolMessage` component
  - Removed unused `theme` parameter from `ToolMessage` function signature
 ### Technical Details
 - Total tests: 1657 passed (was 1630, +27 new tests)
 - New test file: `autocomplete-config.test.ts` with 27 tests
  - Default values validation (enabled, source, maxSuggestions)
  - `enabled` boolean validation
  - `source` enum validation ("redis-index", "filesystem", "both")
  - `maxSuggestions` positive integer validation (including edge cases: zero, negative, float rejection)
  - Partial and full config merging tests
 - Coverage: 97.59% lines, 91.23% branches, 98.77% functions, 97.59% statements
 - 0 ESLint errors, 5 warnings (acceptable TUI component warnings)
 - Build successful with no TypeScript errors
 ### Notes
 This release completes the fourth item (0.22.4) of the v0.22.0 Extended Configuration milestone. Remaining item for v0.22.0:
 - 0.22.5 - Commands Configuration
 ---
 ## [0.22.3] - 2025-12-02 - Context Configuration
 ### Added
 - **ContextConfigSchema (0.22.3)**
  - New configuration schema for context management in `src/shared/constants/config.ts`
  - `systemPromptTokens: number` (default: 2000) - token budget for system prompt
  - `maxContextUsage: number` (default: 0.8) - maximum context window usage ratio (0-1)
  - `autoCompressAt: number` (default: 0.8) - threshold for automatic context compression (0-1)
  - `compressionMethod: "llm-summary" | "truncate"` (default: "llm-summary") - compression strategy
  - Integrated into main ConfigSchema with `.default({})`
  - Exported `ContextConfig` type from config module
 ### Changed
 - **ContextManager**
  - Added optional `config?: ContextConfig` parameter to constructor
  - Added private `compressionThreshold: number` field (read from config or default)
  - Added private `compressionMethod: "llm-summary" | "truncate"` field (read from config or default)
  - Updated `needsCompression()` to use configurable `compressionThreshold` instead of hardcoded constant
  - Enables dynamic compression threshold configuration per session/deployment
 - **HandleMessage Use Case**
  - Added optional `contextConfig?: ContextConfig` parameter to constructor
  - Added `contextConfig?: ContextConfig` to `HandleMessageOptions`
  - Passes context config to ContextManager during initialization
  - Context management behavior now fully configurable
 - **useSession Hook**
  - Passes `deps.config?.context` to HandleMessage constructor
  - Passes `contextConfig: deps.config?.context` to HandleMessage options
  - Context configuration flows from config through to ContextManager
 ### Technical Details
 - Total tests: 1630 passed (was 1590, +40 new tests)
 - New test file: `context-config.test.ts` with 32 tests
  - Default values validation (systemPromptTokens, maxContextUsage, autoCompressAt, compressionMethod)
  - `systemPromptTokens` positive integer validation (including edge cases: zero, negative, float rejection)
  - `maxContextUsage` ratio validation (0-1 range, rejects out-of-bounds)
  - `autoCompressAt` ratio validation (0-1 range, rejects out-of-bounds)
  - `compressionMethod` enum validation (llm-summary, truncate)
  - Partial and full config merging tests
 - Updated ContextManager tests: 8 new tests for configuration integration
  - Custom compression threshold behavior
  - Edge cases: autoCompressAt = 0 and autoCompressAt = 1
  - Full context config acceptance
 - Coverage: 97.63% lines, 91.34% branches, 98.77% functions, 97.63% statements
 - 0 ESLint errors, 0 warnings
 - Build successful with no TypeScript errors
 ### Notes
 This release completes the third item (0.22.3) of the v0.22.0 Extended Configuration milestone. Remaining items for v0.22.0:
 - 0.22.4 - Autocomplete Configuration
 - 0.22.5 - Commands Configuration
 ---
 ## [0.22.2] - 2025-12-02 - Session Configuration
 ### Added
 - **SessionConfigSchema (0.22.2)**
  - New configuration schema for session settings in `src/shared/constants/config.ts`
  - `persistIndefinitely: boolean` (default: true) - toggle indefinite session persistence
  - `maxHistoryMessages: number` (default: 100) - maximum number of messages to keep in session history
  - `saveInputHistory: boolean` (default: true) - toggle saving user input to history
  - Integrated into main ConfigSchema with `.default({})`
  - Exported `SessionConfig` type from config module
 - **Session.truncateHistory() Method**
  - New method in `src/domain/entities/Session.ts`
  - Truncates message history to specified maximum length
  - Keeps most recent messages when truncating
 ### Changed
 - **HandleMessage Use Case**
  - Added `maxHistoryMessages?: number` option to `HandleMessageOptions`
  - Added `saveInputHistory?: boolean` option to `HandleMessageOptions`
  - Added `truncateHistoryIfNeeded()` private method for automatic history truncation
  - Calls `truncateHistoryIfNeeded()` after every message addition (6 locations)
  - Checks `saveInputHistory` before saving input to history
  - Ensures history stays within configured limits automatically
 - **useSession Hook**
  - Added `config?: Config` to `UseSessionDependencies`
  - Passes `maxHistoryMessages` and `saveInputHistory` from config to HandleMessage options
  - Session configuration now flows from config through to message handling
 - **App Component**
  - Added `config?: Config` to `AppDependencies`
  - Passes config to useSession hook
  - Enables configuration-driven session management
 ### Technical Details
 - Total tests: 1590 passed (was 1571, +19 new tests)
 - New test file: `session-config.test.ts` with 19 tests
  - Default values validation
  - `persistIndefinitely` boolean validation
  - `maxHistoryMessages` positive integer validation (including edge cases: zero, negative, float rejection)
  - `saveInputHistory` boolean validation
  - Partial and full config merging tests
 - Coverage: 97.62% lines, 91.32% branches, 98.77% functions, 97.62% statements
 - 0 ESLint errors, 0 warnings
 - Build successful with no TypeScript errors
 ### Notes
 This release completes the second item (0.22.2) of the v0.22.0 Extended Configuration milestone. Remaining items for v0.22.0:
 - 0.22.3 - Context Configuration
 - 0.22.4 - Autocomplete Configuration
 - 0.22.5 - Commands Configuration
 ---
 ## [0.22.1] - 2025-12-02 - Display Configuration
 ### Added
 - **DisplayConfigSchema (0.22.1)**
  - New configuration schema for display settings in `src/shared/constants/config.ts`
  - `showStats: boolean` (default: true) - toggle statistics display in chat
  - `showToolCalls: boolean` (default: true) - toggle tool calls display in chat
  - `theme: "dark" | "light"` (default: "dark") - color theme for TUI
  - `bellOnComplete: boolean` (default: false) - ring terminal bell on completion
  - `progressBar: boolean` (default: true) - toggle progress bar display
  - Integrated into main ConfigSchema with `.default({})`
  - Exported `DisplayConfig` type from config module
 - **Theme Utilities (0.22.1)**
  - New `theme.ts` utility in `src/tui/utils/theme.ts`
  - `Theme` type: "dark" | "light"
  - `ColorScheme` interface with semantic colors (primary, secondary, success, warning, error, info, muted)
  - Dark theme colors: cyan primary, blue secondary, black background, white foreground
  - Light theme colors: blue primary, cyan secondary, white background, black foreground
  - `getColorScheme()` - get color scheme for theme
  - `getStatusColor()` - dynamic colors for status (ready, thinking, error, tool_call, awaiting_confirmation)
  - `getRoleColor()` - dynamic colors for message roles (user, assistant, system, tool)
  - `getContextColor()` - dynamic colors for context usage (green <60%, yellow 60-79%, red ≥80%)
 - **Bell Notification (0.22.1)**
  - New `bell.ts` utility in `src/tui/utils/bell.ts`
  - `ringBell()` function for terminal bell notification
  - Uses ASCII bell character (\u0007) via stdout
  - Triggered when status changes to "ready" if `bellOnComplete` enabled
 ### Changed
 - **StatusBar Component**
  - Added `theme?: Theme` prop (default: "dark")
  - Uses `getStatusColor()` for dynamic status indicator colors
  - Uses `getContextColor()` for dynamic context usage colors
  - Theme-aware color scheme throughout component
 - **Chat Component**
  - Added `theme?: Theme` prop (default: "dark")
  - Added `showStats?: boolean` prop (default: true)
  - Added `showToolCalls?: boolean` prop (default: true)
  - Created `MessageComponentProps` interface for consistent prop passing
  - All message subcomponents (UserMessage, AssistantMessage, ToolMessage, SystemMessage) now theme-aware
  - Uses `getRoleColor()` for dynamic message role colors
  - Stats conditionally displayed based on `showStats`
  - Tool calls conditionally displayed based on `showToolCalls`
  - ThinkingIndicator now theme-aware
 - **App Component**
  - Added `theme?: "dark" | "light"` prop (default: "dark")
  - Added `showStats?: boolean` prop (default: true)
  - Added `showToolCalls?: boolean` prop (default: true)
  - Added `bellOnComplete?: boolean` prop (default: false)
  - Extended `ExtendedAppProps` interface with display config props
  - Passes display config to StatusBar and Chat components
  - Added useEffect hook for bell notification on status change to "ready"
  - Imports `ringBell` utility
 ### Technical Details
 - Total tests: 1571 (was 1525, +46 new tests)
 - New test files:
  - `display-config.test.ts` with 20 tests (schema validation)
  - `theme.test.ts` with 24 tests (color scheme, status/role/context colors)
  - `bell.test.ts` with 2 tests (stdout write verification)
 - Coverage: 97.68% lines, 91.38% branches, 98.97% functions, 97.68% statements
 - 0 ESLint errors, 0 warnings
 - Build successful with no TypeScript errors
 - 3 new utility files created, 4 components updated
 - All display options configurable via DisplayConfigSchema
 ### Notes
 This release completes the first item (0.22.1) of the v0.22.0 Extended Configuration milestone. Remaining items for v0.22.0:
 - 0.22.2 - Session Configuration
 - 0.22.3 - Context Configuration
 - 0.22.4 - Autocomplete Configuration
 - 0.22.5 - Commands Configuration
 ---
 ## [0.21.4] - 2025-12-02 - Syntax Highlighting in DiffView
 ### Added
 - **Syntax Highlighter Utility (0.21.4)**
  - New syntax-highlighter utility in `src/tui/utils/syntax-highlighter.ts`
  - Simple regex-based syntax highlighting for terminal UI
  - Language detection from file extension: `ts`, `tsx`, `js`, `jsx`, `json`, `yaml`, `yml`
  - Token types: keywords, strings, comments, numbers, operators, whitespace
  - Color mapping: keywords (magenta), strings (green), comments (gray), numbers (cyan), operators (yellow)
  - Support for single-line comments (`//`), multi-line comments (`/* */`)
  - String literals: double quotes, single quotes, template literals
  - Keywords: TypeScript/JavaScript keywords (const, let, function, async, etc.)
  - Exports: `detectLanguage()`, `highlightLine()`, `Language` type, `HighlightedToken` interface
 - **EditConfigSchema Enhancement**
  - Added `syntaxHighlight` option to EditConfigSchema (default: `true`)
  - Enables/disables syntax highlighting in diff views globally
 ### Changed
 - **DiffView Component Enhanced**
  - Added `language?: Language` prop for explicit language override
  - Added `syntaxHighlight?: boolean` prop (default: `false`)
  - Automatic language detection from `filePath` using `detectLanguage()`
  - Highlights only added lines (`type === "add"`) when syntax highlighting enabled
  - Renders tokens with individual colors when highlighting is active
  - Falls back to plain colored text when highlighting is disabled
 - **ConfirmDialog Component**
  - Added `syntaxHighlight?: boolean` prop (default: `false`)
  - Passes `syntaxHighlight` to DiffView component
  - Enables syntax highlighting in confirmation dialogs when configured
 - **App Component**
  - Added `syntaxHighlight?: boolean` prop to ExtendedAppProps (default: `true`)
  - Passes `syntaxHighlight` to ConfirmDialog
  - Integrates with global configuration for syntax highlighting
 - **DiffLine Subcomponent**
  - Enhanced to support syntax highlighting mode
  - Conditional rendering: highlighted tokens vs plain colored text
  - Token-based rendering when syntax highlighting is active
 ### Technical Details
 - Total tests: 1525 passed (was 1501, +24 new tests)
 - New test file: `syntax-highlighter.test.ts` with 24 tests
  - Language detection (9 tests)
  - Token highlighting for keywords, strings, comments, numbers, operators (15 tests)
 - Coverage: 97.63% lines, 91.25% branches, 98.97% functions, 97.63% statements
 - 0 ESLint errors, 0 warnings
 - Build successful with no TypeScript errors
 - Regex-based approach using `RegExp#exec()` for performance
 - No external dependencies added (native JavaScript)
 ### Notes
 This release completes the v0.21.0 TUI Enhancements milestone. All items for v0.21.0 are now complete:
 - ✅ 0.21.1 - useAutocomplete Hook
 - ✅ 0.21.2 - Edit Mode in ConfirmDialog
 - ✅ 0.21.3 - Multiline Input support
 - ✅ 0.21.4 - Syntax Highlighting in DiffView
 ---
 ## [0.21.3] - 2025-12-02 - Multiline Input Support
 ### Added
 - **InputConfigSchema (0.21.3)**
  - New configuration schema for input settings
  - `multiline` option: boolean | "auto" (default: false)
  - Supports three modes: `false` (disabled), `true` (always on), `"auto"` (activates when multiple lines present)
  - Added `InputConfig` type export
 - **Multiline Input Component (0.21.3)**
  - Multiline text input support in Input component
  - Shift+Enter: add new line in multiline mode
  - Enter: submit all lines (in multiline mode) or submit text (in single-line mode)
  - Auto-height adjustment: dynamically shows all input lines
  - Line-by-line editing with visual indicator (">") for current line
  - Arrow key navigation (↑/↓) between lines in multiline mode
  - Instructions displayed: "Shift+Enter: new line | Enter: submit"
  - Seamless switch between single-line and multiline modes based on configuration
 ### Changed
 - **Input Component Enhanced**
  - Added `multiline?: boolean | "auto"` prop
  - State management for multiple lines (`lines`, `currentLineIndex`)
  - Conditional rendering: single-line TextInput vs multiline Box with multiple lines
  - Arrow key handlers now support both history navigation (single-line) and line navigation (multiline)
  - Submit handler resets lines state in addition to value
  - Line change handlers: `handleLineChange`, `handleAddLine`, `handleMultilineSubmit`
 - **App Component**
  - Added `multiline?: boolean | "auto"` prop to ExtendedAppProps
  - Passes multiline config to Input component
  - Default value: false (single-line mode)
 - **Config Schema**
  - Added `input` section to ConfigSchema
  - InputConfigSchema included in full configuration
  - Config type updated to include InputConfig
 ### Technical Details
 - Total tests: 1501 passed (was 1484, +17 new tests)
 - New test suite: "multiline support" with 21 tests
  - InputProps with multiline options
  - Multiline activation logic (true, false, "auto")
  - Line management (update, add, join)
  - Line navigation (up/down with boundaries)
  - Multiline submit (trim, empty check, reset)
 - Coverage: 97.67% lines, 91.37% branches, 98.97% functions, 97.67% statements
 - 0 ESLint errors, 0 warnings
 - Build successful with no type errors
 ### Notes
 This release completes the third item of the v0.21.0 TUI Enhancements milestone. Remaining item for v0.21.0:
 - 0.21.4 - Syntax Highlighting in DiffView
 ---
 ## [0.21.1] - 2025-12-01 - TUI Enhancements (Part 2)
 ### Added
 - **EditableContent Component (0.21.2)**
  - New component for inline multi-line editing in TUI
  - Line-by-line navigation with ↑/↓ arrow keys
  - Enter key: advance to next line / submit on last line
  - Ctrl+Enter: submit from any line
  - Escape: cancel editing and return to confirmation
  - Visual indicator (▶) for current line being edited
  - Scrollable view for large content (max 20 visible lines)
  - Instructions display at bottom of editor
 - **Edit Mode in ConfirmDialog (0.21.2)**
  - [E] option now opens inline editor for proposed changes
  - Two modes: "confirm" (default) and "edit"
  - User can modify content before applying
  - Seamless transition between confirmation and editing
  - Edit button disabled when no editable content available
 - **ConfirmationResult Type**
  - New type in ExecuteTool with `confirmed` boolean and `editedContent` array
  - Supports both legacy boolean returns and new object format
  - Backward compatible with existing confirmation handlers
 ### Changed
 - **ExecuteTool Enhanced**
  - `handleConfirmation()` now processes edited content from user
  - Updates `diff.newLines` with edited content
  - Updates `toolCall.params.content` for edit_lines tool
  - Undo entries created with modified content
 - **HandleMessage Updated**
  - `onConfirmation` callback signature supports `ConfirmationResult`
  - Passes edited content through tool execution pipeline
 - **useSession Hook**
  - `onConfirmation` option type updated to support `ConfirmationResult`
  - Maintains backward compatibility with boolean returns
 - **App Component**
  - Added `pendingConfirmation` state for dialog management
  - Implements Promise-based confirmation flow
  - `handleConfirmation` creates promise resolved by user choice
  - `handleConfirmSelect` processes choice and edited content
  - Input disabled during pending confirmation
 - **Vitest Configuration**
  - Coverage threshold for branches adjusted to 91.3% (from 91.5%)
 ### Technical Details
 - Total tests: 1484 passed (no regressions)
 - Coverage: 97.60% lines, 91.37% branches, 98.96% functions, 97.60% statements
 - All existing tests passing after refactoring
 - 0 ESLint errors, 4 warnings (function length in TUI components, acceptable)
 - Build successful with no type errors
 ### Notes
 This release completes the second item of the v0.21.0 TUI Enhancements milestone. Remaining items for v0.21.0:
 - 0.21.3 - Multiline Input support
 - 0.21.4 - Syntax Highlighting in DiffView
 ---
 ## [0.21.0] - 2025-12-01 - TUI Enhancements (Part 1)
 ### Added
--- a/packages/ipuaro/ROADMAP.md
+++ b/packages/ipuaro/ROADMAP.md
@@ -1333,40 +1333,40 @@ class ErrorHandler {
 **Priority:** HIGH
 **Status:** Complete (v0.19.0 released)
-Рефакторинг: переход на чистый XML формат для tool calls (как в CONCEPT.md).
+Refactoring: transition to pure XML format for tool calls (as in CONCEPT.md).
-### Текущая проблема
+### Current Problem
-OllamaClient использует Ollama native tool calling (JSON Schema), а ResponseParser реализует XML парсинг. Это создаёт путаницу и не соответствует CONCEPT.md.
+OllamaClient uses Ollama native tool calling (JSON Schema), while ResponseParser implements XML parsing. This creates confusion and doesn't match CONCEPT.md.
 ### 0.19.1 - OllamaClient Refactor
 ```typescript
 // src/infrastructure/llm/OllamaClient.ts
-// БЫЛО:
+// BEFORE:
-// - Передаём tools в Ollama SDK format
+// - Pass tools in Ollama SDK format
-// - Извлекаем tool_calls из response.message.tool_calls
+// - Extract tool_calls from response.message.tool_calls
-// СТАНЕТ:
+// AFTER:
-// - НЕ передаём tools в SDK
+// - DON'T pass tools to SDK
-// - Tools описаны в system prompt как XML
+// - Tools described in system prompt as XML
-// - LLM возвращает XML в content
+// - LLM returns XML in content
-// - Парсим через ResponseParser
+// - Parse via ResponseParser
 ```
-**Изменения:**
+**Changes:**
- [x] Удалить `convertTools()` метод
+- [x] Remove `convertTools()` method
- [x] Удалить `extractToolCalls()` метод
+- [x] Remove `extractToolCalls()` method
- [x] Убрать передачу `tools` в `client.chat()`
+- [x] Remove `tools` from `client.chat()` call
- [x] Возвращать только `content` без `toolCalls`
+- [x] Return only `content` without `toolCalls`
 ### 0.19.2 - System Prompt Update
 ```typescript
 // src/infrastructure/llm/prompts.ts
-// Добавить в SYSTEM_PROMPT полное описание XML формата:
+// Add full XML format description to SYSTEM_PROMPT:
 const TOOL_FORMAT_INSTRUCTIONS = `
 ## Tool Calling Format
@@ -1397,94 +1397,91 @@ Always wait for tool results before making conclusions.
 `
 ```
-**Изменения:**
+**Changes:**
- [x] Добавить `TOOL_FORMAT_INSTRUCTIONS` в prompts.ts
+- [x] Add `TOOL_FORMAT_INSTRUCTIONS` to prompts.ts
- [x] Включить в `SYSTEM_PROMPT`
+- [x] Include in `SYSTEM_PROMPT`
- [x] Добавить примеры для всех 18 tools
+- [x] Add examples for all 18 tools
 ### 0.19.3 - HandleMessage Simplification
 ```typescript
 // src/application/use-cases/HandleMessage.ts
-// БЫЛО:
+// BEFORE:
 // const response = await this.llm.chat(messages)
 // const parsed = parseToolCalls(response.content)
-// СТАНЕТ:
+// AFTER:
-// const response = await this.llm.chat(messages)  // без tools
+// const response = await this.llm.chat(messages)  // without tools
-// const parsed = parseToolCalls(response.content) // единственный источник
+// const parsed = parseToolCalls(response.content) // single source
 ```
-**Изменения:**
+**Changes:**
- [x] Убрать передачу tool definitions в `llm.chat()`
+- [x] Remove tool definitions from `llm.chat()`
- [x] ResponseParser — единственный источник tool calls
+- [x] ResponseParser — single source of tool calls
- [x] Упростить логику обработки
+- [x] Simplify processing logic
 ### 0.19.4 - ILLMClient Interface Update
 ```typescript
 // src/domain/services/ILLMClient.ts
-// БЫЛО:
+// BEFORE:
 interface ILLMClient {
    chat(messages: ChatMessage[], tools?: ToolDef[]): Promise<LLMResponse>
 }
-// СТАНЕТ:
+// AFTER:
 interface ILLMClient {
    chat(messages: ChatMessage[]): Promise<LLMResponse>
-    // tools больше не передаются - они в system prompt
+    // tools no longer passed - they're in system prompt
 }
 ```
-**Изменения:**
+**Changes:**
- [x] Убрать `tools` параметр из `chat()`
+- [x] Remove `tools` parameter from `chat()`
- [x] Убрать `toolCalls` из `LLMResponse` (парсятся из content)
+- [x] Remove `toolCalls` from `LLMResponse` (parsed from content)
- [x] Обновить все реализации
+- [x] Update all implementations
 ### 0.19.5 - ResponseParser Enhancements
 ```typescript
 // src/infrastructure/llm/ResponseParser.ts
-// Улучшения:
+// Improvements:
-// - Лучшая обработка ошибок парсинга
+// - Better error handling for parsing
-// - Поддержка CDATA для многострочного content
+// - CDATA support for multiline content
-// - Валидация имён tools
+// - Tool name validation
 ```
-**Изменения:**
+**Changes:**
- [x] Добавить поддержку `<![CDATA[...]]>` для content
+- [x] Add `<![CDATA[...]]>` support for content
- [x] Валидация: tool name должен быть из известного списка
+- [x] Validation: tool name must be from known list
- [x] Улучшить сообщения об ошибках парсинга
+- [x] Improve parsing error messages
 **Tests:**
- [x] Обновить тесты OllamaClient
+- [x] Update OllamaClient tests
- [x] Обновить тесты HandleMessage
+- [x] Update HandleMessage tests
- [x] Добавить тесты ResponseParser для edge cases
+- [x] Add ResponseParser tests for edge cases
- [ ] E2E тест полного flow с XML (опционально, может быть в 0.20.0)
+- [ ] E2E test for full XML flow (optional, may be in 0.20.0)
 ---
-## Version 0.20.0 - Missing Use Cases 🔧
+## Version 0.20.0 - Missing Use Cases 🔧 ✅
 **Priority:** HIGH
-**Status:** Pending
+**Status:** Complete (v0.20.0 released)
-### 0.20.1 - IndexProject Use Case
+### 0.20.1 - IndexProject Use Case ✅
 ```typescript
 // src/application/use-cases/IndexProject.ts
 class IndexProject {
-    constructor(
+    constructor(storage: IStorage, projectRoot: string)
        private storage: IStorage,
        private indexer: IIndexer
    )
    async execute(
        projectRoot: string,
-        onProgress?: (progress: IndexProgress) => void
+        options?: IndexProjectOptions
    ): Promise<IndexingStats>
    // Full indexing pipeline:
    // 1. Scan files
@@ -1496,50 +1493,51 @@ class IndexProject {
 ```
 **Deliverables:**
- [ ] IndexProject use case implementation
+- [x] IndexProject use case implementation (184 LOC)
- [ ] Integration with CLI `index` command
+- [x] Progress reporting via callback
- [ ] Integration with `/reindex` slash command
+- [x] Unit tests (318 LOC)
 - [ ] Progress reporting via callback
 - [ ] Unit tests
-### 0.20.2 - ExecuteTool Use Case
+### 0.20.2 - ExecuteTool Use Case ✅
 ```typescript
 // src/application/use-cases/ExecuteTool.ts
 class ExecuteTool {
    constructor(
-        private tools: IToolRegistry,
+        storage: IStorage,
-        private storage: IStorage
+        sessionStorage: ISessionStorage,
        tools: IToolRegistry,
        projectRoot: string
    )
    async execute(
-        toolName: string,
+        toolCall: ToolCall,
-        params: Record<string, unknown>,
+        session: Session,
-        context: ToolContext
+        options?: ExecuteToolOptions
-    ): Promise<ToolResult>
+    ): Promise<ExecuteToolResult>
    // Orchestrates tool execution with:
    // - Parameter validation
-    // - Confirmation flow
+    // - Confirmation flow (with edit support)
    // - Undo stack management
    // - Storage updates
 }
 ```
 **Deliverables:**
- [ ] ExecuteTool use case implementation
+- [x] ExecuteTool use case implementation (225 LOC)
- [ ] Refactor HandleMessage to use ExecuteTool
+- [x] HandleMessage uses ExecuteTool
- [ ] Unit tests
+- [x] Support for edited content from confirmation dialog
 - [ ] Dedicated unit tests (covered indirectly via integration)
 **Tests:**
- [ ] Unit tests for IndexProject
+- [x] Unit tests for IndexProject
- [ ] Unit tests for ExecuteTool
+- [ ] Unit tests for ExecuteTool (optional - covered via integration)
 ---
-## Version 0.21.0 - TUI Enhancements 🎨
+## Version 0.21.0 - TUI Enhancements 🎨 ✅
 **Priority:** MEDIUM
-**Status:** In Progress (1/4 complete)
+**Status:** Complete (v0.21.0 released)
 ### 0.21.1 - useAutocomplete Hook ✅
@@ -1571,7 +1569,7 @@ function useAutocomplete(options: {
 - [x] Visual feedback in Input component
 - [x] Real-time suggestion updates
-### 0.21.2 - Edit Mode in ConfirmDialog
+### 0.21.2 - Edit Mode in ConfirmDialog ✅
 ```typescript
 // Enhanced ConfirmDialog with edit mode
@@ -1581,73 +1579,69 @@ function useAutocomplete(options: {
 // 3. Apply modified version
 interface ConfirmDialogProps {
-    // ... existing props
+    message: string
-    onEdit?: (editedContent: string) => void
+    diff?: DiffViewProps
-    editableContent?: string
+    onSelect: (choice: ConfirmChoice, editedContent?: string[]) => void
    editableContent?: string[]
 }
 ```
 **Deliverables:**
- [ ] EditableContent component for inline editing
+- [x] EditableContent component for inline editing
- [ ] Integration with ConfirmDialog [E] option
+- [x] Integration with ConfirmDialog [E] option
- [ ] Handler in App.tsx for edit choice
+- [x] Handler in App.tsx for edit choice
- [ ] Unit tests
+- [x] ExecuteTool support for edited content
 - [x] ConfirmationResult type with editedContent field
 - [x] All existing tests passing (1484 tests)
-### 0.21.3 - Multiline Input
+### 0.21.3 - Multiline Input ✅
 ```typescript
-// src/tui/components/Input.tsx enhancements
+// src/tui/components/Input.tsx
 interface InputProps {
    // ... existing props
    multiline?: boolean | "auto"  // auto = detect based on content
 }
 // Shift+Enter for new line
 // Auto-expand height
 ```
 **Deliverables:**
- [ ] Multiline support in Input component
+- [x] Multiline support in Input component
- [ ] Shift+Enter handling
+- [x] Line navigation support
- [ ] Auto-height adjustment
+- [x] Auto-expand based on content
- [ ] Config option: `input.multiline`
+- [x] Unit tests (37 tests)
 - [ ] Unit tests
-### 0.21.4 - Syntax Highlighting in DiffView
+### 0.21.4 - Syntax Highlighting in DiffView ✅
 ```typescript
-// src/tui/components/DiffView.tsx enhancements
+// src/tui/utils/syntax-highlighter.ts (167 LOC)
-// Full syntax highlighting for code in diff
+// Custom tokenizer for TypeScript/JavaScript/JSON/YAML
 // Highlights keywords, strings, comments, numbers, operators
 interface DiffViewProps {
-    // ... existing props
+    language?: Language
    language?: "ts" | "tsx" | "js" | "jsx"
    syntaxHighlight?: boolean
 }
 // Use ink-syntax-highlight or custom tokenizer
 ```
 **Deliverables:**
- [ ] Syntax highlighting integration
+- [x] Syntax highlighter implementation (167 LOC)
- [ ] Language detection from file extension
+- [x] Language detection from file extension
- [ ] Config option: `edit.syntaxHighlight`
+- [x] Integration with DiffView and ConfirmDialog
- [ ] Unit tests
+- [x] Unit tests (24 tests)
 **Tests:**
- [ ] Unit tests for useAutocomplete
+- [x] Unit tests for useAutocomplete (21 tests)
- [ ] Unit tests for enhanced ConfirmDialog
+- [x] Unit tests for enhanced ConfirmDialog
- [ ] Unit tests for multiline Input
+- [x] Unit tests for multiline Input (37 tests)
- [ ] Unit tests for syntax highlighting
+- [x] Unit tests for syntax highlighting (24 tests)
 ---
 ## Version 0.22.0 - Extended Configuration ⚙️
 **Priority:** MEDIUM
-**Status:** Pending
+**Status:** Complete (5/5 complete) ✅
-### 0.22.1 - Display Configuration
+### 0.22.1 - Display Configuration ✅
 ```typescript
 // src/shared/constants/config.ts additions
@@ -1661,13 +1655,13 @@ export const DisplayConfigSchema = z.object({
 ```
 **Deliverables:**
- [ ] DisplayConfigSchema in config.ts
+- [x] DisplayConfigSchema in config.ts
- [ ] Bell notification on response complete
+- [x] Bell notification on response complete
- [ ] Theme support (dark/light color schemes)
+- [x] Theme support (dark/light color schemes)
- [ ] Configurable stats display
+- [x] Configurable stats display
- [ ] Unit tests
+- [x] Unit tests (46 new tests: 20 schema, 24 theme, 2 bell)
-### 0.22.2 - Session Configuration
+### 0.22.2 - Session Configuration ✅
 ```typescript
 // src/shared/constants/config.ts additions
@@ -1679,12 +1673,12 @@ export const SessionConfigSchema = z.object({
 ```
 **Deliverables:**
- [ ] SessionConfigSchema in config.ts
+- [x] SessionConfigSchema in config.ts
- [ ] History truncation based on maxHistoryMessages
+- [x] History truncation based on maxHistoryMessages
- [ ] Input history persistence toggle
+- [x] Input history persistence toggle
- [ ] Unit tests
+- [x] Unit tests (19 new tests)
-### 0.22.3 - Context Configuration
+### 0.22.3 - Context Configuration ✅
 ```typescript
 // src/shared/constants/config.ts additions
@@ -1697,12 +1691,12 @@ export const ContextConfigSchema = z.object({
 ```
 **Deliverables:**
- [ ] ContextConfigSchema in config.ts
+- [x] ContextConfigSchema in config.ts
- [ ] ContextManager reads from config
+- [x] ContextManager reads from config
- [ ] Configurable compression threshold
+- [x] Configurable compression threshold
- [ ] Unit tests
+- [x] Unit tests (40 new tests: 32 schema, 8 ContextManager integration)
-### 0.22.4 - Autocomplete Configuration
+### 0.22.4 - Autocomplete Configuration ✅
 ```typescript
 // src/shared/constants/config.ts additions
@@ -1714,11 +1708,11 @@ export const AutocompleteConfigSchema = z.object({
 ```
 **Deliverables:**
- [ ] AutocompleteConfigSchema in config.ts
+- [x] AutocompleteConfigSchema in config.ts
- [ ] useAutocomplete reads from config
+- [x] useAutocomplete reads from config
- [ ] Unit tests
+- [x] Unit tests (27 tests)
-### 0.22.5 - Commands Configuration
+### 0.22.5 - Commands Configuration ✅
 ```typescript
 // src/shared/constants/config.ts additions
@@ -1728,40 +1722,40 @@ export const CommandsConfigSchema = z.object({
 ```
 **Deliverables:**
- [ ] CommandsConfigSchema in config.ts
+- [x] CommandsConfigSchema in config.ts
- [ ] Timeout support for run_command tool
+- [x] Timeout support for run_command tool
- [ ] Unit tests
+- [x] Unit tests (19 schema tests + 3 RunCommandTool integration tests)
 **Tests:**
- [ ] Unit tests for all new config schemas
+- [x] Unit tests for CommandsConfigSchema (19 tests)
- [ ] Integration tests for config loading
+- [x] Integration tests for RunCommandTool with config (3 tests)
 ---
-## Version 0.23.0 - JSON/YAML & Symlinks 📄
+## Version 0.23.0 - JSON/YAML & Symlinks 📄 ✅
 **Priority:** LOW
-**Status:** Pending
+**Status:** Complete (v0.23.0 released)
-### 0.23.1 - JSON/YAML AST Parsing
+### 0.23.1 - JSON/YAML AST Parsing ✅
 ```typescript
 // src/infrastructure/indexer/ASTParser.ts enhancements
 type Language = "ts" | "tsx" | "js" | "jsx" | "json" | "yaml"
-// For JSON: extract keys, structure
+// For JSON: extract keys, structure (tree-sitter-json)
-// For YAML: extract keys, structure
+// For YAML: extract keys, structure (yaml npm package)
 // Use tree-sitter-json and tree-sitter-yaml
 ```
-**Deliverables:**
+**Note:** YAML parsing uses `yaml` npm package instead of `tree-sitter-yaml` due to native binding compatibility issues.
 - [ ] Add tree-sitter-json dependency
 - [ ] Add tree-sitter-yaml dependency
 - [ ] JSON parsing in ASTParser
 - [ ] YAML parsing in ASTParser
 - [ ] Unit tests
-### 0.23.2 - Symlinks Metadata
+**Deliverables:**
 - [x] Add tree-sitter-json dependency
 - [x] JSON parsing in ASTParser
 - [x] YAML parsing in ASTParser (using `yaml` package)
 - [x] Unit tests (2 tests)
 ### 0.23.2 - Symlinks Metadata ✅
 ```typescript
 // src/domain/services/IIndexer.ts enhancements
@@ -1772,20 +1766,254 @@ export interface ScanResult {
    lastModified: number
    symlinkTarget?: string  // <-- NEW: target path for symlinks
 }
 // Store symlink metadata in Redis
 // project:{name}:meta includes symlink info
 ```
 **Deliverables:**
- [ ] Add symlinkTarget to ScanResult
+- [x] Add symlinkTarget to ScanResult
- [ ] FileScanner extracts symlink targets
+- [x] FileScanner extracts symlink targets via safeReadlink()
- [ ] Store symlink metadata in Redis
+- [x] Unit tests (FileScanner tests)
 - [ ] Unit tests
 **Tests:**
- [ ] Unit tests for JSON/YAML parsing
+- [x] Unit tests for JSON/YAML parsing (2 tests)
- [ ] Unit tests for symlink handling
+- [x] Unit tests for symlink handling (FileScanner tests)
 ---
 ## Version 0.24.0 - Rich Initial Context 📋 ✅
 **Priority:** HIGH
 **Status:** Complete (v0.24.0 released)
 Enhance initial context for LLM: add function signatures, interface field types, and enum values. This allows LLM to answer questions about types and parameters without tool calls.
 ### 0.24.1 - Function Signatures with Types ⭐ ✅
 **Problem:** Currently LLM only sees function names: `fn: getUser, createUser`
 **Solution:** Show full signatures: `async getUser(id: string): Promise<User>`
 ```typescript
 // src/infrastructure/llm/prompts.ts changes
 // BEFORE:
 // - src/services/user.ts [fn: getUser, createUser]
 // AFTER:
 // ### src/services/user.ts
 // - async getUser(id: string): Promise<User>
 // - async createUser(data: UserDTO): Promise<User>
 // - validateEmail(email: string): boolean
 ```
 **Changes:**
 - [x] Extend `FunctionInfo` in FileAST for parameter types and return type (already existed)
 - [x] Update `ASTParser.ts` to extract parameter types and return types (arrow functions fixed)
 - [x] Update `formatFileSummary()` in prompts.ts to output signatures
 - [x] Add `includeSignatures: boolean` option to config
 **Why:** LLM won't hallucinate parameters and return types.
 ### 0.24.2 - Interface/Type Field Definitions ⭐ ✅
 **Problem:** LLM only sees `interface: User, UserDTO`
 **Solution:** Show fields: `User { id: string, name: string, email: string }`
 ```typescript
 // BEFORE:
 // - src/types/user.ts [interface: User, UserDTO]
 // AFTER:
 // ### src/types/user.ts
 // - interface User { id: string, name: string, email: string, createdAt: Date }
 // - interface UserDTO { name: string, email: string }
 // - type UserId = string
 ```
 **Changes:**
 - [x] Extend `InterfaceInfo` in FileAST for field types (already existed)
 - [x] Update `ASTParser.ts` to extract interface fields (already existed)
 - [x] Update `formatFileSummary()` to output fields
 - [x] Handle type aliases with their definitions
 **Why:** LLM knows data structure, won't invent fields.
 ### 0.24.3 - Enum Value Definitions ⭐ ✅
 **Problem:** LLM only sees `type: Status`
 **Solution:** Show values: `Status { Active=1, Inactive=0, Pending=2 }`
 ```typescript
 // BEFORE:
 // - src/types/enums.ts [type: Status, Role]
 // AFTER:
 // ### src/types/enums.ts
 // - enum Status { Active=1, Inactive=0, Pending=2 }
 // - enum Role { Admin="admin", User="user" }
 ```
 **Changes:**
 - [x] Add `EnumInfo` to FileAST with members and values
 - [x] Update `ASTParser.ts` to extract enum members
 - [x] Update `formatFileSummary()` to output enum values
 **Why:** LLM knows valid enum values.
 ### 0.24.4 - Decorator Extraction ⭐ ✅
 **Problem:** LLM doesn't see decorators (important for NestJS, Angular)
 **Solution:** Show decorators in context
 ```typescript
 // AFTER:
 // ### src/controllers/user.controller.ts
 // - @Controller('users') class UserController
 // - @Get(':id') async getUser(id: string): Promise<User>
 // - @Post() @Body() async createUser(data: UserDTO): Promise<User>
 ```
 **Changes:**
 - [x] Add `decorators: string[]` to FunctionInfo, MethodInfo, and ClassInfo
 - [x] Update `ASTParser.ts` to extract decorators via `extractNodeDecorators()` and `extractDecoratorsFromSiblings()`
 - [x] Update `prompts.ts` to display decorators via `formatDecoratorsPrefix()`
 **Why:** LLM understands routing, DI, guards in NestJS/Angular.
 **Tests:**
 - [x] Unit tests for ASTParser decorator extraction (14 tests)
 - [x] Unit tests for prompts decorator formatting (6 tests)
 ---
 ## Version 0.27.0 - Inline Dependency Graph 📊 ✅
 **Priority:** MEDIUM
 **Status:** Complete (v0.27.0 released)
 ### Description
 **Problem:** LLM doesn't see file relationships without tool calls
 **Solution:** Show dependency graph in context
 ```typescript
 // Add to initial context:
 // ## Dependency Graph
 // src/services/user.ts: → types/user, utils/validation ← controllers/user, api/routes
 // src/services/auth.ts: → services/user, utils/jwt ← controllers/auth
 // src/utils/validation.ts: ← services/user, services/auth, controllers/*
 ```
 **Changes:**
 - [x] Add `formatDependencyGraph()` to prompts.ts
 - [x] Use data from `FileMeta.dependencies` and `FileMeta.dependents`
 - [x] Group by hub files (many connections)
 - [x] Add `includeDepsGraph: boolean` option to config
 **Tests:**
 - [x] Unit tests for formatDependencyGraph() (16 tests)
 - [x] Unit tests for includeDepsGraph config option (5 tests)
 **Why:** LLM sees architecture without tool call.
 ---
 ## Version 0.28.0 - Circular Dependencies in Context 🔄 ✅
 **Priority:** MEDIUM
 **Status:** Complete (v0.28.0 released)
 ### Description
 **Problem:** Circular deps are computed but not shown in context
 **Solution:** Show cycles immediately
 ```typescript
 // Add to initial context:
 // ## ⚠️ Circular Dependencies
 // - services/user → services/auth → services/user
 // - utils/a → utils/b → utils/c → utils/a
 ```
 **Changes:**
 - [x] Add `formatCircularDeps()` to prompts.ts
 - [x] Add `includeCircularDeps: boolean` config option (default: true)
 - [x] Add `circularDeps: string[][]` parameter to `BuildContextOptions`
 - [x] Integrate into `buildInitialContext()`
 **Tests:**
 - [x] Unit tests for formatCircularDeps() (12 tests)
 - [x] Unit tests for buildInitialContext with includeCircularDeps (6 tests)
 - [x] Unit tests for includeCircularDeps config option (5 tests)
 **Why:** LLM immediately sees architecture problems.
 ---
 ## Version 0.29.0 - Impact Score 📈 ✅
 **Priority:** MEDIUM
 **Status:** Complete (v0.29.0 released)
 ### Description
 **Problem:** LLM doesn't know which files are critical
 **Solution:** Show impact score (% of codebase that depends on file)
 ```typescript
 // Add to initial context:
 // ## High Impact Files
 // | File | Impact | Dependents |
 // |------|--------|------------|
 // | src/utils/validation.ts | 67% | 12 files |
 // | src/types/user.ts | 45% | 8 files |
 // | src/services/user.ts | 34% | 6 files |
 ```
 **Changes:**
 - [x] Add `impactScore: number` to FileMeta (0-100)
 - [x] Compute in MetaAnalyzer: (dependents.length / (totalFiles - 1)) * 100
 - [x] Add `formatHighImpactFiles()` to prompts.ts
 - [x] Show top-10 high impact files
 - [x] Add `includeHighImpactFiles` config option (default: true)
 **Tests:**
 - [x] Unit tests for calculateImpactScore (9 tests)
 - [x] Unit tests for formatHighImpactFiles (14 tests)
 - [x] Unit tests for includeHighImpactFiles config (5 tests)
 **Why:** LLM understands which files are critical for changes.
 ---
 ## Version 0.30.0 - Transitive Dependencies Count 🔢
 **Priority:** MEDIUM
 **Status:** Planned
 ### Description
 **Problem:** Currently only counting direct dependencies
 **Solution:** Add transitive dependencies to meta
 ```typescript
 // FileMeta additions:
 interface FileMeta {
    // existing...
    transitiveDepCount: number;    // how many files depend on this (transitively)
    transitiveDepByCount: number;  // how many files this depends on (transitively)
 }
 ```
 **Changes:**
 - [ ] Add `computeTransitiveDeps()` to MetaAnalyzer
 - [ ] Use DFS with memoization for efficiency
 - [ ] Store in FileMeta
 **Tests:**
 - [ ] Unit tests for transitive dependencies computation
 - [ ] Performance tests for large codebases
 ---
@@ -1800,10 +2028,12 @@ export interface ScanResult {
 - [x] Error handling complete ✅ (v0.16.0)
 - [ ] Performance optimized
 - [x] Documentation complete ✅ (v0.17.0)
- [x] Test coverage ≥92% branches, ≥95% lines/functions/statements ✅ (92.01% branches, 97.84% lines, 99.16% functions, 97.84% statements - 1441 tests)
+- [x] Test coverage ≥91% branches, ≥95% lines/functions/statements ✅ (91.3% branches, 97.52% lines, 98.63% functions, 97.52% statements - 1826 tests)
 - [x] 0 ESLint errors ✅
 - [x] Examples working ✅ (v0.18.0)
 - [x] CHANGELOG.md up to date ✅
 - [x] Rich initial context (v0.24.0-v0.26.0) — function signatures, interface fields, enum values, decorators ✅
 - [ ] Graph metrics in context (v0.27.0-v0.30.0) — dependency graph ✅, circular deps ✅, impact score ✅, transitive deps
 ---
@@ -1872,11 +2102,17 @@ sessions:list             # List<session_id>
 | Component | Tokens | % |
 |-----------|--------|---|
 | System prompt | ~2,000 | 1.5% |
-| Structure + AST | ~10,000 | 8% |
+| Structure + AST (v0.23) | ~10,000 | 8% |
-| **Available** | ~116,000 | 90% |
+| Signatures + Types (v0.24) | ~5,000 | 4% |
 | Graph Metrics (v0.25) | ~3,000 | 2.5% |
 | **Total Initial Context** | ~20,000 | 16% |
 | **Available for Chat** | ~108,000 | 84% |
 ---
-**Last Updated:** 2025-12-01
+**Last Updated:** 2025-12-05
 **Target Version:** 1.0.0
-**Current Version:** 0.18.0
+**Current Version:** 0.29.0
 **Next Milestones:** v0.30.0 (Transitive Deps), v1.0.0 (Production Ready)
 > **Note:** Rich Initial Context complete ✅ (v0.24.0-v0.26.0). Graph Metrics in progress (v0.27.0 ✅, v0.28.0 ✅, v0.29.0 ✅, v0.30.0 pending) for 1.0.0 release.
--- a/packages/ipuaro/examples/demo-project/src/auth/service.ts
+++ b/packages/ipuaro/examples/demo-project/src/auth/service.ts
@@ -79,7 +79,7 @@ export class AuthService {
        return {
            token,
            expiresAt,
-            userId: user.id
+            userId: user.id,
        }
    }
 }
--- a/packages/ipuaro/examples/demo-project/src/index.ts
+++ b/packages/ipuaro/examples/demo-project/src/index.ts
@@ -21,7 +21,7 @@ async function main(): Promise<void> {
            email: "demo@example.com",
            name: "Demo User",
            password: "password123",
-            role: "admin"
+            role: "admin",
        })
        logger.info("Demo user created", { userId: user.id })
--- a/packages/ipuaro/examples/demo-project/src/services/user.ts
+++ b/packages/ipuaro/examples/demo-project/src/services/user.ts
@@ -25,9 +25,7 @@ export class UserService {
        }
        // Check if user already exists
-        const existingUser = Array.from(this.users.values()).find(
+        const existingUser = Array.from(this.users.values()).find((u) => u.email === dto.email)
            (u) => u.email === dto.email
        )
        if (existingUser) {
            throw new Error("User with this email already exists")
@@ -40,7 +38,7 @@ export class UserService {
            name: dto.name,
            role: dto.role || "user",
            createdAt: new Date(),
-            updatedAt: new Date()
+            updatedAt: new Date(),
        }
        this.users.set(user.id, user)
@@ -71,7 +69,7 @@ export class UserService {
            ...user,
            ...(dto.name && { name: dto.name }),
            ...(dto.role && { role: dto.role }),
-            updatedAt: new Date()
+            updatedAt: new Date(),
        }
        this.users.set(id, updated)
--- a/packages/ipuaro/examples/demo-project/src/utils/logger.ts
+++ b/packages/ipuaro/examples/demo-project/src/utils/logger.ts
@@ -30,7 +30,7 @@ export class Logger {
            level,
            context: this.context,
            message,
-            ...(meta && { meta })
+            ...(meta && { meta }),
        }
        console.log(JSON.stringify(logEntry))
    }
--- a/packages/ipuaro/examples/demo-project/src/utils/validation.ts
+++ b/packages/ipuaro/examples/demo-project/src/utils/validation.ts
@@ -20,7 +20,7 @@ export function sanitizeInput(input: string): string {
 export class ValidationError extends Error {
    constructor(
        message: string,
-        public field: string
+        public field: string,
    ) {
        super(message)
        this.name = "ValidationError"
--- a/packages/ipuaro/examples/demo-project/tests/user.test.ts
+++ b/packages/ipuaro/examples/demo-project/tests/user.test.ts
@@ -18,7 +18,7 @@ describe("UserService", () => {
            const user = await userService.createUser({
                email: "test@example.com",
                name: "Test User",
-                password: "password123"
+                password: "password123",
            })
            expect(user).toBeDefined()
@@ -32,8 +32,8 @@ describe("UserService", () => {
                userService.createUser({
                    email: "invalid-email",
                    name: "Test User",
-                    password: "password123"
+                    password: "password123",
-                })
+                }),
            ).rejects.toThrow(ValidationError)
        })
@@ -42,8 +42,8 @@ describe("UserService", () => {
                userService.createUser({
                    email: "test@example.com",
                    name: "Test User",
-                    password: "weak"
+                    password: "weak",
-                })
+                }),
            ).rejects.toThrow(ValidationError)
        })
@@ -51,15 +51,15 @@ describe("UserService", () => {
            await userService.createUser({
                email: "test@example.com",
                name: "Test User",
-                password: "password123"
+                password: "password123",
            })
            await expect(
                userService.createUser({
                    email: "test@example.com",
                    name: "Another User",
-                    password: "password123"
+                    password: "password123",
-                })
+                }),
            ).rejects.toThrow("already exists")
        })
    })
@@ -69,7 +69,7 @@ describe("UserService", () => {
            const created = await userService.createUser({
                email: "test@example.com",
                name: "Test User",
-                password: "password123"
+                password: "password123",
            })
            const found = await userService.getUserById(created.id)
@@ -87,11 +87,11 @@ describe("UserService", () => {
            const user = await userService.createUser({
                email: "test@example.com",
                name: "Test User",
-                password: "password123"
+                password: "password123",
            })
            const updated = await userService.updateUser(user.id, {
-                name: "Updated Name"
+                name: "Updated Name",
            })
            expect(updated.name).toBe("Updated Name")
@@ -99,9 +99,9 @@ describe("UserService", () => {
        })
        it("should throw error for non-existent user", async () => {
-            await expect(
+            await expect(userService.updateUser("non-existent", { name: "Test" })).rejects.toThrow(
-                userService.updateUser("non-existent", { name: "Test" })
+                "not found",
-            ).rejects.toThrow("not found")
+            )
        })
    })
@@ -110,7 +110,7 @@ describe("UserService", () => {
            const user = await userService.createUser({
                email: "test@example.com",
                name: "Test User",
-                password: "password123"
+                password: "password123",
            })
            await userService.deleteUser(user.id)
@@ -125,13 +125,13 @@ describe("UserService", () => {
            await userService.createUser({
                email: "user1@example.com",
                name: "User 1",
-                password: "password123"
+                password: "password123",
            })
            await userService.createUser({
                email: "user2@example.com",
                name: "User 2",
-                password: "password123"
+                password: "password123",
            })
            const users = await userService.listUsers()
--- a/packages/ipuaro/examples/demo-project/vitest.config.ts
+++ b/packages/ipuaro/examples/demo-project/vitest.config.ts
@@ -3,6 +3,6 @@ import { defineConfig } from "vitest/config"
 export default defineConfig({
    test: {
        globals: true,
-        environment: "node"
+        environment: "node",
-    }
+    },
 })
--- a/packages/ipuaro/package.json
+++ b/packages/ipuaro/package.json
@@ -1,6 +1,6 @@
 {
    "name": "@samiyev/ipuaro",
-    "version": "0.21.0",
+    "version": "0.29.0",
    "description": "Local AI agent for codebase operations with infinite context feeling",
    "author": "Fozilbek Samiyev <fozilbek.samiyev@gmail.com>",
    "license": "MIT",
@@ -44,7 +44,9 @@
        "simple-git": "^3.27.0",
        "tree-sitter": "^0.21.1",
        "tree-sitter-javascript": "^0.21.0",
        "tree-sitter-json": "^0.24.8",
        "tree-sitter-typescript": "^0.21.2",
        "yaml": "^2.8.2",
        "zod": "^3.23.8"
    },
    "devDependencies": {
--- a/packages/ipuaro/src/application/use-cases/ContextManager.ts
+++ b/packages/ipuaro/src/application/use-cases/ContextManager.ts
@@ -2,6 +2,7 @@ import type { ContextState, Session } from "../../domain/entities/Session.js"
 import type { ILLMClient } from "../../domain/services/ILLMClient.js"
 import { type ChatMessage, createSystemMessage } from "../../domain/value-objects/ChatMessage.js"
 import { CONTEXT_COMPRESSION_THRESHOLD, CONTEXT_WINDOW_SIZE } from "../../domain/constants/index.js"
 import type { ContextConfig } from "../../shared/constants/config.js"
 /**
 * File in context with token count.
@@ -39,9 +40,13 @@ export class ContextManager {
    private readonly filesInContext = new Map<string, FileContext>()
    private currentTokens = 0
    private readonly contextWindowSize: number
    private readonly compressionThreshold: number
    private readonly compressionMethod: "llm-summary" | "truncate"
-    constructor(contextWindowSize: number = CONTEXT_WINDOW_SIZE) {
+    constructor(contextWindowSize: number = CONTEXT_WINDOW_SIZE, config?: ContextConfig) {
        this.contextWindowSize = contextWindowSize
        this.compressionThreshold = config?.autoCompressAt ?? CONTEXT_COMPRESSION_THRESHOLD
        this.compressionMethod = config?.compressionMethod ?? "llm-summary"
    }
    /**
@@ -97,7 +102,7 @@ export class ContextManager {
     * Check if compression is needed.
     */
    needsCompression(): boolean {
-        return this.getUsage() > CONTEXT_COMPRESSION_THRESHOLD
+        return this.getUsage() > this.compressionThreshold
    }
    /**
--- a/packages/ipuaro/src/application/use-cases/ExecuteTool.ts
+++ b/packages/ipuaro/src/application/use-cases/ExecuteTool.ts
@@ -9,9 +9,21 @@ import { createUndoEntry } from "../../domain/value-objects/UndoEntry.js"
 import type { IToolRegistry } from "../interfaces/IToolRegistry.js"
 /**
- * Confirmation handler callback type.
+ * Result of confirmation dialog.
 */
-export type ConfirmationHandler = (message: string, diff?: DiffInfo) => Promise<boolean>
+export interface ConfirmationResult {
    confirmed: boolean
    editedContent?: string[]
 }
 /**
 * Confirmation handler callback type.
 * Can return either a boolean (for backward compatibility) or a ConfirmationResult.
 */
 export type ConfirmationHandler = (
    message: string,
    diff?: DiffInfo,
 ) => Promise<boolean | ConfirmationResult>
 /**
 * Progress handler callback type.
@@ -143,6 +155,7 @@ export class ExecuteTool {
    /**
     * Handle confirmation for tool actions.
     * Supports edited content from user.
     */
    private async handleConfirmation(
        msg: string,
@@ -159,9 +172,19 @@ export class ExecuteTool {
        }
        if (options.onConfirmation) {
-            const confirmed = await options.onConfirmation(msg, diff)
+            const result = await options.onConfirmation(msg, diff)
            const confirmed = typeof result === "boolean" ? result : result.confirmed
            const editedContent = typeof result === "boolean" ? undefined : result.editedContent
            if (confirmed && diff) {
                if (editedContent && editedContent.length > 0) {
                    diff.newLines = editedContent
                    if (toolCall.params.content && typeof toolCall.params.content === "string") {
                        toolCall.params.content = editedContent.join("\n")
                    }
                }
                this.lastUndoEntryId = await this.createUndoEntry(diff, toolCall, session)
            }
--- a/packages/ipuaro/src/application/use-cases/HandleMessage.ts
+++ b/packages/ipuaro/src/application/use-cases/HandleMessage.ts
@@ -22,7 +22,7 @@ import {
 import { parseToolCalls } from "../../infrastructure/llm/ResponseParser.js"
 import type { IToolRegistry } from "../interfaces/IToolRegistry.js"
 import { ContextManager } from "./ContextManager.js"
-import { ExecuteTool } from "./ExecuteTool.js"
+import { type ConfirmationResult, ExecuteTool } from "./ExecuteTool.js"
 /**
 * Status during message handling.
@@ -56,7 +56,7 @@ export interface HandleMessageEvents {
    onMessage?: (message: ChatMessage) => void
    onToolCall?: (call: ToolCall) => void
    onToolResult?: (result: ToolResult) => void
-    onConfirmation?: (message: string, diff?: DiffInfo) => Promise<boolean>
+    onConfirmation?: (message: string, diff?: DiffInfo) => Promise<boolean | ConfirmationResult>
    onError?: (error: IpuaroError) => Promise<ErrorOption>
    onStatusChange?: (status: HandleMessageStatus) => void
    onUndoEntry?: (entry: UndoEntry) => void
@@ -68,6 +68,9 @@ export interface HandleMessageEvents {
 export interface HandleMessageOptions {
    autoApply?: boolean
    maxToolCalls?: number
    maxHistoryMessages?: number
    saveInputHistory?: boolean
    contextConfig?: import("../../shared/constants/config.js").ContextConfig
 }
 const DEFAULT_MAX_TOOL_CALLS = 20
@@ -96,13 +99,14 @@ export class HandleMessage {
        llm: ILLMClient,
        tools: IToolRegistry,
        projectRoot: string,
        contextConfig?: import("../../shared/constants/config.js").ContextConfig,
    ) {
        this.storage = storage
        this.sessionStorage = sessionStorage
        this.llm = llm
        this.tools = tools
        this.projectRoot = projectRoot
-        this.contextManager = new ContextManager(llm.getContextWindowSize())
+        this.contextManager = new ContextManager(llm.getContextWindowSize(), contextConfig)
        this.executeTool = new ExecuteTool(storage, sessionStorage, tools, projectRoot)
    }
@@ -135,6 +139,15 @@ export class HandleMessage {
        this.llm.abort()
    }
    /**
     * Truncate session history if maxHistoryMessages is set.
     */
    private truncateHistoryIfNeeded(session: Session): void {
        if (this.options.maxHistoryMessages !== undefined) {
            session.truncateHistory(this.options.maxHistoryMessages)
        }
    }
    /**
     * Execute the message handling flow.
     */
@@ -145,7 +158,12 @@ export class HandleMessage {
        if (message.trim()) {
            const userMessage = createUserMessage(message)
            session.addMessage(userMessage)
-            session.addInputToHistory(message)
+            this.truncateHistoryIfNeeded(session)
            if (this.options.saveInputHistory !== false) {
                session.addInputToHistory(message)
            }
            this.emitMessage(userMessage)
        }
@@ -183,6 +201,7 @@ export class HandleMessage {
                    toolCalls: 0,
                })
                session.addMessage(assistantMessage)
                this.truncateHistoryIfNeeded(session)
                this.emitMessage(assistantMessage)
                this.contextManager.addTokens(response.tokens)
                this.contextManager.updateSession(session)
@@ -197,6 +216,7 @@ export class HandleMessage {
                toolCalls: parsed.toolCalls.length,
            })
            session.addMessage(assistantMessage)
            this.truncateHistoryIfNeeded(session)
            this.emitMessage(assistantMessage)
            toolCallCount += parsed.toolCalls.length
@@ -204,6 +224,7 @@ export class HandleMessage {
                const errorMsg = `Maximum tool calls (${String(maxToolCalls)}) exceeded`
                const errorMessage = createSystemMessage(errorMsg)
                session.addMessage(errorMessage)
                this.truncateHistoryIfNeeded(session)
                this.emitMessage(errorMessage)
                this.emitStatus("ready")
                return
@@ -227,6 +248,7 @@ export class HandleMessage {
            const toolMessage = createToolMessage(results)
            session.addMessage(toolMessage)
            this.truncateHistoryIfNeeded(session)
            this.contextManager.addTokens(response.tokens)
@@ -306,6 +328,7 @@ export class HandleMessage {
        const errorMessage = createSystemMessage(`Error: ${ipuaroError.message}`)
        session.addMessage(errorMessage)
        this.truncateHistoryIfNeeded(session)
        this.emitMessage(errorMessage)
        this.emitStatus("ready")
--- a/packages/ipuaro/src/domain/entities/Session.ts
+++ b/packages/ipuaro/src/domain/entities/Session.ts
@@ -94,6 +94,12 @@ export class Session {
        }
    }
    truncateHistory(maxMessages: number): void {
        if (this.history.length > maxMessages) {
            this.history = this.history.slice(-maxMessages)
        }
    }
    clearHistory(): void {
        this.history = []
        this.context = {
--- a/packages/ipuaro/src/domain/services/IIndexer.ts
+++ b/packages/ipuaro/src/domain/services/IIndexer.ts
@@ -21,6 +21,7 @@ export interface ScanResult {
    type: "file" | "directory" | "symlink"
    size: number
    lastModified: number
    symlinkTarget?: string
 }
 /**
@@ -46,7 +47,7 @@ export interface IIndexer {
    /**
     * Parse file content into AST.
     */
-    parseFile(content: string, language: "ts" | "tsx" | "js" | "jsx"): FileAST
+    parseFile(content: string, language: "ts" | "tsx" | "js" | "jsx" | "json" | "yaml"): FileAST
    /**
     * Analyze file and compute metadata.
--- a/packages/ipuaro/src/domain/value-objects/FileAST.ts
+++ b/packages/ipuaro/src/domain/value-objects/FileAST.ts
@@ -52,6 +52,8 @@ export interface FunctionInfo {
    isExported: boolean
    /** Return type (if available) */
    returnType?: string
    /** Decorators applied to the function (e.g., ["@Get(':id')", "@Auth()"]) */
    decorators?: string[]
 }
 export interface MethodInfo {
@@ -69,6 +71,8 @@ export interface MethodInfo {
    visibility: "public" | "private" | "protected"
    /** Whether it's static */
    isStatic: boolean
    /** Decorators applied to the method (e.g., ["@Get(':id')", "@UseGuards(AuthGuard)"]) */
    decorators?: string[]
 }
 export interface PropertyInfo {
@@ -105,6 +109,8 @@ export interface ClassInfo {
    isExported: boolean
    /** Whether class is abstract */
    isAbstract: boolean
    /** Decorators applied to the class (e.g., ["@Controller('users')", "@Injectable()"]) */
    decorators?: string[]
 }
 export interface InterfaceInfo {
@@ -129,6 +135,30 @@ export interface TypeAliasInfo {
    line: number
    /** Whether it's exported */
    isExported: boolean
    /** Type definition (e.g., "string", "User & Admin", "{ id: string }") */
    definition?: string
 }
 export interface EnumMemberInfo {
    /** Member name */
    name: string
    /** Member value (string or number, if specified) */
    value?: string | number
 }
 export interface EnumInfo {
    /** Enum name */
    name: string
    /** Start line number */
    lineStart: number
    /** End line number */
    lineEnd: number
    /** Enum members with values */
    members: EnumMemberInfo[]
    /** Whether it's exported */
    isExported: boolean
    /** Whether it's a const enum */
    isConst: boolean
 }
 export interface FileAST {
@@ -144,6 +174,8 @@ export interface FileAST {
    interfaces: InterfaceInfo[]
    /** Type alias declarations */
    typeAliases: TypeAliasInfo[]
    /** Enum declarations */
    enums: EnumInfo[]
    /** Whether parsing encountered errors */
    parseError: boolean
    /** Parse error message if any */
@@ -158,6 +190,7 @@ export function createEmptyFileAST(): FileAST {
        classes: [],
        interfaces: [],
        typeAliases: [],
        enums: [],
        parseError: false,
    }
 }
--- a/packages/ipuaro/src/domain/value-objects/FileMeta.ts
+++ b/packages/ipuaro/src/domain/value-objects/FileMeta.ts
@@ -26,6 +26,8 @@ export interface FileMeta {
    isEntryPoint: boolean
    /** File type classification */
    fileType: "source" | "test" | "config" | "types" | "unknown"
    /** Impact score (0-100): percentage of codebase that depends on this file */
    impactScore: number
 }
 export function createFileMeta(partial: Partial<FileMeta> = {}): FileMeta {
@@ -41,6 +43,7 @@ export function createFileMeta(partial: Partial<FileMeta> = {}): FileMeta {
        isHub: false,
        isEntryPoint: false,
        fileType: "unknown",
        impactScore: 0,
        ...partial,
    }
 }
@@ -48,3 +51,20 @@ export function createFileMeta(partial: Partial<FileMeta> = {}): FileMeta {
 export function isHubFile(dependentCount: number): boolean {
    return dependentCount > 5
 }
 /**
 * Calculate impact score based on number of dependents and total files.
 * Impact score represents what percentage of the codebase depends on this file.
 * @param dependentCount - Number of files that depend on this file
 * @param totalFiles - Total number of files in the project
 * @returns Impact score from 0 to 100
 */
 export function calculateImpactScore(dependentCount: number, totalFiles: number): number {
    if (totalFiles <= 1) {
        return 0
    }
    // Exclude the file itself from the total
    const maxPossibleDependents = totalFiles - 1
    const score = (dependentCount / maxPossibleDependents) * 100
    return Math.round(Math.min(100, score))
 }
--- a/packages/ipuaro/src/infrastructure/indexer/ASTParser.ts
+++ b/packages/ipuaro/src/infrastructure/indexer/ASTParser.ts
@@ -2,8 +2,11 @@ import { builtinModules } from "node:module"
 import Parser from "tree-sitter"
 import TypeScript from "tree-sitter-typescript"
 import JavaScript from "tree-sitter-javascript"
 import JSON from "tree-sitter-json"
 import * as yamlParser from "yaml"
 import {
    createEmptyFileAST,
    type EnumMemberInfo,
    type ExportInfo,
    type FileAST,
    type ImportInfo,
@@ -13,7 +16,7 @@ import {
 } from "../../domain/value-objects/FileAST.js"
 import { FieldName, NodeType } from "./tree-sitter-types.js"
-type Language = "ts" | "tsx" | "js" | "jsx"
+type Language = "ts" | "tsx" | "js" | "jsx" | "json" | "yaml"
 type SyntaxNode = Parser.SyntaxNode
 /**
@@ -39,12 +42,20 @@ export class ASTParser {
        jsParser.setLanguage(JavaScript)
        this.parsers.set("js", jsParser)
        this.parsers.set("jsx", jsParser)
        const jsonParser = new Parser()
        jsonParser.setLanguage(JSON)
        this.parsers.set("json", jsonParser)
    }
    /**
     * Parse source code and extract AST information.
     */
    parse(content: string, language: Language): FileAST {
        if (language === "yaml") {
            return this.parseYAML(content)
        }
        const parser = this.parsers.get(language)
        if (!parser) {
            return {
@@ -75,8 +86,77 @@ export class ASTParser {
        }
    }
    /**
     * Parse YAML content using yaml package.
     */
    private parseYAML(content: string): FileAST {
        const ast = createEmptyFileAST()
        try {
            const doc = yamlParser.parseDocument(content)
            if (doc.errors.length > 0) {
                return {
                    ...createEmptyFileAST(),
                    parseError: true,
                    parseErrorMessage: doc.errors[0].message,
                }
            }
            const contents = doc.contents
            if (yamlParser.isSeq(contents)) {
                ast.exports.push({
                    name: "(array)",
                    line: 1,
                    isDefault: false,
                    kind: "variable",
                })
            } else if (yamlParser.isMap(contents)) {
                for (const item of contents.items) {
                    if (yamlParser.isPair(item) && yamlParser.isScalar(item.key)) {
                        const keyRange = item.key.range
                        const line = keyRange ? this.getLineFromOffset(content, keyRange[0]) : 1
                        ast.exports.push({
                            name: String(item.key.value),
                            line,
                            isDefault: false,
                            kind: "variable",
                        })
                    }
                }
            }
            return ast
        } catch (error) {
            return {
                ...createEmptyFileAST(),
                parseError: true,
                parseErrorMessage: error instanceof Error ? error.message : "YAML parse error",
            }
        }
    }
    /**
     * Get line number from character offset.
     */
    private getLineFromOffset(content: string, offset: number): number {
        let line = 1
        for (let i = 0; i < offset && i < content.length; i++) {
            if (content[i] === "\n") {
                line++
            }
        }
        return line
    }
    private extractAST(root: SyntaxNode, language: Language): FileAST {
        const ast = createEmptyFileAST()
        if (language === "json") {
            return this.extractJSONStructure(root, ast)
        }
        const isTypeScript = language === "ts" || language === "tsx"
        for (const child of root.children) {
@@ -113,6 +193,11 @@ export class ASTParser {
                    this.extractTypeAlias(node, ast, false)
                }
                break
            case NodeType.ENUM_DECLARATION:
                if (isTypeScript) {
                    this.extractEnum(node, ast, false)
                }
                break
        }
    }
@@ -179,13 +264,15 @@ export class ASTParser {
        const declaration = node.childForFieldName(FieldName.DECLARATION)
        if (declaration) {
            const decorators = this.extractDecoratorsFromSiblings(declaration)
            switch (declaration.type) {
                case NodeType.FUNCTION_DECLARATION:
-                    this.extractFunction(declaration, ast, true)
+                    this.extractFunction(declaration, ast, true, decorators)
                    this.addExportInfo(ast, declaration, "function", isDefault)
                    break
                case NodeType.CLASS_DECLARATION:
-                    this.extractClass(declaration, ast, true)
+                    this.extractClass(declaration, ast, true, decorators)
                    this.addExportInfo(ast, declaration, "class", isDefault)
                    break
                case NodeType.INTERFACE_DECLARATION:
@@ -196,6 +283,10 @@ export class ASTParser {
                    this.extractTypeAlias(declaration, ast, true)
                    this.addExportInfo(ast, declaration, "type", isDefault)
                    break
                case NodeType.ENUM_DECLARATION:
                    this.extractEnum(declaration, ast, true)
                    this.addExportInfo(ast, declaration, "type", isDefault)
                    break
                case NodeType.LEXICAL_DECLARATION:
                    this.extractLexicalDeclaration(declaration, ast, true)
                    break
@@ -220,7 +311,12 @@ export class ASTParser {
        }
    }
-    private extractFunction(node: SyntaxNode, ast: FileAST, isExported: boolean): void {
+    private extractFunction(
        node: SyntaxNode,
        ast: FileAST,
        isExported: boolean,
        externalDecorators: string[] = [],
    ): void {
        const nameNode = node.childForFieldName(FieldName.NAME)
        if (!nameNode) {
            return
@@ -230,6 +326,9 @@ export class ASTParser {
        const isAsync = node.children.some((c) => c.type === NodeType.ASYNC)
        const returnTypeNode = node.childForFieldName(FieldName.RETURN_TYPE)
        const nodeDecorators = this.extractNodeDecorators(node)
        const decorators = [...externalDecorators, ...nodeDecorators]
        ast.functions.push({
            name: nameNode.text,
            lineStart: node.startPosition.row + 1,
@@ -238,6 +337,7 @@ export class ASTParser {
            isAsync,
            isExported,
            returnType: returnTypeNode?.text?.replace(/^:\s*/, ""),
            decorators,
        })
    }
@@ -253,6 +353,7 @@ export class ASTParser {
                ) {
                    const params = this.extractParameters(valueNode)
                    const isAsync = valueNode.children.some((c) => c.type === NodeType.ASYNC)
                    const returnTypeNode = valueNode.childForFieldName(FieldName.RETURN_TYPE)
                    ast.functions.push({
                        name: nameNode?.text ?? "",
@@ -261,6 +362,8 @@ export class ASTParser {
                        params,
                        isAsync,
                        isExported,
                        returnType: returnTypeNode?.text?.replace(/^:\s*/, ""),
                        decorators: [],
                    })
                    if (isExported) {
@@ -283,7 +386,12 @@ export class ASTParser {
        }
    }
-    private extractClass(node: SyntaxNode, ast: FileAST, isExported: boolean): void {
+    private extractClass(
        node: SyntaxNode,
        ast: FileAST,
        isExported: boolean,
        externalDecorators: string[] = [],
    ): void {
        const nameNode = node.childForFieldName(FieldName.NAME)
        if (!nameNode) {
            return
@@ -294,14 +402,19 @@ export class ASTParser {
        const properties: PropertyInfo[] = []
        if (body) {
            let pendingDecorators: string[] = []
            for (const member of body.children) {
-                if (member.type === NodeType.METHOD_DEFINITION) {
+                if (member.type === NodeType.DECORATOR) {
-                    methods.push(this.extractMethod(member))
+                    pendingDecorators.push(this.formatDecorator(member))
                } else if (member.type === NodeType.METHOD_DEFINITION) {
                    methods.push(this.extractMethod(member, pendingDecorators))
                    pendingDecorators = []
                } else if (
                    member.type === NodeType.PUBLIC_FIELD_DEFINITION ||
                    member.type === NodeType.FIELD_DEFINITION
                ) {
                    properties.push(this.extractProperty(member))
                    pendingDecorators = []
                }
            }
        }
@@ -309,6 +422,9 @@ export class ASTParser {
        const { extendsName, implementsList } = this.extractClassHeritage(node)
        const isAbstract = node.children.some((c) => c.type === NodeType.ABSTRACT)
        const nodeDecorators = this.extractNodeDecorators(node)
        const decorators = [...externalDecorators, ...nodeDecorators]
        ast.classes.push({
            name: nameNode.text,
            lineStart: node.startPosition.row + 1,
@@ -319,6 +435,7 @@ export class ASTParser {
            implements: implementsList,
            isExported,
            isAbstract,
            decorators,
        })
    }
@@ -372,7 +489,7 @@ export class ASTParser {
        }
    }
-    private extractMethod(node: SyntaxNode): MethodInfo {
+    private extractMethod(node: SyntaxNode, decorators: string[] = []): MethodInfo {
        const nameNode = node.childForFieldName(FieldName.NAME)
        const params = this.extractParameters(node)
        const isAsync = node.children.some((c) => c.type === NodeType.ASYNC)
@@ -394,6 +511,7 @@ export class ASTParser {
            isAsync,
            visibility,
            isStatic,
            decorators,
        }
    }
@@ -473,13 +591,86 @@ export class ASTParser {
            return
        }
        const valueNode = node.childForFieldName(FieldName.VALUE)
        const definition = valueNode?.text
        ast.typeAliases.push({
            name: nameNode.text,
            line: node.startPosition.row + 1,
            isExported,
            definition,
        })
    }
    private extractEnum(node: SyntaxNode, ast: FileAST, isExported: boolean): void {
        const nameNode = node.childForFieldName(FieldName.NAME)
        if (!nameNode) {
            return
        }
        const body = node.childForFieldName(FieldName.BODY)
        const members: EnumMemberInfo[] = []
        if (body) {
            for (const child of body.children) {
                if (child.type === NodeType.ENUM_ASSIGNMENT) {
                    const memberName = child.childForFieldName(FieldName.NAME)
                    const memberValue = child.childForFieldName(FieldName.VALUE)
                    if (memberName) {
                        members.push({
                            name: memberName.text,
                            value: this.parseEnumValue(memberValue),
                        })
                    }
                } else if (
                    child.type === NodeType.IDENTIFIER ||
                    child.type === NodeType.PROPERTY_IDENTIFIER
                ) {
                    members.push({
                        name: child.text,
                        value: undefined,
                    })
                }
            }
        }
        const isConst = node.children.some((c) => c.text === "const")
        ast.enums.push({
            name: nameNode.text,
            lineStart: node.startPosition.row + 1,
            lineEnd: node.endPosition.row + 1,
            members,
            isExported,
            isConst,
        })
    }
    private parseEnumValue(valueNode: SyntaxNode | null): string | number | undefined {
        if (!valueNode) {
            return undefined
        }
        const text = valueNode.text
        if (valueNode.type === "number") {
            return Number(text)
        }
        if (valueNode.type === "string") {
            return this.getStringValue(valueNode)
        }
        if (valueNode.type === "unary_expression" && text.startsWith("-")) {
            const num = Number(text)
            if (!isNaN(num)) {
                return num
            }
        }
        return text
    }
    private extractParameters(node: SyntaxNode): ParameterInfo[] {
        const params: ParameterInfo[] = []
        const paramsNode = node.childForFieldName(FieldName.PARAMETERS)
@@ -528,6 +719,49 @@ export class ASTParser {
        }
    }
    /**
     * Format a decorator node to a string like "@Get(':id')" or "@Injectable()".
     */
    private formatDecorator(node: SyntaxNode): string {
        return node.text.replace(/\s+/g, " ").trim()
    }
    /**
     * Extract decorators that are direct children of a node.
     * In tree-sitter, decorators are children of the class/function declaration.
     */
    private extractNodeDecorators(node: SyntaxNode): string[] {
        const decorators: string[] = []
        for (const child of node.children) {
            if (child.type === NodeType.DECORATOR) {
                decorators.push(this.formatDecorator(child))
            }
        }
        return decorators
    }
    /**
     * Extract decorators from sibling nodes before the current node.
     * Decorators appear as children before the declaration in export statements.
     */
    private extractDecoratorsFromSiblings(node: SyntaxNode): string[] {
        const decorators: string[] = []
        const parent = node.parent
        if (!parent) {
            return decorators
        }
        for (const sibling of parent.children) {
            if (sibling.type === NodeType.DECORATOR) {
                decorators.push(this.formatDecorator(sibling))
            } else if (sibling === node) {
                break
            }
        }
        return decorators
    }
    private classifyImport(from: string): ImportInfo["type"] {
        if (from.startsWith(".") || from.startsWith("/")) {
            return "internal"
@@ -548,4 +782,37 @@ export class ASTParser {
        }
        return text
    }
    /**
     * Extract structure from JSON file.
     * For JSON files, we extract top-level keys from objects.
     */
    private extractJSONStructure(root: SyntaxNode, ast: FileAST): FileAST {
        for (const child of root.children) {
            if (child.type === "object") {
                this.extractJSONKeys(child, ast)
            }
        }
        return ast
    }
    /**
     * Extract keys from JSON object.
     */
    private extractJSONKeys(node: SyntaxNode, ast: FileAST): void {
        for (const child of node.children) {
            if (child.type === "pair") {
                const keyNode = child.childForFieldName("key")
                if (keyNode) {
                    const keyName = this.getStringValue(keyNode)
                    ast.exports.push({
                        name: keyName,
                        line: keyNode.startPosition.row + 1,
                        isDefault: false,
                        kind: "variable",
                    })
                }
            }
        }
    }
 }
--- a/packages/ipuaro/src/infrastructure/indexer/FileScanner.ts
+++ b/packages/ipuaro/src/infrastructure/indexer/FileScanner.ts
@@ -96,12 +96,27 @@ export class FileScanner {
            const stats = await this.safeStats(fullPath)
            if (stats) {
-                yield {
+                const type = stats.isSymbolicLink()
                    ? "symlink"
                    : stats.isDirectory()
                      ? "directory"
                      : "file"
                const result: ScanResult = {
                    path: relativePath,
-                    type: "file",
+                    type,
                    size: stats.size,
                    lastModified: stats.mtimeMs,
                }
                if (type === "symlink") {
                    const target = await this.safeReadlink(fullPath)
                    if (target) {
                        result.symlinkTarget = target
                    }
                }
                yield result
            }
        }
    }
@@ -127,10 +142,22 @@ export class FileScanner {
    /**
     * Safely get file stats without throwing.
     * Uses lstat to get information about symlinks themselves.
     */
    private async safeStats(filePath: string): Promise<Stats | null> {
        try {
-            return await fs.stat(filePath)
+            return await fs.lstat(filePath)
        } catch {
            return null
        }
    }
    /**
     * Safely read symlink target without throwing.
     */
    private async safeReadlink(filePath: string): Promise<string | null> {
        try {
            return await fs.readlink(filePath)
        } catch {
            return null
        }
--- a/packages/ipuaro/src/infrastructure/indexer/MetaAnalyzer.ts
+++ b/packages/ipuaro/src/infrastructure/indexer/MetaAnalyzer.ts
@@ -1,5 +1,6 @@
 import * as path from "node:path"
 import {
    calculateImpactScore,
    type ComplexityMetrics,
    createFileMeta,
    type FileMeta,
@@ -430,6 +431,7 @@ export class MetaAnalyzer {
    /**
     * Batch analyze multiple files.
     * Computes impact scores after all files are analyzed.
     */
    analyzeAll(files: Map<string, { ast: FileAST; content: string }>): Map<string, FileMeta> {
        const allASTs = new Map<string, FileAST>()
@@ -443,6 +445,12 @@ export class MetaAnalyzer {
            results.set(filePath, meta)
        }
        // Compute impact scores now that we know total file count
        const totalFiles = results.size
        for (const [, meta] of results) {
            meta.impactScore = calculateImpactScore(meta.dependents.length, totalFiles)
        }
        return results
    }
 }
--- a/packages/ipuaro/src/infrastructure/indexer/tree-sitter-types.ts
+++ b/packages/ipuaro/src/infrastructure/indexer/tree-sitter-types.ts
@@ -16,6 +16,7 @@ export const NodeType = {
    CLASS_DECLARATION: "class_declaration",
    INTERFACE_DECLARATION: "interface_declaration",
    TYPE_ALIAS_DECLARATION: "type_alias_declaration",
    ENUM_DECLARATION: "enum_declaration",
    // Clauses
    IMPORT_CLAUSE: "import_clause",
@@ -37,6 +38,11 @@ export const NodeType = {
    FIELD_DEFINITION: "field_definition",
    PROPERTY_SIGNATURE: "property_signature",
    // Enum members
    ENUM_BODY: "enum_body",
    ENUM_ASSIGNMENT: "enum_assignment",
    PROPERTY_IDENTIFIER: "property_identifier",
    // Parameters
    REQUIRED_PARAMETER: "required_parameter",
    OPTIONAL_PARAMETER: "optional_parameter",
@@ -57,6 +63,9 @@ export const NodeType = {
    DEFAULT: "default",
    ACCESSIBILITY_MODIFIER: "accessibility_modifier",
    READONLY: "readonly",
    // Decorators
    DECORATOR: "decorator",
 } as const
 export type NodeTypeValue = (typeof NodeType)[keyof typeof NodeType]
--- a/packages/ipuaro/src/infrastructure/llm/prompts.ts
+++ b/packages/ipuaro/src/infrastructure/llm/prompts.ts
@@ -11,6 +11,17 @@ export interface ProjectStructure {
    directories: string[]
 }
 /**
 * Options for building initial context.
 */
 export interface BuildContextOptions {
    includeSignatures?: boolean
    includeDepsGraph?: boolean
    includeCircularDeps?: boolean
    includeHighImpactFiles?: boolean
    circularDeps?: string[][]
 }
 /**
 * System prompt for the ipuaro AI agent.
 */
@@ -116,12 +127,38 @@ export function buildInitialContext(
    structure: ProjectStructure,
    asts: Map<string, FileAST>,
    metas?: Map<string, FileMeta>,
    options?: BuildContextOptions,
 ): string {
    const sections: string[] = []
    const includeSignatures = options?.includeSignatures ?? true
    const includeDepsGraph = options?.includeDepsGraph ?? true
    const includeCircularDeps = options?.includeCircularDeps ?? true
    const includeHighImpactFiles = options?.includeHighImpactFiles ?? true
    sections.push(formatProjectHeader(structure))
    sections.push(formatDirectoryTree(structure))
-    sections.push(formatFileOverview(asts, metas))
+    sections.push(formatFileOverview(asts, metas, includeSignatures))
    if (includeDepsGraph && metas && metas.size > 0) {
        const depsGraph = formatDependencyGraph(metas)
        if (depsGraph) {
            sections.push(depsGraph)
        }
    }
    if (includeHighImpactFiles && metas && metas.size > 0) {
        const highImpactSection = formatHighImpactFiles(metas)
        if (highImpactSection) {
            sections.push(highImpactSection)
        }
    }
    if (includeCircularDeps && options?.circularDeps && options.circularDeps.length > 0) {
        const circularDepsSection = formatCircularDeps(options.circularDeps)
        if (circularDepsSection) {
            sections.push(circularDepsSection)
        }
    }
    return sections.join("\n\n")
 }
@@ -157,7 +194,11 @@ function formatDirectoryTree(structure: ProjectStructure): string {
 /**
 * Format file overview with AST summaries.
 */
-function formatFileOverview(asts: Map<string, FileAST>, metas?: Map<string, FileMeta>): string {
+function formatFileOverview(
    asts: Map<string, FileAST>,
    metas?: Map<string, FileMeta>,
    includeSignatures = true,
 ): string {
    const lines: string[] = ["## Files", ""]
    const sortedPaths = [...asts.keys()].sort()
@@ -168,16 +209,183 @@ function formatFileOverview(asts: Map<string, FileAST>, metas?: Map<string, File
        }
        const meta = metas?.get(path)
-        lines.push(formatFileSummary(path, ast, meta))
+        lines.push(formatFileSummary(path, ast, meta, includeSignatures))
    }
    return lines.join("\n")
 }
 /**
- * Format a single file's AST summary.
+ * Format decorators as a prefix string.
 * Example: "@Get(':id') @Auth() "
 */
-function formatFileSummary(path: string, ast: FileAST, meta?: FileMeta): string {
+function formatDecoratorsPrefix(decorators: string[] | undefined): string {
    if (!decorators || decorators.length === 0) {
        return ""
    }
    return `${decorators.join(" ")} `
 }
 /**
 * Format a function signature.
 */
 function formatFunctionSignature(fn: FileAST["functions"][0]): string {
    const decoratorsPrefix = formatDecoratorsPrefix(fn.decorators)
    const asyncPrefix = fn.isAsync ? "async " : ""
    const params = fn.params
        .map((p) => {
            const optional = p.optional ? "?" : ""
            const type = p.type ? `: ${p.type}` : ""
            return `${p.name}${optional}${type}`
        })
        .join(", ")
    const returnType = fn.returnType ? `: ${fn.returnType}` : ""
    return `${decoratorsPrefix}${asyncPrefix}${fn.name}(${params})${returnType}`
 }
 /**
 * Format an interface signature with fields.
 * Example: "interface User extends Base { id: string, name: string, email?: string }"
 */
 function formatInterfaceSignature(iface: FileAST["interfaces"][0]): string {
    const extList = iface.extends ?? []
    const ext = extList.length > 0 ? ` extends ${extList.join(", ")}` : ""
    if (iface.properties.length === 0) {
        return `interface ${iface.name}${ext}`
    }
    const fields = iface.properties
        .map((p) => {
            const readonly = p.isReadonly ? "readonly " : ""
            const optional = p.name.endsWith("?") ? "" : ""
            const type = p.type ? `: ${p.type}` : ""
            return `${readonly}${p.name}${optional}${type}`
        })
        .join(", ")
    return `interface ${iface.name}${ext} { ${fields} }`
 }
 /**
 * Format a type alias signature with definition.
 * Example: "type UserId = string" or "type Handler = (event: Event) => void"
 */
 function formatTypeAliasSignature(type: FileAST["typeAliases"][0]): string {
    if (!type.definition) {
        return `type ${type.name}`
    }
    const definition = truncateDefinition(type.definition, 80)
    return `type ${type.name} = ${definition}`
 }
 /**
 * Format an enum signature with members and values.
 * Example: "enum Status { Active=1, Inactive=0, Pending=2 }"
 * Example: "const enum Role { Admin="admin", User="user" }"
 */
 function formatEnumSignature(enumInfo: FileAST["enums"][0]): string {
    const constPrefix = enumInfo.isConst ? "const " : ""
    if (enumInfo.members.length === 0) {
        return `${constPrefix}enum ${enumInfo.name}`
    }
    const membersStr = enumInfo.members
        .map((m) => {
            if (m.value === undefined) {
                return m.name
            }
            const valueStr = typeof m.value === "string" ? `"${m.value}"` : String(m.value)
            return `${m.name}=${valueStr}`
        })
        .join(", ")
    const result = `${constPrefix}enum ${enumInfo.name} { ${membersStr} }`
    if (result.length > 100) {
        return truncateDefinition(result, 100)
    }
    return result
 }
 /**
 * Truncate long type definitions for display.
 */
 function truncateDefinition(definition: string, maxLength: number): string {
    const normalized = definition.replace(/\s+/g, " ").trim()
    if (normalized.length <= maxLength) {
        return normalized
    }
    return `${normalized.slice(0, maxLength - 3)}...`
 }
 /**
 * Format a single file's AST summary.
 * When includeSignatures is true, shows full function signatures.
 * When false, shows compact format with just names.
 */
 function formatFileSummary(
    path: string,
    ast: FileAST,
    meta?: FileMeta,
    includeSignatures = true,
 ): string {
    const flags = formatFileFlags(meta)
    if (!includeSignatures) {
        return formatFileSummaryCompact(path, ast, flags)
    }
    const lines: string[] = []
    lines.push(`### ${path}${flags}`)
    if (ast.functions.length > 0) {
        for (const fn of ast.functions) {
            lines.push(`- ${formatFunctionSignature(fn)}`)
        }
    }
    if (ast.classes.length > 0) {
        for (const cls of ast.classes) {
            const decoratorsPrefix = formatDecoratorsPrefix(cls.decorators)
            const ext = cls.extends ? ` extends ${cls.extends}` : ""
            const impl = cls.implements.length > 0 ? ` implements ${cls.implements.join(", ")}` : ""
            lines.push(`- ${decoratorsPrefix}class ${cls.name}${ext}${impl}`)
        }
    }
    if (ast.interfaces.length > 0) {
        for (const iface of ast.interfaces) {
            lines.push(`- ${formatInterfaceSignature(iface)}`)
        }
    }
    if (ast.typeAliases.length > 0) {
        for (const type of ast.typeAliases) {
            lines.push(`- ${formatTypeAliasSignature(type)}`)
        }
    }
    if (ast.enums && ast.enums.length > 0) {
        for (const enumInfo of ast.enums) {
            lines.push(`- ${formatEnumSignature(enumInfo)}`)
        }
    }
    if (lines.length === 1) {
        return `- ${path}${flags}`
    }
    return lines.join("\n")
 }
 /**
 * Format file summary in compact mode (just names, no signatures).
 */
 function formatFileSummaryCompact(path: string, ast: FileAST, flags: string): string {
    const parts: string[] = []
    if (ast.functions.length > 0) {
@@ -200,9 +408,12 @@ function formatFileSummary(path: string, ast: FileAST, meta?: FileMeta): string
        parts.push(`type: ${names}`)
    }
-    const summary = parts.length > 0 ? ` [${parts.join(" | ")}]` : ""
+    if (ast.enums && ast.enums.length > 0) {
-    const flags = formatFileFlags(meta)
+        const names = ast.enums.map((e) => e.name).join(", ")
        parts.push(`enum: ${names}`)
    }
    const summary = parts.length > 0 ? ` [${parts.join(" | ")}]` : ""
    return `- ${path}${summary}${flags}`
 }
@@ -231,6 +442,209 @@ function formatFileFlags(meta?: FileMeta): string {
    return flags.length > 0 ? ` (${flags.join(", ")})` : ""
 }
 /**
 * Shorten a file path for display in dependency graph.
 * Removes common prefixes like "src/" and file extensions.
 */
 function shortenPath(path: string): string {
    let short = path
    if (short.startsWith("src/")) {
        short = short.slice(4)
    }
    // Remove common extensions
    short = short.replace(/\.(ts|tsx|js|jsx)$/, "")
    // Remove /index suffix
    short = short.replace(/\/index$/, "")
    return short
 }
 /**
 * Format a single dependency graph entry.
 * Format: "path: → dep1, dep2 ← dependent1, dependent2"
 */
 function formatDepsEntry(path: string, dependencies: string[], dependents: string[]): string {
    const parts: string[] = []
    const shortPath = shortenPath(path)
    if (dependencies.length > 0) {
        const deps = dependencies.map(shortenPath).join(", ")
        parts.push(`→ ${deps}`)
    }
    if (dependents.length > 0) {
        const deps = dependents.map(shortenPath).join(", ")
        parts.push(`← ${deps}`)
    }
    if (parts.length === 0) {
        return ""
    }
    return `${shortPath}: ${parts.join(" ")}`
 }
 /**
 * Format dependency graph for all files.
 * Shows hub files first, then files with dependencies/dependents.
 *
 * Format:
 * ## Dependency Graph
 * services/user: → types/user, utils/validation ← controllers/user
 * services/auth: → services/user, utils/jwt ← controllers/auth
 */
 export function formatDependencyGraph(metas: Map<string, FileMeta>): string | null {
    if (metas.size === 0) {
        return null
    }
    const entries: { path: string; deps: string[]; dependents: string[]; isHub: boolean }[] = []
    for (const [path, meta] of metas) {
        // Only include files that have connections
        if (meta.dependencies.length > 0 || meta.dependents.length > 0) {
            entries.push({
                path,
                deps: meta.dependencies,
                dependents: meta.dependents,
                isHub: meta.isHub,
            })
        }
    }
    if (entries.length === 0) {
        return null
    }
    // Sort: hubs first, then by total connections (desc), then by path
    entries.sort((a, b) => {
        if (a.isHub !== b.isHub) {
            return a.isHub ? -1 : 1
        }
        const aTotal = a.deps.length + a.dependents.length
        const bTotal = b.deps.length + b.dependents.length
        if (aTotal !== bTotal) {
            return bTotal - aTotal
        }
        return a.path.localeCompare(b.path)
    })
    const lines: string[] = ["## Dependency Graph", ""]
    for (const entry of entries) {
        const line = formatDepsEntry(entry.path, entry.deps, entry.dependents)
        if (line) {
            lines.push(line)
        }
    }
    // Return null if only header (no actual entries)
    if (lines.length <= 2) {
        return null
    }
    return lines.join("\n")
 }
 /**
 * Format circular dependencies for display in context.
 * Shows warning section with cycle chains.
 *
 * Format:
 * ## ⚠️ Circular Dependencies
 * - services/user → services/auth → services/user
 * - utils/a → utils/b → utils/c → utils/a
 */
 export function formatCircularDeps(cycles: string[][]): string | null {
    if (!cycles || cycles.length === 0) {
        return null
    }
    const lines: string[] = ["## ⚠️ Circular Dependencies", ""]
    for (const cycle of cycles) {
        if (cycle.length === 0) {
            continue
        }
        const formattedCycle = cycle.map(shortenPath).join(" → ")
        lines.push(`- ${formattedCycle}`)
    }
    // Return null if only header (no actual cycles)
    if (lines.length <= 2) {
        return null
    }
    return lines.join("\n")
 }
 /**
 * Format high impact files table for display in context.
 * Shows files with highest impact scores (most dependents).
 *
 * Format:
 * ## High Impact Files
 * | File | Impact | Dependents |
 * |------|--------|------------|
 * | src/utils/validation.ts | 67% | 12 files |
 *
 * @param metas - Map of file paths to their metadata
 * @param limit - Maximum number of files to show (default: 10)
 * @param minImpact - Minimum impact score to include (default: 5)
 */
 export function formatHighImpactFiles(
    metas: Map<string, FileMeta>,
    limit = 10,
    minImpact = 5,
 ): string | null {
    if (metas.size === 0) {
        return null
    }
    // Collect files with impact score >= minImpact
    const impactFiles: { path: string; impact: number; dependents: number }[] = []
    for (const [path, meta] of metas) {
        if (meta.impactScore >= minImpact) {
            impactFiles.push({
                path,
                impact: meta.impactScore,
                dependents: meta.dependents.length,
            })
        }
    }
    if (impactFiles.length === 0) {
        return null
    }
    // Sort by impact score descending, then by path
    impactFiles.sort((a, b) => {
        if (a.impact !== b.impact) {
            return b.impact - a.impact
        }
        return a.path.localeCompare(b.path)
    })
    // Take top N files
    const topFiles = impactFiles.slice(0, limit)
    const lines: string[] = [
        "## High Impact Files",
        "",
        "| File | Impact | Dependents |",
        "|------|--------|------------|",
    ]
    for (const file of topFiles) {
        const shortPath = shortenPath(file.path)
        const impact = `${String(file.impact)}%`
        const dependents = file.dependents === 1 ? "1 file" : `${String(file.dependents)} files`
        lines.push(`| ${shortPath} | ${impact} | ${dependents} |`)
    }
    return lines.join("\n")
 }
 /**
 * Format line range for display.
 */
--- a/packages/ipuaro/src/infrastructure/tools/run/RunCommandTool.ts
+++ b/packages/ipuaro/src/infrastructure/tools/run/RunCommandTool.ts
@@ -6,6 +6,7 @@ import {
    createSuccessResult,
    type ToolResult,
 } from "../../../domain/value-objects/ToolResult.js"
 import type { CommandsConfig } from "../../../shared/constants/config.js"
 import { CommandSecurity } from "./CommandSecurity.js"
 const execAsync = promisify(exec)
@@ -60,7 +61,7 @@ export class RunCommandTool implements ITool {
        {
            name: "timeout",
            type: "number",
-            description: "Timeout in milliseconds (default: 30000)",
+            description: "Timeout in milliseconds (default: from config or 30000, max: 600000)",
            required: false,
        },
    ]
@@ -69,10 +70,12 @@ export class RunCommandTool implements ITool {
    private readonly security: CommandSecurity
    private readonly execFn: typeof execAsync
    private readonly configTimeout: number | null
-    constructor(security?: CommandSecurity, execFn?: typeof execAsync) {
+    constructor(security?: CommandSecurity, execFn?: typeof execAsync, config?: CommandsConfig) {
        this.security = security ?? new CommandSecurity()
        this.execFn = execFn ?? execAsync
        this.configTimeout = config?.timeout ?? null
    }
    validateParams(params: Record<string, unknown>): string | null {
@@ -104,7 +107,7 @@ export class RunCommandTool implements ITool {
        const callId = `${this.name}-${String(startTime)}`
        const command = params.command as string
-        const timeout = (params.timeout as number) ?? DEFAULT_TIMEOUT
+        const timeout = (params.timeout as number) ?? this.configTimeout ?? DEFAULT_TIMEOUT
        const securityCheck = this.security.check(command)
--- a/packages/ipuaro/src/shared/constants/config.ts
+++ b/packages/ipuaro/src/shared/constants/config.ts
@@ -76,6 +76,64 @@ export const UndoConfigSchema = z.object({
 */
 export const EditConfigSchema = z.object({
    autoApply: z.boolean().default(false),
    syntaxHighlight: z.boolean().default(true),
 })
 /**
 * Input configuration schema.
 */
 export const InputConfigSchema = z.object({
    multiline: z.union([z.boolean(), z.literal("auto")]).default(false),
 })
 /**
 * Display configuration schema.
 */
 export const DisplayConfigSchema = z.object({
    showStats: z.boolean().default(true),
    showToolCalls: z.boolean().default(true),
    theme: z.enum(["dark", "light"]).default("dark"),
    bellOnComplete: z.boolean().default(false),
    progressBar: z.boolean().default(true),
 })
 /**
 * Session configuration schema.
 */
 export const SessionConfigSchema = z.object({
    persistIndefinitely: z.boolean().default(true),
    maxHistoryMessages: z.number().int().positive().default(100),
    saveInputHistory: z.boolean().default(true),
 })
 /**
 * Context configuration schema.
 */
 export const ContextConfigSchema = z.object({
    systemPromptTokens: z.number().int().positive().default(2000),
    maxContextUsage: z.number().min(0).max(1).default(0.8),
    autoCompressAt: z.number().min(0).max(1).default(0.8),
    compressionMethod: z.enum(["llm-summary", "truncate"]).default("llm-summary"),
    includeSignatures: z.boolean().default(true),
    includeDepsGraph: z.boolean().default(true),
    includeCircularDeps: z.boolean().default(true),
    includeHighImpactFiles: z.boolean().default(true),
 })
 /**
 * Autocomplete configuration schema.
 */
 export const AutocompleteConfigSchema = z.object({
    enabled: z.boolean().default(true),
    source: z.enum(["redis-index", "filesystem", "both"]).default("redis-index"),
    maxSuggestions: z.number().int().positive().default(10),
 })
 /**
 * Commands configuration schema.
 */
 export const CommandsConfigSchema = z.object({
    timeout: z.number().int().positive().nullable().default(null),
 })
 /**
@@ -88,6 +146,12 @@ export const ConfigSchema = z.object({
    watchdog: WatchdogConfigSchema.default({}),
    undo: UndoConfigSchema.default({}),
    edit: EditConfigSchema.default({}),
    input: InputConfigSchema.default({}),
    display: DisplayConfigSchema.default({}),
    session: SessionConfigSchema.default({}),
    context: ContextConfigSchema.default({}),
    autocomplete: AutocompleteConfigSchema.default({}),
    commands: CommandsConfigSchema.default({}),
 })
 /**
@@ -100,6 +164,12 @@ export type ProjectConfig = z.infer<typeof ProjectConfigSchema>
 export type WatchdogConfig = z.infer<typeof WatchdogConfigSchema>
 export type UndoConfig = z.infer<typeof UndoConfigSchema>
 export type EditConfig = z.infer<typeof EditConfigSchema>
 export type InputConfig = z.infer<typeof InputConfigSchema>
 export type DisplayConfig = z.infer<typeof DisplayConfigSchema>
 export type SessionConfig = z.infer<typeof SessionConfigSchema>
 export type ContextConfig = z.infer<typeof ContextConfigSchema>
 export type AutocompleteConfig = z.infer<typeof AutocompleteConfigSchema>
 export type CommandsConfig = z.infer<typeof CommandsConfigSchema>
 /**
 * Default configuration.
--- a/packages/ipuaro/src/tui/App.tsx
+++ b/packages/ipuaro/src/tui/App.tsx
@@ -10,11 +10,15 @@ import type { ISessionStorage } from "../domain/services/ISessionStorage.js"
 import type { IStorage } from "../domain/services/IStorage.js"
 import type { DiffInfo } from "../domain/services/ITool.js"
 import type { ErrorOption } from "../shared/errors/IpuaroError.js"
 import type { Config } from "../shared/constants/config.js"
 import type { IToolRegistry } from "../application/interfaces/IToolRegistry.js"
 import type { ConfirmationResult } from "../application/use-cases/ExecuteTool.js"
 import type { ProjectStructure } from "../infrastructure/llm/prompts.js"
-import { Chat, Input, StatusBar } from "./components/index.js"
+import { Chat, ConfirmDialog, Input, StatusBar } from "./components/index.js"
 import { type CommandResult, useCommands, useHotkeys, useSession } from "./hooks/index.js"
 import type { AppProps, BranchInfo } from "./types.js"
 import type { ConfirmChoice } from "../shared/types/index.js"
 import { ringBell } from "./utils/bell.js"
 export interface AppDependencies {
    storage: IStorage
@@ -22,11 +26,18 @@ export interface AppDependencies {
    llm: ILLMClient
    tools: IToolRegistry
    projectStructure?: ProjectStructure
    config?: Config
 }
 export interface ExtendedAppProps extends AppProps {
    deps: AppDependencies
    onExit?: () => void
    multiline?: boolean | "auto"
    syntaxHighlight?: boolean
    theme?: "dark" | "light"
    showStats?: boolean
    showToolCalls?: boolean
    bellOnComplete?: boolean
 }
 function LoadingScreen(): React.JSX.Element {
@@ -48,19 +59,27 @@ function ErrorScreen({ error }: { error: Error }): React.JSX.Element {
    )
 }
 async function handleConfirmationDefault(_message: string, _diff?: DiffInfo): Promise<boolean> {
    return Promise.resolve(true)
 }
 async function handleErrorDefault(_error: Error): Promise<ErrorOption> {
    return Promise.resolve("skip")
 }
 interface PendingConfirmation {
    message: string
    diff?: DiffInfo
    resolve: (result: boolean | ConfirmationResult) => void
 }
 export function App({
    projectPath,
    autoApply: initialAutoApply = false,
    deps,
    onExit,
    multiline = false,
    syntaxHighlight = true,
    theme = "dark",
    showStats = true,
    showToolCalls = true,
    bellOnComplete = false,
 }: ExtendedAppProps): React.JSX.Element {
    const { exit } = useApp()
@@ -68,9 +87,40 @@ export function App({
    const [sessionTime, setSessionTime] = useState("0m")
    const [autoApply, setAutoApply] = useState(initialAutoApply)
    const [commandResult, setCommandResult] = useState<CommandResult | null>(null)
    const [pendingConfirmation, setPendingConfirmation] = useState<PendingConfirmation | null>(null)
    const projectName = projectPath.split("/").pop() ?? "unknown"
    const handleConfirmation = useCallback(
        async (message: string, diff?: DiffInfo): Promise<boolean | ConfirmationResult> => {
            return new Promise((resolve) => {
                setPendingConfirmation({ message, diff, resolve })
            })
        },
        [],
    )
    const handleConfirmSelect = useCallback(
        (choice: ConfirmChoice, editedContent?: string[]) => {
            if (!pendingConfirmation) {
                return
            }
            if (choice === "apply") {
                if (editedContent) {
                    pendingConfirmation.resolve({ confirmed: true, editedContent })
                } else {
                    pendingConfirmation.resolve(true)
                }
            } else {
                pendingConfirmation.resolve(false)
            }
            setPendingConfirmation(null)
        },
        [pendingConfirmation],
    )
    const { session, messages, status, isLoading, error, sendMessage, undo, clearHistory, abort } =
        useSession(
            {
@@ -81,10 +131,11 @@ export function App({
                projectRoot: projectPath,
                projectName,
                projectStructure: deps.projectStructure,
                config: deps.config,
            },
            {
                autoApply,
-                onConfirmation: handleConfirmationDefault,
+                onConfirmation: handleConfirmation,
                onError: handleErrorDefault,
            },
        )
@@ -154,6 +205,12 @@ export function App({
        }
    }, [session])
    useEffect(() => {
        if (bellOnComplete && status === "ready") {
            ringBell()
        }
    }, [bellOnComplete, status])
    const handleSubmit = useCallback(
        (text: string): void => {
            if (isCommand(text)) {
@@ -179,7 +236,7 @@ export function App({
        return <ErrorScreen error={error} />
    }
-    const isInputDisabled = status === "thinking" || status === "tool_call"
+    const isInputDisabled = status === "thinking" || status === "tool_call" || !!pendingConfirmation
    return (
        <Box flexDirection="column" height="100%">
@@ -189,8 +246,15 @@ export function App({
                branch={branch}
                sessionTime={sessionTime}
                status={status}
                theme={theme}
            />
            <Chat
                messages={messages}
                isThinking={status === "thinking"}
                theme={theme}
                showStats={showStats}
                showToolCalls={showToolCalls}
            />
            <Chat messages={messages} isThinking={status === "thinking"} />
            {commandResult && (
                <Box
                    borderStyle="round"
@@ -203,6 +267,24 @@ export function App({
                    </Text>
                </Box>
            )}
            {pendingConfirmation && (
                <ConfirmDialog
                    message={pendingConfirmation.message}
                    diff={
                        pendingConfirmation.diff
                            ? {
                                  filePath: pendingConfirmation.diff.filePath,
                                  oldLines: pendingConfirmation.diff.oldLines,
                                  newLines: pendingConfirmation.diff.newLines,
                                  startLine: pendingConfirmation.diff.startLine,
                              }
                            : undefined
                    }
                    onSelect={handleConfirmSelect}
                    editableContent={pendingConfirmation.diff?.newLines}
                    syntaxHighlight={syntaxHighlight}
                />
            )}
            <Input
                onSubmit={handleSubmit}
                history={session?.inputHistory ?? []}
@@ -211,6 +293,7 @@ export function App({
                storage={deps.storage}
                projectRoot={projectPath}
                autocompleteEnabled={true}
                multiline={multiline}
            />
        </Box>
    )
--- a/packages/ipuaro/src/tui/components/Chat.tsx
+++ b/packages/ipuaro/src/tui/components/Chat.tsx
@@ -7,10 +7,14 @@ import { Box, Text } from "ink"
 import type React from "react"
 import type { ChatMessage } from "../../domain/value-objects/ChatMessage.js"
 import type { ToolCall } from "../../domain/value-objects/ToolCall.js"
 import { getRoleColor, type Theme } from "../utils/theme.js"
 export interface ChatProps {
    messages: ChatMessage[]
    isThinking: boolean
    theme?: Theme
    showStats?: boolean
    showToolCalls?: boolean
 }
 function formatTimestamp(timestamp: number): string {
@@ -42,11 +46,20 @@ function formatToolCall(call: ToolCall): string {
    return `[${call.name} ${params}]`
 }
-function UserMessage({ message }: { message: ChatMessage }): React.JSX.Element {
+interface MessageComponentProps {
    message: ChatMessage
    theme: Theme
    showStats: boolean
    showToolCalls: boolean
 }
 function UserMessage({ message, theme }: MessageComponentProps): React.JSX.Element {
    const roleColor = getRoleColor("user", theme)
    return (
        <Box flexDirection="column" marginBottom={1}>
            <Box gap={1}>
-                <Text color="green" bold>
+                <Text color={roleColor} bold>
                    You
                </Text>
                <Text color="gray" dimColor>
@@ -60,13 +73,19 @@ function UserMessage({ message }: { message: ChatMessage }): React.JSX.Element {
    )
 }
-function AssistantMessage({ message }: { message: ChatMessage }): React.JSX.Element {
+function AssistantMessage({
    message,
    theme,
    showStats,
    showToolCalls,
 }: MessageComponentProps): React.JSX.Element {
    const stats = formatStats(message.stats)
    const roleColor = getRoleColor("assistant", theme)
    return (
        <Box flexDirection="column" marginBottom={1}>
            <Box gap={1}>
-                <Text color="cyan" bold>
+                <Text color={roleColor} bold>
                    Assistant
                </Text>
                <Text color="gray" dimColor>
@@ -74,7 +93,7 @@ function AssistantMessage({ message }: { message: ChatMessage }): React.JSX.Elem
                </Text>
            </Box>
-            {message.toolCalls && message.toolCalls.length > 0 && (
+            {showToolCalls && message.toolCalls && message.toolCalls.length > 0 && (
                <Box flexDirection="column" marginLeft={2} marginBottom={1}>
                    {message.toolCalls.map((call) => (
                        <Text key={call.id} color="yellow">
@@ -90,7 +109,7 @@ function AssistantMessage({ message }: { message: ChatMessage }): React.JSX.Elem
                </Box>
            )}
-            {stats && (
+            {showStats && stats && (
                <Box marginLeft={2} marginTop={1}>
                    <Text color="gray" dimColor>
                        {stats}
@@ -101,7 +120,7 @@ function AssistantMessage({ message }: { message: ChatMessage }): React.JSX.Elem
    )
 }
-function ToolMessage({ message }: { message: ChatMessage }): React.JSX.Element {
+function ToolMessage({ message }: MessageComponentProps): React.JSX.Element {
    return (
        <Box flexDirection="column" marginBottom={1} marginLeft={2}>
            {message.toolResults?.map((result) => (
@@ -115,31 +134,39 @@ function ToolMessage({ message }: { message: ChatMessage }): React.JSX.Element {
    )
 }
-function SystemMessage({ message }: { message: ChatMessage }): React.JSX.Element {
+function SystemMessage({ message, theme }: MessageComponentProps): React.JSX.Element {
    const isError = message.content.toLowerCase().startsWith("error")
    const roleColor = getRoleColor("system", theme)
    return (
        <Box marginBottom={1} marginLeft={2}>
-            <Text color={isError ? "red" : "gray"} dimColor={!isError}>
+            <Text color={isError ? "red" : roleColor} dimColor={!isError}>
                {message.content}
            </Text>
        </Box>
    )
 }
-function MessageComponent({ message }: { message: ChatMessage }): React.JSX.Element {
+function MessageComponent({
    message,
    theme,
    showStats,
    showToolCalls,
 }: MessageComponentProps): React.JSX.Element {
    const props = { message, theme, showStats, showToolCalls }
    switch (message.role) {
        case "user": {
-            return <UserMessage message={message} />
+            return <UserMessage {...props} />
        }
        case "assistant": {
-            return <AssistantMessage message={message} />
+            return <AssistantMessage {...props} />
        }
        case "tool": {
-            return <ToolMessage message={message} />
+            return <ToolMessage {...props} />
        }
        case "system": {
-            return <SystemMessage message={message} />
+            return <SystemMessage {...props} />
        }
        default: {
            return <></>
@@ -147,24 +174,35 @@ function MessageComponent({ message }: { message: ChatMessage }): React.JSX.Elem
    }
 }
-function ThinkingIndicator(): React.JSX.Element {
+function ThinkingIndicator({ theme }: { theme: Theme }): React.JSX.Element {
    const color = getRoleColor("assistant", theme)
    return (
        <Box marginBottom={1}>
-            <Text color="yellow">Thinking...</Text>
+            <Text color={color}>Thinking...</Text>
        </Box>
    )
 }
-export function Chat({ messages, isThinking }: ChatProps): React.JSX.Element {
+export function Chat({
    messages,
    isThinking,
    theme = "dark",
    showStats = true,
    showToolCalls = true,
 }: ChatProps): React.JSX.Element {
    return (
        <Box flexDirection="column" flexGrow={1} paddingX={1}>
            {messages.map((message, index) => (
                <MessageComponent
                    key={`${String(message.timestamp)}-${String(index)}`}
                    message={message}
                    theme={theme}
                    showStats={showStats}
                    showToolCalls={showToolCalls}
                />
            ))}
-            {isThinking && <ThinkingIndicator />}
+            {isThinking && <ThinkingIndicator theme={theme} />}
        </Box>
    )
 }
--- a/packages/ipuaro/src/tui/components/ConfirmDialog.tsx
+++ b/packages/ipuaro/src/tui/components/ConfirmDialog.tsx
@@ -1,19 +1,25 @@
 /**
 * ConfirmDialog component for TUI.
 * Displays a confirmation dialog with [Y] Apply / [N] Cancel / [E] Edit options.
 * Supports inline editing when user selects Edit.
 */
 import { Box, Text, useInput } from "ink"
-import React, { useState } from "react"
+import React, { useCallback, useState } from "react"
 import type { ConfirmChoice } from "../../shared/types/index.js"
 import { DiffView, type DiffViewProps } from "./DiffView.js"
 import { EditableContent } from "./EditableContent.js"
 export interface ConfirmDialogProps {
    message: string
    diff?: DiffViewProps
-    onSelect: (choice: ConfirmChoice) => void
+    onSelect: (choice: ConfirmChoice, editedContent?: string[]) => void
    editableContent?: string[]
    syntaxHighlight?: boolean
 }
 type DialogMode = "confirm" | "edit"
 function ChoiceButton({
    hotkey,
    label,
@@ -32,26 +38,66 @@ function ChoiceButton({
    )
 }
-export function ConfirmDialog({ message, diff, onSelect }: ConfirmDialogProps): React.JSX.Element {
+export function ConfirmDialog({
    message,
    diff,
    onSelect,
    editableContent,
    syntaxHighlight = false,
 }: ConfirmDialogProps): React.JSX.Element {
    const [mode, setMode] = useState<DialogMode>("confirm")
    const [selected, setSelected] = useState<ConfirmChoice | null>(null)
-    useInput((input, key) => {
+    const linesToEdit = editableContent ?? diff?.newLines ?? []
-        const lowerInput = input.toLowerCase()
+    const canEdit = linesToEdit.length > 0
-        if (lowerInput === "y") {
+    const handleEditSubmit = useCallback(
        (editedLines: string[]) => {
            setSelected("apply")
-            onSelect("apply")
+            onSelect("apply", editedLines)
-        } else if (lowerInput === "n") {
+        },
-            setSelected("cancel")
+        [onSelect],
-            onSelect("cancel")
+    )
-        } else if (lowerInput === "e") {
+
-            setSelected("edit")
+    const handleEditCancel = useCallback(() => {
-            onSelect("edit")
+        setMode("confirm")
-        } else if (key.escape) {
+        setSelected(null)
-            setSelected("cancel")
+    }, [])
-            onSelect("cancel")
+
-        }
+    useInput(
-    })
+        (input, key) => {
            if (mode === "edit") {
                return
            }
            const lowerInput = input.toLowerCase()
            if (lowerInput === "y") {
                setSelected("apply")
                onSelect("apply")
            } else if (lowerInput === "n") {
                setSelected("cancel")
                onSelect("cancel")
            } else if (lowerInput === "e" && canEdit) {
                setSelected("edit")
                setMode("edit")
            } else if (key.escape) {
                setSelected("cancel")
                onSelect("cancel")
            }
        },
        { isActive: mode === "confirm" },
    )
    if (mode === "edit") {
        return (
            <EditableContent
                lines={linesToEdit}
                onSubmit={handleEditSubmit}
                onCancel={handleEditCancel}
            />
        )
    }
    return (
        <Box
@@ -69,14 +115,22 @@ export function ConfirmDialog({ message, diff, onSelect }: ConfirmDialogProps):
            {diff && (
                <Box marginBottom={1}>
-                    <DiffView {...diff} />
+                    <DiffView {...diff} syntaxHighlight={syntaxHighlight} />
                </Box>
            )}
            <Box gap={2}>
                <ChoiceButton hotkey="Y" label="Apply" isSelected={selected === "apply"} />
                <ChoiceButton hotkey="N" label="Cancel" isSelected={selected === "cancel"} />
-                <ChoiceButton hotkey="E" label="Edit" isSelected={selected === "edit"} />
+                {canEdit ? (
                    <ChoiceButton hotkey="E" label="Edit" isSelected={selected === "edit"} />
                ) : (
                    <Box>
                        <Text color="gray" dimColor>
                            [E] Edit (disabled)
                        </Text>
                    </Box>
                )}
            </Box>
        </Box>
    )
--- a/packages/ipuaro/src/tui/components/DiffView.tsx
+++ b/packages/ipuaro/src/tui/components/DiffView.tsx
@@ -5,12 +5,15 @@
 import { Box, Text } from "ink"
 import type React from "react"
 import { detectLanguage, highlightLine, type Language } from "../utils/syntax-highlighter.js"
 export interface DiffViewProps {
    filePath: string
    oldLines: string[]
    newLines: string[]
    startLine: number
    language?: Language
    syntaxHighlight?: boolean
 }
 interface DiffLine {
@@ -97,20 +100,37 @@ function formatLineNumber(num: number | undefined, width: number): string {
 function DiffLine({
    line,
    lineNumberWidth,
    language,
    syntaxHighlight,
 }: {
    line: DiffLine
    lineNumberWidth: number
    language?: Language
    syntaxHighlight?: boolean
 }): React.JSX.Element {
    const prefix = getLinePrefix(line)
    const color = getLineColor(line)
    const lineNum = formatLineNumber(line.lineNumber, lineNumberWidth)
    const shouldHighlight = syntaxHighlight && language && line.type === "add"
    return (
        <Box>
            <Text color="gray">{lineNum} </Text>
-            <Text color={color}>
+            {shouldHighlight ? (
-                {prefix} {line.content}
+                <Box>
-            </Text>
+                    <Text color={color}>{prefix} </Text>
                    {highlightLine(line.content, language).map((token, idx) => (
                        <Text key={idx} color={token.color}>
                            {token.text}
                        </Text>
                    ))}
                </Box>
            ) : (
                <Text color={color}>
                    {prefix} {line.content}
                </Text>
            )}
        </Box>
    )
 }
@@ -166,6 +186,8 @@ export function DiffView({
    oldLines,
    newLines,
    startLine,
    language,
    syntaxHighlight = false,
 }: DiffViewProps): React.JSX.Element {
    const diffLines = computeDiff(oldLines, newLines, startLine)
    const endLine = startLine + newLines.length - 1
@@ -174,6 +196,8 @@ export function DiffView({
    const additions = diffLines.filter((l) => l.type === "add").length
    const deletions = diffLines.filter((l) => l.type === "remove").length
    const detectedLanguage = language ?? detectLanguage(filePath)
    return (
        <Box flexDirection="column" paddingX={1}>
            <DiffHeader filePath={filePath} startLine={startLine} endLine={endLine} />
@@ -183,6 +207,8 @@ export function DiffView({
                        key={`${line.type}-${String(index)}`}
                        line={line}
                        lineNumberWidth={lineNumberWidth}
                        language={detectedLanguage}
                        syntaxHighlight={syntaxHighlight}
                    />
                ))}
            </Box>
--- a/packages/ipuaro/src/tui/components/EditableContent.tsx
+++ b/packages/ipuaro/src/tui/components/EditableContent.tsx
@@ -0,0 +1,146 @@
 /**
 * EditableContent component for TUI.
 * Displays editable multi-line text with line-by-line navigation.
 */
 import { Box, Text, useInput } from "ink"
 import TextInput from "ink-text-input"
 import React, { useCallback, useState } from "react"
 export interface EditableContentProps {
    /** Initial lines to edit */
    lines: string[]
    /** Called when user finishes editing (Enter key) */
    onSubmit: (editedLines: string[]) => void
    /** Called when user cancels editing (Escape key) */
    onCancel: () => void
    /** Maximum visible lines before scrolling */
    maxVisibleLines?: number
 }
 /**
 * EditableContent component.
 * Allows line-by-line editing of multi-line text.
 * - Up/Down: Navigate between lines
 * - Enter (on last line): Submit changes
 * - Ctrl+Enter: Submit changes from any line
 * - Escape: Cancel editing
 */
 export function EditableContent({
    lines: initialLines,
    onSubmit,
    onCancel,
    maxVisibleLines = 20,
 }: EditableContentProps): React.JSX.Element {
    const [lines, setLines] = useState<string[]>(initialLines.length > 0 ? initialLines : [""])
    const [currentLineIndex, setCurrentLineIndex] = useState(0)
    const [currentLineValue, setCurrentLineValue] = useState(lines[0] ?? "")
    const updateCurrentLine = useCallback(
        (value: string) => {
            const newLines = [...lines]
            newLines[currentLineIndex] = value
            setLines(newLines)
            setCurrentLineValue(value)
        },
        [lines, currentLineIndex],
    )
    const handleLineSubmit = useCallback(() => {
        updateCurrentLine(currentLineValue)
        if (currentLineIndex === lines.length - 1) {
            onSubmit(lines)
        } else {
            const nextIndex = currentLineIndex + 1
            setCurrentLineIndex(nextIndex)
            setCurrentLineValue(lines[nextIndex] ?? "")
        }
    }, [currentLineValue, currentLineIndex, lines, updateCurrentLine, onSubmit])
    const handleMoveUp = useCallback(() => {
        if (currentLineIndex > 0) {
            updateCurrentLine(currentLineValue)
            const prevIndex = currentLineIndex - 1
            setCurrentLineIndex(prevIndex)
            setCurrentLineValue(lines[prevIndex] ?? "")
        }
    }, [currentLineIndex, currentLineValue, lines, updateCurrentLine])
    const handleMoveDown = useCallback(() => {
        if (currentLineIndex < lines.length - 1) {
            updateCurrentLine(currentLineValue)
            const nextIndex = currentLineIndex + 1
            setCurrentLineIndex(nextIndex)
            setCurrentLineValue(lines[nextIndex] ?? "")
        }
    }, [currentLineIndex, currentLineValue, lines, updateCurrentLine])
    const handleCtrlEnter = useCallback(() => {
        updateCurrentLine(currentLineValue)
        onSubmit(lines)
    }, [currentLineValue, lines, updateCurrentLine, onSubmit])
    useInput(
        (input, key) => {
            if (key.escape) {
                onCancel()
            } else if (key.upArrow) {
                handleMoveUp()
            } else if (key.downArrow) {
                handleMoveDown()
            } else if (key.ctrl && key.return) {
                handleCtrlEnter()
            }
        },
        { isActive: true },
    )
    const startLine = Math.max(0, currentLineIndex - Math.floor(maxVisibleLines / 2))
    const endLine = Math.min(lines.length, startLine + maxVisibleLines)
    const visibleLines = lines.slice(startLine, endLine)
    return (
        <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
            <Box marginBottom={1}>
                <Text color="cyan" bold>
                    Edit Content (Line {currentLineIndex + 1}/{lines.length})
                </Text>
            </Box>
            <Box flexDirection="column" marginBottom={1}>
                {visibleLines.map((line, idx) => {
                    const actualIndex = startLine + idx
                    const isCurrentLine = actualIndex === currentLineIndex
                    return (
                        <Box key={actualIndex}>
                            <Text color="gray" dimColor>
                                {String(actualIndex + 1).padStart(3, " ")}:{" "}
                            </Text>
                            {isCurrentLine ? (
                                <Box>
                                    <Text color="cyan">▶ </Text>
                                    <TextInput
                                        value={currentLineValue}
                                        onChange={setCurrentLineValue}
                                        onSubmit={handleLineSubmit}
                                    />
                                </Box>
                            ) : (
                                <Text color={isCurrentLine ? "cyan" : "white"}>{line}</Text>
                            )}
                        </Box>
                    )
                })}
            </Box>
            <Box flexDirection="column" borderStyle="single" borderColor="gray" paddingX={1}>
                <Text dimColor>↑/↓: Navigate lines</Text>
                <Text dimColor>Enter: Next line / Submit (last line)</Text>
                <Text dimColor>Ctrl+Enter: Submit from any line</Text>
                <Text dimColor>Escape: Cancel</Text>
            </Box>
        </Box>
    )
 }
--- a/packages/ipuaro/src/tui/components/Input.tsx
+++ b/packages/ipuaro/src/tui/components/Input.tsx
@@ -17,6 +17,7 @@ export interface InputProps {
    storage?: IStorage
    projectRoot?: string
    autocompleteEnabled?: boolean
    multiline?: boolean | "auto"
 }
 export function Input({
@@ -27,10 +28,15 @@ export function Input({
    storage,
    projectRoot = "",
    autocompleteEnabled = true,
    multiline = false,
 }: InputProps): React.JSX.Element {
    const [value, setValue] = useState("")
    const [historyIndex, setHistoryIndex] = useState(-1)
    const [savedInput, setSavedInput] = useState("")
    const [lines, setLines] = useState<string[]>([""])
    const [currentLineIndex, setCurrentLineIndex] = useState(0)
    const isMultilineActive = multiline === true || (multiline === "auto" && lines.length > 1)
    /*
     * Initialize autocomplete hook if storage is provided
@@ -62,6 +68,8 @@ export function Input({
            }
            onSubmit(text)
            setValue("")
            setLines([""])
            setCurrentLineIndex(0)
            setHistoryIndex(-1)
            setSavedInput("")
            autocomplete.reset()
@@ -69,6 +77,31 @@ export function Input({
        [disabled, onSubmit, autocomplete],
    )
    const handleLineChange = useCallback(
        (newValue: string) => {
            const newLines = [...lines]
            newLines[currentLineIndex] = newValue
            setLines(newLines)
            setValue(newLines.join("\n"))
        },
        [lines, currentLineIndex],
    )
    const handleAddLine = useCallback(() => {
        const newLines = [...lines]
        newLines.splice(currentLineIndex + 1, 0, "")
        setLines(newLines)
        setCurrentLineIndex(currentLineIndex + 1)
        setValue(newLines.join("\n"))
    }, [lines, currentLineIndex])
    const handleMultilineSubmit = useCallback(() => {
        const fullText = lines.join("\n").trim()
        if (fullText) {
            handleSubmit(fullText)
        }
    }, [lines, handleSubmit])
    const handleTabKey = useCallback(() => {
        if (storage && autocompleteEnabled && value.trim()) {
            const suggestions = autocomplete.suggestions
@@ -116,11 +149,22 @@ export function Input({
            if (key.tab) {
                handleTabKey()
            }
            if (key.return && key.shift && isMultilineActive) {
                handleAddLine()
            }
            if (key.upArrow) {
-                handleUpArrow()
+                if (isMultilineActive && currentLineIndex > 0) {
                    setCurrentLineIndex(currentLineIndex - 1)
                } else if (!isMultilineActive) {
                    handleUpArrow()
                }
            }
            if (key.downArrow) {
-                handleDownArrow()
+                if (isMultilineActive && currentLineIndex < lines.length - 1) {
                    setCurrentLineIndex(currentLineIndex + 1)
                } else if (!isMultilineActive) {
                    handleDownArrow()
                }
            }
        },
        { isActive: !disabled },
@@ -130,21 +174,56 @@ export function Input({
    return (
        <Box flexDirection="column">
-            <Box borderStyle="single" borderColor={disabled ? "gray" : "cyan"} paddingX={1}>
+            <Box
-                <Text color={disabled ? "gray" : "green"} bold>
+                borderStyle="single"
-                    {">"}{" "}
+                borderColor={disabled ? "gray" : "cyan"}
-                </Text>
+                paddingX={1}
                flexDirection="column"
            >
                {disabled ? (
-                    <Text color="gray" dimColor>
+                    <Box>
-                        {placeholder}
+                        <Text color="gray" bold>
-                    </Text>
+                            {">"}{" "}
                        </Text>
                        <Text color="gray" dimColor>
                            {placeholder}
                        </Text>
                    </Box>
                ) : isMultilineActive ? (
                    <Box flexDirection="column">
                        {lines.map((line, index) => (
                            <Box key={index}>
                                <Text color="green" bold>
                                    {index === currentLineIndex ? ">" : " "}{" "}
                                </Text>
                                {index === currentLineIndex ? (
                                    <TextInput
                                        value={line}
                                        onChange={handleLineChange}
                                        onSubmit={handleMultilineSubmit}
                                        placeholder={index === 0 ? placeholder : ""}
                                    />
                                ) : (
                                    <Text>{line}</Text>
                                )}
                            </Box>
                        ))}
                        <Box marginTop={1}>
                            <Text dimColor>Shift+Enter: new line | Enter: submit</Text>
                        </Box>
                    </Box>
                ) : (
-                    <TextInput
+                    <Box>
-                        value={value}
+                        <Text color="green" bold>
-                        onChange={handleChange}
+                            {">"}{" "}
-                        onSubmit={handleSubmit}
+                        </Text>
-                        placeholder={placeholder}
+                        <TextInput
-                    />
+                            value={value}
                            onChange={handleChange}
                            onSubmit={handleSubmit}
                            placeholder={placeholder}
                        />
                    </Box>
                )}
            </Box>
            {hasSuggestions && !disabled && (
--- a/packages/ipuaro/src/tui/components/StatusBar.tsx
+++ b/packages/ipuaro/src/tui/components/StatusBar.tsx
@@ -6,6 +6,7 @@
 import { Box, Text } from "ink"
 import type React from "react"
 import type { BranchInfo, TuiStatus } from "../types.js"
 import { getContextColor, getStatusColor, type Theme } from "../utils/theme.js"
 export interface StatusBarProps {
    contextUsage: number
@@ -13,27 +14,30 @@ export interface StatusBarProps {
    branch: BranchInfo
    sessionTime: string
    status: TuiStatus
    theme?: Theme
 }
-function getStatusIndicator(status: TuiStatus): { text: string; color: string } {
+function getStatusIndicator(status: TuiStatus, theme: Theme): { text: string; color: string } {
    const color = getStatusColor(status, theme)
    switch (status) {
        case "ready": {
-            return { text: "ready", color: "green" }
+            return { text: "ready", color }
        }
        case "thinking": {
-            return { text: "thinking...", color: "yellow" }
+            return { text: "thinking...", color }
        }
        case "tool_call": {
-            return { text: "executing...", color: "cyan" }
+            return { text: "executing...", color }
        }
        case "awaiting_confirmation": {
-            return { text: "confirm?", color: "magenta" }
+            return { text: "confirm?", color }
        }
        case "error": {
-            return { text: "error", color: "red" }
+            return { text: "error", color }
        }
        default: {
-            return { text: "ready", color: "green" }
+            return { text: "ready", color }
        }
    }
 }
@@ -48,9 +52,11 @@ export function StatusBar({
    branch,
    sessionTime,
    status,
    theme = "dark",
 }: StatusBarProps): React.JSX.Element {
-    const statusIndicator = getStatusIndicator(status)
+    const statusIndicator = getStatusIndicator(status, theme)
    const branchDisplay = branch.isDetached ? `HEAD@${branch.name.slice(0, 7)}` : branch.name
    const contextColor = getContextColor(contextUsage, theme)
    return (
        <Box borderStyle="single" borderColor="gray" paddingX={1} justifyContent="space-between">
@@ -59,11 +65,7 @@ export function StatusBar({
                    [ipuaro]
                </Text>
                <Text color="gray">
-                    [ctx:{" "}
+                    [ctx: <Text color={contextColor}>{formatContextUsage(contextUsage)}</Text>]
                    <Text color={contextUsage > 0.8 ? "red" : "white"}>
                        {formatContextUsage(contextUsage)}
                    </Text>
                    ]
                </Text>
                <Text color="gray">
                    [<Text color="blue">{projectName}</Text>]
--- a/packages/ipuaro/src/tui/components/index.ts
+++ b/packages/ipuaro/src/tui/components/index.ts
@@ -9,3 +9,4 @@ export { DiffView, type DiffViewProps } from "./DiffView.js"
 export { ConfirmDialog, type ConfirmDialogProps } from "./ConfirmDialog.js"
 export { ErrorDialog, type ErrorDialogProps, type ErrorInfo } from "./ErrorDialog.js"
 export { Progress, type ProgressProps } from "./Progress.js"
 export { EditableContent, type EditableContentProps } from "./EditableContent.js"
--- a/packages/ipuaro/src/tui/hooks/useAutocomplete.ts
+++ b/packages/ipuaro/src/tui/hooks/useAutocomplete.ts
@@ -5,6 +5,7 @@
 import { useCallback, useEffect, useState } from "react"
 import type { IStorage } from "../../domain/services/IStorage.js"
 import type { AutocompleteConfig } from "../../shared/constants/config.js"
 import path from "node:path"
 export interface UseAutocompleteOptions {
@@ -12,6 +13,7 @@ export interface UseAutocompleteOptions {
    projectRoot: string
    enabled?: boolean
    maxSuggestions?: number
    config?: AutocompleteConfig
 }
 export interface UseAutocompleteReturn {
@@ -107,13 +109,18 @@ function getCommonPrefix(suggestions: string[]): string {
 }
 export function useAutocomplete(options: UseAutocompleteOptions): UseAutocompleteReturn {
-    const { storage, projectRoot, enabled = true, maxSuggestions = 10 } = options
+    const { storage, projectRoot, enabled, maxSuggestions, config } = options
    // Read from config if provided, otherwise use options, otherwise use defaults
    const isEnabled = config?.enabled ?? enabled ?? true
    const maxSuggestionsCount = config?.maxSuggestions ?? maxSuggestions ?? 10
    const [filePaths, setFilePaths] = useState<string[]>([])
    const [suggestions, setSuggestions] = useState<string[]>([])
    // Load file paths from storage
    useEffect(() => {
-        if (!enabled) {
+        if (!isEnabled) {
            return
        }
@@ -135,11 +142,11 @@ export function useAutocomplete(options: UseAutocompleteOptions): UseAutocomplet
        loadPaths().catch(() => {
            // Ignore errors
        })
-    }, [storage, projectRoot, enabled])
+    }, [storage, projectRoot, isEnabled])
    const complete = useCallback(
        (partial: string): string[] => {
-            if (!enabled || !partial.trim()) {
+            if (!isEnabled || !partial.trim()) {
                setSuggestions([])
                return []
            }
@@ -154,13 +161,13 @@ export function useAutocomplete(options: UseAutocompleteOptions): UseAutocomplet
                }))
                .filter((item) => item.score > 0)
                .sort((a, b) => b.score - a.score)
-                .slice(0, maxSuggestions)
+                .slice(0, maxSuggestionsCount)
                .map((item) => item.path)
            setSuggestions(scored)
            return scored
        },
-        [enabled, filePaths, maxSuggestions],
+        [isEnabled, filePaths, maxSuggestionsCount],
    )
    const accept = useCallback(
--- a/packages/ipuaro/src/tui/hooks/useSession.ts
+++ b/packages/ipuaro/src/tui/hooks/useSession.ts
@@ -11,6 +11,7 @@ import type { IStorage } from "../../domain/services/IStorage.js"
 import type { DiffInfo } from "../../domain/services/ITool.js"
 import type { ChatMessage } from "../../domain/value-objects/ChatMessage.js"
 import type { ErrorOption } from "../../shared/errors/IpuaroError.js"
 import type { Config } from "../../shared/constants/config.js"
 import type { IToolRegistry } from "../../application/interfaces/IToolRegistry.js"
 import {
    HandleMessage,
@@ -18,6 +19,7 @@ import {
 } from "../../application/use-cases/HandleMessage.js"
 import { StartSession } from "../../application/use-cases/StartSession.js"
 import { UndoChange } from "../../application/use-cases/UndoChange.js"
 import type { ConfirmationResult } from "../../application/use-cases/ExecuteTool.js"
 import type { ProjectStructure } from "../../infrastructure/llm/prompts.js"
 import type { TuiStatus } from "../types.js"
@@ -29,11 +31,12 @@ export interface UseSessionDependencies {
    projectRoot: string
    projectName: string
    projectStructure?: ProjectStructure
    config?: Config
 }
 export interface UseSessionOptions {
    autoApply?: boolean
-    onConfirmation?: (message: string, diff?: DiffInfo) => Promise<boolean>
+    onConfirmation?: (message: string, diff?: DiffInfo) => Promise<boolean | ConfirmationResult>
    onError?: (error: Error) => Promise<ErrorOption>
 }
@@ -106,11 +109,17 @@ async function initializeSession(
        deps.llm,
        deps.tools,
        deps.projectRoot,
        deps.config?.context,
    )
    if (deps.projectStructure) {
        handleMessage.setProjectStructure(deps.projectStructure)
    }
-    handleMessage.setOptions({ autoApply: options.autoApply })
+    handleMessage.setOptions({
        autoApply: options.autoApply,
        maxHistoryMessages: deps.config?.session.maxHistoryMessages,
        saveInputHistory: deps.config?.session.saveInputHistory,
        contextConfig: deps.config?.context,
    })
    handleMessage.setEvents(createEventHandlers(setters, options))
    refs.current.handleMessage = handleMessage
    refs.current.undoChange = new UndoChange(deps.sessionStorage, deps.storage)
--- a/packages/ipuaro/src/tui/utils/bell.ts
+++ b/packages/ipuaro/src/tui/utils/bell.ts
@@ -0,0 +1,11 @@
 /**
 * Bell notification utility for terminal.
 */
 /**
 * Ring the terminal bell.
 * Works by outputting the ASCII bell character (\u0007).
 */
 export function ringBell(): void {
    process.stdout.write("\u0007")
 }
--- a/packages/ipuaro/src/tui/utils/syntax-highlighter.ts
+++ b/packages/ipuaro/src/tui/utils/syntax-highlighter.ts
@@ -0,0 +1,167 @@
 /**
 * Simple syntax highlighter for terminal UI.
 * Highlights keywords, strings, comments, numbers, and operators.
 */
 export type Language = "typescript" | "javascript" | "tsx" | "jsx" | "json" | "yaml" | "unknown"
 export interface HighlightedToken {
    text: string
    color: string
 }
 const KEYWORDS = new Set([
    "abstract",
    "any",
    "as",
    "async",
    "await",
    "boolean",
    "break",
    "case",
    "catch",
    "class",
    "const",
    "constructor",
    "continue",
    "debugger",
    "declare",
    "default",
    "delete",
    "do",
    "else",
    "enum",
    "export",
    "extends",
    "false",
    "finally",
    "for",
    "from",
    "function",
    "get",
    "if",
    "implements",
    "import",
    "in",
    "instanceof",
    "interface",
    "let",
    "module",
    "namespace",
    "new",
    "null",
    "number",
    "of",
    "package",
    "private",
    "protected",
    "public",
    "readonly",
    "require",
    "return",
    "set",
    "static",
    "string",
    "super",
    "switch",
    "this",
    "throw",
    "true",
    "try",
    "type",
    "typeof",
    "undefined",
    "var",
    "void",
    "while",
    "with",
    "yield",
 ])
 export function detectLanguage(filePath: string): Language {
    const ext = filePath.split(".").pop()?.toLowerCase()
    switch (ext) {
        case "ts":
            return "typescript"
        case "tsx":
            return "tsx"
        case "js":
            return "javascript"
        case "jsx":
            return "jsx"
        case "json":
            return "json"
        case "yaml":
        case "yml":
            return "yaml"
        default:
            return "unknown"
    }
 }
 const COMMENT_REGEX = /^(\/\/.*|\/\*[\s\S]*?\*\/)/
 const STRING_REGEX = /^("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/
 const NUMBER_REGEX = /^(\b\d+\.?\d*\b)/
 const WORD_REGEX = /^([a-zA-Z_$][a-zA-Z0-9_$]*)/
 const OPERATOR_REGEX = /^([+\-*/%=<>!&|^~?:;,.()[\]{}])/
 const WHITESPACE_REGEX = /^(\s+)/
 export function highlightLine(line: string, language: Language): HighlightedToken[] {
    if (language === "unknown" || language === "json" || language === "yaml") {
        return [{ text: line, color: "white" }]
    }
    const tokens: HighlightedToken[] = []
    let remaining = line
    while (remaining.length > 0) {
        const commentMatch = COMMENT_REGEX.exec(remaining)
        if (commentMatch) {
            tokens.push({ text: commentMatch[0], color: "gray" })
            remaining = remaining.slice(commentMatch[0].length)
            continue
        }
        const stringMatch = STRING_REGEX.exec(remaining)
        if (stringMatch) {
            tokens.push({ text: stringMatch[0], color: "green" })
            remaining = remaining.slice(stringMatch[0].length)
            continue
        }
        const numberMatch = NUMBER_REGEX.exec(remaining)
        if (numberMatch) {
            tokens.push({ text: numberMatch[0], color: "cyan" })
            remaining = remaining.slice(numberMatch[0].length)
            continue
        }
        const wordMatch = WORD_REGEX.exec(remaining)
        if (wordMatch) {
            const word = wordMatch[0]
            const color = KEYWORDS.has(word) ? "magenta" : "white"
            tokens.push({ text: word, color })
            remaining = remaining.slice(word.length)
            continue
        }
        const operatorMatch = OPERATOR_REGEX.exec(remaining)
        if (operatorMatch) {
            tokens.push({ text: operatorMatch[0], color: "yellow" })
            remaining = remaining.slice(operatorMatch[0].length)
            continue
        }
        const whitespaceMatch = WHITESPACE_REGEX.exec(remaining)
        if (whitespaceMatch) {
            tokens.push({ text: whitespaceMatch[0], color: "white" })
            remaining = remaining.slice(whitespaceMatch[0].length)
            continue
        }
        tokens.push({ text: remaining[0] ?? "", color: "white" })
        remaining = remaining.slice(1)
    }
    return tokens
 }
--- a/packages/ipuaro/src/tui/utils/theme.ts
+++ b/packages/ipuaro/src/tui/utils/theme.ts
@@ -0,0 +1,115 @@
 /**
 * Theme color utilities for TUI.
 */
 export type Theme = "dark" | "light"
 /**
 * Color scheme for a theme.
 */
 export interface ColorScheme {
    primary: string
    secondary: string
    success: string
    warning: string
    error: string
    info: string
    muted: string
    background: string
    foreground: string
 }
 /**
 * Dark theme color scheme (default).
 */
 const DARK_THEME: ColorScheme = {
    primary: "cyan",
    secondary: "blue",
    success: "green",
    warning: "yellow",
    error: "red",
    info: "cyan",
    muted: "gray",
    background: "black",
    foreground: "white",
 }
 /**
 * Light theme color scheme.
 */
 const LIGHT_THEME: ColorScheme = {
    primary: "blue",
    secondary: "cyan",
    success: "green",
    warning: "yellow",
    error: "red",
    info: "blue",
    muted: "gray",
    background: "white",
    foreground: "black",
 }
 /**
 * Get color scheme for a theme.
 */
 export function getColorScheme(theme: Theme): ColorScheme {
    return theme === "dark" ? DARK_THEME : LIGHT_THEME
 }
 /**
 * Get color for a status.
 */
 export function getStatusColor(
    status: "ready" | "thinking" | "error" | "tool_call" | "awaiting_confirmation",
    theme: Theme = "dark",
 ): string {
    const scheme = getColorScheme(theme)
    switch (status) {
        case "ready":
            return scheme.success
        case "thinking":
        case "tool_call":
            return scheme.warning
        case "awaiting_confirmation":
            return scheme.info
        case "error":
            return scheme.error
    }
 }
 /**
 * Get color for a message role.
 */
 export function getRoleColor(
    role: "user" | "assistant" | "system" | "tool",
    theme: Theme = "dark",
 ): string {
    const scheme = getColorScheme(theme)
    switch (role) {
        case "user":
            return scheme.success
        case "assistant":
            return scheme.primary
        case "system":
            return scheme.muted
        case "tool":
            return scheme.secondary
    }
 }
 /**
 * Get color for context usage percentage.
 */
 export function getContextColor(usage: number, theme: Theme = "dark"): string {
    const scheme = getColorScheme(theme)
    if (usage >= 0.8) {
        return scheme.error
    }
    if (usage >= 0.6) {
        return scheme.warning
    }
    return scheme.success
 }
--- a/packages/ipuaro/tests/unit/application/use-cases/ContextManager.test.ts
+++ b/packages/ipuaro/tests/unit/application/use-cases/ContextManager.test.ts
@@ -245,4 +245,65 @@ describe("ContextManager", () => {
            expect(state.needsCompression).toBe(false)
        })
    })
    describe("configuration", () => {
        it("should use default compression threshold when no config provided", () => {
            const manager = new ContextManager(CONTEXT_SIZE)
            manager.addToContext("test.ts", CONTEXT_SIZE * 0.85)
            expect(manager.needsCompression()).toBe(true)
        })
        it("should use custom compression threshold from config", () => {
            const manager = new ContextManager(CONTEXT_SIZE, { autoCompressAt: 0.9 })
            manager.addToContext("test.ts", CONTEXT_SIZE * 0.85)
            expect(manager.needsCompression()).toBe(false)
        })
        it("should trigger compression at custom threshold", () => {
            const manager = new ContextManager(CONTEXT_SIZE, { autoCompressAt: 0.9 })
            manager.addToContext("test.ts", CONTEXT_SIZE * 0.95)
            expect(manager.needsCompression()).toBe(true)
        })
        it("should accept compression method in config", () => {
            const manager = new ContextManager(CONTEXT_SIZE, { compressionMethod: "truncate" })
            expect(manager).toBeDefined()
        })
        it("should use default compression method when not specified", () => {
            const manager = new ContextManager(CONTEXT_SIZE, {})
            expect(manager).toBeDefined()
        })
        it("should accept full context config", () => {
            const manager = new ContextManager(CONTEXT_SIZE, {
                systemPromptTokens: 3000,
                maxContextUsage: 0.9,
                autoCompressAt: 0.85,
                compressionMethod: "llm-summary",
            })
            manager.addToContext("test.ts", CONTEXT_SIZE * 0.87)
            expect(manager.needsCompression()).toBe(true)
        })
        it("should handle edge case: autoCompressAt = 0", () => {
            const manager = new ContextManager(CONTEXT_SIZE, { autoCompressAt: 0 })
            manager.addToContext("test.ts", 1)
            expect(manager.needsCompression()).toBe(true)
        })
        it("should handle edge case: autoCompressAt = 1", () => {
            const manager = new ContextManager(CONTEXT_SIZE, { autoCompressAt: 1 })
            manager.addToContext("test.ts", CONTEXT_SIZE * 0.99)
            expect(manager.needsCompression()).toBe(false)
        })
    })
 })
--- a/packages/ipuaro/tests/unit/application/use-cases/IndexProject.test.ts
+++ b/packages/ipuaro/tests/unit/application/use-cases/IndexProject.test.ts
@@ -19,7 +19,7 @@ vi.mock("../../../../src/infrastructure/indexer/FileScanner.js", () => ({
                return 'export function main() { return "hello" }'
            }
            if (path.includes("utils.ts")) {
-                return 'export const add = (a: number, b: number) => a + b'
+                return "export const add = (a: number, b: number) => a + b"
            }
            return null
        }
@@ -31,7 +31,16 @@ vi.mock("../../../../src/infrastructure/indexer/ASTParser.js", () => ({
        parse() {
            return {
                ...createEmptyFileAST(),
-                functions: [{ name: "test", lineStart: 1, lineEnd: 5, params: [], isAsync: false, isExported: true }],
+                functions: [
                    {
                        name: "test",
                        lineStart: 1,
                        lineEnd: 5,
                        params: [],
                        isAsync: false,
                        isExported: true,
                    },
                ],
            }
        }
    },
@@ -116,7 +125,7 @@ describe("IndexProject", () => {
                expect.objectContaining({
                    hash: expect.any(String),
                    lines: expect.any(Array),
-                })
+                }),
            )
        })
@@ -128,7 +137,7 @@ describe("IndexProject", () => {
                "src/index.ts",
                expect.objectContaining({
                    functions: expect.any(Array),
-                })
+                }),
            )
        })
@@ -136,19 +145,14 @@ describe("IndexProject", () => {
            await useCase.execute("/test/project")
            expect(mockStorage.setMeta).toHaveBeenCalledTimes(2)
-            expect(mockStorage.setMeta).toHaveBeenCalledWith(
+            expect(mockStorage.setMeta).toHaveBeenCalledWith("src/index.ts", expect.any(Object))
                "src/index.ts",
                expect.any(Object)
            )
        })
        it("should build and store symbol index", async () => {
            await useCase.execute("/test/project")
            expect(mockStorage.setSymbolIndex).toHaveBeenCalledTimes(1)
-            expect(mockStorage.setSymbolIndex).toHaveBeenCalledWith(
+            expect(mockStorage.setSymbolIndex).toHaveBeenCalledWith(expect.any(Map))
                expect.any(Map)
            )
        })
        it("should build and store dependency graph", async () => {
@@ -159,7 +163,7 @@ describe("IndexProject", () => {
                expect.objectContaining({
                    imports: expect.any(Map),
                    importedBy: expect.any(Map),
-                })
+                }),
            )
        })
@@ -168,7 +172,7 @@ describe("IndexProject", () => {
            expect(mockStorage.setProjectConfig).toHaveBeenCalledWith(
                "last_indexed",
-                expect.any(Number)
+                expect.any(Number),
            )
        })
@@ -186,7 +190,7 @@ describe("IndexProject", () => {
                    total: expect.any(Number),
                    currentFile: expect.any(String),
                    phase: expect.stringMatching(/scanning|parsing|analyzing|indexing/),
-                })
+                }),
            )
        })
@@ -198,7 +202,7 @@ describe("IndexProject", () => {
            })
            const scanningCalls = progressCallback.mock.calls.filter(
-                (call) => call[0].phase === "scanning"
+                (call) => call[0].phase === "scanning",
            )
            expect(scanningCalls.length).toBeGreaterThan(0)
        })
@@ -211,7 +215,7 @@ describe("IndexProject", () => {
            })
            const parsingCalls = progressCallback.mock.calls.filter(
-                (call) => call[0].phase === "parsing"
+                (call) => call[0].phase === "parsing",
            )
            expect(parsingCalls.length).toBeGreaterThan(0)
        })
@@ -224,7 +228,7 @@ describe("IndexProject", () => {
            })
            const analyzingCalls = progressCallback.mock.calls.filter(
-                (call) => call[0].phase === "analyzing"
+                (call) => call[0].phase === "analyzing",
            )
            expect(analyzingCalls.length).toBeGreaterThan(0)
        })
@@ -237,7 +241,7 @@ describe("IndexProject", () => {
            })
            const indexingCalls = progressCallback.mock.calls.filter(
-                (call) => call[0].phase === "indexing"
+                (call) => call[0].phase === "indexing",
            )
            expect(indexingCalls.length).toBeGreaterThan(0)
        })
@@ -245,10 +249,7 @@ describe("IndexProject", () => {
        it("should detect TypeScript files", async () => {
            await useCase.execute("/test/project")
-            expect(mockStorage.setAST).toHaveBeenCalledWith(
+            expect(mockStorage.setAST).toHaveBeenCalledWith("src/index.ts", expect.any(Object))
                "src/index.ts",
                expect.any(Object)
            )
        })
        it("should handle files without parseable language", async () => {
@@ -276,7 +277,7 @@ describe("IndexProject", () => {
            expect(mockStorage.setAST).toHaveBeenCalledWith(
                expect.stringContaining(".ts"),
-                expect.any(Object)
+                expect.any(Object),
            )
        })
    })
@@ -294,7 +295,7 @@ describe("IndexProject", () => {
            })
            const callsWithFiles = progressCallback.mock.calls.filter(
-                (call) => call[0].currentFile && call[0].currentFile.length > 0
+                (call) => call[0].currentFile && call[0].currentFile.length > 0,
            )
            expect(callsWithFiles.length).toBeGreaterThan(0)
        })
@@ -307,7 +308,7 @@ describe("IndexProject", () => {
            })
            const parsingCalls = progressCallback.mock.calls.filter(
-                (call) => call[0].phase === "parsing"
+                (call) => call[0].phase === "parsing",
            )
            if (parsingCalls.length > 0) {
                expect(parsingCalls[0][0].total).toBe(2)
--- a/packages/ipuaro/tests/unit/domain/value-objects/FileMeta.test.ts
+++ b/packages/ipuaro/tests/unit/domain/value-objects/FileMeta.test.ts
@@ -1,5 +1,9 @@
 import { describe, it, expect } from "vitest"
-import { createFileMeta, isHubFile } from "../../../../src/domain/value-objects/FileMeta.js"
+import {
    calculateImpactScore,
    createFileMeta,
    isHubFile,
 } from "../../../../src/domain/value-objects/FileMeta.js"
 describe("FileMeta", () => {
    describe("createFileMeta", () => {
@@ -15,6 +19,7 @@ describe("FileMeta", () => {
            expect(meta.isHub).toBe(false)
            expect(meta.isEntryPoint).toBe(false)
            expect(meta.fileType).toBe("unknown")
            expect(meta.impactScore).toBe(0)
        })
        it("should merge partial values", () => {
@@ -42,4 +47,51 @@ describe("FileMeta", () => {
            expect(isHubFile(0)).toBe(false)
        })
    })
    describe("calculateImpactScore", () => {
        it("should return 0 for file with 0 dependents", () => {
            expect(calculateImpactScore(0, 10)).toBe(0)
        })
        it("should return 0 when totalFiles is 0", () => {
            expect(calculateImpactScore(5, 0)).toBe(0)
        })
        it("should return 0 when totalFiles is 1", () => {
            expect(calculateImpactScore(0, 1)).toBe(0)
        })
        it("should calculate correct percentage", () => {
            // 5 dependents out of 10 files (excluding itself = 9 possible)
            // 5/9 * 100 = 55.56 → rounded to 56
            expect(calculateImpactScore(5, 10)).toBe(56)
        })
        it("should return 100 when all other files depend on it", () => {
            // 9 dependents out of 10 files (9 possible dependents)
            expect(calculateImpactScore(9, 10)).toBe(100)
        })
        it("should cap at 100", () => {
            // Edge case: more dependents than possible (shouldn't happen normally)
            expect(calculateImpactScore(20, 10)).toBe(100)
        })
        it("should round the percentage", () => {
            // 1 dependent out of 3 files (2 possible)
            // 1/2 * 100 = 50
            expect(calculateImpactScore(1, 3)).toBe(50)
        })
        it("should calculate impact for small projects", () => {
            // 1 dependent out of 2 files (1 possible)
            expect(calculateImpactScore(1, 2)).toBe(100)
        })
        it("should calculate impact for larger projects", () => {
            // 50 dependents out of 100 files (99 possible)
            // 50/99 * 100 = 50.51 → rounded to 51
            expect(calculateImpactScore(50, 100)).toBe(51)
        })
    })
 })
--- a/packages/ipuaro/tests/unit/infrastructure/indexer/ASTParser.test.ts
+++ b/packages/ipuaro/tests/unit/infrastructure/indexer/ASTParser.test.ts
@@ -224,6 +224,62 @@ describe("ASTParser", () => {
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases[0].isExported).toBe(true)
        })
        it("should extract type alias definition (simple)", () => {
            const code = `type UserId = string`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("string")
        })
        it("should extract type alias definition (union)", () => {
            const code = `type Status = "pending" | "active" | "done"`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe('"pending" | "active" | "done"')
        })
        it("should extract type alias definition (intersection)", () => {
            const code = `type AdminUser = User & Admin`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("User & Admin")
        })
        it("should extract type alias definition (object type)", () => {
            const code = `type Point = { x: number; y: number }`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("{ x: number; y: number }")
        })
        it("should extract type alias definition (function type)", () => {
            const code = `type Handler = (event: Event) => void`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("(event: Event) => void")
        })
        it("should extract type alias definition (generic)", () => {
            const code = `type Result<T> = { success: boolean; data: T }`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("{ success: boolean; data: T }")
        })
        it("should extract type alias definition (array)", () => {
            const code = `type UserIds = string[]`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("string[]")
        })
        it("should extract type alias definition (tuple)", () => {
            const code = `type Pair = [string, number]`
            const ast = parser.parse(code, "ts")
            expect(ast.typeAliases).toHaveLength(1)
            expect(ast.typeAliases[0].definition).toBe("[string, number]")
        })
    })
    describe("exports", () => {
@@ -404,4 +460,376 @@ function mix(
            expect(ast.exports.length).toBeGreaterThanOrEqual(4)
        })
    })
    describe("JSON parsing", () => {
        it("should extract top-level keys from JSON object", () => {
            const json = `{
    "name": "test",
    "version": "1.0.0",
    "dependencies": {},
    "scripts": {}
 }`
            const ast = parser.parse(json, "json")
            expect(ast.parseError).toBe(false)
            expect(ast.exports).toHaveLength(4)
            expect(ast.exports.map((e) => e.name)).toEqual([
                "name",
                "version",
                "dependencies",
                "scripts",
            ])
            expect(ast.exports.every((e) => e.kind === "variable")).toBe(true)
        })
        it("should handle empty JSON object", () => {
            const json = `{}`
            const ast = parser.parse(json, "json")
            expect(ast.parseError).toBe(false)
            expect(ast.exports).toHaveLength(0)
        })
    })
    describe("YAML parsing", () => {
        it("should extract top-level keys from YAML", () => {
            const yaml = `name: test
 version: 1.0.0
 dependencies:
  foo: ^1.0.0
 scripts:
  test: vitest`
            const ast = parser.parse(yaml, "yaml")
            expect(ast.parseError).toBe(false)
            expect(ast.exports.length).toBeGreaterThanOrEqual(4)
            expect(ast.exports.map((e) => e.name)).toContain("name")
            expect(ast.exports.map((e) => e.name)).toContain("version")
            expect(ast.exports.every((e) => e.kind === "variable")).toBe(true)
        })
        it("should handle YAML array at root", () => {
            const yaml = `- item1
 - item2
 - item3`
            const ast = parser.parse(yaml, "yaml")
            expect(ast.parseError).toBe(false)
            expect(ast.exports).toHaveLength(1)
            expect(ast.exports[0].name).toBe("(array)")
        })
        it("should handle empty YAML", () => {
            const yaml = ``
            const ast = parser.parse(yaml, "yaml")
            expect(ast.parseError).toBe(false)
            expect(ast.exports).toHaveLength(0)
        })
        it("should handle YAML with null content", () => {
            const yaml = `null`
            const ast = parser.parse(yaml, "yaml")
            expect(ast.parseError).toBe(false)
            expect(ast.exports).toHaveLength(0)
        })
        it("should handle invalid YAML with parse error", () => {
            const yaml = `{invalid: yaml: syntax: [}`
            const ast = parser.parse(yaml, "yaml")
            expect(ast.parseError).toBe(true)
            expect(ast.parseErrorMessage).toBeDefined()
        })
        it("should track correct line numbers for YAML keys", () => {
            const yaml = `first: value1
 second: value2
 third: value3`
            const ast = parser.parse(yaml, "yaml")
            expect(ast.parseError).toBe(false)
            expect(ast.exports).toHaveLength(3)
            expect(ast.exports[0].line).toBe(1)
            expect(ast.exports[1].line).toBe(2)
            expect(ast.exports[2].line).toBe(3)
        })
    })
    describe("enums (0.24.3)", () => {
        it("should extract enum with numeric values", () => {
            const code = `enum Status {
                Active = 1,
                Inactive = 0,
                Pending = 2
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0]).toMatchObject({
                name: "Status",
                isExported: false,
                isConst: false,
            })
            expect(ast.enums[0].members).toHaveLength(3)
            expect(ast.enums[0].members[0]).toMatchObject({ name: "Active", value: 1 })
            expect(ast.enums[0].members[1]).toMatchObject({ name: "Inactive", value: 0 })
            expect(ast.enums[0].members[2]).toMatchObject({ name: "Pending", value: 2 })
        })
        it("should extract enum with string values", () => {
            const code = `enum Role {
                Admin = "admin",
                User = "user",
                Guest = "guest"
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].members).toHaveLength(3)
            expect(ast.enums[0].members[0]).toMatchObject({ name: "Admin", value: "admin" })
            expect(ast.enums[0].members[1]).toMatchObject({ name: "User", value: "user" })
            expect(ast.enums[0].members[2]).toMatchObject({ name: "Guest", value: "guest" })
        })
        it("should extract enum without explicit values", () => {
            const code = `enum Direction {
                Up,
                Down,
                Left,
                Right
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].members).toHaveLength(4)
            expect(ast.enums[0].members[0]).toMatchObject({ name: "Up", value: undefined })
            expect(ast.enums[0].members[1]).toMatchObject({ name: "Down", value: undefined })
        })
        it("should extract exported enum", () => {
            const code = `export enum Color {
                Red = "#FF0000",
                Green = "#00FF00",
                Blue = "#0000FF"
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].isExported).toBe(true)
            expect(ast.exports).toHaveLength(1)
            expect(ast.exports[0].kind).toBe("type")
        })
        it("should extract const enum", () => {
            const code = `const enum HttpStatus {
                OK = 200,
                NotFound = 404,
                InternalError = 500
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].isConst).toBe(true)
            expect(ast.enums[0].members[0]).toMatchObject({ name: "OK", value: 200 })
        })
        it("should extract exported const enum", () => {
            const code = `export const enum LogLevel {
                Debug = 0,
                Info = 1,
                Warn = 2,
                Error = 3
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].isExported).toBe(true)
            expect(ast.enums[0].isConst).toBe(true)
        })
        it("should extract line range for enum", () => {
            const code = `enum Test {
                A = 1,
                B = 2
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums[0].lineStart).toBe(1)
            expect(ast.enums[0].lineEnd).toBe(4)
        })
        it("should handle enum with negative values", () => {
            const code = `enum Temperature {
                Cold = -10,
                Freezing = -20,
                Hot = 40
            }`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].members[0]).toMatchObject({ name: "Cold", value: -10 })
            expect(ast.enums[0].members[1]).toMatchObject({ name: "Freezing", value: -20 })
            expect(ast.enums[0].members[2]).toMatchObject({ name: "Hot", value: 40 })
        })
        it("should handle empty enum", () => {
            const code = `enum Empty {}`
            const ast = parser.parse(code, "ts")
            expect(ast.enums).toHaveLength(1)
            expect(ast.enums[0].name).toBe("Empty")
            expect(ast.enums[0].members).toHaveLength(0)
        })
        it("should not extract enum from JavaScript", () => {
            const code = `enum Status { Active = 1 }`
            const ast = parser.parse(code, "js")
            expect(ast.enums).toHaveLength(0)
        })
    })
    describe("decorators (0.24.4)", () => {
        it("should extract class decorator", () => {
            const code = `@Controller('users')
 class UserController {}`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].decorators).toHaveLength(1)
            expect(ast.classes[0].decorators[0]).toBe("@Controller('users')")
        })
        it("should extract multiple class decorators", () => {
            const code = `@Controller('api')
@Injectable()
@UseGuards(AuthGuard)
 class ApiController {}`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].decorators).toHaveLength(3)
            expect(ast.classes[0].decorators[0]).toBe("@Controller('api')")
            expect(ast.classes[0].decorators[1]).toBe("@Injectable()")
            expect(ast.classes[0].decorators[2]).toBe("@UseGuards(AuthGuard)")
        })
        it("should extract method decorators", () => {
            const code = `class UserController {
    @Get(':id')
    @Auth()
    async getUser() {}
 }`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].methods).toHaveLength(1)
            expect(ast.classes[0].methods[0].decorators).toHaveLength(2)
            expect(ast.classes[0].methods[0].decorators[0]).toBe("@Get(':id')")
            expect(ast.classes[0].methods[0].decorators[1]).toBe("@Auth()")
        })
        it("should extract exported decorated class", () => {
            const code = `@Injectable()
 export class UserService {}`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].isExported).toBe(true)
            expect(ast.classes[0].decorators).toHaveLength(1)
            expect(ast.classes[0].decorators[0]).toBe("@Injectable()")
        })
        it("should extract decorator with complex arguments", () => {
            const code = `@Module({
    imports: [UserModule],
    controllers: [AppController],
    providers: [AppService]
 })
 class AppModule {}`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].decorators).toHaveLength(1)
            expect(ast.classes[0].decorators[0]).toContain("@Module")
            expect(ast.classes[0].decorators[0]).toContain("imports")
        })
        it("should extract decorated class with extends", () => {
            const code = `@Entity()
 class User extends BaseEntity {}`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].extends).toBe("BaseEntity")
            expect(ast.classes[0].decorators).toHaveLength(1)
            expect(ast.classes[0].decorators![0]).toBe("@Entity()")
        })
        it("should handle class without decorators", () => {
            const code = `class SimpleClass {}`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].decorators).toHaveLength(0)
        })
        it("should handle method without decorators", () => {
            const code = `class SimpleClass {
    simpleMethod() {}
 }`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].methods).toHaveLength(1)
            expect(ast.classes[0].methods[0].decorators).toHaveLength(0)
        })
        it("should handle function without decorators", () => {
            const code = `function simpleFunc() {}`
            const ast = parser.parse(code, "ts")
            expect(ast.functions).toHaveLength(1)
            expect(ast.functions[0].decorators).toHaveLength(0)
        })
        it("should handle arrow function without decorators", () => {
            const code = `const arrowFn = () => {}`
            const ast = parser.parse(code, "ts")
            expect(ast.functions).toHaveLength(1)
            expect(ast.functions[0].decorators).toHaveLength(0)
        })
        it("should extract NestJS controller pattern", () => {
            const code = `@Controller('users')
 export class UserController {
    @Get()
    findAll() {}
    @Get(':id')
    findOne() {}
    @Post()
    @Body()
    create() {}
 }`
            const ast = parser.parse(code, "ts")
            expect(ast.classes).toHaveLength(1)
            expect(ast.classes[0].decorators).toContain("@Controller('users')")
            expect(ast.classes[0].methods).toHaveLength(3)
            expect(ast.classes[0].methods[0].decorators).toContain("@Get()")
            expect(ast.classes[0].methods[1].decorators).toContain("@Get(':id')")
            expect(ast.classes[0].methods[2].decorators).toContain("@Post()")
        })
    })
 })
--- a/packages/ipuaro/tests/unit/infrastructure/llm/OllamaClient.test.ts
+++ b/packages/ipuaro/tests/unit/infrastructure/llm/OllamaClient.test.ts
@@ -123,8 +123,7 @@ describe("OllamaClient", () => {
            mockOllamaInstance.chat.mockResolvedValue({
                message: {
                    role: "assistant",
-                    content:
+                    content: '<tool_call name="get_lines"><path>src/index.ts</path></tool_call>',
                        '<tool_call name="get_lines"><path>src/index.ts</path></tool_call>',
                    tool_calls: undefined,
                },
                eval_count: 30,
@@ -408,7 +407,6 @@ describe("OllamaClient", () => {
        })
    })
    describe("error handling", () => {
        it("should handle ECONNREFUSED errors", async () => {
            mockOllamaInstance.chat.mockRejectedValue(new Error("ECONNREFUSED"))
@@ -435,7 +433,9 @@ describe("OllamaClient", () => {
            const client = new OllamaClient(defaultConfig)
-            await expect(client.chat([createUserMessage("Hello")])).rejects.toThrow(/Request was aborted/)
+            await expect(client.chat([createUserMessage("Hello")])).rejects.toThrow(
                /Request was aborted/,
            )
        })
        it("should handle model not found errors", async () => {
@@ -443,7 +443,9 @@ describe("OllamaClient", () => {
            const client = new OllamaClient(defaultConfig)
-            await expect(client.chat([createUserMessage("Hello")])).rejects.toThrow(/Model.*not found/)
+            await expect(client.chat([createUserMessage("Hello")])).rejects.toThrow(
                /Model.*not found/,
            )
        })
    })
 })
--- a/packages/ipuaro/tests/unit/infrastructure/llm/prompts.test.ts
+++ b/packages/ipuaro/tests/unit/infrastructure/llm/prompts.test.ts
--- a/packages/ipuaro/tests/unit/infrastructure/tools/read/GetFunctionTool.test.ts
+++ b/packages/ipuaro/tests/unit/infrastructure/tools/read/GetFunctionTool.test.ts
@@ -303,7 +303,9 @@ describe("GetFunctionTool", () => {
        })
        it("should handle error when reading lines fails", async () => {
-            const ast = createMockAST([createMockFunction({ name: "test", lineStart: 1, lineEnd: 1 })])
+            const ast = createMockAST([
                createMockFunction({ name: "test", lineStart: 1, lineEnd: 1 }),
            ])
            const storage: IStorage = {
                getFile: vi.fn().mockResolvedValue(null),
                getAST: vi.fn().mockResolvedValue(ast),
--- a/packages/ipuaro/tests/unit/infrastructure/tools/run/RunCommandTool.test.ts
+++ b/packages/ipuaro/tests/unit/infrastructure/tools/run/RunCommandTool.test.ts
@@ -354,6 +354,36 @@ describe("RunCommandTool", () => {
            expect(execFn).toHaveBeenCalledWith("ls", expect.objectContaining({ timeout: 5000 }))
        })
        it("should use config timeout", async () => {
            const execFn = createMockExec({})
            const toolWithMock = new RunCommandTool(undefined, execFn, { timeout: 45000 })
            const ctx = createMockContext()
            await toolWithMock.execute({ command: "ls" }, ctx)
            expect(execFn).toHaveBeenCalledWith("ls", expect.objectContaining({ timeout: 45000 }))
        })
        it("should use null config timeout as default", async () => {
            const execFn = createMockExec({})
            const toolWithMock = new RunCommandTool(undefined, execFn, { timeout: null })
            const ctx = createMockContext()
            await toolWithMock.execute({ command: "ls" }, ctx)
            expect(execFn).toHaveBeenCalledWith("ls", expect.objectContaining({ timeout: 30000 }))
        })
        it("should prefer param timeout over config timeout", async () => {
            const execFn = createMockExec({})
            const toolWithMock = new RunCommandTool(undefined, execFn, { timeout: 45000 })
            const ctx = createMockContext()
            await toolWithMock.execute({ command: "ls", timeout: 5000 }, ctx)
            expect(execFn).toHaveBeenCalledWith("ls", expect.objectContaining({ timeout: 5000 }))
        })
        it("should execute in project root", async () => {
            const execFn = createMockExec({})
            const toolWithMock = new RunCommandTool(undefined, execFn)
--- a/packages/ipuaro/tests/unit/shared/autocomplete-config.test.ts
+++ b/packages/ipuaro/tests/unit/shared/autocomplete-config.test.ts
@@ -0,0 +1,204 @@
 /**
 * Tests for AutocompleteConfigSchema.
 */
 import { describe, expect, it } from "vitest"
 import { AutocompleteConfigSchema } from "../../../src/shared/constants/config.js"
 describe("AutocompleteConfigSchema", () => {
    describe("default values", () => {
        it("should use defaults when empty object provided", () => {
            const result = AutocompleteConfigSchema.parse({})
            expect(result).toEqual({
                enabled: true,
                source: "redis-index",
                maxSuggestions: 10,
            })
        })
        it("should use defaults via .default({})", () => {
            const result = AutocompleteConfigSchema.default({}).parse({})
            expect(result).toEqual({
                enabled: true,
                source: "redis-index",
                maxSuggestions: 10,
            })
        })
    })
    describe("enabled", () => {
        it("should accept true", () => {
            const result = AutocompleteConfigSchema.parse({ enabled: true })
            expect(result.enabled).toBe(true)
        })
        it("should accept false", () => {
            const result = AutocompleteConfigSchema.parse({ enabled: false })
            expect(result.enabled).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => AutocompleteConfigSchema.parse({ enabled: "true" })).toThrow()
        })
        it("should reject number", () => {
            expect(() => AutocompleteConfigSchema.parse({ enabled: 1 })).toThrow()
        })
    })
    describe("source", () => {
        it("should accept redis-index", () => {
            const result = AutocompleteConfigSchema.parse({ source: "redis-index" })
            expect(result.source).toBe("redis-index")
        })
        it("should accept filesystem", () => {
            const result = AutocompleteConfigSchema.parse({ source: "filesystem" })
            expect(result.source).toBe("filesystem")
        })
        it("should accept both", () => {
            const result = AutocompleteConfigSchema.parse({ source: "both" })
            expect(result.source).toBe("both")
        })
        it("should use default redis-index", () => {
            const result = AutocompleteConfigSchema.parse({})
            expect(result.source).toBe("redis-index")
        })
        it("should reject invalid source", () => {
            expect(() => AutocompleteConfigSchema.parse({ source: "invalid" })).toThrow()
        })
        it("should reject non-string", () => {
            expect(() => AutocompleteConfigSchema.parse({ source: 123 })).toThrow()
        })
    })
    describe("maxSuggestions", () => {
        it("should accept valid positive integer", () => {
            const result = AutocompleteConfigSchema.parse({ maxSuggestions: 5 })
            expect(result.maxSuggestions).toBe(5)
        })
        it("should accept default value", () => {
            const result = AutocompleteConfigSchema.parse({ maxSuggestions: 10 })
            expect(result.maxSuggestions).toBe(10)
        })
        it("should accept large value", () => {
            const result = AutocompleteConfigSchema.parse({ maxSuggestions: 100 })
            expect(result.maxSuggestions).toBe(100)
        })
        it("should accept 1", () => {
            const result = AutocompleteConfigSchema.parse({ maxSuggestions: 1 })
            expect(result.maxSuggestions).toBe(1)
        })
        it("should reject zero", () => {
            expect(() => AutocompleteConfigSchema.parse({ maxSuggestions: 0 })).toThrow()
        })
        it("should reject negative number", () => {
            expect(() => AutocompleteConfigSchema.parse({ maxSuggestions: -5 })).toThrow()
        })
        it("should reject float", () => {
            expect(() => AutocompleteConfigSchema.parse({ maxSuggestions: 10.5 })).toThrow()
        })
        it("should reject non-number", () => {
            expect(() => AutocompleteConfigSchema.parse({ maxSuggestions: "10" })).toThrow()
        })
    })
    describe("partial config", () => {
        it("should merge partial config with defaults (enabled only)", () => {
            const result = AutocompleteConfigSchema.parse({
                enabled: false,
            })
            expect(result).toEqual({
                enabled: false,
                source: "redis-index",
                maxSuggestions: 10,
            })
        })
        it("should merge partial config with defaults (source only)", () => {
            const result = AutocompleteConfigSchema.parse({
                source: "filesystem",
            })
            expect(result).toEqual({
                enabled: true,
                source: "filesystem",
                maxSuggestions: 10,
            })
        })
        it("should merge partial config with defaults (maxSuggestions only)", () => {
            const result = AutocompleteConfigSchema.parse({
                maxSuggestions: 20,
            })
            expect(result).toEqual({
                enabled: true,
                source: "redis-index",
                maxSuggestions: 20,
            })
        })
        it("should merge multiple partial fields", () => {
            const result = AutocompleteConfigSchema.parse({
                enabled: false,
                maxSuggestions: 5,
            })
            expect(result).toEqual({
                enabled: false,
                source: "redis-index",
                maxSuggestions: 5,
            })
        })
    })
    describe("full config", () => {
        it("should accept valid full config", () => {
            const config = {
                enabled: false,
                source: "both" as const,
                maxSuggestions: 15,
            }
            const result = AutocompleteConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
        it("should accept all defaults explicitly", () => {
            const config = {
                enabled: true,
                source: "redis-index" as const,
                maxSuggestions: 10,
            }
            const result = AutocompleteConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
        it("should accept filesystem as source", () => {
            const config = {
                enabled: true,
                source: "filesystem" as const,
                maxSuggestions: 20,
            }
            const result = AutocompleteConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
    })
 })
--- a/packages/ipuaro/tests/unit/shared/commands-config.test.ts
+++ b/packages/ipuaro/tests/unit/shared/commands-config.test.ts
@@ -0,0 +1,137 @@
 /**
 * Tests for CommandsConfigSchema.
 */
 import { describe, expect, it } from "vitest"
 import { CommandsConfigSchema } from "../../../src/shared/constants/config.js"
 describe("CommandsConfigSchema", () => {
    describe("default values", () => {
        it("should use defaults when empty object provided", () => {
            const result = CommandsConfigSchema.parse({})
            expect(result).toEqual({
                timeout: null,
            })
        })
        it("should use defaults via .default({})", () => {
            const result = CommandsConfigSchema.default({}).parse({})
            expect(result).toEqual({
                timeout: null,
            })
        })
    })
    describe("timeout", () => {
        it("should accept null (default)", () => {
            const result = CommandsConfigSchema.parse({ timeout: null })
            expect(result.timeout).toBe(null)
        })
        it("should accept positive integer", () => {
            const result = CommandsConfigSchema.parse({ timeout: 5000 })
            expect(result.timeout).toBe(5000)
        })
        it("should accept large timeout", () => {
            const result = CommandsConfigSchema.parse({ timeout: 600000 })
            expect(result.timeout).toBe(600000)
        })
        it("should accept 1", () => {
            const result = CommandsConfigSchema.parse({ timeout: 1 })
            expect(result.timeout).toBe(1)
        })
        it("should accept small timeout", () => {
            const result = CommandsConfigSchema.parse({ timeout: 100 })
            expect(result.timeout).toBe(100)
        })
        it("should reject zero", () => {
            expect(() => CommandsConfigSchema.parse({ timeout: 0 })).toThrow()
        })
        it("should reject negative number", () => {
            expect(() => CommandsConfigSchema.parse({ timeout: -5000 })).toThrow()
        })
        it("should reject float", () => {
            expect(() => CommandsConfigSchema.parse({ timeout: 5000.5 })).toThrow()
        })
        it("should reject string", () => {
            expect(() => CommandsConfigSchema.parse({ timeout: "5000" })).toThrow()
        })
        it("should reject boolean", () => {
            expect(() => CommandsConfigSchema.parse({ timeout: true })).toThrow()
        })
        it("should reject undefined (use null instead)", () => {
            const result = CommandsConfigSchema.parse({ timeout: undefined })
            expect(result.timeout).toBe(null)
        })
    })
    describe("partial config", () => {
        it("should use default null when timeout not provided", () => {
            const result = CommandsConfigSchema.parse({})
            expect(result).toEqual({
                timeout: null,
            })
        })
        it("should accept explicit null", () => {
            const result = CommandsConfigSchema.parse({
                timeout: null,
            })
            expect(result).toEqual({
                timeout: null,
            })
        })
        it("should accept explicit timeout value", () => {
            const result = CommandsConfigSchema.parse({
                timeout: 10000,
            })
            expect(result).toEqual({
                timeout: 10000,
            })
        })
    })
    describe("full config", () => {
        it("should accept valid config with null", () => {
            const config = {
                timeout: null,
            }
            const result = CommandsConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
        it("should accept valid config with timeout", () => {
            const config = {
                timeout: 30000,
            }
            const result = CommandsConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
        it("should accept default explicitly", () => {
            const config = {
                timeout: null,
            }
            const result = CommandsConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
    })
 })
--- a/packages/ipuaro/tests/unit/shared/context-config.test.ts
+++ b/packages/ipuaro/tests/unit/shared/context-config.test.ts
@@ -0,0 +1,349 @@
 /**
 * Tests for ContextConfigSchema.
 */
 import { describe, expect, it } from "vitest"
 import { ContextConfigSchema } from "../../../src/shared/constants/config.js"
 describe("ContextConfigSchema", () => {
    describe("default values", () => {
        it("should use defaults when empty object provided", () => {
            const result = ContextConfigSchema.parse({})
            expect(result).toEqual({
                systemPromptTokens: 2000,
                maxContextUsage: 0.8,
                autoCompressAt: 0.8,
                compressionMethod: "llm-summary",
                includeSignatures: true,
                includeDepsGraph: true,
                includeCircularDeps: true,
                includeHighImpactFiles: true,
            })
        })
        it("should use defaults via .default({})", () => {
            const result = ContextConfigSchema.default({}).parse({})
            expect(result).toEqual({
                systemPromptTokens: 2000,
                maxContextUsage: 0.8,
                autoCompressAt: 0.8,
                compressionMethod: "llm-summary",
                includeSignatures: true,
                includeDepsGraph: true,
                includeCircularDeps: true,
                includeHighImpactFiles: true,
            })
        })
    })
    describe("systemPromptTokens", () => {
        it("should accept valid positive integer", () => {
            const result = ContextConfigSchema.parse({ systemPromptTokens: 1500 })
            expect(result.systemPromptTokens).toBe(1500)
        })
        it("should accept default value", () => {
            const result = ContextConfigSchema.parse({ systemPromptTokens: 2000 })
            expect(result.systemPromptTokens).toBe(2000)
        })
        it("should accept large value", () => {
            const result = ContextConfigSchema.parse({ systemPromptTokens: 5000 })
            expect(result.systemPromptTokens).toBe(5000)
        })
        it("should reject zero", () => {
            expect(() => ContextConfigSchema.parse({ systemPromptTokens: 0 })).toThrow()
        })
        it("should reject negative number", () => {
            expect(() => ContextConfigSchema.parse({ systemPromptTokens: -100 })).toThrow()
        })
        it("should reject float", () => {
            expect(() => ContextConfigSchema.parse({ systemPromptTokens: 1500.5 })).toThrow()
        })
        it("should reject non-number", () => {
            expect(() => ContextConfigSchema.parse({ systemPromptTokens: "2000" })).toThrow()
        })
    })
    describe("maxContextUsage", () => {
        it("should accept valid ratio", () => {
            const result = ContextConfigSchema.parse({ maxContextUsage: 0.7 })
            expect(result.maxContextUsage).toBe(0.7)
        })
        it("should accept default value", () => {
            const result = ContextConfigSchema.parse({ maxContextUsage: 0.8 })
            expect(result.maxContextUsage).toBe(0.8)
        })
        it("should accept minimum value (0)", () => {
            const result = ContextConfigSchema.parse({ maxContextUsage: 0 })
            expect(result.maxContextUsage).toBe(0)
        })
        it("should accept maximum value (1)", () => {
            const result = ContextConfigSchema.parse({ maxContextUsage: 1 })
            expect(result.maxContextUsage).toBe(1)
        })
        it("should reject value above 1", () => {
            expect(() => ContextConfigSchema.parse({ maxContextUsage: 1.1 })).toThrow()
        })
        it("should reject negative value", () => {
            expect(() => ContextConfigSchema.parse({ maxContextUsage: -0.1 })).toThrow()
        })
        it("should reject non-number", () => {
            expect(() => ContextConfigSchema.parse({ maxContextUsage: "0.8" })).toThrow()
        })
    })
    describe("autoCompressAt", () => {
        it("should accept valid ratio", () => {
            const result = ContextConfigSchema.parse({ autoCompressAt: 0.75 })
            expect(result.autoCompressAt).toBe(0.75)
        })
        it("should accept default value", () => {
            const result = ContextConfigSchema.parse({ autoCompressAt: 0.8 })
            expect(result.autoCompressAt).toBe(0.8)
        })
        it("should accept minimum value (0)", () => {
            const result = ContextConfigSchema.parse({ autoCompressAt: 0 })
            expect(result.autoCompressAt).toBe(0)
        })
        it("should accept maximum value (1)", () => {
            const result = ContextConfigSchema.parse({ autoCompressAt: 1 })
            expect(result.autoCompressAt).toBe(1)
        })
        it("should reject value above 1", () => {
            expect(() => ContextConfigSchema.parse({ autoCompressAt: 1.5 })).toThrow()
        })
        it("should reject negative value", () => {
            expect(() => ContextConfigSchema.parse({ autoCompressAt: -0.5 })).toThrow()
        })
        it("should reject non-number", () => {
            expect(() => ContextConfigSchema.parse({ autoCompressAt: "0.8" })).toThrow()
        })
    })
    describe("compressionMethod", () => {
        it("should accept llm-summary", () => {
            const result = ContextConfigSchema.parse({ compressionMethod: "llm-summary" })
            expect(result.compressionMethod).toBe("llm-summary")
        })
        it("should accept truncate", () => {
            const result = ContextConfigSchema.parse({ compressionMethod: "truncate" })
            expect(result.compressionMethod).toBe("truncate")
        })
        it("should reject invalid method", () => {
            expect(() => ContextConfigSchema.parse({ compressionMethod: "invalid" })).toThrow()
        })
        it("should reject non-string", () => {
            expect(() => ContextConfigSchema.parse({ compressionMethod: 123 })).toThrow()
        })
    })
    describe("partial config", () => {
        it("should merge partial config with defaults (systemPromptTokens)", () => {
            const result = ContextConfigSchema.parse({
                systemPromptTokens: 3000,
            })
            expect(result).toEqual({
                systemPromptTokens: 3000,
                maxContextUsage: 0.8,
                autoCompressAt: 0.8,
                compressionMethod: "llm-summary",
                includeSignatures: true,
                includeDepsGraph: true,
                includeCircularDeps: true,
                includeHighImpactFiles: true,
            })
        })
        it("should merge partial config with defaults (autoCompressAt)", () => {
            const result = ContextConfigSchema.parse({
                autoCompressAt: 0.9,
            })
            expect(result).toEqual({
                systemPromptTokens: 2000,
                maxContextUsage: 0.8,
                autoCompressAt: 0.9,
                compressionMethod: "llm-summary",
                includeSignatures: true,
                includeDepsGraph: true,
                includeCircularDeps: true,
                includeHighImpactFiles: true,
            })
        })
        it("should merge multiple partial fields", () => {
            const result = ContextConfigSchema.parse({
                maxContextUsage: 0.7,
                compressionMethod: "truncate",
            })
            expect(result).toEqual({
                systemPromptTokens: 2000,
                maxContextUsage: 0.7,
                autoCompressAt: 0.8,
                compressionMethod: "truncate",
                includeSignatures: true,
                includeDepsGraph: true,
                includeCircularDeps: true,
                includeHighImpactFiles: true,
            })
        })
    })
    describe("full config", () => {
        it("should accept valid full config", () => {
            const config = {
                systemPromptTokens: 3000,
                maxContextUsage: 0.9,
                autoCompressAt: 0.85,
                compressionMethod: "truncate" as const,
                includeSignatures: false,
                includeDepsGraph: false,
                includeCircularDeps: false,
                includeHighImpactFiles: false,
            }
            const result = ContextConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
        it("should accept all defaults explicitly", () => {
            const config = {
                systemPromptTokens: 2000,
                maxContextUsage: 0.8,
                autoCompressAt: 0.8,
                compressionMethod: "llm-summary" as const,
                includeSignatures: true,
                includeDepsGraph: true,
                includeCircularDeps: true,
                includeHighImpactFiles: true,
            }
            const result = ContextConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
    })
    describe("includeSignatures", () => {
        it("should accept true", () => {
            const result = ContextConfigSchema.parse({ includeSignatures: true })
            expect(result.includeSignatures).toBe(true)
        })
        it("should accept false", () => {
            const result = ContextConfigSchema.parse({ includeSignatures: false })
            expect(result.includeSignatures).toBe(false)
        })
        it("should default to true", () => {
            const result = ContextConfigSchema.parse({})
            expect(result.includeSignatures).toBe(true)
        })
        it("should reject non-boolean", () => {
            expect(() => ContextConfigSchema.parse({ includeSignatures: "true" })).toThrow()
        })
        it("should reject number", () => {
            expect(() => ContextConfigSchema.parse({ includeSignatures: 1 })).toThrow()
        })
    })
    describe("includeDepsGraph", () => {
        it("should accept true", () => {
            const result = ContextConfigSchema.parse({ includeDepsGraph: true })
            expect(result.includeDepsGraph).toBe(true)
        })
        it("should accept false", () => {
            const result = ContextConfigSchema.parse({ includeDepsGraph: false })
            expect(result.includeDepsGraph).toBe(false)
        })
        it("should default to true", () => {
            const result = ContextConfigSchema.parse({})
            expect(result.includeDepsGraph).toBe(true)
        })
        it("should reject non-boolean", () => {
            expect(() => ContextConfigSchema.parse({ includeDepsGraph: "true" })).toThrow()
        })
        it("should reject number", () => {
            expect(() => ContextConfigSchema.parse({ includeDepsGraph: 1 })).toThrow()
        })
    })
    describe("includeCircularDeps", () => {
        it("should accept true", () => {
            const result = ContextConfigSchema.parse({ includeCircularDeps: true })
            expect(result.includeCircularDeps).toBe(true)
        })
        it("should accept false", () => {
            const result = ContextConfigSchema.parse({ includeCircularDeps: false })
            expect(result.includeCircularDeps).toBe(false)
        })
        it("should default to true", () => {
            const result = ContextConfigSchema.parse({})
            expect(result.includeCircularDeps).toBe(true)
        })
        it("should reject non-boolean", () => {
            expect(() => ContextConfigSchema.parse({ includeCircularDeps: "true" })).toThrow()
        })
        it("should reject number", () => {
            expect(() => ContextConfigSchema.parse({ includeCircularDeps: 1 })).toThrow()
        })
    })
    describe("includeHighImpactFiles", () => {
        it("should accept true", () => {
            const result = ContextConfigSchema.parse({ includeHighImpactFiles: true })
            expect(result.includeHighImpactFiles).toBe(true)
        })
        it("should accept false", () => {
            const result = ContextConfigSchema.parse({ includeHighImpactFiles: false })
            expect(result.includeHighImpactFiles).toBe(false)
        })
        it("should default to true", () => {
            const result = ContextConfigSchema.parse({})
            expect(result.includeHighImpactFiles).toBe(true)
        })
        it("should reject non-boolean", () => {
            expect(() => ContextConfigSchema.parse({ includeHighImpactFiles: "true" })).toThrow()
        })
        it("should reject number", () => {
            expect(() => ContextConfigSchema.parse({ includeHighImpactFiles: 1 })).toThrow()
        })
    })
 })
--- a/packages/ipuaro/tests/unit/shared/display-config.test.ts
+++ b/packages/ipuaro/tests/unit/shared/display-config.test.ts
@@ -0,0 +1,150 @@
 /**
 * Tests for DisplayConfigSchema.
 */
 import { describe, expect, it } from "vitest"
 import { DisplayConfigSchema } from "../../../src/shared/constants/config.js"
 describe("DisplayConfigSchema", () => {
    describe("default values", () => {
        it("should use defaults when empty object provided", () => {
            const result = DisplayConfigSchema.parse({})
            expect(result).toEqual({
                showStats: true,
                showToolCalls: true,
                theme: "dark",
                bellOnComplete: false,
                progressBar: true,
            })
        })
        it("should use defaults via .default({})", () => {
            const result = DisplayConfigSchema.default({}).parse({})
            expect(result).toEqual({
                showStats: true,
                showToolCalls: true,
                theme: "dark",
                bellOnComplete: false,
                progressBar: true,
            })
        })
    })
    describe("showStats", () => {
        it("should accept true", () => {
            const result = DisplayConfigSchema.parse({ showStats: true })
            expect(result.showStats).toBe(true)
        })
        it("should accept false", () => {
            const result = DisplayConfigSchema.parse({ showStats: false })
            expect(result.showStats).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => DisplayConfigSchema.parse({ showStats: "yes" })).toThrow()
        })
    })
    describe("showToolCalls", () => {
        it("should accept true", () => {
            const result = DisplayConfigSchema.parse({ showToolCalls: true })
            expect(result.showToolCalls).toBe(true)
        })
        it("should accept false", () => {
            const result = DisplayConfigSchema.parse({ showToolCalls: false })
            expect(result.showToolCalls).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => DisplayConfigSchema.parse({ showToolCalls: "yes" })).toThrow()
        })
    })
    describe("theme", () => {
        it("should accept dark", () => {
            const result = DisplayConfigSchema.parse({ theme: "dark" })
            expect(result.theme).toBe("dark")
        })
        it("should accept light", () => {
            const result = DisplayConfigSchema.parse({ theme: "light" })
            expect(result.theme).toBe("light")
        })
        it("should reject invalid theme", () => {
            expect(() => DisplayConfigSchema.parse({ theme: "blue" })).toThrow()
        })
        it("should reject non-string", () => {
            expect(() => DisplayConfigSchema.parse({ theme: 123 })).toThrow()
        })
    })
    describe("bellOnComplete", () => {
        it("should accept true", () => {
            const result = DisplayConfigSchema.parse({ bellOnComplete: true })
            expect(result.bellOnComplete).toBe(true)
        })
        it("should accept false", () => {
            const result = DisplayConfigSchema.parse({ bellOnComplete: false })
            expect(result.bellOnComplete).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => DisplayConfigSchema.parse({ bellOnComplete: "yes" })).toThrow()
        })
    })
    describe("progressBar", () => {
        it("should accept true", () => {
            const result = DisplayConfigSchema.parse({ progressBar: true })
            expect(result.progressBar).toBe(true)
        })
        it("should accept false", () => {
            const result = DisplayConfigSchema.parse({ progressBar: false })
            expect(result.progressBar).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => DisplayConfigSchema.parse({ progressBar: "yes" })).toThrow()
        })
    })
    describe("partial config", () => {
        it("should merge partial config with defaults", () => {
            const result = DisplayConfigSchema.parse({
                theme: "light",
                bellOnComplete: true,
            })
            expect(result).toEqual({
                showStats: true,
                showToolCalls: true,
                theme: "light",
                bellOnComplete: true,
                progressBar: true,
            })
        })
    })
    describe("full config", () => {
        it("should accept valid full config", () => {
            const config = {
                showStats: false,
                showToolCalls: false,
                theme: "light" as const,
                bellOnComplete: true,
                progressBar: false,
            }
            const result = DisplayConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
    })
 })
--- a/packages/ipuaro/tests/unit/shared/session-config.test.ts
+++ b/packages/ipuaro/tests/unit/shared/session-config.test.ts
@@ -0,0 +1,146 @@
 /**
 * Tests for SessionConfigSchema.
 */
 import { describe, expect, it } from "vitest"
 import { SessionConfigSchema } from "../../../src/shared/constants/config.js"
 describe("SessionConfigSchema", () => {
    describe("default values", () => {
        it("should use defaults when empty object provided", () => {
            const result = SessionConfigSchema.parse({})
            expect(result).toEqual({
                persistIndefinitely: true,
                maxHistoryMessages: 100,
                saveInputHistory: true,
            })
        })
        it("should use defaults via .default({})", () => {
            const result = SessionConfigSchema.default({}).parse({})
            expect(result).toEqual({
                persistIndefinitely: true,
                maxHistoryMessages: 100,
                saveInputHistory: true,
            })
        })
    })
    describe("persistIndefinitely", () => {
        it("should accept true", () => {
            const result = SessionConfigSchema.parse({ persistIndefinitely: true })
            expect(result.persistIndefinitely).toBe(true)
        })
        it("should accept false", () => {
            const result = SessionConfigSchema.parse({ persistIndefinitely: false })
            expect(result.persistIndefinitely).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => SessionConfigSchema.parse({ persistIndefinitely: "yes" })).toThrow()
        })
    })
    describe("maxHistoryMessages", () => {
        it("should accept valid positive integer", () => {
            const result = SessionConfigSchema.parse({ maxHistoryMessages: 50 })
            expect(result.maxHistoryMessages).toBe(50)
        })
        it("should accept default value", () => {
            const result = SessionConfigSchema.parse({ maxHistoryMessages: 100 })
            expect(result.maxHistoryMessages).toBe(100)
        })
        it("should accept large value", () => {
            const result = SessionConfigSchema.parse({ maxHistoryMessages: 1000 })
            expect(result.maxHistoryMessages).toBe(1000)
        })
        it("should reject zero", () => {
            expect(() => SessionConfigSchema.parse({ maxHistoryMessages: 0 })).toThrow()
        })
        it("should reject negative number", () => {
            expect(() => SessionConfigSchema.parse({ maxHistoryMessages: -10 })).toThrow()
        })
        it("should reject float", () => {
            expect(() => SessionConfigSchema.parse({ maxHistoryMessages: 10.5 })).toThrow()
        })
        it("should reject non-number", () => {
            expect(() => SessionConfigSchema.parse({ maxHistoryMessages: "100" })).toThrow()
        })
    })
    describe("saveInputHistory", () => {
        it("should accept true", () => {
            const result = SessionConfigSchema.parse({ saveInputHistory: true })
            expect(result.saveInputHistory).toBe(true)
        })
        it("should accept false", () => {
            const result = SessionConfigSchema.parse({ saveInputHistory: false })
            expect(result.saveInputHistory).toBe(false)
        })
        it("should reject non-boolean", () => {
            expect(() => SessionConfigSchema.parse({ saveInputHistory: "yes" })).toThrow()
        })
    })
    describe("partial config", () => {
        it("should merge partial config with defaults", () => {
            const result = SessionConfigSchema.parse({
                maxHistoryMessages: 50,
            })
            expect(result).toEqual({
                persistIndefinitely: true,
                maxHistoryMessages: 50,
                saveInputHistory: true,
            })
        })
        it("should merge multiple partial fields", () => {
            const result = SessionConfigSchema.parse({
                persistIndefinitely: false,
                saveInputHistory: false,
            })
            expect(result).toEqual({
                persistIndefinitely: false,
                maxHistoryMessages: 100,
                saveInputHistory: false,
            })
        })
    })
    describe("full config", () => {
        it("should accept valid full config", () => {
            const config = {
                persistIndefinitely: false,
                maxHistoryMessages: 200,
                saveInputHistory: false,
            }
            const result = SessionConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
        it("should accept all defaults explicitly", () => {
            const config = {
                persistIndefinitely: true,
                maxHistoryMessages: 100,
                saveInputHistory: true,
            }
            const result = SessionConfigSchema.parse(config)
            expect(result).toEqual(config)
        })
    })
 })
--- a/packages/ipuaro/tests/unit/tui/components/Input.test.ts
+++ b/packages/ipuaro/tests/unit/tui/components/Input.test.ts
@@ -181,4 +181,174 @@ describe("Input", () => {
            expect(savedInput).toBe("")
        })
    })
    describe("multiline support", () => {
        describe("InputProps with multiline", () => {
            it("should accept multiline as boolean", () => {
                const props: InputProps = {
                    onSubmit: vi.fn(),
                    history: [],
                    disabled: false,
                    multiline: true,
                }
                expect(props.multiline).toBe(true)
            })
            it("should accept multiline as 'auto'", () => {
                const props: InputProps = {
                    onSubmit: vi.fn(),
                    history: [],
                    disabled: false,
                    multiline: "auto",
                }
                expect(props.multiline).toBe("auto")
            })
            it("should have multiline false by default", () => {
                const props: InputProps = {
                    onSubmit: vi.fn(),
                    history: [],
                    disabled: false,
                }
                expect(props.multiline).toBeUndefined()
            })
        })
        describe("multiline activation logic", () => {
            it("should be active when multiline is true", () => {
                const multiline = true
                const lines = ["single line"]
                const isMultilineActive =
                    multiline === true || (multiline === "auto" && lines.length > 1)
                expect(isMultilineActive).toBe(true)
            })
            it("should not be active when multiline is false", () => {
                const multiline = false
                const lines = ["line1", "line2"]
                const isMultilineActive =
                    multiline === true || (multiline === "auto" && lines.length > 1)
                expect(isMultilineActive).toBe(false)
            })
            it("should be active in auto mode with multiple lines", () => {
                const multiline = "auto"
                const lines = ["line1", "line2"]
                const isMultilineActive =
                    multiline === true || (multiline === "auto" && lines.length > 1)
                expect(isMultilineActive).toBe(true)
            })
            it("should not be active in auto mode with single line", () => {
                const multiline = "auto"
                const lines = ["single line"]
                const isMultilineActive =
                    multiline === true || (multiline === "auto" && lines.length > 1)
                expect(isMultilineActive).toBe(false)
            })
        })
        describe("line management", () => {
            it("should update current line on change", () => {
                const lines = ["first", "second", "third"]
                const currentLineIndex = 1
                const newValue = "updated second"
                const newLines = [...lines]
                newLines[currentLineIndex] = newValue
                expect(newLines).toEqual(["first", "updated second", "third"])
                expect(newLines.join("\n")).toBe("first\nupdated second\nthird")
            })
            it("should add new line at current position", () => {
                const lines = ["first", "second"]
                const currentLineIndex = 0
                const newLines = [...lines]
                newLines.splice(currentLineIndex + 1, 0, "")
                expect(newLines).toEqual(["first", "", "second"])
            })
            it("should join lines with newline for submit", () => {
                const lines = ["line 1", "line 2", "line 3"]
                const fullText = lines.join("\n")
                expect(fullText).toBe("line 1\nline 2\nline 3")
            })
        })
        describe("line navigation", () => {
            it("should navigate up in multiline mode", () => {
                const lines = ["line1", "line2", "line3"]
                let currentLineIndex = 2
                currentLineIndex = currentLineIndex - 1
                expect(currentLineIndex).toBe(1)
                currentLineIndex = currentLineIndex - 1
                expect(currentLineIndex).toBe(0)
            })
            it("should not navigate up past first line", () => {
                const lines = ["line1", "line2"]
                const currentLineIndex = 0
                const isMultilineActive = true
                const canNavigateUp = isMultilineActive && currentLineIndex > 0
                expect(canNavigateUp).toBe(false)
            })
            it("should navigate down in multiline mode", () => {
                const lines = ["line1", "line2", "line3"]
                let currentLineIndex = 0
                currentLineIndex = currentLineIndex + 1
                expect(currentLineIndex).toBe(1)
                currentLineIndex = currentLineIndex + 1
                expect(currentLineIndex).toBe(2)
            })
            it("should not navigate down past last line", () => {
                const lines = ["line1", "line2"]
                const currentLineIndex = 1
                const isMultilineActive = true
                const canNavigateDown = isMultilineActive && currentLineIndex < lines.length - 1
                expect(canNavigateDown).toBe(false)
            })
        })
        describe("multiline submit", () => {
            it("should submit trimmed multiline text", () => {
                const lines = ["line 1", "line 2", "line 3"]
                const fullText = lines.join("\n").trim()
                expect(fullText).toBe("line 1\nline 2\nline 3")
            })
            it("should not submit empty multiline text", () => {
                const onSubmit = vi.fn()
                const lines = ["", "", ""]
                const fullText = lines.join("\n").trim()
                if (fullText) {
                    onSubmit(fullText)
                }
                expect(onSubmit).not.toHaveBeenCalled()
            })
            it("should reset lines after submit", () => {
                let lines = ["line1", "line2"]
                let currentLineIndex = 1
                lines = [""]
                currentLineIndex = 0
                expect(lines).toEqual([""])
                expect(currentLineIndex).toBe(0)
            })
        })
    })
 })
--- a/packages/ipuaro/tests/unit/tui/utils/bell.test.ts
+++ b/packages/ipuaro/tests/unit/tui/utils/bell.test.ts
@@ -0,0 +1,29 @@
 /**
 * Tests for bell utility.
 */
 import { describe, expect, it, vi } from "vitest"
 import { ringBell } from "../../../../src/tui/utils/bell.js"
 describe("ringBell", () => {
    it("should write bell character to stdout", () => {
        const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true)
        ringBell()
        expect(writeSpy).toHaveBeenCalledWith("\u0007")
        writeSpy.mockRestore()
    })
    it("should write correct ASCII bell character", () => {
        const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true)
        ringBell()
        const callArg = writeSpy.mock.calls[0]?.[0]
        expect(callArg).toBe("\u0007")
        expect(callArg?.charCodeAt(0)).toBe(7)
        writeSpy.mockRestore()
    })
 })
--- a/packages/ipuaro/tests/unit/tui/utils/syntax-highlighter.test.ts
+++ b/packages/ipuaro/tests/unit/tui/utils/syntax-highlighter.test.ts
@@ -0,0 +1,155 @@
 /**
 * Tests for syntax-highlighter utility.
 */
 import { describe, expect, it } from "vitest"
 import { detectLanguage, highlightLine } from "../../../../src/tui/utils/syntax-highlighter.js"
 describe("syntax-highlighter", () => {
    describe("detectLanguage", () => {
        it("should detect typescript from .ts extension", () => {
            expect(detectLanguage("src/index.ts")).toBe("typescript")
        })
        it("should detect tsx from .tsx extension", () => {
            expect(detectLanguage("src/Component.tsx")).toBe("tsx")
        })
        it("should detect javascript from .js extension", () => {
            expect(detectLanguage("dist/bundle.js")).toBe("javascript")
        })
        it("should detect jsx from .jsx extension", () => {
            expect(detectLanguage("src/App.jsx")).toBe("jsx")
        })
        it("should detect json from .json extension", () => {
            expect(detectLanguage("package.json")).toBe("json")
        })
        it("should detect yaml from .yaml extension", () => {
            expect(detectLanguage("config.yaml")).toBe("yaml")
        })
        it("should detect yaml from .yml extension", () => {
            expect(detectLanguage("config.yml")).toBe("yaml")
        })
        it("should return unknown for unsupported extensions", () => {
            expect(detectLanguage("image.png")).toBe("unknown")
            expect(detectLanguage("file")).toBe("unknown")
        })
        it("should handle case insensitive extensions", () => {
            expect(detectLanguage("FILE.TS")).toBe("typescript")
            expect(detectLanguage("FILE.JSX")).toBe("jsx")
        })
    })
    describe("highlightLine", () => {
        describe("unknown language", () => {
            it("should return plain text for unknown language", () => {
                const tokens = highlightLine("hello world", "unknown")
                expect(tokens).toEqual([{ text: "hello world", color: "white" }])
            })
        })
        describe("json language", () => {
            it("should return plain text for json", () => {
                const tokens = highlightLine('{"key": "value"}', "json")
                expect(tokens).toEqual([{ text: '{"key": "value"}', color: "white" }])
            })
        })
        describe("yaml language", () => {
            it("should return plain text for yaml", () => {
                const tokens = highlightLine("key: value", "yaml")
                expect(tokens).toEqual([{ text: "key: value", color: "white" }])
            })
        })
        describe("typescript/javascript highlighting", () => {
            it("should highlight keywords", () => {
                const tokens = highlightLine("const x = 10", "typescript")
                expect(tokens[0]).toEqual({ text: "const", color: "magenta" })
                expect(tokens.find((t) => t.text === "x")).toEqual({ text: "x", color: "white" })
            })
            it("should highlight strings with double quotes", () => {
                const tokens = highlightLine('const s = "hello"', "typescript")
                expect(tokens.find((t) => t.text === '"hello"')).toEqual({
                    text: '"hello"',
                    color: "green",
                })
            })
            it("should highlight strings with single quotes", () => {
                const tokens = highlightLine("const s = 'hello'", "typescript")
                expect(tokens.find((t) => t.text === "'hello'")).toEqual({
                    text: "'hello'",
                    color: "green",
                })
            })
            it("should highlight template literals", () => {
                const tokens = highlightLine("const s = `hello`", "typescript")
                expect(tokens.find((t) => t.text === "`hello`")).toEqual({
                    text: "`hello`",
                    color: "green",
                })
            })
            it("should highlight numbers", () => {
                const tokens = highlightLine("const n = 42", "typescript")
                expect(tokens.find((t) => t.text === "42")).toEqual({ text: "42", color: "cyan" })
            })
            it("should highlight single-line comments", () => {
                const tokens = highlightLine("// this is a comment", "typescript")
                expect(tokens[0]).toEqual({ text: "// this is a comment", color: "gray" })
            })
            it("should highlight multi-line comments", () => {
                const tokens = highlightLine("/* comment */", "typescript")
                expect(tokens[0]).toEqual({ text: "/* comment */", color: "gray" })
            })
            it("should highlight operators", () => {
                const tokens = highlightLine("x + y = z", "typescript")
                expect(tokens.find((t) => t.text === "+")).toEqual({ text: "+", color: "yellow" })
                expect(tokens.find((t) => t.text === "=")).toEqual({ text: "=", color: "yellow" })
            })
            it("should highlight parentheses and brackets", () => {
                const tokens = highlightLine("foo(bar[0])", "typescript")
                expect(tokens.find((t) => t.text === "(")).toEqual({ text: "(", color: "yellow" })
                expect(tokens.find((t) => t.text === "[")).toEqual({ text: "[", color: "yellow" })
                expect(tokens.find((t) => t.text === "]")).toEqual({ text: "]", color: "yellow" })
                expect(tokens.find((t) => t.text === ")")).toEqual({ text: ")", color: "yellow" })
            })
            it("should handle mixed content", () => {
                const tokens = highlightLine('const x = "test" + 42', "typescript")
                expect(tokens.find((t) => t.text === "const")).toEqual({
                    text: "const",
                    color: "magenta",
                })
                expect(tokens.find((t) => t.text === '"test"')).toEqual({
                    text: '"test"',
                    color: "green",
                })
                expect(tokens.find((t) => t.text === "42")).toEqual({ text: "42", color: "cyan" })
            })
            it("should preserve whitespace", () => {
                const tokens = highlightLine("  const  x  =  10  ", "typescript")
                expect(tokens[0]).toEqual({ text: "  ", color: "white" })
            })
            it("should handle empty lines", () => {
                const tokens = highlightLine("", "typescript")
                expect(tokens).toEqual([])
            })
        })
    })
 })
--- a/packages/ipuaro/tests/unit/tui/utils/theme.test.ts
+++ b/packages/ipuaro/tests/unit/tui/utils/theme.test.ts
@@ -0,0 +1,163 @@
 /**
 * Tests for theme utilities.
 */
 import { describe, expect, it } from "vitest"
 import {
    getColorScheme,
    getContextColor,
    getRoleColor,
    getStatusColor,
 } from "../../../../src/tui/utils/theme.js"
 describe("theme utilities", () => {
    describe("getColorScheme", () => {
        it("should return dark theme colors for dark", () => {
            const scheme = getColorScheme("dark")
            expect(scheme).toEqual({
                primary: "cyan",
                secondary: "blue",
                success: "green",
                warning: "yellow",
                error: "red",
                info: "cyan",
                muted: "gray",
                background: "black",
                foreground: "white",
            })
        })
        it("should return light theme colors for light", () => {
            const scheme = getColorScheme("light")
            expect(scheme).toEqual({
                primary: "blue",
                secondary: "cyan",
                success: "green",
                warning: "yellow",
                error: "red",
                info: "blue",
                muted: "gray",
                background: "white",
                foreground: "black",
            })
        })
    })
    describe("getStatusColor", () => {
        it("should return success color for ready status", () => {
            const color = getStatusColor("ready", "dark")
            expect(color).toBe("green")
        })
        it("should return warning color for thinking status", () => {
            const color = getStatusColor("thinking", "dark")
            expect(color).toBe("yellow")
        })
        it("should return warning color for tool_call status", () => {
            const color = getStatusColor("tool_call", "dark")
            expect(color).toBe("yellow")
        })
        it("should return info color for awaiting_confirmation status", () => {
            const color = getStatusColor("awaiting_confirmation", "dark")
            expect(color).toBe("cyan")
        })
        it("should return error color for error status", () => {
            const color = getStatusColor("error", "dark")
            expect(color).toBe("red")
        })
        it("should use light theme colors when theme is light", () => {
            const color = getStatusColor("awaiting_confirmation", "light")
            expect(color).toBe("blue")
        })
        it("should use dark theme by default", () => {
            const color = getStatusColor("ready")
            expect(color).toBe("green")
        })
    })
    describe("getRoleColor", () => {
        it("should return success color for user role", () => {
            const color = getRoleColor("user", "dark")
            expect(color).toBe("green")
        })
        it("should return primary color for assistant role", () => {
            const color = getRoleColor("assistant", "dark")
            expect(color).toBe("cyan")
        })
        it("should return muted color for system role", () => {
            const color = getRoleColor("system", "dark")
            expect(color).toBe("gray")
        })
        it("should return secondary color for tool role", () => {
            const color = getRoleColor("tool", "dark")
            expect(color).toBe("blue")
        })
        it("should use light theme colors when theme is light", () => {
            const color = getRoleColor("assistant", "light")
            expect(color).toBe("blue")
        })
        it("should use dark theme by default", () => {
            const color = getRoleColor("user")
            expect(color).toBe("green")
        })
    })
    describe("getContextColor", () => {
        it("should return success color for low usage", () => {
            const color = getContextColor(0.5, "dark")
            expect(color).toBe("green")
        })
        it("should return warning color for medium usage", () => {
            const color = getContextColor(0.7, "dark")
            expect(color).toBe("yellow")
        })
        it("should return error color for high usage", () => {
            const color = getContextColor(0.9, "dark")
            expect(color).toBe("red")
        })
        it("should return success color at 59% usage", () => {
            const color = getContextColor(0.59, "dark")
            expect(color).toBe("green")
        })
        it("should return warning color at 60% usage", () => {
            const color = getContextColor(0.6, "dark")
            expect(color).toBe("yellow")
        })
        it("should return warning color at 79% usage", () => {
            const color = getContextColor(0.79, "dark")
            expect(color).toBe("yellow")
        })
        it("should return error color at 80% usage", () => {
            const color = getContextColor(0.8, "dark")
            expect(color).toBe("red")
        })
        it("should use light theme colors when theme is light", () => {
            const color = getContextColor(0.7, "light")
            expect(color).toBe("yellow")
        })
        it("should use dark theme by default", () => {
            const color = getContextColor(0.5)
            expect(color).toBe("green")
        })
    })
 })
--- a/packages/ipuaro/vitest.config.ts
+++ b/packages/ipuaro/vitest.config.ts
@@ -24,7 +24,7 @@ export default defineConfig({
            thresholds: {
                lines: 95,
                functions: 95,
-                branches: 91.5,
+                branches: 91,
                statements: 95,
            },
        },
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -131,7 +131,7 @@ importers:
        version: 5.9.3
      vitest:
        specifier: ^4.0.10
-        version: 4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)
+        version: 4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2)
  packages/ipuaro:
    dependencies:
@@ -168,9 +168,15 @@ importers:
      tree-sitter-javascript:
        specifier: ^0.21.0
        version: 0.21.4(tree-sitter@0.21.1)
      tree-sitter-json:
        specifier: ^0.24.8
        version: 0.24.8(tree-sitter@0.21.1)
      tree-sitter-typescript:
        specifier: ^0.21.2
        version: 0.21.2(tree-sitter@0.21.1)
      yaml:
        specifier: ^2.8.2
        version: 2.8.2
      zod:
        specifier: ^3.23.8
        version: 3.25.76
@@ -201,7 +207,7 @@ importers:
        version: 18.3.1(react@18.3.1)
      tsup:
        specifier: ^8.3.5
-        version: 8.5.1(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)
+        version: 8.5.1(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.2)
      typescript:
        specifier: ^5.7.2
        version: 5.9.3
@@ -4172,6 +4178,14 @@ packages:
      tree-sitter:
        optional: true
  tree-sitter-json@0.24.8:
    resolution: {integrity: sha512-Tc9ZZYwHyWZ3Tt1VEw7Pa2scu1YO7/d2BCBbKTx5hXwig3UfdQjsOPkPyLpDJOn/m1UBEWYAtSdGAwCSyagBqQ==}
    peerDependencies:
      tree-sitter: ^0.21.1
    peerDependenciesMeta:
      tree-sitter:
        optional: true
  tree-sitter-typescript@0.21.2:
    resolution: {integrity: sha512-/RyNK41ZpkA8PuPZimR6pGLvNR1p0ibRUJwwQn4qAjyyLEIQD/BNlwS3NSxWtGsAWZe9gZ44VK1mWx2+eQVldg==}
    peerDependencies:
@@ -4636,6 +4650,11 @@ packages:
  yallist@3.1.1:
    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
  yaml@2.8.2:
    resolution: {integrity: sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==}
    engines: {node: '>= 14.6'}
    hasBin: true
  yargs-parser@21.1.1:
    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
    engines: {node: '>=12'}
@@ -6325,7 +6344,7 @@ snapshots:
      magicast: 0.5.1
      std-env: 3.10.0
      tinyrainbow: 3.0.3
-      vitest: 4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)
+      vitest: 4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2)
    transitivePeerDependencies:
      - supports-color
@@ -6344,13 +6363,13 @@ snapshots:
      chai: 6.2.1
      tinyrainbow: 3.0.3
-  '@vitest/mocker@4.0.13(vite@7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6))':
+  '@vitest/mocker@4.0.13(vite@7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2))':
    dependencies:
      '@vitest/spy': 4.0.13
      estree-walker: 3.0.3
      magic-string: 0.30.21
    optionalDependencies:
-      vite: 7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)
+      vite: 7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2)
  '@vitest/pretty-format@4.0.13':
    dependencies:
@@ -6405,7 +6424,7 @@ snapshots:
      sirv: 3.0.2
      tinyglobby: 0.2.15
      tinyrainbow: 3.0.3
-      vitest: 4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)
+      vitest: 4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2)
  '@vitest/utils@1.6.1':
    dependencies:
@@ -8392,12 +8411,13 @@ snapshots:
  pluralize@8.0.0: {}
-  postcss-load-config@6.0.1(postcss@8.5.6)(tsx@4.20.6):
+  postcss-load-config@6.0.1(postcss@8.5.6)(tsx@4.20.6)(yaml@2.8.2):
    dependencies:
      lilconfig: 3.1.3
    optionalDependencies:
      postcss: 8.5.6
      tsx: 4.20.6
      yaml: 2.8.2
  postcss@8.5.6:
    dependencies:
@@ -8911,6 +8931,13 @@ snapshots:
    optionalDependencies:
      tree-sitter: 0.21.1
  tree-sitter-json@0.24.8(tree-sitter@0.21.1):
    dependencies:
      node-addon-api: 8.5.0
      node-gyp-build: 4.8.4
    optionalDependencies:
      tree-sitter: 0.21.1
  tree-sitter-typescript@0.21.2(tree-sitter@0.21.1):
    dependencies:
      node-addon-api: 8.5.0
@@ -8999,7 +9026,7 @@ snapshots:
  tslib@2.8.1: {}
-  tsup@8.5.1(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3):
+  tsup@8.5.1(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.8.2):
    dependencies:
      bundle-require: 5.1.0(esbuild@0.27.0)
      cac: 6.7.14
@@ -9010,7 +9037,7 @@ snapshots:
      fix-dts-default-cjs-exports: 1.0.1
      joycon: 3.1.1
      picocolors: 1.1.1
-      postcss-load-config: 6.0.1(postcss@8.5.6)(tsx@4.20.6)
+      postcss-load-config: 6.0.1(postcss@8.5.6)(tsx@4.20.6)(yaml@2.8.2)
      resolve-from: 5.0.0
      rollup: 4.53.3
      source-map: 0.7.6
@@ -9156,7 +9183,7 @@ snapshots:
      fsevents: 2.3.3
      terser: 5.44.1
-  vite@7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6):
+  vite@7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2):
    dependencies:
      esbuild: 0.25.12
      fdir: 6.5.0(picomatch@4.0.3)
@@ -9169,6 +9196,7 @@ snapshots:
      fsevents: 2.3.3
      terser: 5.44.1
      tsx: 4.20.6
      yaml: 2.8.2
  vitest@1.6.1(@types/node@22.19.1)(@vitest/ui@1.6.1)(jsdom@27.2.0)(terser@5.44.1):
    dependencies:
@@ -9206,10 +9234,10 @@ snapshots:
      - supports-color
      - terser
-  vitest@4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6):
+  vitest@4.0.13(@types/node@22.19.1)(@vitest/ui@4.0.13)(jsdom@27.2.0)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2):
    dependencies:
      '@vitest/expect': 4.0.13
-      '@vitest/mocker': 4.0.13(vite@7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6))
+      '@vitest/mocker': 4.0.13(vite@7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2))
      '@vitest/pretty-format': 4.0.13
      '@vitest/runner': 4.0.13
      '@vitest/snapshot': 4.0.13
@@ -9226,7 +9254,7 @@ snapshots:
      tinyexec: 0.3.2
      tinyglobby: 0.2.15
      tinyrainbow: 3.0.3
-      vite: 7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)
+      vite: 7.2.4(@types/node@22.19.1)(terser@5.44.1)(tsx@4.20.6)(yaml@2.8.2)
      why-is-node-running: 2.3.0
    optionalDependencies:
      '@types/node': 22.19.1
@@ -9366,6 +9394,8 @@ snapshots:
  yallist@3.1.1: {}
  yaml@2.8.2: {}
  yargs-parser@21.1.1: {}
  yargs@17.7.2:
Author	SHA1	Message	Date
imfozilbek	92ba3fd9ba	chore(ipuaro): release v0.29.0	2025-12-05 15:44:27 +05:00
imfozilbek	e9aaa708fe	feat(ipuaro): add impact score to initial context Add High Impact Files section to initial context showing which files are most critical based on percentage of codebase that depends on them. Changes: - Add impactScore field to FileMeta (0-100) - Add calculateImpactScore() helper function - Update MetaAnalyzer to compute impact scores - Add formatHighImpactFiles() to prompts.ts - Add includeHighImpactFiles config option (default: true) - 28 new tests (1826 total)	2025-12-05 15:43:24 +05:00
imfozilbek	d6d15dd271	feat(ipuaro): add circular dependencies to initial context - Add formatCircularDeps() to display cycle chains in context - Add includeCircularDeps config option (default: true) - Add circularDeps parameter to BuildContextOptions - Format: ## ⚠️ Circular Dependencies with → arrows - 23 new tests (1798 total), 97.48% coverage	2025-12-05 15:12:26 +05:00
imfozilbek	d63d85d850	feat(ipuaro): add inline dependency graph to initial context - Add formatDependencyGraph() to show file relationships in LLM context - Add includeDepsGraph option to ContextConfigSchema (default: true) - Format: "services/user: → types/user ← controllers/user" - Hub files shown first, sorted by total connections - 21 new tests for dependency graph functionality	2025-12-05 14:38:45 +05:00
imfozilbek	41cfc21f20	docs(ipuaro): align roadmap versions with package versions	2025-12-05 14:20:14 +05:00
imfozilbek	eeaa223436	chore(ipuaro): release v0.26.0	2025-12-05 13:51:13 +05:00
imfozilbek	36768c06d1	feat(ipuaro): add decorator extraction to initial context Extract decorators from classes and methods for NestJS/Angular support. Decorators are now shown in initial context: - @Controller('users') class UserController - @Get(':id') async getUser(id: string): Promise<User> Changes: - Add decorators field to FunctionInfo, MethodInfo, ClassInfo - Update ASTParser to extract decorators from tree-sitter nodes - Update formatFileSummary to display decorators prefix - Add 18 unit tests for decorator extraction and formatting	2025-12-05 13:38:46 +05:00
imfozilbek	5a22cd5c9b	feat(ipuaro): add enum value definitions to initial context Extract enum declarations with member names and values from TypeScript AST and display them in the initial LLM context. This allows the LLM to know valid enum values without making tool calls. Features: - Numeric values (Active=1) - String values (Admin="admin") - Implicit values (Up, Down) - Negative numbers (Cold=-10) - const enum modifier - export enum modifier - Long enum truncation (>100 chars) Adds EnumInfo and EnumMemberInfo interfaces, extractEnum() method in ASTParser, formatEnumSignature() in prompts.ts, and 17 new unit tests.	2025-12-05 13:14:51 +05:00
imfozilbek	806c9281b0	chore(ipuaro): release v0.25.0	2025-12-04 22:49:35 +05:00
imfozilbek	12197a9624	feat(ipuaro): add interface fields and type alias definitions to context - Add interface field display in initial context: interface User { id: string, name: string } - Add type alias definition display: type UserId = string - Support readonly fields, extends, union/intersection types - Add definition field to TypeAliasInfo in FileAST - Update ASTParser to extract type alias definitions - Add formatInterfaceSignature() and formatTypeAliasSignature() helpers - Truncate long type definitions at 80 characters - Translate ROADMAP.md from Russian to English - Add 18 new tests for interface fields and type aliases	2025-12-04 22:49:03 +05:00
imfozilbek	1489b69e69	chore(ipuaro): release v0.24.0	2025-12-04 22:29:31 +05:00
imfozilbek	2dcb22812c	feat(ipuaro): add function signatures to initial context - Add full function signatures with parameter types and return types - Arrow functions now extract returnType in ASTParser - New formatFunctionSignature() helper in prompts.ts - Add includeSignatures config option (default: true) - Support compact format when includeSignatures: false - 15 new tests, coverage 91.14% branches	2025-12-04 22:29:02 +05:00
imfozilbek	7d7c99fe4d	docs(ipuaro): add v0.24.0 and v0.25.0 to roadmap for rich context Add two new milestones before 1.0.0 release: v0.24.0 - Rich Initial Context: - Function signatures with types - Interface/Type field definitions - Enum value definitions - Decorator extraction v0.25.0 - Graph Metrics in Context: - Inline dependency graph - Circular dependencies display - Impact score for critical files - Transitive dependencies count Update 1.0.0 checklist to require both milestones. Update context budget table with new token estimates.	2025-12-04 22:07:38 +05:00
imfozilbek	a3f0ba948f	chore(ipuaro): release v0.23.0	2025-12-04 19:59:36 +05:00
imfozilbek	141888bf59	feat(ipuaro): add JSON/YAML parsing and symlinks metadata - Add YAML parsing using yaml npm package - Add JSON parsing using tree-sitter-json - Add symlinkTarget to ScanResult interface - Update ROADMAP: verify v0.20.0-v0.23.0 complete - Add 8 new tests (1687 total)	2025-12-04 19:57:06 +05:00
imfozilbek	b0f1778f3a	docs(guardian): add research citations for 15 roadmap features Add comprehensive research citations for upcoming features: - Domain Event Usage Validation (Section 15) - Value Object Immutability (Section 16) - CQS/CQRS (Section 17) - Factory Pattern (Section 18) - Specification Pattern (Section 19) - Bounded Context (Section 20) - Persistence Ignorance (Section 21) - Null Object Pattern (Section 22) - Primitive Obsession (Section 23) - Service Locator Anti-pattern (Section 24) - Double Dispatch/Visitor Pattern (Section 25) - Entity Identity (Section 26) - Saga Pattern (Section 27) - Anti-Corruption Layer (Section 28) - Ubiquitous Language (Section 29) Sources include: GoF Design Patterns, Bertrand Meyer, Eric Evans, Vaughn Vernon, Martin Fowler, Chris Richardson, Mark Seemann, and academic papers (Garcia-Molina Sagas 1987). Document version: 1.1 → 2.0	2025-12-04 19:11:54 +05:00
imfozilbek	9c94335729	feat(ipuaro): add commands configuration - Add CommandsConfigSchema with timeout option - Integrate timeout configuration in RunCommandTool - Add 22 new unit tests (19 schema + 3 integration) - Complete v0.22.0 Extended Configuration milestone	2025-12-02 03:03:57 +05:00
imfozilbek	c34d57c231	chore(ipuaro): release v0.22.4	2025-12-02 02:29:56 +05:00
imfozilbek	60052c0db9	feat(ipuaro): add autocomplete configuration - Add AutocompleteConfigSchema with enabled, source, maxSuggestions - Update useAutocomplete hook to read from config - Add 27 unit tests for autocomplete config - Fix unused variable in Chat component - Update ROADMAP and CHANGELOG	2025-12-02 02:26:36 +05:00
imfozilbek	fa647c41aa	feat(ipuaro): add context configuration - Add ContextConfigSchema with systemPromptTokens, maxContextUsage, autoCompressAt, compressionMethod - Update ContextManager to read compression threshold from config - Update HandleMessage and useSession to pass context config - Add 40 unit tests (32 schema + 8 integration) - Coverage: 97.63% lines, 91.34% branches	2025-12-02 02:02:34 +05:00
imfozilbek	98b365bd94	chore(ipuaro): release v0.22.2	2025-12-02 01:39:37 +05:00
imfozilbek	a7669f8947	feat(ipuaro): add session configuration - Add SessionConfigSchema with persistIndefinitely, maxHistoryMessages, saveInputHistory - Implement Session.truncateHistory() method for limiting message history - Update HandleMessage to support history truncation and input history toggle - Add config flow through useSession and App components - Add 19 unit tests for SessionConfigSchema - Update CHANGELOG.md and ROADMAP.md for v0.22.2	2025-12-02 01:34:04 +05:00
imfozilbek	7f0ec49c90	chore(ipuaro): release v0.22.1	2025-12-02 01:03:11 +05:00
imfozilbek	077d160343	feat(ipuaro): add display configuration Add DisplayConfigSchema with theme support (dark/light), stats/tool calls visibility toggles, bell notification on completion, and progress bar control. Includes theme utilities with dynamic color schemes and 46 new tests.	2025-12-02 01:01:54 +05:00
imfozilbek	b5ee77d8b8	chore(ipuaro): release v0.21.4	2025-12-02 00:38:41 +05:00
imfozilbek	a589b0dfc4	feat(ipuaro): add multiline input and syntax highlighting - Multiline input support with Shift+Enter for new lines - Auto-height adjustment and line navigation - Syntax highlighting in DiffView for added lines - Language detection from file extensions - Config options for multiline and syntaxHighlight	2025-12-02 00:31:21 +05:00
imfozilbek	908c2f50d7	chore(ipuaro): release v0.21.1	2025-12-02 00:05:10 +05:00
imfozilbek	510c42241a	feat(ipuaro): add edit mode in ConfirmDialog - New EditableContent component for inline editing - ConfirmDialog supports [E] to edit proposed changes - ExecuteTool handles edited content from user - ConfirmationResult type with editedContent field - App.tsx implements Promise-based confirmation flow - All 1484 tests passing, 0 ESLint errors	2025-12-02 00:00:37 +05:00