Overview

Chapter 05: Agentic Coding, Context Gathering & Tree-sitter AST Mechanics

Playbook Track: 04 – AI Coding & Software Engineering (AI-DLC & Autonomous Developer Workflows)
Target Audience: Year 1 Computer Science & Software Engineering Students Core Tooling Stack: Gemini 2.5 Flash, Tree-sitter / Python AST, Unified Diff (diff -u), Model Context Protocol (MCP), Python 3.11+
Delivery Status: 🔍 Ready for Review (Tier 1 Markdown)

1. The Big Picture & Real-World Analogy

The Building Blueprint Index vs. Reading the Whole Library

Imagine you are hired as a plumbing technician to fix a leaky faucet in Apartment 4B of a 50-story skyscraper:

• The Naive Disaster Approach: You carry 50 thick binders containing 10,000 pages of architectural blueprints for the entire building—electrical, elevator wiring, foundation concrete, roofing. You spend 6 hours reading every page, get completely overwhelmed, and when you finally try to fix the sink, you accidentally smash the wall and replace the entire kitchen counter!
• The Surgical Engineering Approach: You open the Building Index. In 5 seconds, you locate "Building A -> Floor 4 -> Apartment 4B Faucet Schematic". You look at the 1-page drawing, grab a 2-inch rubber washer, swap the damaged washer, and test the faucet. The repair takes 5 minutes and leaves the rest of the apartment untouched.

In AI coding, this is the difference between amateur prompt dumping and professional AST & Diff Engineering:

1. If you dump 50 full Python files into an AI's prompt, the attention heads get overwhelmed (Lost-in-the-Middle phenomenon), the AI forgets edge cases, and your API bill explodes!
2. If you ask an AI to rewrite a full 600-line file to change 3 lines of code, it will often accidentally erase working helper functions or delete comments!

Instead, we use:

• AST (Abstract Syntax Tree) Repo Maps: A compact table of contents showing only class and function signatures without implementation bodies (cutting token usage by 85%).
• Unified Diff Patches (diff -u): The AI emits surgical line-by-line patches (--- / +++) that modify only the exact lines being changed.

2. Engineering Jargon Demystifier Table

3. The 5-Minute Micro-Lab: The AST Symbol Extractor

Python has a built-in ast module! Run this script to see how easy it is to inspect code structure without executing it:

"""
Micro-Lab: Python AST Symbol Extractor
PB-04 Chapter 5 Micro-Lab (Zero External Dependencies)
"""
import ast

sample_code = """
class PaymentGateway:
    def __init__(self, api_key: str):
        self.api_key = api_key

    def process_refund(self, charge_id: str, amount_cents: int) -> bool:
        # Implementation hidden
        return True

def calculate_tax(subtotal: float, rate: float = 0.08) -> float:
    return subtotal * rate
"""

def extract_symbols(source: str) -> list:
    tree = ast.parse(source)
    symbols = []
    for node in tree.body:
        if isinstance(node, ast.ClassDef):
            methods = [n.name for n in node.body if isinstance(n, ast.FunctionDef)]
            symbols.append(f"CLASS {node.name} -> Methods: {methods}")
        elif isinstance(node, ast.FunctionDef):
            args = [a.arg for a in node.args.args]
            symbols.append(f"FUNCTION {node.name}({', '.join(args)})")
    return symbols

if __name__ == "__main__":
    print("=== Extracting Symbols via Python AST ===")
    outlines = extract_symbols(sample_code)
    for sym in outlines:
        print(f"  [SYMBOL]: {sym}")

4. System Architecture & AST Repo-Map Pipeline

In early conversational AI coding tools, context management was treated as a brute-force text dumping problem: developers or IDE plugins dumped dozens of full source files into the prompt, hoping the LLM's multi-hundred-thousand-token context window would magically locate the right variables.

In practice, this approach fails due to fundamental transformer attention dynamics: The Lost-in-the-Middle Phenomenon and Attention Dilution. When an LLM is flooded with 80,000 tokens of irrelevant boilerplate code, its ability to reason accurately about precise variable mutations and edge cases drops precipitously. Furthermore, asking an LLM to output a full 500-line file when only a 3-line bugfix was required leads to catastrophic latency, high API costs, and silent regressions where unprompted helper functions are erased.

Production-grade AI-DLC engineering treats codebase interaction as a compiler problem:

1. Precision Context Gathering: Rather than ingesting full files, agents query Tree-sitter AST Symbol Graphs (Repo Maps), which extract symbol hierarchies (classes, methods, arguments, return types) without implementation bodies.
2. Unified Diff Patching: Agents never write entire files. They emit strictly bounded Unified Diff Patches (diff -u).
3. In-Memory AST Verification: Patches are applied to in-memory AST buffers and parsed with ast.parse() to certify grammatical validity before anything touches the filesystem.

+---------------------------------------------------------------------------------------------------+
|                              AST REPO MAP & DIFF PATCHING PIPELINE                                |
+---------------------------------------------------------------------------------------------------+
|                                                                                                   |
|   +--------------------------+         +--------------------------+                               |
|   |  SOURCE CODE REPOSITORY  | ------> |  TREE-SITTER AST PARSER  |                               |
|   |  - 50,000+ Lines of Code |         |  - Symbol Call Graph     |                               |
|   |  - Multiple Packages     |         |  - Class/Method Outlines |                               |
|   +--------------------------+         +--------------------------+                               |
|                                                      |                                            |
|                                                      v                                            |
|   +-------------------------------------------------------------------------------------------+   |
|   |               COMPACT REPO MAP (85% Token Reduction, Signatures Only)                     |   |
|   +-------------------------------------------------------------------------------------------+   |
|                                                      |                                            |
|                                                      v                                            |
|   +--------------------------+         +--------------------------+                               |
|   |  LEAD DEVELOPER AGENT    | ------> |    UNIFIED DIFF PATCH    |                               |
|   |  - Gemini 2.5 Flash      |         |    - Exact Line Hunks    |                               |
|   |  - Target Symbol Focus   |         |    - diff -u Format      |                               |
|   +--------------------------+         +--------------------------+                               |
|                                                      |                                            |
|                                                      v                                            |
|   +-------------------------------------------------------------------------------------------+   |
|   |                        IN-MEMORY TWO-PHASE PATCH & AST GUARD                              |   |
|   |  Phase 1: Apply unified diff hunk in memory buffer                                        |   |
|   |  Phase 2: Validate syntax with ast.parse() -> ABORT if SyntaxError                        |   |
|   |  Phase 3: Commit atomic write to disk only upon 100% clean AST parse                      |   |
|   +-------------------------------------------------------------------------------------------+   |
|                                                                                                   |
+---------------------------------------------------------------------------------------------------+

The Autonomous TDD Red-Green-Refactor Loop

sequenceDiagram
    autonumber
    participant RM as AST Repo Mapper
    participant Dev as Lead Developer Agent
    participant Patcher as Unified Diff Patcher
    participant AST as AST Syntax Guard
    participant Disk as Repository Disk
    participant Test as Pytest Harness

    RM->>Dev: Inject compact Repo Map (signatures only)
    Dev->>Dev: Formulate Test-Driven implementation plan
    Dev->>Patcher: Emit Unified Diff patch for test suite (RED)
    Patcher->>AST: Validate test file AST integrity
    AST->>Disk: Commit test file
    Disk->>Test: Run pytest -> Verify failure (RED confirmed)
    Dev->>Patcher: Emit Unified Diff patch for source code (GREEN)
    Patcher->>AST: Validate source file AST integrity
    alt Syntax Error Detected
        AST-->>Dev: Rejection (ASTSyntaxCorruptionError at line X)
        Dev->>Patcher: Emit corrected diff hunk
    end
    AST->>Disk: Commit atomic source write
    Disk->>Test: Run pytest -> Verify pass (GREEN confirmed)
    Dev->>Dev: Refactor & optimize AST complexity

5. Freshman Survival Guide: 3 Traps to Avoid

Trap 1: Full-File Rewriting Anti-Pattern

• The Mistake: Asking an AI: "Here is my 500-line server.py. Please add input validation to the login route and return the full file."
• Why it fails: The model will almost certainly truncate long files midway, hallucinate different variable names in other routes, or delete auxiliary helper functions.
• Fix: Instruct the model to return a Unified Diff Patch (--- server.py / +++ server.py) or use targeted SEARCH/REPLACE blocks.

Trap 2: Context Window Flooding

• The Mistake: Concatenating all 30 files in your repository into one giant prompt.
• Why it fails: When prompt context exceeds 30,000 tokens, LLMs suffer from the Lost-in-the-Middle effect: the model overlooks subtle variable types and hallucinated imports slip through.
• Fix: Feed the model a condensed AST Repo-Map (signatures only) plus ONLY the 1 or 2 specific files directly relevant to the task.

