agile-context-engineering 0.2.2 → 0.5.0

package/skills/map-subsystem/templates/system.xml

@@ -0,0 +1,381 @@
+<system>
+    <purpose>
+        Template for `.docs/wiki/subsystems/[subsystem-name]/systems/<system-name>.md` — a coherent
+        domain system within a codebase subsystem. Answers "How does this system work RIGHT NOW?"
+
+        Each system doc describes WHAT exists, HOW it works, and WHERE things live for one
+        domain concern. It is the primary document an AI agent reads before implementing a
+        related story.
+
+        A "system" is a logical grouping of components that together deliver one domain capability
+        (e.g., Drawing System, User Management, Order Processing). A codebase subsystem may
+        contain multiple systems.
+
+        Complements:
+        - patterns/ docs (HOW to apply reusable implementation patterns)
+        - cross-cutting/ docs (concerns spanning multiple systems)
+        - guides/ docs (step-by-step recipes combining multiple patterns)
+        - decisions/ docs (WHY significant choices were made)
+    </purpose>
+
+    <template>
+        <overview>
+            # [System Name]
+
+            ## Overview
+            One paragraph: what this system does, why it exists.
+        </overview>
+
+        <file-tree>
+            ## File Tree
+
+            All files belonging to this system with purpose annotations.
+            Update when new files are added by a story.
+
+            ```
+            src/[layer]/[area]/
+            |-- FileA.ts                    # Brief purpose
+            |-- FileB.ts                    # Brief purpose
+            `-- subfolder/
+                |-- FileC.ts                # Brief purpose
+                `-- FileD.ts                # Brief purpose
+            ```
+        </file-tree>
+
+        <system-boundary>
+            ## System Boundary
+
+            Mermaid diagram showing what is INSIDE this system vs what it connects to OUTSIDE.
+            Helps agents understand scope — what to touch, what NOT to touch.
+
+            ```mermaid
+            graph TB
+                subgraph "System Name"
+                    A[Component A]
+                    B[Component B]
+                    C[Component C]
+                end
+                External[External System]
+                B --&gt; External
+            ```
+        </system-boundary>
+
+        <class-and-interface-hierarchy>
+            ## Class and Interface Hierarchy
+
+            Inheritance chains and interface implementations.
+
+            ```mermaid
+            classDiagram
+                class IExample {
+                    &lt;&lt;interface&gt;&gt;
+                }
+                class BaseClass {
+                    &lt;&lt;abstract&gt;&gt;
+                }
+                IExample &lt;|.. BaseClass
+                BaseClass &lt;|-- ConcreteA
+                BaseClass &lt;|-- ConcreteB
+            ```
+
+            Key contracts INLINE (only interfaces/types that define the API shape):
+
+            ```typescript
+            export interface IExample {
+                // Only the contract shape — not implementation code
+            }
+            ```
+        </class-and-interface-hierarchy>
+
+        <entry-points>
+            ## Entry Points
+
+            Where flows begin. Each entry point is a "front door" into this system.
+            - User action: Click on chart -&gt; `file:MouseHandler.onClick`
+            - API endpoint: POST /api/resource -&gt; `file:ResourceController.create`
+            - Event handler: onTimeframeChange -&gt; `file:VisibilityManager.handleTimeframeChange`
+        </entry-points>
+
+        <data-flow-and-sequence-diagrams required="true">
+            ## Data Flow and Sequence Diagrams
+
+            **MANDATORY — every system doc MUST have at least one mermaid sequenceDiagram.**
+            This is the most critical section. Without E2E flow diagrams, an agent cannot
+            understand how data moves through the system.
+
+            How data moves through this system for each key behavior.
+            Use mermaid sequence diagrams showing the complete flow through all layers.
+
+            ### Flow: [Behavior Name]
+
+            ```mermaid
+            sequenceDiagram
+                participant User
+                participant Entry as EntryPoint
+                participant Svc as Service
+                participant Domain as DomainEntity
+                participant Repo as Repository
+                participant DB as DataStore
+
+                User-&gt;&gt;Entry: action
+                Entry-&gt;&gt;Svc: command/query
+                Svc-&gt;&gt;Domain: business logic
+                Domain--&gt;&gt;Svc: result
+                Svc-&gt;&gt;Repo: persist/retrieve
+                Repo-&gt;&gt;DB: SQL/query
+                DB--&gt;&gt;Repo: result
+                Repo--&gt;&gt;Svc: domain object
+                Svc--&gt;&gt;Entry: response
+                Entry--&gt;&gt;User: feedback
+            ```
+        </data-flow-and-sequence-diagrams>
+
+        <components>
+            ## Components
+
+            ### [Component A]
+            - **Location**: `src/infrastructure/primitives/trend-line/TrendLine.ts:TrendLine`
+            - **Purpose**: One line
+            - **Key interface**: `src/domain/interfaces/IDrawing.ts:IDrawing`
+            - **Implements**: ISeriesPrimitive, IDrawing
+
+            ### [Component B]
+            ...
+        </components>
+
+        <key-behaviors>
+            ## Key Behaviors
+
+            ### [Behavior 1]
+            - **Trigger**: What causes this behavior
+            - **Logic**: Where the logic lives (`file:ClassName.method`), brief description
+            - **Effect**: What happens as a result
+
+            ### [Behavior 2]
+            ...
+        </key-behaviors>
+
+        <state-management>
+            ## State Management
+
+            What state this system owns, where it lives, how it flows.
+            - **State location**: Redux store at `file:drawingSlice` / local state in `file:DrawingManager`
+            - **Key state shape**: (inline only if non-obvious)
+            - **State transitions**: What actions/events cause state changes
+        </state-management>
+
+        <error-propagation>
+            ## Error Propagation
+
+            What errors this system throws/handles and how they propagate through layers.
+            - `DrawingValidationError` at `file:Path.validate` -&gt; caught by `file:DrawingFactory` -&gt; user notification
+            - `RepositoryError` at `file:ResourceRepository.save` -&gt; propagates to controller -&gt; HTTP 500
+        </error-propagation>
+
+        <constants-and-enums>
+            ## Constants and Enums
+
+            Where constants and enums for this system are defined. Agent MUST use these, never hardcode.
+            - **Constants**: `src/domain/constants/DrawingConstants.ts:DrawingConstants`
+            - **Enums**: `src/domain/enums/DrawingType.ts:DrawingType`
+            - **Config lookup**: `src/domain/configs/DrawingConfigLookup.ts:DrawingConfigLookup`
+        </constants-and-enums>
+
+        <related-systems>
+            ## Related Systems
+
+            What other systems this one interacts with. Agent should read these docs before modifying.
+            - [Event System](../cross-cutting/event-system.md) — publishes/subscribes to events
+            - [Settings System](./settings-system.md) — configuration modal
+        </related-systems>
+
+        <integration-points>
+            ## Integration Points
+
+            - Connects to: [other system] via [mechanism] at `file:ClassName.method`
+            - Consumed by: [component] at `file:ClassName.method`
+        </integration-points>
+
+        <configuration-and-options>
+            ## Configuration and Options
+
+            Options interface shape and defaults. Agent needs this to implement new variants.
+
+            ```typescript
+            export interface ISystemOptions {
+                // Contract shape — what options this system accepts
+            }
+            ```
+
+            Default values: `file:SystemDefaults.ts:SYSTEM_DEFAULTS`
+        </configuration-and-options>
+
+        <database>
+            ## Database
+
+            Include ONLY if this system has database interactions. Omit entirely for pure frontend systems.
+
+            - **Table**: `table_name` — migration at `file:migrations/20240101_CreateTable.sql`
+            - **Key columns**: id, type, data (jsonb), created_at
+            - **Indexes**: `idx_table_column` on `column`
+        </database>
+
+        <gotchas>
+            ## Gotchas
+
+            Things that commonly go wrong or are easy to forget when working with this system.
+            - Constructor timing: factory methods called from `super()` BEFORE subclass fields initialize
+            - Button IDs have NO hyphens, registry types DO have hyphens
+        </gotchas>
+
+        <tech-debt>
+            ## Tech Debt
+
+            Known quality issues in this system discovered during story code reviews.
+            Items are added by the wiki mapper and removed when fixed by a future story.
+            Include ONLY if this system has known tech debt items. Omit section entirely if clean.
+
+            ### [Short descriptive title of the issue]
+            - **Severity:** high | medium | low
+            - **File:** `[file-path:SymbolName]`
+            - **Description:** What the issue is, why it matters, and what could go wrong
+              if left unfixed. Reference specific code constructs where applicable.
+            - **Discovered during:** [story-id] — [story title]
+
+            ### [Another issue]
+            - **Severity:** ...
+            - **File:** ...
+            - **Description:** ...
+            - **Discovered during:** ...
+        </tech-debt>
+    </template>
+
+    <guidelines>
+
+        **Documentation Style:**
+        - EXTREMELY SUCCINCT — every word must add value
+        - NO FLUFF — direct, actionable information only
+        - Bullet points over paragraphs
+        - File trees: ASCII only (`|--`, backtick-dash-dash) — never Unicode box-drawing characters
+        - **ALL visual representations of architecture, dependencies, flows, or relationships MUST be ```mermaid fenced code blocks. NO ASCII arrows (->), NO dependency trees, NO PlantUML. Only mermaid. The ONLY ASCII exception is file trees (directory listings).**
+        - Code references as `file-path:ClassName.methodName` or `file-path:functionName` (not line numbers)
+        - Inline snippets ONLY for interfaces, types, and short patterns that define contracts
+        - When referencing a whole class/module: `file-path:ClassName`
+        - When referencing a specific method: `file-path:ClassName.methodName`
+        - When referencing a standalone function: `file-path:functionName`
+        - When referencing a type/interface: `file-path:InterfaceName`
+
+        **Overview:**
+        - ONE paragraph. If you need more, the system boundary is too large — split it.
+        - State what the system DOES, not what it IS.
+
+        **File Tree:**
+        - List ALL files belonging to this system, grouped by directory.
+        - Every file gets a `# Brief purpose` comment.
+        - Use ASCII only: `|--` for branches, backtick-dash-dash for last item, `|` for continuation.
+        - Paths relative to subsystem root.
+
+        **System Boundary:**
+        - The mermaid diagram must clearly separate INSIDE from OUTSIDE.
+        - An agent reading this knows: "If my change touches something inside, I'm in scope.
+          If it touches something outside, I need to read that system's doc too."
+
+        **Class and Interface Hierarchy:**
+        - Use mermaid `classDiagram` for inheritance and interface implementation.
+        - Inline code snippets ONLY for interface/type contracts — never implementation code.
+        - If the hierarchy is trivial (1 class, no inheritance), omit this section.
+
+        **Entry Points:**
+        - Every "front door" into this system. An agent needs to know WHERE flows start.
+        - Use `file:ClassName.methodName` references.
+
+        **Data Flow and Sequence Diagrams (MANDATORY — never skip):**
+        - Every system doc MUST have at least one ```mermaid sequenceDiagram.
+        - One sequence diagram per key behavior (1-5 behaviors typically).
+        - Show COMPLETE E2E flow through all layers — entry to data store and back.
+        - Participants = components, not files. Keep it at the right abstraction level.
+        - If you cannot trace the flow, read more source files until you can. Do NOT skip.
+
+        **Components:**
+        - One subsection per major component. Location + Purpose + Key interface.
+        - Skip trivial components (DTOs, simple value objects) unless they define important contracts.
+
+        **Key Behaviors:**
+        - Trigger -&gt; Logic -&gt; Effect format. Concise.
+        - Reference code locations with `file:ClassName.method`.
+
+        **State Management:**
+        - Where state lives (Redux, local, database) and what causes transitions.
+        - Omit if the system is stateless or state is trivial.
+
+        **Error Propagation:**
+        - How errors flow through layers. What gets caught where.
+        - Omit if error handling follows a system-wide pattern documented in cross-cutting.
+
+        **Constants and Enums:**
+        - CRITICAL for AI agents — they must NEVER hardcode values.
+        - Always list the exact file paths where constants and enums are defined.
+
+        **Related Systems:**
+        - Cross-reference with markdown links to other docs.
+        - Agent should read these before modifying this system.
+
+        **Tech Debt:**
+        - One `###` subsection per known issue — NOT a table. Each issue needs enough context
+          for an agent to understand the problem without reading the code.
+        - Severity: `high` (security, data loss, production instability), `medium` (quality,
+          maintainability), `low` (cosmetic, minor inefficiency).
+        - Always link to the discovering story for traceability.
+        - REMOVE items when fixed by a future story.
+        - Omit the entire section if no tech debt exists in this system.
+
+        **Section Inclusion:**
+        - Include ALL sections that are relevant to the system.
+        - OMIT sections that genuinely don't apply (e.g., no Database for pure frontend).
+        - **NEVER omit Data Flow and Sequence Diagrams** — this section is always required.
+        - When updating, ADD or expand sections — don't rewrite sections that haven't changed.
+
+        **What does NOT belong here:**
+        - Story numbers, sprint context, or agile artifacts
+        - Planned vs Actual comparisons
+        - Acceptance criteria checklists
+        - Revision history (git handles this)
+        - Duplicated implementation code (reference it, don't copy it)
+        - Line numbers in references (they go stale)
+        - Testing docs, coverage metrics, test code
+        - Performance benchmarks
+        - Debugging utilities
+        - ASCII arrows or dependency trees (use mermaid; exception: file trees use ASCII)
+
+    </guidelines>
+
+    <evolution>
+
+        This is a LIVING document — updated after each story that touches this system.
+
+        **Update triggers:**
+        - New component added to this system
+        - New behavior or entry point introduced
+        - Existing behavior changed significantly
+        - New integration point or dependency added
+        - Class hierarchy changed (new subclass, interface change)
+        - State management approach changed
+        - New constants or enums added
+        - File tree changed (new files, removed files, moved files)
+        - Tech debt discovered or resolved in this system's files
+
+        **NOT an update trigger:**
+        - Bug fixes that don't change system behavior
+        - Internal refactoring within existing components
+        - New test files
+        - Style/formatting changes
+
+        **Update rules:**
+        - ADD new sections or expand existing ones — don't rewrite unchanged sections
+        - UPDATE file tree to reflect current state
+        - REMOVE references to deleted files or components
+        - The document must always reflect the CURRENT state, not history
+
+    </evolution>
+
+</system>

package/skills/map-subsystem/templates/walkthrough.xml

@@ -0,0 +1,255 @@
+<walkthrough>
+    <purpose>
+        Template for `.docs/wiki/subsystems/[subsystem-name]/walkthroughs/<flow-name>.md` — a deep,
+        tutorial-style explanation of a complex end-to-end flow. Answers "Walk me through EXACTLY
+        what happens when X."
+
+        Each walkthrough traces a single flow from entry point to exit point, showing ACTUAL code
+        from the codebase at every step, explaining what each piece does and WHY, and calling out
+        framework/library concepts with info boxes when external tools are involved.
+
+        Written for humans (especially new developers and interns) who need to UNDERSTAND a flow
+        before they can work with it. Unlike system docs (terse references for AI agents),
+        walkthroughs prioritize completeness of information — but deliver it in minimal words.
+
+        A "walkthrough" is a traced execution flow through multiple classes and layers:
+        e.g., "Message arrives via SignalR until it reaches the LLM", "LLM calls a tool until
+        the drawing appears on the chart", "User places an order until it's confirmed".
+
+        Create a walkthrough when:
+        - A flow spans 3+ classes across multiple architectural layers
+        - External frameworks/libraries are involved that need explanation (MAF, SignalR, EF Core)
+        - A system doc would need paragraphs of explanation with code snippets (that's a walkthrough, not a system doc)
+        - An intern reading the code alone would not understand what's happening without guidance
+
+        **Emphasis Frameworks:**
+        Walkthroughs can specify one or more "emphasis frameworks" — external frameworks,
+        libraries, APIs, or SDKs that deserve deep explanation throughout the walkthrough.
+        When an emphasis framework is specified:
+        - EVERY step where the flow touches that framework MUST have a framework info box
+        - The info box explains the specific framework concept used in that step
+        - ALL code from ALL steps that interact with the emphasis framework is shown and explained
+        - The agent researches the framework (via WebSearch/context7 or provided docs) if needed
+        - The Framework Concepts Reference table at the end is MANDATORY
+
+        Examples of emphasis frameworks: SignalR, EF Core, MAF (Microsoft Agent Framework),
+        React Query, gRPC, MediatR, AutoMapper. Can be specified by name (agent researches)
+        or with documentation paths/URLs (agent reads provided docs).
+
+        Complements:
+        - systems/ docs (terse WHAT reference — walkthroughs explain the HOW in depth)
+        - patterns/ docs (reusable structural patterns — walkthroughs trace specific flows through them)
+        - guides/ docs (procedural recipes for DOING — walkthroughs explain for UNDERSTANDING)
+        - cross-cutting/ docs (shared infrastructure — walkthroughs show how flows pass through them)
+    </purpose>
+
+    <template>
+        <title>
+            # [Flow Name]
+
+            One line: what this flow does and when it triggers.
+        </title>
+
+        <file-map>
+            ## Files Involved
+
+            Every file this flow touches, in execution order.
+
+            ```
+            src/[layer]/[area]/
+            |-- FileA.cs                    # Entry point
+            |-- FileB.cs                    # Orchestrates flow
+            |-- FileC.cs                    # Core logic
+            `-- FileD.cs                    # Sends result
+            ```
+        </file-map>
+
+        <flow-diagram>
+            ## Flow Overview
+
+            ```mermaid
+            sequenceDiagram
+                participant A as ComponentA
+                participant B as ComponentB
+                participant C as ComponentC
+                participant D as ExternalSystem
+
+                A->>B: step description
+                B->>C: step description
+                C->>D: step description
+                D-->>C: response
+                C-->>B: result
+                B-->>A: result
+            ```
+
+            Participants = real classes/components. Arrows = real method calls.
+            Steps below explain each arrow.
+        </flow-diagram>
+
+        <steps>
+            ## Step-by-Step
+
+            ### Step 1: [What happens]
+
+            **File:** `path/to/File.cs:ClassName.MethodName`
+
+            [1-2 sentences: what this step does and WHY. No filler.]
+
+            ```csharp
+            // Actual code from the codebase
+            public async Task MethodName(string param1, string param2)
+            {
+                var result = await _dependency.DoSomething(param1);
+            }
+            ```
+
+            `_dependency` — injected via constructor, does X.
+            `param1` — the Y received from Z.
+            [Only explain what's non-obvious. Skip what the code already says clearly.]
+
+            ---
+
+            ### Step 2: [What happens]
+
+            **File:** `path/to/AnotherFile.cs:ClassName.MethodName`
+
+            [What and why — terse.]
+
+            ```csharp
+            // Actual code...
+            ```
+
+            > **[Framework]: [Concept]**
+            >
+            > [Succinct explanation of the framework concept. What it is, what it does for us.
+            > No history, no alternatives, no "in general" — just what the reader needs to
+            > understand THIS code.]
+            >
+            > *Source: [link to official docs]*
+
+            ---
+
+            ### Step 3: [What happens]
+
+            ...continue for every step in the flow...
+        </steps>
+
+        <framework-concepts>
+            ## Framework Concepts Reference
+
+            Consolidated lookup for framework concepts explained inline above.
+
+            | Concept | Framework | What It Does | First Appearance |
+            |---------|-----------|-------------|------------------|
+            | `AIFunctionFactory.Create()` | MS Agent Framework | C# method -> LLM tool | [Step N](#step-n) |
+            | `ChatClientAgent` | MS Agent Framework | Wraps IChatClient with auto tool loop | [Step M](#step-m) |
+
+            Include ONLY if external frameworks/libraries are involved.
+        </framework-concepts>
+
+        <related-docs>
+            ## Related Documentation
+
+            - [System Doc](../systems/relevant-system.md) — terse reference
+            - [Guide](../guides/relevant-guide.md) — recipe for adding to this flow
+            - [Official Docs](../framework-docs/relevant-page.md) — framework docs
+        </related-docs>
+    </template>
+
+    <guidelines>
+
+        ### Density Over Prose
+        - **EXTREMELY SUCCINCT** — every word must add value. If a word does not add value, remove it.
+        - **NO FLUFF** — no introductions, no summaries of what the section will contain, no transitions
+        - Bullet points over paragraphs. Tables over bullet points when comparing.
+        - If you can say it in 3 words, don't use 10. Then try to say it in 2.
+        - **BUT: ALL needed information MUST be present.** Succinctness means cutting WORDS, not cutting INFORMATION. Every concept, every parameter, every non-obvious behavior must be explained — just in fewer words.
+
+        ### Complete but Dense Explanations
+        - Explain the WHY, not just the WHAT — "X because Y" not "X happens"
+        - After each code snippet: explain ONLY what's non-obvious. If the code says `price > 0`, don't write "checks that price is positive" — the code already says that. DO explain hidden behaviors, framework magic, non-obvious field origins.
+        - Use inline code references for fields/params: `` `_connectionId` — captured from `Context.ConnectionId` in AgentHub ``
+        - One-line explanations preferred. Multi-line only when genuinely complex.
+
+        ### Code Snippets (MANDATORY per step)
+        - ALWAYS from the actual codebase — verified by reading the file
+        - NEVER pseudocode, NEVER summaries, NEVER fabricated
+        - Use correct language tag: ```csharp, ```typescript, ```json
+        - **FOCUSED**: show ONLY the lines relevant to what the step is explaining. If a method has 50 lines but this step is about lines 10-15, show lines 10-15 with a `// ... (validation above)` or `// ... (setup omitted)` comment for context. The snippet serves the step's explanation, not the other way around.
+        - Short methods (under 20 lines) where the ENTIRE method is relevant: show entirely
+        - Long methods: show the relevant portion only. Use `// ...` comments to indicate omitted sections above/below.
+
+        ### Flow Diagram (MANDATORY)
+        - Every walkthrough MUST start with a mermaid sequenceDiagram
+        - Participants = real classes/components, not abstract concepts
+        - Arrows = real method calls, labeled with method name
+        - The diagram is the map; the steps are the guided tour
+
+        ### Framework Info Boxes (when applicable)
+        - Use markdown blockquotes (`>`) with `> **[Framework]: [Concept]**` header
+        - Explain as if the reader has NEVER used this framework — but in minimal words
+        - Place IMMEDIATELY after the first code snippet that uses the concept
+        - Each concept explained ONCE — do not repeat
+        - Link to official docs with `*Source: [link]*`
+        - Keep it dense: what it is, what it does for us, done. No history, no alternatives.
+
+        ### Emphasis Frameworks (when specified)
+        - When emphasis-frameworks are specified, framework info boxes become MANDATORY
+          for EVERY step that touches the emphasis framework — not just the first occurrence
+        - ALL code that interacts with the emphasis framework must be shown in full
+        - The Framework Concepts Reference table is MANDATORY (not optional)
+        - If the agent does not know the framework: use WebSearch or context7 MCP to research it
+        - If framework docs are provided (file paths or URLs): read them BEFORE writing any steps
+
+        ### Minimum Length
+        - At least 300 lines — length comes from code snippets and completeness, not from prose
+        - Complex flows (3+ frameworks, 10+ classes): 500-1000 lines
+        - Under 200 lines = not enough information, add more steps/explanations
+
+        ### Section Inclusion
+        - Title, File Map, Flow Diagram, Step-by-Step: ALWAYS required
+        - Framework Concepts Reference: MANDATORY if emphasis-frameworks specified; otherwise ONLY if external frameworks involved
+        - Related Documentation: ALWAYS required
+
+        ### What Does NOT Belong Here
+        - Terse bullet-point references (that's systems/)
+        - Structural pattern descriptions (that's patterns/)
+        - Procedural "how to add X" recipes (that's guides/)
+        - Architecture decision rationale (that's decisions/)
+        - Story numbers, sprint context, revision history
+        - Testing instructions or test code
+        - Frontend code in a backend walkthrough (or vice versa) — scope to ONE side
+        - Speculation about future changes — document what IS, not what might be
+        - Filler phrases: "Let's look at", "Now we'll examine", "As mentioned above", "It's worth noting"
+
+    </guidelines>
+
+    <evolution>
+
+        This is a LIVING document — updated when the flow it describes changes.
+
+        **Update triggers:**
+        - New step added to the flow
+        - Step removed from the flow
+        - Step logic changed significantly
+        - Framework/library upgraded, APIs changed
+        - Code snippets no longer match codebase
+        - New framework concept introduced
+
+        **NOT an update trigger:**
+        - Bug fixes that don't change flow structure
+        - Internal refactoring within a single step
+        - New feature using a DIFFERENT flow (create a new walkthrough)
+        - Style/formatting changes to the code
+
+        **Update rules:**
+        - UPDATE code snippets to match current codebase — stale snippets are worse than no docs
+        - ADD new steps when the flow gains a stage
+        - REMOVE steps that no longer exist
+        - UPDATE framework info boxes when APIs change
+        - UPDATE mermaid diagram to reflect current flow
+        - Document must always reflect CURRENT code state, not history
+
+    </evolution>
+
+</walkthrough>