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

gobby/storage/database.py

@@ -11,7 +11,7 @@ import threading
 import weakref
 from collections.abc import Iterator
 from contextlib import AbstractContextManager, contextmanager
-from datetime import date, datetime
+from datetime import UTC, date, datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
 
@@ -21,6 +21,9 @@ from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
 
 def _adapt_datetime(val: datetime) -> str:
     """Adapt datetime to ISO format string for SQLite storage."""
+    # If naive datetime, assume UTC and add timezone info for RFC3339 compliance
+    if val.tzinfo is None:
+        val = val.replace(tzinfo=UTC)
     return val.isoformat()
 
 
@@ -31,7 +34,11 @@ def _adapt_date(val: date) -> str:
 
 def _convert_datetime(val: bytes) -> datetime:
     """Convert SQLite datetime string back to datetime object."""
-    return datetime.fromisoformat(val.decode())
+    dt = datetime.fromisoformat(val.decode())
+    # Ensure timezone-aware (treat naive as UTC) for consistency
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return dt
 
 
 def _convert_date(val: bytes) -> date:

gobby/storage/memories.py

@@ -197,40 +197,51 @@ class LocalMemoryManager:
         return row is not None
 
     def content_exists(self, content: str, project_id: str | None = None) -> bool:
-        """Check if a memory with identical content already exists."""
-        # Normalize content same way as ID generation in create_memory
-        normalized_content = content.strip()
-        project_str = project_id if project_id else ""
-        # Use delimiter to match create_memory ID generation
-        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
+        """Check if a memory with identical content already exists.
 
-        # Check by ID (content-hash based) for consistent dedup
-        row = self.db.fetchone("SELECT 1 FROM memories WHERE id = ?", (memory_id,))
+        Uses global deduplication - checks if any memory has the same content,
+        regardless of project_id. This prevents duplicates when the same content
+        is stored with different or NULL project_ids.
+
+        Args:
+            content: The content to check for
+            project_id: Ignored (kept for backward compatibility)
+
+        Returns:
+            True if a memory with identical content exists
+        """
+        # Global deduplication: check by content directly, ignoring project_id
+        # This fixes the duplicate issue where same content + different project_id
+        # would create different memory IDs
+        normalized_content = content.strip()
+        row = self.db.fetchone(
+            "SELECT 1 FROM memories WHERE content = ? LIMIT 1",
+            (normalized_content,),
+        )
         return row is not None
 
     def get_memory_by_content(self, content: str, project_id: str | None = None) -> Memory | None:
-        """Get a memory by its exact content, using the content-derived ID.
+        """Get a memory by its exact content.
 
-        This provides a reliable way to fetch an existing memory without
-        relying on search result ordering.
+        Uses global lookup - finds any memory with matching content regardless
+        of project_id. This matches the behavior of content_exists().
 
         Args:
             content: The exact content to look up (will be normalized)
-            project_id: Optional project ID for scoping
+            project_id: Ignored (kept for backward compatibility)
 
         Returns:
             The Memory object if found, None otherwise
         """
-        # Normalize content same way as ID generation in create_memory
+        # Global lookup: find by content directly, ignoring project_id
         normalized_content = content.strip()
-        project_str = project_id if project_id else ""
-        # Use delimiter to match create_memory ID generation
-        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
-
-        try:
-            return self.get_memory(memory_id)
-        except ValueError:
-            return None
+        row = self.db.fetchone(
+            "SELECT * FROM memories WHERE content = ? LIMIT 1",
+            (normalized_content,),
+        )
+        if row:
+            return Memory.from_row(row)
+        return None
 
     def update_memory(
         self,

gobby/storage/migrations.py

@@ -43,11 +43,11 @@ class MigrationUnsupportedError(Exception):
 # Migration can be SQL string or a callable that takes LocalDatabase
 MigrationAction = str | Callable[[LocalDatabase], None]
 
-# Baseline version - the schema state after all legacy migrations
-# Baseline version - the schema state at v75 (flattened)
-BASELINE_VERSION = 75
+# Baseline version - the schema state at v79 (flattened)
+# This is applied for new databases directly
+BASELINE_VERSION = 79
 
-# Baseline schema - flattened from v75 production state
+# Baseline schema - flattened from v78 production state, includes hub tracking fields
 # This is applied for new databases directly
 # Generated by: sqlite3 ~/.gobby/gobby-hub.db .schema
 BASELINE_SCHEMA = """
@@ -583,7 +583,12 @@ CREATE TABLE skills (
     source_path TEXT,
     source_type TEXT,
     source_ref TEXT,
+    hub_name TEXT,
+    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
@@ -591,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;
 
@@ -692,11 +698,47 @@ def _migrate_backfill_session_seq_num_per_project(db: LocalDatabase) -> None:
     logger.info(f"Re-numbered {updated} sessions with per-project seq_num")
 
 
+def _migrate_add_hub_tracking_to_skills(db: LocalDatabase) -> None:
+    """Add hub tracking fields to skills table.
+
+    Adds hub_name, hub_slug, and hub_version columns to track which hub
+    a skill was installed from.
+    """
+    with db.transaction() as conn:
+        conn.execute("ALTER TABLE skills ADD COLUMN hub_name TEXT")
+        conn.execute("ALTER TABLE skills ADD COLUMN hub_slug TEXT")
+        conn.execute("ALTER TABLE skills ADD COLUMN hub_version TEXT")
+
+    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),
     # Project-scoped session refs: Re-backfill seq_num per project
     (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/sessions.py

@@ -166,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.
@@ -241,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, had_edits
+                        workflow_name, status, created_at, updated_at, seq_num, had_edits
                     )
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 0)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 0)
                     """,
                     (
                         session_id,
@@ -258,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,

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,8 +84,15 @@ 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
+    always_apply: bool = False
+    injection_format: str = "summary"  # "summary", "full", "content"
     project_id: str | None = None
 
     # Timestamps
@@ -117,7 +129,14 @@ 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"]),
+            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"],
@@ -142,7 +161,12 @@ 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,
+            "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,
@@ -176,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
@@ -387,7 +415,12 @@ 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,
+        always_apply: bool = False,
+        injection_format: str = "summary",
         project_id: str | None = None,
     ) -> Skill:
         """Create a new skill.
@@ -404,7 +437,12 @@ 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
+            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:
@@ -434,9 +472,10 @@ class LocalSkillManager:
                 INSERT INTO skills (
                     id, name, description, content, version, license,
                     compatibility, allowed_tools, metadata, source_path,
-                    source_type, source_ref, enabled, project_id,
+                    source_type, source_ref, hub_name, hub_slug, hub_version,
+                    enabled, always_apply, injection_format, project_id,
                     created_at, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     skill_id,
@@ -451,7 +490,12 @@ class LocalSkillManager:
                     source_path,
                     source_type,
                     source_ref,
+                    hub_name,
+                    hub_slug,
+                    hub_version,
                     enabled,
+                    always_apply,
+                    injection_format,
                     project_id,
                     now,
                     now,
@@ -530,7 +574,12 @@ 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,
+        always_apply: bool | None = None,
+        injection_format: str | None = None,
     ) -> Skill:
         """Update an existing skill.
 
@@ -547,7 +596,12 @@ 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)
+            always_apply: New always_apply state (optional)
+            injection_format: New injection format (optional)
 
         Returns:
             The updated Skill
@@ -591,9 +645,24 @@ 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)
+        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)
@@ -730,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
@@ -738,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)