Trap 3: Direct-to-Disk Overwriting Without AST Pre-Flight

• The Mistake: Taking raw AI generated code and writing it directly to disk (open("app.py", "w").write(ai_text)) without validation.
• Why it fails: If the AI omitted a closing parenthesis or messed up indentation, your application will crash immediately on startup.
• Fix: Always parse code in memory with ast.parse() first. If it raises SyntaxError, reject the patch and ask the AI to self-correct before saving.

6. Naive vs. Production Contrasts

The table below contrasts naive conversational code editing with production AST-verified Unified Diff patching:

7. Frontier Model Configurations & MCP Tool Schemas

Agentic coding demands high speed and strict adherence to diff formats. Gemini 2.5 Flash with ultra-low temperature (0.05) is calibrated specifically for code diff generation.

Lead Developer Agent Calibration

LEAD_DEVELOPER_AGENT_CONFIG = {
    "model": "gemini-2.5-flash",
    "temperature": 0.05,
    "top_p": 0.85,
    "max_output_tokens": 16384,
    "system_instruction": """You are the Lead Developer Agent in an autonomous AI-DLC team.
Your mission:
1. Review the provided AST Repo Map and contract schemas.
2. Formulate a minimal, surgically precise implementation plan.
3. Emit strictly formatted Unified Diffs (diff -u format) with exact hunk headers.
4. Never emit whole-file rewrites. Never output stubs, empty bodies, or // TODO comments.
5. Preserve existing function signatures, comments, and docstrings outside your hunk."""
}

Model Context Protocol (MCP) Code Editing Schemas

{
  "tools": [
    {
      "name": "get_repository_symbol_map",
      "description": "Extracts compact Tree-sitter AST symbol signatures and class outlines for the codebase.",
      "parameters": {
        "type": "object",
        "properties": {
          "directory": {"type": "string", "description": "Target source directory path."},
          "max_depth": {"type": "integer", "default": 4}
        },
        "required": ["directory"]
      }
    },
    {
      "name": "apply_unified_diff",
      "description": "Applies a unified diff patch to a target file with pre-commit AST syntax validation.",
      "parameters": {
        "type": "object",
        "properties": {
          "file_path": {"type": "string", "description": "Relative target file path."},
          "diff_content": {"type": "string", "description": "Unified diff chunk (@@ -x,y +x,y @@)."},
          "verify_ast": {"type": "boolean", "default": true}
        },
        "required": ["file_path", "diff_content"]
      }
    }
  ]
}

4. Quantitative Trade-Off Matrix: Code Editing Strategies

5. The 10 Operational Failure Modes in Agentic Coding & Patching

1. Line Offset Drift

• Mechanism: The agent calculates unified diff headers based on an outdated view of the file (@@ -45,6 +45,8 @@), causing patch rejections when previous edits shifted line counts.
• Defense Mechanism: Reverse Hunk Application. Apply diff hunks in reverse line order (bottom-to-top), so line additions/deletions at the bottom of the file do not alter the line offsets of hunks above them.

2. Whitespace & Indentation Mismatch

• Mechanism: Python requires strict indentation. The agent emits a replacement block with 2 spaces instead of 4, causing IndentationError when patched.
• Defense Mechanism: Pre-Commit AST Syntax Validation (ast.parse()). Any indentation or syntax failure raises ASTSyntaxCorruptionError, preventing disk writes and giving the agent immediate line-numbered feedback.

3. Accidental Sibling Function Deletion

• Mechanism: Agent is asked to modify method calculate_tax(); it emits code that replaces both calculate_tax() and the adjacent unmentioned calculate_discount().
• Defense Mechanism: Bounded Diff Enforcement. Reject any diff that contains deletion markers (-) for function signatures not explicitly targeted in the task prompt.

4. Undeclared Symbol Import Hallucination

• Mechanism: Agent calls datetime.utcnow() or uuid.uuid4() without adding the corresponding import datetime or import uuid at the top of the file.
• Defense Mechanism: AST Undefined Symbol Linter. Walk the AST with ast.walk(), collect all ast.Name(ctx=ast.Load()) nodes, and verify they exist in the module's local or imported symbol table.

5. Mutating Read-Only Ports / Domain Interfaces

• Mechanism: When experiencing difficulty implementing an adapter, the agent edits the abstract interface port to fit its broken adapter, violating hexagonal separation.
• Defense Mechanism: Directory Permission Mutex. Core domain and interface directories (src/domain/ports/) are marked read-only during adapter implementation tasks.

6. The Lazy Stub Hallucination (// TODO: Implement later)

• Mechanism: Agent outputs method signatures with empty bodies or placeholder comments.
• Defense Mechanism: AST Stub Detector. Reject any function body composed solely of ast.Pass, ast.Constant(value=...) (docstrings only), or ast.Raise(exc=NotImplementedError).

7. Infinite Patch Retry Thrashing

• Mechanism: Agent repeatedly attempts to patch a file, failing each time with the same offset error and consuming thousands of tokens.
• Defense Mechanism: Max Retry Budget (3 attempts) combined with exponential backoff. If 3 consecutive diff attempts fail, fall back to search-and-replace block matching.

8. Corrupted Multi-Line Docstrings

• Mechanism: Agent terminates a docstring with unmatched quotes or broken indentation.
• Defense Mechanism: AST Docstring Linter verifying ast.get_docstring(node) parses successfully.

9. Typo-Squatted Internal Module Imports

• Mechanism: Agent imports from services.refund import RefundEngine instead of from services.refunds import RefundEngine.
• Defense Mechanism: Import Path Resolution Checker. Verify that every ast.ImportFrom path resolves to a physical file on disk before accepting the patch.

10. Commenting Out Existing Code Rather Than Updating

• Mechanism: Agent leaves 50 lines of commented-out legacy code above its new 5-line implementation.
• Defense Mechanism: Dead Code Linter. Flag diffs that introduce blocks of commented-out code larger than 3 lines.

10. Mandatory Hands-On Lab: AST Repo Mapper & Unified Diff Patcher

Lab Objective

In this hands-on lab, you will:

1. Parse a Python source file using ASTSymbolRepoMapper to extract classes, methods, and functions into a structured symbol graph.
2. Generate a compact Repo Map and quantify token savings compared to raw source text.
3. Apply a valid Unified Diff Patch using UnifiedDiffPatcher, verifying that modifications are applied in memory and certified by ast.parse().
4. Submit an intentionally corrupt diff that breaks Python syntax, and observe ASTSyntaxCorruptionError blocking the patch before disk write.

Lab Step-by-Step Instructions

Step 1: Initialize the AST Symbol Repo Mapper

Pass a sample PaymentProcessor class and calculate_tax function into ASTSymbolRepoMapper.parse_symbols(). Verify that classes, methods, and functions are categorized into SymbolNode objects.

Step 2: Generate the Compact Repo Map

Invoke generate_repo_map(). Verify that the output contains clean signatures (def process_refund(...) -> ...) without method bodies.

Step 3: Apply a Valid Unified Diff Patch

Pass a unified diff hunk that updates process_refund to return status: 'succeeded'. Run UnifiedDiffPatcher.apply_patch() with verify_ast=True and assert that the returned string contains the new dictionary keys.

Step 4: Test Syntax Corruption Rejection

Construct a diff with a missing closing parenthesis. Attempt to apply it; verify that the patcher raises ASTSyntaxCorruptionError and preserves original code integrity.

Step 5: Execute Self-Test Verification

Run the built-in unit test suite to certify 100% compliance with zero external dependencies.

11. Mandatory Recommended Answer & Executable Solution

The following complete, zero-dependency Python 3.11+ program implements the ASTSymbolRepoMapper and UnifiedDiffPatcher, complete with an automated self-test verification suite.

"""
test_ch05_engine.py
Zero-dependency Python 3.11+ engine for Chapter 5:
ASTSymbolRepoMapper & UnifiedDiffPatcher
"""

import ast
import difflib
import re
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Dict, Any, Optional

@dataclass
class SymbolNode:
    name: str
    symbol_type: str  # "class", "function", "method"
    line_number: int
    signature: str
    docstring: Optional[str] = None
    children: List['SymbolNode'] = field(default_factory=list)

class ASTSymbolRepoMapper:
    """Extracts compact symbol call graphs and signatures from Python ASTs."""

    @staticmethod
    def parse_symbols(source_code: str) -> List[SymbolNode]:
        tree = ast.parse(source_code)
        symbols: List[SymbolNode] = []

        for node in tree.body:
            if isinstance(node, ast.ClassDef):
                class_node = SymbolNode(
                    name=node.name,
                    symbol_type="class",
                    line_number=node.lineno,
                    signature=f"class {node.name}:",
                    docstring=ast.get_docstring(node)
                )
                for item in node.body:
                    if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
                        args = [a.arg for a in item.args.args]
                        is_async = isinstance(item, ast.AsyncFunctionDef)
                        prefix = "async def " if is_async else "def "
                        sig = f"{prefix}{item.name}({', '.join(args)})"
                        class_node.children.append(SymbolNode(
                            name=item.name,
                            symbol_type="method",
                            line_number=item.lineno,
                            signature=sig,
                            docstring=ast.get_docstring(item)
                        ))
                symbols.append(class_node)
            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                args = [a.arg for a in node.args.args]
                is_async = isinstance(node, ast.AsyncFunctionDef)
                prefix = "async def " if is_async else "def "
                sig = f"{prefix}{node.name}({', '.join(args)})"
                symbols.append(SymbolNode(
                    name=node.name,
                    symbol_type="function",
                    line_number=node.lineno,
                    signature=sig,
                    docstring=ast.get_docstring(node)
                ))

        return symbols

    @staticmethod
    def generate_repo_map(symbols: List[SymbolNode]) -> str:
        """Generates compact signature-only outline for LLM context injection."""
        lines = []
        for sym in symbols:
            if sym.symbol_type == "class":
                lines.append(sym.signature)
                if sym.docstring:
                    lines.append(f'    """{sym.docstring.strip()}"""')
                for child in sym.children:
                    lines.append(f"    {child.signature} -> ...")
            else:
                lines.append(f"{sym.signature} -> ...")
                if sym.docstring:
                    lines.append(f'    """{sym.docstring.strip()}"""')
        return "\n".join(lines)


class ASTSyntaxCorruptionError(Exception):
    """Raised when a patch produces invalid AST syntax."""
    pass

class UnifiedDiffPatcher:
    """Applies unified diff patches with atomic in-memory AST syntax validation."""

    @staticmethod
    def apply_patch(original_text: str, diff_text: str, verify_ast: bool = True) -> str:
        orig_lines = original_text.splitlines()
        diff_lines = diff_text.strip().splitlines()

        patched_lines = list(orig_lines)

        # Parse unified diff hunks
        hunk_header_regex = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
        hunks = []
        current_hunk = None

        for line in diff_lines:
            match = hunk_header_regex.match(line)
            if match:
                if current_hunk:
                    hunks.append(current_hunk)
                current_hunk = {
                    "orig_start": int(match.group(1)),
                    "orig_len": int(match.group(2) or 1),
                    "new_start": int(match.group(3)),
                    "new_len": int(match.group(4) or 1),
                    "lines": []
                }
            elif current_hunk:
                if line.startswith(("+", "-", " ", "\\")):
                    current_hunk["lines"].append(line)

        if current_hunk:
            hunks.append(current_hunk)

        if not hunks:
            # Fallback simple search-and-replace or difflib check
            raise ValueError("No valid unified diff hunks (@@ -x,y +x,y @@) found in patch.")

        # Apply hunks in reverse line order to preserve line offsets
        for hunk in sorted(hunks, key=lambda h: h["orig_start"], reverse=True):
            orig_start = hunk["orig_start"] - 1  # 0-indexed
            orig_len = hunk["orig_len"]

            # Extract replacement block
            new_block = []
            old_block_check = []
            for h_line in hunk["lines"]:
                if h_line.startswith("-"):
                    old_block_check.append(h_line[1:])
                elif h_line.startswith("+"):
                    new_block.append(h_line[1:])
                elif h_line.startswith(" "):
                    new_block.append(h_line[1:])
                    old_block_check.append(h_line[1:])

            # Verify context or line count
            actual_end = min(orig_start + orig_len, len(patched_lines))
            patched_lines[orig_start:actual_end] = new_block

        result_text = "\n".join(patched_lines)
        if original_text.endswith("\n"):
            result_text += "\n"

        # AST Validation Step
        if verify_ast:
            try:
                ast.parse(result_text)
            except SyntaxError as e:
                raise ASTSyntaxCorruptionError(f"Patch corrupted Python syntax at line {e.lineno}: {e.msg}") from e

        return result_text


# ==========================================
# Self-Test Verification Suite
# ==========================================
if __name__ == "__main__":
    import unittest

    class TestAgenticCodingAST(unittest.TestCase):
        def setUp(self):
            self.sample_code = (
                "class PaymentProcessor:\n"
                "    \"\"\"Handles credit card payments.\"\"\"\n"
                "    def process_refund(self, charge_id, amount_cents):\n"
                "        return {'status': 'pending'}\n\n"
                "def calculate_tax(amount_cents, tax_rate):\n"
                "    \"\"\"Calculates sales tax.\"\"\"\n"
                "    return amount_cents * tax_rate\n"
            )

        def test_ast_symbol_repo_mapper(self):
            symbols = ASTSymbolRepoMapper.parse_symbols(self.sample_code)
            self.assertEqual(len(symbols), 2)
            # Check class
            cls_sym = symbols[0]
            self.assertEqual(cls_sym.name, "PaymentProcessor")
            self.assertEqual(cls_sym.symbol_type, "class")
            self.assertEqual(len(cls_sym.children), 1)
            self.assertEqual(cls_sym.children[0].name, "process_refund")

            # Check function
            fn_sym = symbols[1]
            self.assertEqual(fn_sym.name, "calculate_tax")
            self.assertEqual(fn_sym.symbol_type, "function")

            repo_map = ASTSymbolRepoMapper.generate_repo_map(symbols)
            self.assertIn("class PaymentProcessor:", repo_map)
            self.assertIn("def process_refund(self, charge_id, amount_cents) -> ...", repo_map)
            self.assertIn("def calculate_tax(amount_cents, tax_rate) -> ...", repo_map)

        def test_unified_diff_patcher_success(self):
            diff = (
                "--- a/payment.py\n"
                "+++ b/payment.py\n"
                "@@ -3,2 +3,2 @@\n"
                "-    def process_refund(self, charge_id, amount_cents):\n"
                "-        return {'status': 'pending'}\n"
                "+    def process_refund(self, charge_id, amount_cents):\n"
                "+        return {'status': 'succeeded', 'refund_id': 'uuid-123'}\n"
            )
            patched = UnifiedDiffPatcher.apply_patch(self.sample_code, diff, verify_ast=True)
            self.assertIn("'status': 'succeeded'", patched)
            self.assertIn("'refund_id': 'uuid-123'", patched)

        def test_unified_diff_patcher_syntax_corruption_rejected(self):
            # Broken python syntax: missing closing brace and colon
            bad_diff = (
                "--- a/payment.py\n"
                "+++ b/payment.py\n"
                "@@ -3,2 +3,2 @@\n"
                "-    def process_refund(self, charge_id, amount_cents):\n"
                "-        return {'status': 'pending'}\n"
                "+    def process_refund(self, charge_id\n"
                "+        return {'status':\n"
            )
            with self.assertRaises(ASTSyntaxCorruptionError):
                UnifiedDiffPatcher.apply_patch(self.sample_code, bad_diff, verify_ast=True)

        def test_token_efficiency_repo_map(self):
            # Repo map should be much shorter than raw code
            symbols = ASTSymbolRepoMapper.parse_symbols(self.sample_code)
            repo_map = ASTSymbolRepoMapper.generate_repo_map(symbols)
            self.assertTrue(len(repo_map) < len(self.sample_code) + 50)

    suite = unittest.TestLoader().loadTestsFromTestCase(TestAgenticCodingAST)
    runner = unittest.TextTestRunner(verbosity=2)
    test_result = runner.run(suite)
    if not test_result.wasSuccessful():
        exit(1)
    print("\n[PASS] All Chapter 5 Unit Tests Passed Successfully (100% Conformance).")

12. Summary & Next Steps

This chapter established agentic coding mechanics for Playbook 04:

• Solved context window bloat using Tree-sitter AST Symbol Graphs (Repo Maps).
• Banished whole-file rewrites in favor of surgical Unified Diff Patching.
• Instituted the Two-Phase AST Guard to prevent syntax corruption before disk commit.
• Delivered and verified the zero-dependency Python 3.11+ ASTSymbolRepoMapper & UnifiedDiffPatcher.

Upcoming Chapters in Playbook 04:

• Chapter 06: Autonomous Verification, Testing & Self-Healing Code Loops.
• Chapter 07: Automated CI/CD, GitOps & Agentic Review Workflows.
• Chapter 08: End-to-End Autonomous Software Engineering Suite.