gobby 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

gobby/servers/routes/mcp/endpoints/registry.py

@@ -255,17 +255,17 @@ async def refresh_mcp_tools(
                     try:
                         session = await server.mcp_manager.ensure_connected(server_name)
                         tools_result = await session.list_tools()
-                        for t in tools_result.tools:
+                        for mcp_tool in tools_result.tools:
                             schema = None
-                            if hasattr(t, "inputSchema"):
-                                if hasattr(t.inputSchema, "model_dump"):
-                                    schema = t.inputSchema.model_dump()
-                                elif isinstance(t.inputSchema, dict):
-                                    schema = t.inputSchema
+                            if hasattr(mcp_tool, "inputSchema"):
+                                if hasattr(mcp_tool.inputSchema, "model_dump"):
+                                    schema = mcp_tool.inputSchema.model_dump()
+                                elif isinstance(mcp_tool.inputSchema, dict):
+                                    schema = mcp_tool.inputSchema
                             tools.append(
                                 {
-                                    "name": getattr(t, "name", ""),
-                                    "description": getattr(t, "description", ""),
+                                    "name": getattr(mcp_tool, "name", ""),
+                                    "description": getattr(mcp_tool, "description", ""),
                                     "inputSchema": schema,
                                 }
                             )

gobby/sessions/analyzer.py

@@ -32,8 +32,8 @@ class HandoffContext:
     key_decisions: list[str] | None = None
     active_worktree: dict[str, Any] | None = None
     """Worktree context if session is operating in a worktree."""
-    active_skills: list[str] = field(default_factory=list)
-    """List of skill names that were active/injected during the session."""
+    # Note: active_skills field removed - redundant with _build_skill_injection_context()
+    # which already handles skill restoration on session start
 
 
 class TranscriptAnalyzer:

gobby/skills/parser.py

@@ -64,6 +64,8 @@ class ParsedSkill:
         scripts: List of script file paths (relative to skill dir)
         references: List of reference file paths (relative to skill dir)
         assets: List of asset file paths (relative to skill dir)
+        always_apply: Whether skill should always be injected at session start
+        injection_format: How to inject skill (summary, full, content)
     """
 
     name: str
@@ -80,6 +82,8 @@ class ParsedSkill:
     scripts: list[str] | None = None
     references: list[str] | None = None
     assets: list[str] | None = None
+    always_apply: bool = False
+    injection_format: str = "summary"
 
     def get_category(self) -> str | None:
         """Get category from top-level or metadata.skillport.category."""
@@ -139,6 +143,8 @@ class ParsedSkill:
             "scripts": self.scripts,
             "references": self.references,
             "assets": self.assets,
+            "always_apply": self.always_apply,
+            "injection_format": self.injection_format,
         }
 
 
@@ -232,6 +238,7 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     # This allows both top-level and nested formats to work
     top_level_always_apply = frontmatter.get("alwaysApply")
     top_level_category = frontmatter.get("category")
+    top_level_injection_format = frontmatter.get("injectionFormat")
 
     if top_level_always_apply is not None or top_level_category is not None:
         if metadata is None:
@@ -251,6 +258,20 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     if version is not None:
         version = str(version)
 
+    # Extract always_apply: check top-level first, then metadata.skillport.alwaysApply
+    always_apply = False
+    if top_level_always_apply is not None:
+        always_apply = bool(top_level_always_apply)
+    elif metadata and isinstance(metadata, dict):
+        skillport = metadata.get("skillport", {})
+        if isinstance(skillport, dict) and skillport.get("alwaysApply"):
+            always_apply = bool(skillport["alwaysApply"])
+
+    # Extract injection_format: check top-level first, default to "summary"
+    injection_format = "summary"
+    if top_level_injection_format is not None:
+        injection_format = str(top_level_injection_format)
+
     return ParsedSkill(
         name=name,
         description=description,
@@ -261,6 +282,8 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
         allowed_tools=allowed_tools,
         metadata=metadata,
         source_path=source_path,
+        always_apply=always_apply,
+        injection_format=injection_format,
     )
 
 

gobby/skills/sync.py

@@ -23,10 +23,9 @@ def get_bundled_skills_path() -> Path:
     Returns:
         Path to src/gobby/install/shared/skills/
     """
-    # Navigate from this file to install/shared/skills/
-    # This file: src/gobby/skills/sync.py
-    # Target: src/gobby/install/shared/skills/
-    return Path(__file__).parent.parent / "install" / "shared" / "skills"
+    from gobby.paths import get_install_dir
+
+    return get_install_dir() / "shared" / "skills"
 
 
 def sync_bundled_skills(db: DatabaseProtocol) -> dict[str, Any]:
@@ -101,6 +100,8 @@ def sync_bundled_skills(db: DatabaseProtocol) -> dict[str, Any]:
                 source_ref=None,
                 project_id=None,  # Global scope
                 enabled=True,
+                always_apply=parsed.always_apply,
+                injection_format=parsed.injection_format,
             )
 
             logger.info(f"Synced bundled skill: {parsed.name}")

gobby/storage/artifacts.py

@@ -283,3 +283,22 @@ class LocalArtifactManager:
 
         rows = self.db.fetchall(sql, tuple(params))
         return [Artifact.from_row(row) for row in rows]
+
+    def count_artifacts(self, session_id: str | None = None) -> int:
+        """Count total artifacts, optionally filtered by session.
+
+        Args:
+            session_id: Optional session ID to filter by
+
+        Returns:
+            Total artifact count
+        """
+        if session_id:
+            row = self.db.fetchone(
+                "SELECT COUNT(*) FROM session_artifacts WHERE session_id = ?",
+                (session_id,),
+            )
+        else:
+            row = self.db.fetchone("SELECT COUNT(*) FROM session_artifacts")
+
+        return row[0] if row else 0

gobby/storage/migrations.py

@@ -43,9 +43,9 @@ class MigrationUnsupportedError(Exception):
 # Migration can be SQL string or a callable that takes LocalDatabase
 MigrationAction = str | Callable[[LocalDatabase], None]
 
-# Baseline version - the schema state at v78 (flattened)
+# Baseline version - the schema state at v79 (flattened)
 # This is applied for new databases directly
-BASELINE_VERSION = 78
+BASELINE_VERSION = 79
 
 # Baseline schema - flattened from v78 production state, includes hub tracking fields
 # This is applied for new databases directly
@@ -587,6 +587,8 @@ CREATE TABLE skills (
     hub_slug TEXT,
     hub_version TEXT,
     enabled INTEGER DEFAULT 1,
+    always_apply INTEGER DEFAULT 0,
+    injection_format TEXT DEFAULT 'summary',
     project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL
@@ -594,6 +596,7 @@ CREATE TABLE skills (
 CREATE INDEX idx_skills_name ON skills(name);
 CREATE INDEX idx_skills_project_id ON skills(project_id);
 CREATE INDEX idx_skills_enabled ON skills(enabled);
+CREATE INDEX idx_skills_always_apply ON skills(always_apply);
 CREATE UNIQUE INDEX idx_skills_name_project ON skills(name, project_id);
 CREATE UNIQUE INDEX idx_skills_name_global ON skills(name) WHERE project_id IS NULL;
 
@@ -709,6 +712,24 @@ def _migrate_add_hub_tracking_to_skills(db: LocalDatabase) -> None:
     logger.info("Added hub tracking fields to skills table")
 
 
+def _migrate_add_skill_injection_columns(db: LocalDatabase) -> None:
+    """Add always_apply and injection_format columns to skills table.
+
+    These columns enable per-skill control over:
+    - always_apply: Whether skill should always be injected at session start
+    - injection_format: How to inject the skill (summary, full, content)
+
+    The values are extracted from SKILL.md frontmatter during sync and stored
+    as columns for efficient querying.
+    """
+    with db.transaction() as conn:
+        conn.execute("ALTER TABLE skills ADD COLUMN always_apply INTEGER DEFAULT 0")
+        conn.execute("ALTER TABLE skills ADD COLUMN injection_format TEXT DEFAULT 'summary'")
+        conn.execute("CREATE INDEX idx_skills_always_apply ON skills(always_apply)")
+
+    logger.info("Added always_apply and injection_format columns to skills table")
+
+
 MIGRATIONS: list[tuple[int, str, MigrationAction]] = [
     # Project-scoped session refs: Change seq_num index from global to project-scoped
     (76, "Make sessions.seq_num project-scoped", _migrate_session_seq_num_project_scoped),
@@ -716,6 +737,8 @@ MIGRATIONS: list[tuple[int, str, MigrationAction]] = [
     (77, "Backfill sessions.seq_num per project", _migrate_backfill_session_seq_num_per_project),
     # Hub tracking: Add hub_name, hub_slug, hub_version to skills table
     (78, "Add hub tracking fields to skills", _migrate_add_hub_tracking_to_skills),
+    # Skill injection: Add always_apply and injection_format columns
+    (79, "Add skill injection columns", _migrate_add_skill_injection_columns),
 ]
 
 

gobby/storage/skills.py

@@ -91,6 +91,8 @@ class Skill:
 
     # Gobby-specific
     enabled: bool = True
+    always_apply: bool = False
+    injection_format: str = "summary"  # "summary", "full", "content"
     project_id: str | None = None
 
     # Timestamps
@@ -131,6 +133,10 @@ class Skill:
             hub_slug=row["hub_slug"] if "hub_slug" in row.keys() else None,
             hub_version=row["hub_version"] if "hub_version" in row.keys() else None,
             enabled=bool(row["enabled"]),
+            always_apply=bool(row["always_apply"]) if "always_apply" in row.keys() else False,
+            injection_format=row["injection_format"]
+            if "injection_format" in row.keys()
+            else "summary",
             project_id=row["project_id"],
             created_at=row["created_at"],
             updated_at=row["updated_at"],
@@ -159,6 +165,8 @@ class Skill:
             "hub_slug": self.hub_slug,
             "hub_version": self.hub_version,
             "enabled": self.enabled,
+            "always_apply": self.always_apply,
+            "injection_format": self.injection_format,
             "project_id": self.project_id,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
@@ -192,9 +200,13 @@ class Skill:
     def is_always_apply(self) -> bool:
         """Check if this is a core skill that should always be applied.
 
-        Supports both top-level alwaysApply and nested metadata.skillport.alwaysApply.
-        Top-level takes precedence.
+        Reads from the always_apply column first (set during sync from frontmatter).
+        Falls back to metadata for backwards compatibility with older records.
         """
+        # Primary: read from column (set during sync)
+        if self.always_apply:
+            return True
+        # Fallback: check metadata for backwards compatibility
         if not self.metadata:
             return False
         # Check top-level first
@@ -407,6 +419,8 @@ class LocalSkillManager:
         hub_slug: str | None = None,
         hub_version: str | None = None,
         enabled: bool = True,
+        always_apply: bool = False,
+        injection_format: str = "summary",
         project_id: str | None = None,
     ) -> Skill:
         """Create a new skill.
@@ -427,6 +441,8 @@ class LocalSkillManager:
             hub_slug: Optional hub slug
             hub_version: Optional hub version
             enabled: Whether skill is active
+            always_apply: Whether skill should always be injected at session start
+            injection_format: How to inject skill (summary, full, content)
             project_id: Project scope (None for global)
 
         Returns:
@@ -457,8 +473,9 @@ class LocalSkillManager:
                     id, name, description, content, version, license,
                     compatibility, allowed_tools, metadata, source_path,
                     source_type, source_ref, hub_name, hub_slug, hub_version,
-                    enabled, project_id, created_at, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    enabled, always_apply, injection_format, project_id,
+                    created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     skill_id,
@@ -477,6 +494,8 @@ class LocalSkillManager:
                     hub_slug,
                     hub_version,
                     enabled,
+                    always_apply,
+                    injection_format,
                     project_id,
                     now,
                     now,
@@ -559,6 +578,8 @@ class LocalSkillManager:
         hub_slug: str | None = _UNSET,
         hub_version: str | None = _UNSET,
         enabled: bool | None = None,
+        always_apply: bool | None = None,
+        injection_format: str | None = None,
     ) -> Skill:
         """Update an existing skill.
 
@@ -579,6 +600,8 @@ class LocalSkillManager:
             hub_slug: New hub slug (use _UNSET to leave unchanged, None to clear)
             hub_version: New hub version (use _UNSET to leave unchanged, None to clear)
             enabled: New enabled state (optional)
+            always_apply: New always_apply state (optional)
+            injection_format: New injection format (optional)
 
         Returns:
             The updated Skill
@@ -634,6 +657,12 @@ class LocalSkillManager:
         if enabled is not None:
             updates.append("enabled = ?")
             params.append(enabled)
+        if always_apply is not None:
+            updates.append("always_apply = ?")
+            params.append(always_apply)
+        if injection_format is not None:
+            updates.append("injection_format = ?")
+            params.append(injection_format)
 
         if not updates:
             return self.get_skill(skill_id)
@@ -770,7 +799,7 @@ class LocalSkillManager:
         return [Skill.from_row(row) for row in rows]
 
     def list_core_skills(self, project_id: str | None = None) -> list[Skill]:
-        """List skills with alwaysApply=true.
+        """List skills with always_apply=true (efficiently via column query).
 
         Args:
             project_id: Optional project scope
@@ -778,8 +807,19 @@ class LocalSkillManager:
         Returns:
             List of core skills (always-apply skills)
         """
-        skills = self.list_skills(project_id=project_id, enabled=True, limit=1000)
-        return [s for s in skills if s.is_always_apply()]
+        query = "SELECT * FROM skills WHERE always_apply = 1 AND enabled = 1"
+        params: list[Any] = []
+
+        if project_id:
+            query += " AND (project_id = ? OR project_id IS NULL)"
+            params.append(project_id)
+        else:
+            query += " AND project_id IS NULL"
+
+        query += " ORDER BY name ASC"
+
+        rows = self.db.fetchall(query, tuple(params))
+        return [Skill.from_row(row) for row in rows]
 
     def skill_exists(self, skill_id: str) -> bool:
         """Check if a skill with the given ID exists.

gobby/tasks/external_validator.py

@@ -46,12 +46,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 # Default system prompt for external validators
-DEFAULT_EXTERNAL_SYSTEM_PROMPT = (
-    "You are an objective QA validator reviewing code changes. "
-    "You have no prior context about this task - evaluate purely based on "
-    "the acceptance criteria and the changes provided. "
-    "Be thorough but fair in your assessment."
-)
+
 
 # Module-level loader (initialized lazily)
 _loader: PromptLoader | None = None
@@ -62,10 +57,7 @@ def _get_loader(project_dir: Path | None = None) -> PromptLoader:
     global _loader
     if _loader is None:
         _loader = PromptLoader(project_dir=project_dir)
-        # Register fallbacks for strangler fig pattern
-        _loader.register_fallback(
-            "external_validation/system", lambda: DEFAULT_EXTERNAL_SYSTEM_PROMPT
-        )
+
     return _loader
 
 
@@ -218,13 +210,8 @@ async def _run_llm_validation(
     # Build the validation prompt
     prompt = _build_external_validation_prompt(task, changes_context)
 
-    # System prompt emphasizing objectivity
-    system_prompt = (
-        "You are an objective QA validator reviewing code changes. "
-        "You have no prior context about this task - evaluate purely based on "
-        "the acceptance criteria and the changes provided. "
-        "Be thorough but fair in your assessment."
-    )
+    # Render system prompt
+    system_prompt = _get_loader().render("external_validation/system", {})
 
     try:
         provider = llm_service.get_provider(config.provider)

gobby/tasks/validation.py

@@ -27,51 +27,6 @@ from gobby.utils.json_helpers import extract_json_object
 
 logger = logging.getLogger(__name__)
 
-# Default prompts (fallbacks for strangler fig pattern)
-DEFAULT_VALIDATE_PROMPT = """Validate if the following changes satisfy the requirements.
-
-Task: {title}
-{category_section}{criteria_text}
-
-{changes_section}
-IMPORTANT: Return ONLY a JSON object, nothing else. No explanation, no preamble.
-Format: {{"status": "valid", "feedback": "..."}} or {{"status": "invalid", "feedback": "..."}}
-"""
-
-DEFAULT_CRITERIA_PROMPT = """Generate validation criteria for this task.
-
-Task: {title}
-Description: {description}
-
-CRITICAL RULES - You MUST follow these:
-1. **Only stated requirements** - Include ONLY requirements explicitly written in the title or description
-2. **No invented values** - Do NOT invent specific numbers, timeouts, thresholds, or limits unless they appear in the task
-3. **No invented edge cases** - Do NOT add edge cases, error scenarios, or boundary conditions beyond what's described
-4. **Proportional detail** - Vague tasks get vague criteria; detailed tasks get detailed criteria
-5. **When in doubt, leave it out** - If something isn't mentioned, don't include it
-
-For vague requirements like "fix X" or "add Y", use criteria like:
-- "X no longer produces the reported error/warning"
-- "Y functionality works as expected"
-- "Existing tests continue to pass"
-- "No regressions introduced"
-
-DO NOT generate criteria like:
-- "timeout defaults to 30 seconds" (unless 30 seconds is in the task description)
-- "handles edge case Z" (unless Z is mentioned in the task)
-- "logs with format X" (unless that format is specified)
-
-Format as markdown checkboxes:
-## Deliverable
-- [ ] What the task explicitly asks for
-
-## Functional Requirements
-- [ ] Only requirements stated in the description
-
-## Verification
-- [ ] Tests pass (if applicable)
-- [ ] No regressions
-"""
 
 # Default number of commits to look back when gathering context
 DEFAULT_COMMIT_WINDOW = 10
@@ -490,10 +445,6 @@ class TaskValidator:
         self.llm_service = llm_service
         self._loader = PromptLoader(project_dir=project_dir)
 
-        # Register fallbacks for strangler fig pattern
-        self._loader.register_fallback("validation/validate", lambda: DEFAULT_VALIDATE_PROMPT)
-        self._loader.register_fallback("validation/criteria", lambda: DEFAULT_CRITERIA_PROMPT)
-
     async def gather_validation_context(self, file_paths: list[str]) -> str:
         """
         Gather context for validation from files.
@@ -588,35 +539,16 @@ class TaskValidator:
             else:
                 category_section += "\n"
 
-        # Build prompt using PromptLoader or legacy config
-        if self.config.prompt_path:
-            prompt_path = self.config.prompt_path
-            template_context = {
-                "title": title,
-                "category_section": category_section,
-                "criteria_text": criteria_text,
-                "changes_section": changes_section,
-                "file_context": file_context[:50000] if file_context else "",
-            }
-            try:
-                prompt = self._loader.render(prompt_path, template_context)
-            except FileNotFoundError:
-                logger.debug(f"Prompt template '{prompt_path}' not found, using fallback")
-                prompt = DEFAULT_VALIDATE_PROMPT.format(**template_context)
-                if file_context:
-                    prompt += f"\nFile Context:\n{file_context[:50000]}\n"
-        else:
-            # Default behavior
-            template_context = {
-                "title": title,
-                "category_section": category_section,
-                "criteria_text": criteria_text,
-                "changes_section": changes_section,
-                "file_context": file_context[:50000] if file_context else "",
-            }
-            prompt = DEFAULT_VALIDATE_PROMPT.format(**template_context)
-            if file_context:
-                prompt += f"\nFile Context:\n{file_context[:50000]}\n"
+        # Build prompt using PromptLoader
+        prompt_path = self.config.prompt_path or "validation/validate"
+        template_context = {
+            "title": title,
+            "category_section": category_section,
+            "criteria_text": criteria_text,
+            "changes_section": changes_section,
+            "file_context": file_context[:50000] if file_context else "",
+        }
+        prompt = self._loader.render(prompt_path, template_context)
 
         try:
             provider = self.llm_service.get_provider(self.config.provider)
@@ -670,19 +602,13 @@ class TaskValidator:
         if not self.config.enabled:
             return None
 
-        # Build prompt using PromptLoader or legacy config
+        # Use PromptLoader
+        prompt_path = self.config.criteria_prompt_path or "validation/criteria"
         template_context = {
             "title": title,
             "description": description or "(no description)",
         }
-
-        # Use PromptLoader
-        prompt_path = self.config.criteria_prompt_path or "validation/criteria"
-        try:
-            prompt = self._loader.render(prompt_path, template_context)
-        except FileNotFoundError:
-            logger.debug(f"Prompt template '{prompt_path}' not found, using fallback")
-            prompt = DEFAULT_CRITERIA_PROMPT.format(**template_context)
+        prompt = self._loader.render(prompt_path, template_context)
 
         try:
             provider = self.llm_service.get_provider(self.config.provider)

gobby/tools/summarizer.py

@@ -23,25 +23,6 @@ MAX_DESCRIPTION_LENGTH = 200
 _config: ToolSummarizerConfig | None = None
 _loader: PromptLoader | None = None
 
-DEFAULT_SUMMARY_PROMPT = """Summarize this MCP tool description in 180 characters or less.
-Keep it to three sentences or less. Be concise and preserve the key functionality.
-Do not add quotes, extra formatting, or code examples.
-
-Description: {description}
-
-Summary:"""
-
-DEFAULT_SUMMARY_SYSTEM_PROMPT = "You are a technical summarizer. Create concise tool descriptions."
-
-DEFAULT_SERVER_DESC_PROMPT = """Write a single concise sentence describing what the '{server_name}' MCP server does based on its tools.
-
-Tools:
-{tools_list}
-
-Description (1 sentence, try to keep under 100 characters):"""
-
-DEFAULT_SERVER_DESC_SYSTEM_PROMPT = "You write concise technical descriptions."
-
 
 def init_summarizer_config(config: ToolSummarizerConfig, project_dir: str | None = None) -> None:
     """Initialize the summarizer with configuration."""
@@ -50,13 +31,6 @@ def init_summarizer_config(config: ToolSummarizerConfig, project_dir: str | None
     global _config, _loader
     _config = config
     _loader = PromptLoader(project_dir=Path(project_dir) if project_dir else None)
-    # Register fallbacks
-    _loader.register_fallback("features/tool_summary", lambda: DEFAULT_SUMMARY_PROMPT)
-    _loader.register_fallback("features/tool_summary_system", lambda: DEFAULT_SUMMARY_SYSTEM_PROMPT)
-    _loader.register_fallback("features/server_description", lambda: DEFAULT_SERVER_DESC_PROMPT)
-    _loader.register_fallback(
-        "features/server_description_system", lambda: DEFAULT_SERVER_DESC_SYSTEM_PROMPT
-    )
 
 
 def _get_config() -> ToolSummarizerConfig:
@@ -96,9 +70,9 @@ async def _summarize_description_with_claude(description: str) -> str:
             if _loader is None:
                 raise RuntimeError("Summarizer not initialized")
             prompt = _loader.render(prompt_path, {"description": description})
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load prompt from {prompt_path}: {e}, using default")
-            prompt = DEFAULT_SUMMARY_PROMPT.format(description=description)
+        except (OSError, KeyError, ValueError, RuntimeError) as e:
+            logger.debug(f"Failed to load prompt from {prompt_path}: {e}")
+            raise
 
         # Get system prompt
         sys_prompt_path = config.system_prompt_path or "features/tool_summary_system"
@@ -106,9 +80,9 @@ async def _summarize_description_with_claude(description: str) -> str:
             if _loader is None:
                 raise RuntimeError("Summarizer not initialized")
             system_prompt = _loader.render(sys_prompt_path, {})
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load system prompt from {sys_prompt_path}: {e}, using default")
-            system_prompt = DEFAULT_SUMMARY_SYSTEM_PROMPT
+        except (OSError, KeyError, ValueError, RuntimeError) as e:
+            logger.debug(f"Failed to load system prompt from {sys_prompt_path}: {e}")
+            system_prompt = "You are a technical summarizer."
 
         # Configure for single-turn completion
         options = ClaudeAgentOptions(
@@ -198,30 +172,23 @@ async def generate_server_description(
             "server_name": server_name,
             "tools_list": tools_list,
         }
-        try:
-            if _loader is None:
-                _get_config()  # force init
-            if _loader is None:
-                # Still None after _get_config, use default
-                prompt = DEFAULT_SERVER_DESC_PROMPT.format(**context)
-            else:
-                prompt = _loader.render(prompt_path, context)
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load prompt from {prompt_path}: {e}, using default")
-            prompt = DEFAULT_SERVER_DESC_PROMPT.format(**context)
+        if _loader is None:
+            _get_config()  # force init
+        if _loader is None:
+            # Still None after _get_config, use default
+            raise RuntimeError("Summarizer not initialized")
+        else:
+            prompt = _loader.render(prompt_path, context)
 
         # Get system prompt
         sys_prompt_path = (
             config.server_description_system_prompt_path or "features/server_description_system"
         )
-        try:
-            if _loader is None:
-                system_prompt = DEFAULT_SERVER_DESC_SYSTEM_PROMPT
-            else:
-                system_prompt = _loader.render(sys_prompt_path, {})
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load system prompt from {sys_prompt_path}: {e}, using default")
-            system_prompt = DEFAULT_SERVER_DESC_SYSTEM_PROMPT
+
+        if _loader is None:
+            system_prompt = "You write concise technical descriptions."
+        else:
+            system_prompt = _loader.render(sys_prompt_path, {})
 
         # Configure for single-turn completion
         options = ClaudeAgentOptions(