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

gobby/storage/sessions.py

@@ -52,6 +52,8 @@ class Session:
     terminal_context: dict[str, Any] | None = None
     # Global sequence number
     seq_num: int | None = None
+    # Edit history tracking
+    had_edits: bool = False
 
     @classmethod
     def from_row(cls, row: Any) -> Session:
@@ -86,6 +88,7 @@ class Session:
             model=row["model"] if "model" in row.keys() else None,
             terminal_context=cls._parse_terminal_context(row["terminal_context"]),
             seq_num=row["seq_num"] if "seq_num" in row.keys() else None,
+            had_edits=bool(row["had_edits"]) if "had_edits" in row.keys() else False,
         )
 
     @classmethod
@@ -135,6 +138,7 @@ class Session:
             "usage_cache_read_tokens": self.usage_cache_read_tokens,
             "usage_total_cost_usd": self.usage_total_cost_usd,
             "terminal_context": self.terminal_context,
+            "had_edits": self.had_edits,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
             "seq_num": self.seq_num,
@@ -162,6 +166,7 @@ class LocalSessionManager:
         agent_depth: int = 0,
         spawned_by_agent_id: str | None = None,
         terminal_context: dict[str, Any] | None = None,
+        workflow_name: str | None = None,
     ) -> Session:
         """
         Register a new session or return existing one.
@@ -224,8 +229,11 @@ class LocalSessionManager:
         max_retries = 3
         for attempt in range(max_retries):
             try:
-                # Get next seq_num (global)
-                max_seq_row = self.db.fetchone("SELECT MAX(seq_num) as max_seq FROM sessions")
+                # Get next seq_num (per-project)
+                max_seq_row = self.db.fetchone(
+                    "SELECT MAX(seq_num) as max_seq FROM sessions WHERE project_id = ?",
+                    (project_id,),
+                )
                 next_seq_num = ((max_seq_row["max_seq"] if max_seq_row else None) or 0) + 1
 
                 self.db.execute(
@@ -234,9 +242,9 @@ class LocalSessionManager:
                         id, external_id, machine_id, source, project_id, title,
                         jsonl_path, git_branch, parent_session_id,
                         agent_depth, spawned_by_agent_id, terminal_context,
-                        status, created_at, updated_at, seq_num
+                        workflow_name, status, created_at, updated_at, seq_num, had_edits
                     )
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 0)
                     """,
                     (
                         session_id,
@@ -251,6 +259,7 @@ class LocalSessionManager:
                         agent_depth,
                         spawned_by_agent_id,
                         json.dumps(terminal_context) if terminal_context else None,
+                        workflow_name,
                         now,
                         now,
                         next_seq_num,
@@ -279,18 +288,20 @@ class LocalSessionManager:
         row = self.db.fetchone("SELECT * FROM sessions WHERE id = ?", (session_id,))
         return Session.from_row(row) if row else None
 
-    def resolve_session_reference(self, ref: str) -> str:
+    def resolve_session_reference(self, ref: str, project_id: str | None = None) -> str:
         """
         Resolve a session reference to a UUID.
 
         Supports:
-        - #N: Global Sequence Number (e.g., #1)
+        - #N: Project-scoped Sequence Number (e.g., #1) - requires project_id
         - N: Integer string treated as #N (e.g., "1")
         - UUID: Full UUID
         - Prefix: UUID prefix (must be unambiguous)
 
         Args:
             ref: Session reference string
+            project_id: Project ID for project-scoped #N lookup.
+                If not provided, falls back to global lookup for backwards compat.
 
         Returns:
             Resolved Session UUID
@@ -308,7 +319,15 @@ class LocalSessionManager:
 
         if seq_num_ref.isdigit():
             seq_num = int(seq_num_ref)
-            row = self.db.fetchone("SELECT id FROM sessions WHERE seq_num = ?", (seq_num,))
+            if project_id:
+                # Project-scoped lookup
+                row = self.db.fetchone(
+                    "SELECT id FROM sessions WHERE project_id = ? AND seq_num = ?",
+                    (project_id, seq_num),
+                )
+            else:
+                # Fallback to global lookup for backwards compat
+                row = self.db.fetchone("SELECT id FROM sessions WHERE seq_num = ?", (seq_num,))
             if not row:
                 raise ValueError(f"Session #{seq_num} not found")
             return str(row["id"])
@@ -426,6 +445,15 @@ class LocalSessionManager:
         )
         return self.get(session_id)
 
+    def mark_had_edits(self, session_id: str) -> Session | None:
+        """Mark session as having edits."""
+        now = datetime.now(UTC).isoformat()
+        self.db.execute(
+            "UPDATE sessions SET had_edits = 1, updated_at = ? WHERE id = ?",
+            (now, session_id),
+        )
+        return self.get(session_id)
+
     def update_title(self, session_id: str, title: str) -> Session | None:
         """Update session title."""
         now = datetime.now(UTC).isoformat()
@@ -435,6 +463,16 @@ class LocalSessionManager:
         )
         return self.get(session_id)
 
+    def update_model(self, session_id: str, model: str) -> Session | None:
+        """Update session model (LLM model used)."""
+        now = datetime.now(UTC).isoformat()
+        with self.db.transaction():
+            self.db.execute(
+                "UPDATE sessions SET model = ?, updated_at = ? WHERE id = ?",
+                (model, now, session_id),
+            )
+        return self.get(session_id)
+
     def update_summary(
         self,
         session_id: str,

gobby/storage/skills.py

@@ -52,6 +52,11 @@ class Skill:
         - source_type: 'local', 'github', 'url', 'zip', 'filesystem'
         - source_ref: Git ref for updates (branch/tag/commit)
 
+    Hub Tracking:
+        - hub_name: Name of the hub the skill originated from
+        - hub_slug: Slug of the hub the skill originated from
+        - hub_version: Version of the skill as reported by the hub
+
     Gobby-specific:
         - enabled: Toggle skill on/off without removing
         - project_id: NULL for global, else project-scoped
@@ -79,6 +84,11 @@ class Skill:
     source_type: SkillSourceType | None = None
     source_ref: str | None = None
 
+    # Hub Tracking
+    hub_name: str | None = None
+    hub_slug: str | None = None
+    hub_version: str | None = None
+
     # Gobby-specific
     enabled: bool = True
     project_id: str | None = None
@@ -117,6 +127,9 @@ class Skill:
             source_path=row["source_path"],
             source_type=row["source_type"],
             source_ref=row["source_ref"],
+            hub_name=row["hub_name"] if "hub_name" in row.keys() else None,
+            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"]),
             project_id=row["project_id"],
             created_at=row["created_at"],
@@ -142,6 +155,9 @@ class Skill:
             "source_path": self.source_path,
             "source_type": self.source_type,
             "source_ref": self.source_ref,
+            "hub_name": self.hub_name,
+            "hub_slug": self.hub_slug,
+            "hub_version": self.hub_version,
             "enabled": self.enabled,
             "project_id": self.project_id,
             "created_at": self.created_at,
@@ -149,9 +165,18 @@ class Skill:
         }
 
     def get_category(self) -> str | None:
-        """Get the skill category from metadata.skillport.category."""
+        """Get the skill category from top-level or metadata.skillport.category.
+
+        Supports both top-level category and nested metadata.skillport.category.
+        Top-level takes precedence.
+        """
         if not self.metadata:
             return None
+        # Check top-level first
+        result = self.metadata.get("category")
+        if result is not None:
+            return str(result)
+        # Fall back to nested skillport.category
         skillport = self.metadata.get("skillport", {})
         result = skillport.get("category")
         return str(result) if result is not None else None
@@ -165,9 +190,18 @@ class Skill:
         return list(tags) if isinstance(tags, list) else []
 
     def is_always_apply(self) -> bool:
-        """Check if this is a core skill that should always be applied."""
+        """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.
+        """
         if not self.metadata:
             return False
+        # Check top-level first
+        top_level = self.metadata.get("alwaysApply")
+        if top_level is not None:
+            return bool(top_level)
+        # Fall back to nested skillport.alwaysApply
         skillport = self.metadata.get("skillport", {})
         return bool(skillport.get("alwaysApply", False))
 
@@ -369,6 +403,9 @@ class LocalSkillManager:
         source_path: str | None = None,
         source_type: SkillSourceType | None = None,
         source_ref: str | None = None,
+        hub_name: str | None = None,
+        hub_slug: str | None = None,
+        hub_version: str | None = None,
         enabled: bool = True,
         project_id: str | None = None,
     ) -> Skill:
@@ -386,6 +423,9 @@ class LocalSkillManager:
             source_path: Original file path or URL
             source_type: Source type ('local', 'github', 'url', 'zip', 'filesystem')
             source_ref: Git ref for updates
+            hub_name: Optional hub name
+            hub_slug: Optional hub slug
+            hub_version: Optional hub version
             enabled: Whether skill is active
             project_id: Project scope (None for global)
 
@@ -416,9 +456,9 @@ class LocalSkillManager:
                 INSERT INTO skills (
                     id, name, description, content, version, license,
                     compatibility, allowed_tools, metadata, source_path,
-                    source_type, source_ref, enabled, project_id,
-                    created_at, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    source_type, source_ref, hub_name, hub_slug, hub_version,
+                    enabled, project_id, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     skill_id,
@@ -433,6 +473,9 @@ class LocalSkillManager:
                     source_path,
                     source_type,
                     source_ref,
+                    hub_name,
+                    hub_slug,
+                    hub_version,
                     enabled,
                     project_id,
                     now,
@@ -465,21 +508,32 @@ class LocalSkillManager:
         self,
         name: str,
         project_id: str | None = None,
+        include_global: bool = True,
     ) -> Skill | None:
         """Get a skill by name within a project scope.
 
         Args:
             name: The skill name
             project_id: Project scope (None for global)
+            include_global: Include global skills when project_id is set.
+                           When True and project_id is set, first looks for
+                           project-scoped skill, then falls back to global.
 
         Returns:
             The Skill if found, None otherwise
         """
         if project_id:
+            # First try project-scoped skill
             row = self.db.fetchone(
                 "SELECT * FROM skills WHERE name = ? AND project_id = ?",
                 (name, project_id),
             )
+            # If not found and include_global, try global
+            if row is None and include_global:
+                row = self.db.fetchone(
+                    "SELECT * FROM skills WHERE name = ? AND project_id IS NULL",
+                    (name,),
+                )
         else:
             row = self.db.fetchone(
                 "SELECT * FROM skills WHERE name = ? AND project_id IS NULL",
@@ -501,6 +555,9 @@ class LocalSkillManager:
         source_path: str | None = _UNSET,
         source_type: SkillSourceType | None = _UNSET,
         source_ref: str | None = _UNSET,
+        hub_name: str | None = _UNSET,
+        hub_slug: str | None = _UNSET,
+        hub_version: str | None = _UNSET,
         enabled: bool | None = None,
     ) -> Skill:
         """Update an existing skill.
@@ -518,6 +575,9 @@ class LocalSkillManager:
             source_path: New source path (use _UNSET to leave unchanged, None to clear)
             source_type: New source type (use _UNSET to leave unchanged, None to clear)
             source_ref: New source ref (use _UNSET to leave unchanged, None to clear)
+            hub_name: New hub name (use _UNSET to leave unchanged, None to clear)
+            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)
 
         Returns:
@@ -562,6 +622,15 @@ class LocalSkillManager:
         if source_ref is not _UNSET:
             updates.append("source_ref = ?")
             params.append(source_ref)
+        if hub_name is not _UNSET:
+            updates.append("hub_name = ?")
+            params.append(hub_name)
+        if hub_slug is not _UNSET:
+            updates.append("hub_slug = ?")
+            params.append(hub_slug)
+        if hub_version is not _UNSET:
+            updates.append("hub_version = ?")
+            params.append(hub_version)
         if enabled is not None:
             updates.append("enabled = ?")
             params.append(enabled)
@@ -649,9 +718,13 @@ class LocalSkillManager:
             params.append(enabled)
 
         # Filter by category using JSON extraction in SQL to avoid under-filled results
+        # Check both top-level $.category and nested $.skillport.category
         if category:
-            query += " AND json_extract(metadata, '$.skillport.category') = ?"
-            params.append(category)
+            query += """ AND (
+                json_extract(metadata, '$.category') = ?
+                OR json_extract(metadata, '$.skillport.category') = ?
+            )"""
+            params.extend([category, category])
 
         query += " ORDER BY name ASC LIMIT ? OFFSET ?"
         params.extend([limit, offset])

gobby/storage/tasks/_lifecycle.py

@@ -275,7 +275,11 @@ def unlink_commit(
 
 
 def delete_task(
-    db: DatabaseProtocol, task_id: str, cascade: bool = False, unlink: bool = False
+    db: DatabaseProtocol,
+    task_id: str,
+    cascade: bool = False,
+    unlink: bool = False,
+    _visited: set[str] | None = None,
 ) -> bool:
     """Delete a task.
 
@@ -285,6 +289,8 @@ def delete_task(
         cascade: If True, delete children AND dependent tasks recursively
         unlink: If True, remove dependency links but preserve dependent tasks
                 (ignored if cascade=True)
+        _visited: Internal parameter to track visited tasks and prevent infinite recursion
+                  when a parent task depends on its children (circular dependency)
 
     Returns:
         True if task was deleted, False if task not found.
@@ -292,6 +298,15 @@ def delete_task(
     Raises:
         ValueError: If task has children or dependents and neither cascade nor unlink is True.
     """
+    # Initialize visited set on first call to prevent infinite recursion
+    if _visited is None:
+        _visited = set()
+
+    # Skip if already being deleted (prevents cycles when parent depends on children)
+    if task_id in _visited:
+        return True
+    _visited.add(task_id)
+
     # Check if task exists first
     existing = db.fetchone("SELECT 1 FROM tasks WHERE id = ?", (task_id,))
     if not existing:
@@ -326,7 +341,7 @@ def delete_task(
         # Recursive delete children
         children = db.fetchall("SELECT id FROM tasks WHERE parent_task_id = ?", (task_id,))
         for child in children:
-            delete_task(db, child["id"], cascade=True)
+            delete_task(db, child["id"], cascade=True, _visited=_visited)
 
         # Delete tasks that depend on this task (only 'blocks' dependencies)
         dependents = db.fetchall(
@@ -336,7 +351,7 @@ def delete_task(
             (task_id,),
         )
         for dep in dependents:
-            delete_task(db, dep["id"], cascade=True)
+            delete_task(db, dep["id"], cascade=True, _visited=_visited)
 
     # Note: if unlink=True, dependency links are removed by ON DELETE CASCADE
     # when the task is deleted - no explicit action needed

gobby/sync/memories.py

@@ -29,7 +29,7 @@ __all__ = [
 # TODO: Rename MemorySyncConfig to MemoryBackupConfig in gobby.config.persistence
 # for consistency with MemoryBackupManager naming. Keeping current name for now
 # to minimize breaking changes across the codebase.
-from gobby.config.app import MemorySyncConfig
+from gobby.config.persistence import MemorySyncConfig
 from gobby.memory.manager import MemoryManager
 from gobby.storage.database import DatabaseProtocol
 

gobby/tasks/external_validator.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from gobby.config.app import TaskValidationConfig
+from gobby.config.tasks import TaskValidationConfig
 from gobby.llm import LLMService
 from gobby.prompts import PromptLoader
 from gobby.tasks.commits import (

gobby/tasks/validation.py

@@ -20,7 +20,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal
 
-from gobby.config.app import TaskValidationConfig
+from gobby.config.tasks import TaskValidationConfig
 from gobby.llm import LLMService
 from gobby.prompts import PromptLoader
 from gobby.utils.json_helpers import extract_json_object
@@ -589,14 +589,8 @@ class TaskValidator:
                 category_section += "\n"
 
         # Build prompt using PromptLoader or legacy config
-        if self.config.prompt:
-            # Legacy inline config (deprecated)
-            prompt = self.config.prompt
-            if file_context:
-                prompt += f"\nFile Context:\n{file_context[:50000]}\n"
-        else:
-            # Use PromptLoader
-            prompt_path = self.config.prompt_path or "validation/validate"
+        if self.config.prompt_path:
+            prompt_path = self.config.prompt_path
             template_context = {
                 "title": title,
                 "category_section": category_section,
@@ -611,6 +605,18 @@ class TaskValidator:
                 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"
 
         try:
             provider = self.llm_service.get_provider(self.config.provider)
@@ -670,17 +676,13 @@ class TaskValidator:
             "description": description or "(no description)",
         }
 
-        if self.config.criteria_prompt:
-            # Legacy inline config (deprecated)
-            prompt = self.config.criteria_prompt.format(**template_context)
-        else:
-            # 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)
+        # 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)
 
         try:
             provider = self.llm_service.get_provider(self.config.provider)

gobby/tools/summarizer.py

@@ -11,7 +11,8 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from gobby.config.app import ToolSummarizerConfig
+    from gobby.config.features import ToolSummarizerConfig
+from gobby.prompts import PromptLoader
 
 logger = logging.getLogger(__name__)
 
@@ -20,12 +21,42 @@ MAX_DESCRIPTION_LENGTH = 200
 
 # Module-level config reference (set by init_summarizer_config)
 _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.
 
-def init_summarizer_config(config: ToolSummarizerConfig) -> None:
+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."""
-    global _config
+    from pathlib import Path
+
+    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:
@@ -33,7 +64,12 @@ def _get_config() -> ToolSummarizerConfig:
     if _config is not None:
         return _config
     # Import here to avoid circular imports
-    from gobby.config.app import ToolSummarizerConfig
+    from gobby.config.features import ToolSummarizerConfig
+
+    # Ensure loader defaults exist even if init wasn't called
+    global _loader
+    if _loader is None:
+        _loader = PromptLoader()
 
     return ToolSummarizerConfig()
 
@@ -53,11 +89,30 @@ async def _summarize_description_with_claude(description: str) -> str:
     try:
         from claude_agent_sdk import AssistantMessage, ClaudeAgentOptions, TextBlock, query
 
-        prompt = config.prompt.format(description=description)
+        # Get summary prompt
+        prompt_path = config.prompt_path or "features/tool_summary"
+        try:
+            # We assume _loader is initialized by _get_config() logic or init
+            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)
+
+        # Get system prompt
+        sys_prompt_path = config.system_prompt_path or "features/tool_summary_system"
+        try:
+            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
 
         # Configure for single-turn completion
         options = ClaudeAgentOptions(
-            system_prompt=config.system_prompt,
+            system_prompt=system_prompt,
             max_turns=1,
             model=config.model,
             allowed_tools=[],
@@ -137,14 +192,40 @@ async def generate_server_description(
         # Build tools list for prompt
         tools_list = "\n".join([f"- {t['name']}: {t['description']}" for t in tool_summaries])
 
-        prompt = config.server_description_prompt.format(
-            server_name=server_name,
-            tools_list=tools_list,
+        # Build prompt
+        prompt_path = config.server_description_prompt_path or "features/server_description"
+        context = {
+            "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)
+
+        # 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
 
         # Configure for single-turn completion
         options = ClaudeAgentOptions(
-            system_prompt=config.server_description_system_prompt,
+            system_prompt=system_prompt,
             max_turns=1,
             model=config.model,
             allowed_tools=[],

gobby/utils/project_context.py

@@ -10,8 +10,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
 if TYPE_CHECKING:
-    from gobby.config.app import ProjectVerificationConfig
-    from gobby.config.features import HooksConfig
+    from gobby.config.features import HooksConfig, ProjectVerificationConfig
 
 logger = logging.getLogger(__name__)
 
@@ -138,7 +137,7 @@ def get_verification_config(cwd: Path | None = None) -> ProjectVerificationConfi
     Returns:
         ProjectVerificationConfig if verification section exists, None otherwise.
     """
-    from gobby.config.app import ProjectVerificationConfig
+    from gobby.config.features import ProjectVerificationConfig
 
     context = get_project_context(cwd)
     if not context: