WP-0001 complete: v1.1.0 lazy registry and install performance

Lazy-load agent registry (frontmatter index, parse on demand), copy
agents by path during install, fix Makefile template tab lint issue,
add registry performance tests, bump to 1.1.0, document CLI reinstall
after pull.

src/kaizen_agentic/registry.py

@@ -32,6 +32,18 @@ class AgentDefinition:
     model: Optional[str] = None
     memory: Optional[str] = None  # "enabled" (default) | "disabled"
 
+    @staticmethod
+    def _read_frontmatter(file_path: Path) -> dict:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        frontmatter_match = re.match(r"^---\n(.*?)\n---\n", content, re.DOTALL)
+        if not frontmatter_match:
+            raise ValueError(f"No YAML frontmatter found in {file_path}")
+        frontmatter = yaml.safe_load(frontmatter_match.group(1))
+        if not isinstance(frontmatter, dict) or "name" not in frontmatter:
+            raise ValueError(f"Invalid frontmatter in {file_path}")
+        return frontmatter
+
     @classmethod
     def from_file(cls, file_path: Path) -> "AgentDefinition":
         """Create AgentDefinition from a markdown file."""
@@ -158,29 +170,50 @@ class AgentRegistry:
     def __init__(self, agents_dir: Path):
         self.agents_dir = Path(agents_dir)
         self._agents: Dict[str, AgentDefinition] = {}
-        self._load_agents()
+        self._file_index: Dict[str, Path] = {}
+        self._index_agent_files()
 
-    def _load_agents(self):
-        """Load all agents from the agents directory."""
+    def _index_agent_files(self) -> None:
+        """Index agent files by frontmatter name without full parse."""
         if not self.agents_dir.exists():
             return
 
         for agent_file in self.agents_dir.glob("agent-*.md"):
             try:
-                agent_def = AgentDefinition.from_file(agent_file)
-                self._agents[agent_def.name] = agent_def
+                frontmatter = AgentDefinition._read_frontmatter(agent_file)
+                self._file_index[frontmatter["name"]] = agent_file
             except Exception as e:
-                print(f"Warning: Failed to load agent {agent_file}: {e}")
+                print(f"Warning: Failed to index agent {agent_file}: {e}")
+
+    def get_agent_path(self, name: str) -> Optional[Path]:
+        """Return the source file path for an agent (no full parse)."""
+        return self._file_index.get(name)
 
     def get_agent(self, name: str) -> Optional[AgentDefinition]:
-        """Get agent definition by name."""
-        return self._agents.get(name)
+        """Get agent definition by name (lazy-loaded)."""
+        if name in self._agents:
+            return self._agents[name]
+        file_path = self._file_index.get(name)
+        if file_path is None:
+            return None
+        try:
+            agent_def = AgentDefinition.from_file(file_path)
+        except Exception as e:
+            print(f"Warning: Failed to load agent {name}: {e}")
+            return None
+        self._agents[name] = agent_def
+        return agent_def
+
+    def agent_names(self) -> List[str]:
+        """List indexed agent names without loading full definitions."""
+        return sorted(self._file_index.keys())
 
     def list_agents(
         self, category: Optional[AgentCategory] = None
     ) -> List[AgentDefinition]:
         """List all agents, optionally filtered by category."""
-        agents = list(self._agents.values())
+        agents = [self.get_agent(name) for name in self.agent_names()]
+        agents = [agent for agent in agents if agent is not None]
         if category:
             agents = [a for a in agents if a.category == category]
         return sorted(agents, key=lambda a: a.name)
@@ -188,7 +221,7 @@ class AgentRegistry:
     def get_categories(self) -> Dict[AgentCategory, List[AgentDefinition]]:
         """Get agents organized by category."""
         categories = {}
-        for agent in self._agents.values():
+        for agent in self.list_agents():
             if agent.category not in categories:
                 categories[agent.category] = []
             categories[agent.category].append(agent)
@@ -230,12 +263,16 @@ class AgentRegistry:
         """Validate all agents and return validation errors."""
         errors = {}
 
-        for name, agent in self._agents.items():
+        for name in self.agent_names():
+            agent = self.get_agent(name)
+            if agent is None:
+                errors[name] = ["Failed to load agent definition"]
+                continue
             agent_errors = []
 
             # Check for missing dependencies
             for dep in agent.dependencies:
-                if dep not in self._agents:
+                if dep not in self._file_index:
                     agent_errors.append(f"Missing dependency: {dep}")
 
             # Check file exists