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

gobby/storage/tasks/_crud.py

@@ -276,7 +276,7 @@ def update_task(
     agent_name: Any = UNSET,
     reference_doc: Any = UNSET,
     is_expanded: Any = UNSET,
-    is_tdd_applied: Any = UNSET,
+    expansion_status: Any = UNSET,
     validation_override_reason: Any = UNSET,
     requires_user_review: Any = UNSET,
 ) -> bool:
@@ -412,9 +412,9 @@ def update_task(
     if is_expanded is not UNSET:
         updates.append("is_expanded = ?")
         params.append(1 if is_expanded else 0)
-    if is_tdd_applied is not UNSET:
-        updates.append("is_tdd_applied = ?")
-        params.append(1 if is_tdd_applied else 0)
+    if expansion_status is not UNSET:
+        updates.append("expansion_status = ?")
+        params.append(expansion_status)
     if validation_override_reason is not UNSET:
         updates.append("validation_override_reason = ?")
         params.append(validation_override_reason)

gobby/storage/tasks/_lifecycle.py

@@ -274,19 +274,23 @@ def unlink_commit(
     return False
 
 
-def delete_task(db: DatabaseProtocol, task_id: str, cascade: bool = False) -> bool:
-    """Delete a task. If cascade is True, delete children recursively.
+def delete_task(
+    db: DatabaseProtocol, task_id: str, cascade: bool = False, unlink: bool = False
+) -> bool:
+    """Delete a task.
 
     Args:
         db: Database protocol instance
         task_id: The task ID to delete
-        cascade: If True, delete children recursively (default: False)
+        cascade: If True, delete children AND dependent tasks recursively
+        unlink: If True, remove dependency links but preserve dependent tasks
+                (ignored if cascade=True)
 
     Returns:
         True if task was deleted, False if task not found.
 
     Raises:
-        ValueError: If task has children and cascade is False.
+        ValueError: If task has children or dependents and neither cascade nor unlink is True.
     """
     # Check if task exists first
     existing = db.fetchone("SELECT 1 FROM tasks WHERE id = ?", (task_id,))
@@ -299,13 +303,44 @@ def delete_task(db: DatabaseProtocol, task_id: str, cascade: bool = False) -> bo
         if row:
             raise ValueError(f"Task {task_id} has children. Use cascade=True to delete.")
 
+    if not cascade and not unlink:
+        # Check for dependents (tasks that depend on this task)
+        dependent_rows = db.fetchall(
+            """SELECT t.id, t.seq_num, t.title
+               FROM tasks t
+               JOIN task_dependencies d ON d.task_id = t.id
+               WHERE d.depends_on = ? AND d.dep_type = 'blocks'""",
+            (task_id,),
+        )
+        if dependent_rows:
+            refs = [f"#{r['seq_num']}" for r in dependent_rows[:5] if r["seq_num"]]
+            refs_str = ", ".join(refs) if refs else str(len(dependent_rows)) + " task(s)"
+            if len(dependent_rows) > 5:
+                refs_str += f" and {len(dependent_rows) - 5} more"
+            raise ValueError(
+                f"Task {task_id} has {len(dependent_rows)} dependent task(s): {refs_str}. "
+                f"Use cascade=True to delete dependents, or unlink=True to preserve them."
+            )
+
     if cascade:
-        # Recursive delete
-        # Find all children
+        # 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 tasks that depend on this task (only 'blocks' dependencies)
+        dependents = db.fetchall(
+            """SELECT t.id FROM tasks t
+               JOIN task_dependencies d ON d.task_id = t.id
+               WHERE d.depends_on = ? AND d.dep_type = 'blocks'""",
+            (task_id,),
+        )
+        for dep in dependents:
+            delete_task(db, dep["id"], cascade=True)
+
+    # Note: if unlink=True, dependency links are removed by ON DELETE CASCADE
+    # when the task is deleted - no explicit action needed
+
     with db.transaction() as conn:
         conn.execute("DELETE FROM tasks WHERE id = ?", (task_id,))
     return True

gobby/storage/tasks/_manager.py

@@ -306,7 +306,7 @@ class LocalTaskManager:
         agent_name: str | None | Any = UNSET,
         reference_doc: str | None | Any = UNSET,
         is_expanded: bool | None | Any = UNSET,
-        is_tdd_applied: bool | None | Any = UNSET,
+        expansion_status: str | None | Any = UNSET,
         validation_override_reason: str | None | Any = UNSET,
         requires_user_review: bool | None | Any = UNSET,
     ) -> Task:
@@ -344,7 +344,7 @@ class LocalTaskManager:
             agent_name=agent_name,
             reference_doc=reference_doc,
             is_expanded=is_expanded,
-            is_tdd_applied=is_tdd_applied,
+            expansion_status=expansion_status,
             validation_override_reason=validation_override_reason,
             requires_user_review=requires_user_review,
         )
@@ -462,13 +462,22 @@ class LocalTaskManager:
             self._notify_listeners()
         return self.get_task(task_id)
 
-    def delete_task(self, task_id: str, cascade: bool = False) -> bool:
-        """Delete a task. If cascade is True, delete children recursively.
+    def delete_task(self, task_id: str, cascade: bool = False, unlink: bool = False) -> bool:
+        """Delete a task.
+
+        Args:
+            task_id: The task ID to delete
+            cascade: If True, delete children AND dependent tasks recursively
+            unlink: If True, remove dependency links but preserve dependent tasks
+                    (ignored if cascade=True)
 
         Returns:
             True if task was deleted, False if task not found.
+
+        Raises:
+            ValueError: If task has children or dependents and neither cascade nor unlink is True.
         """
-        result = _delete_task(self.db, task_id, cascade)
+        result = _delete_task(self.db, task_id, cascade=cascade, unlink=unlink)
         if result:
             self._notify_listeners()
         return result

gobby/storage/tasks/_models.py

@@ -133,7 +133,8 @@ class Task:
     reference_doc: str | None = None  # Path to source specification document
     # Processing flags for idempotent operations
     is_expanded: bool = False  # Subtasks have been created
-    is_tdd_applied: bool = False  # TDD pairs have been generated
+    # Skill-based expansion status (for new /gobby-expand flow)
+    expansion_status: Literal["none", "pending", "completed"] = "none"
     # Review status fields (HITL support)
     requires_user_review: bool = False  # Task requires user sign-off before closing
     accepted_by_user: bool = False  # Set True when user moves review → closed
@@ -213,7 +214,11 @@ class Task:
             agent_name=row["agent_name"] if "agent_name" in keys else None,
             reference_doc=row["reference_doc"] if "reference_doc" in keys else None,
             is_expanded=bool(row["is_expanded"]) if "is_expanded" in keys else False,
-            is_tdd_applied=bool(row["is_tdd_applied"]) if "is_tdd_applied" in keys else False,
+            expansion_status=(
+                row["expansion_status"]
+                if "expansion_status" in keys and row["expansion_status"]
+                else "none"
+            ),
             requires_user_review=(
                 bool(row["requires_user_review"]) if "requires_user_review" in keys else False
             ),
@@ -268,7 +273,7 @@ class Task:
             "agent_name": self.agent_name,
             "reference_doc": self.reference_doc,
             "is_expanded": self.is_expanded,
-            "is_tdd_applied": self.is_tdd_applied,
+            "expansion_status": self.expansion_status,
             "requires_user_review": self.requires_user_review,
             "accepted_by_user": self.accepted_by_user,
             "id": self.id,  # UUID at end for backwards compat

gobby/sync/memories.py

@@ -16,8 +16,10 @@ Classes:
 import asyncio
 import json
 import logging
+import os
 import time
 from pathlib import Path
+from typing import Any
 
 __all__ = [
     "MemoryBackupManager",
@@ -251,19 +253,52 @@ class MemoryBackupManager:
 
         return count
 
+    def _sanitize_content(self, content: str) -> str:
+        """Replace user home directories with ~ for privacy.
+
+        Prevents absolute user paths like /Users/josh from being
+        committed to version control.
+        """
+        home = os.path.expanduser("~")
+        return content.replace(home, "~")
+
+    def _deduplicate_memories(self, memories: list[Any]) -> list[Any]:
+        """Deduplicate memories by normalized content, keeping earliest.
+
+        Args:
+            memories: List of memory objects
+
+        Returns:
+            List of unique memories (by content), keeping the earliest created_at
+        """
+        seen_content: dict[str, Any] = {}  # normalized_content -> memory
+        for memory in memories:
+            normalized = memory.content.strip()
+            if normalized not in seen_content:
+                seen_content[normalized] = memory
+            else:
+                # Keep the one with earlier created_at
+                existing = seen_content[normalized]
+                if memory.created_at < existing.created_at:
+                    seen_content[normalized] = memory
+        return list(seen_content.values())
+
     def _export_memories_sync(self, file_path: Path) -> int:
-        """Export memories to JSONL file (sync)."""
+        """Export memories to JSONL file (sync) with deduplication and path sanitization."""
         if not self.memory_manager:
             return 0
 
         try:
             memories = self.memory_manager.list_memories()
 
+            # Deduplicate by content before export
+            unique_memories = self._deduplicate_memories(memories)
+
             with open(file_path, "w", encoding="utf-8") as f:
-                for memory in memories:
+                for memory in unique_memories:
                     data = {
                         "id": memory.id,
-                        "content": memory.content,
+                        "content": self._sanitize_content(memory.content),
                         "type": memory.memory_type,
                         "importance": memory.importance,
                         "tags": memory.tags,
@@ -274,7 +309,7 @@ class MemoryBackupManager:
                     }
                     f.write(json.dumps(data, ensure_ascii=False) + "\n")
 
-            return len(memories)
+            return len(unique_memories)
         except Exception as e:
             logger.error(f"Failed to export memories: {e}")
             return 0

gobby/sync/tasks.py

@@ -15,6 +15,56 @@ from gobby.utils.git import normalize_commit_sha
 logger = logging.getLogger(__name__)
 
 
+def _parse_timestamp(ts: str) -> datetime:
+    """Parse ISO 8601 timestamp string to datetime.
+
+    Handles both Z suffix and +HH:MM offset formats for compatibility
+    with existing data that may use either format.
+
+    Args:
+        ts: ISO 8601 timestamp string (e.g., "2026-01-25T01:43:54Z" or
+            "2026-01-25T01:43:54.123456+00:00")
+
+    Returns:
+        Timezone-aware datetime object in UTC
+    """
+    # Handle Z suffix for fromisoformat compatibility
+    parse_ts = ts[:-1] + "+00:00" if ts.endswith("Z") else ts
+    dt = datetime.fromisoformat(parse_ts)
+
+    # Ensure timezone is UTC
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=UTC)
+    return dt.astimezone(UTC)
+
+
+def _normalize_timestamp(ts: str | None) -> str | None:
+    """Normalize timestamp to consistent RFC 3339 format.
+
+    Ensures all timestamps have:
+    - Microsecond precision (.ffffff)
+    - UTC timezone as +00:00 suffix
+
+    Args:
+        ts: ISO 8601 timestamp string
+
+    Returns:
+        Timestamp in format YYYY-MM-DDTHH:MM:SS.ffffff+00:00, or None if input was None
+    """
+    if ts is None:
+        return None
+
+    try:
+        dt = _parse_timestamp(ts)
+    except ValueError:
+        # If parsing fails, return original (shouldn't happen with valid ISO 8601)
+        return ts
+
+    # Format with consistent microseconds and +00:00 suffix
+    base = dt.strftime("%Y-%m-%dT%H:%M:%S")
+    return f"{base}.{dt.microsecond:06d}+00:00"
+
+
 class TaskSyncManager:
     """
     Manages synchronization of tasks to the filesystem (JSONL) for Git versioning.
@@ -137,8 +187,9 @@ class TaskSyncManager:
                     "title": task.title,
                     "description": task.description,
                     "status": task.status,
-                    "created_at": task.created_at,
-                    "updated_at": task.updated_at,
+                    # Normalize timestamps to ensure RFC 3339 compliance (with timezone)
+                    "created_at": _normalize_timestamp(task.created_at),
+                    "updated_at": _normalize_timestamp(task.updated_at),
                     "project_id": task.project_id,
                     "parent_id": task.parent_task_id,
                     "deps_on": sorted(deps_map.get(task.id, [])),  # Sort deps for stability
@@ -157,8 +208,8 @@ class TaskSyncManager:
                         if task.validation_status
                         else None
                     ),
-                    # Escalation fields
-                    "escalated_at": task.escalated_at,
+                    # Escalation fields (normalize timestamps)
+                    "escalated_at": _normalize_timestamp(task.escalated_at),
                     "escalation_reason": task.escalation_reason,
                     # Human-friendly IDs (preserve across sync)
                     "seq_num": task.seq_num,
@@ -248,7 +299,21 @@ class TaskSyncManager:
 
                         data = json.loads(line)
                         task_id = data["id"]
-                        updated_at_file = datetime.fromisoformat(data["updated_at"])
+                        # Guard against None/missing updated_at in JSONL
+                        raw_updated_at = data.get("updated_at")
+                        if raw_updated_at is None:
+                            # Skip tasks without timestamps or use a safe default
+                            logger.warning(f"Task {task_id} missing updated_at, skipping")
+                            skipped_count += 1
+                            continue
+                        try:
+                            updated_at_file = _parse_timestamp(raw_updated_at)
+                        except ValueError as e:
+                            logger.warning(
+                                f"Task {task_id}: malformed timestamp '{raw_updated_at}': {e}, skipping"
+                            )
+                            skipped_count += 1
+                            continue
 
                         # Check if task exists (also fetch seq_num/path_cache to preserve)
                         existing_row = self.db.fetchone(
@@ -263,7 +328,19 @@ class TaskSyncManager:
                             should_update = True
                             imported_count += 1
                         else:
-                            updated_at_db = datetime.fromisoformat(existing_row["updated_at"])
+                            # Handle NULL timestamps in DB (treat as infinitely old)
+                            db_updated_at = existing_row["updated_at"]
+                            if db_updated_at is None:
+                                updated_at_db = datetime.min.replace(tzinfo=UTC)
+                            else:
+                                try:
+                                    updated_at_db = _parse_timestamp(db_updated_at)
+                                except ValueError as e:
+                                    logger.warning(
+                                        f"Task {task_id}: failed to parse DB timestamp "
+                                        f"'{db_updated_at}': {e}, treating as old"
+                                    )
+                                    updated_at_db = datetime.min.replace(tzinfo=UTC)
                             existing_seq_num = existing_row["seq_num"]
                             existing_path_cache = existing_row["path_cache"]
                             if updated_at_file > updated_at_db:

gobby/tasks/__init__.py

@@ -2,7 +2,6 @@
 Task management components.
 """
 
-from gobby.tasks.expansion import TaskExpander
 from gobby.tasks.validation import TaskValidator, ValidationResult
 
-__all__ = ["TaskExpander", "TaskValidator", "ValidationResult"]
+__all__ = ["TaskValidator", "ValidationResult"]

gobby/tasks/validation.py

@@ -21,10 +21,8 @@ from pathlib import Path
 from typing import Literal
 
 from gobby.config.app import TaskValidationConfig
-from gobby.config.tasks import PatternCriteriaConfig
 from gobby.llm import LLMService
 from gobby.prompts import PromptLoader
-from gobby.tasks.criteria import PatternCriteriaInjector
 from gobby.utils.json_helpers import extract_json_object
 
 logger = logging.getLogger(__name__)
@@ -655,14 +653,10 @@ class TaskValidator:
         """
         Generate validation criteria from task title and description.
 
-        When labels are provided (e.g., 'tdd', 'strangler-fig', 'refactoring'),
-        pattern-specific criteria from PatternCriteriaConfig are appended to
-        the LLM-generated criteria.
-
         Args:
             title: Task title
             description: Task description (optional)
-            labels: Task labels for pattern criteria injection (optional)
+            labels: Task labels (currently unused, kept for API compatibility)
 
         Returns:
             Generated validation criteria string, or None if generation fails
@@ -695,18 +689,33 @@ class TaskValidator:
                 system_prompt=self.config.criteria_system_prompt,
                 model=self.config.model,
             )
-            llm_criteria = response.strip()
+            if not response or not response.strip():
+                logger.warning("Empty LLM response for criteria generation")
+                return None
+
+            llm_result = response.strip()
 
-            # Inject pattern-specific criteria if labels are provided
+            # Inject pattern criteria if labels provided
             if labels:
-                pattern_config = PatternCriteriaConfig()
-                injector = PatternCriteriaInjector(pattern_config=pattern_config)
-                pattern_criteria = injector.inject_for_labels(labels=labels)
+                try:
+                    from gobby.config.tasks import PatternCriteriaConfig
+
+                    pattern_config = PatternCriteriaConfig()
+                    pattern_sections = []
+
+                    for label in labels:
+                        if label in pattern_config.patterns:
+                            criteria_list = pattern_config.patterns[label]
+                            section = f"\n\n## {label.title().replace('-', ' ')} Pattern Criteria\n"
+                            section += "\n".join(f"- [ ] {c}" for c in criteria_list)
+                            pattern_sections.append(section)
 
-                if pattern_criteria:
-                    llm_criteria = f"{llm_criteria}\n\n{pattern_criteria}"
+                    if pattern_sections:
+                        llm_result += "".join(pattern_sections)
+                except Exception as e:
+                    logger.warning(f"Failed to inject pattern criteria: {e}")
 
-            return llm_criteria
+            return llm_result
         except Exception as e:
             logger.error(f"Failed to generate validation criteria: {e}")
             return None

gobby/tui/api_client.py

@@ -10,7 +10,7 @@ import httpx
 class GobbyAPIClient:
     """HTTP client for communicating with Gobby daemon."""
 
-    def __init__(self, base_url: str = "http://localhost:8765") -> None:
+    def __init__(self, base_url: str = "http://localhost:60887") -> None:
         self.base_url = base_url.rstrip("/")
         self._client: httpx.AsyncClient | None = None
 
@@ -177,17 +177,14 @@ class GobbyAPIClient:
         self,
         task_id: str,
         commit_sha: str | None = None,
-        no_commit_needed: bool = False,
-        override_justification: str | None = None,
+        reason: str | None = None,
     ) -> dict[str, Any]:
         """Close a task."""
         args: dict[str, Any] = {"task_id": task_id}
         if commit_sha:
             args["commit_sha"] = commit_sha
-        if no_commit_needed:
-            args["no_commit_needed"] = True
-        if override_justification:
-            args["override_justification"] = override_justification
+        if reason:
+            args["reason"] = reason
         return await self.call_tool("gobby-tasks", "close_task", args)
 
     async def suggest_next_task(self) -> dict[str, Any]:

gobby/tui/app.py

@@ -158,8 +158,8 @@ class GobbyApp(App[None]):
 
     def __init__(
         self,
-        daemon_url: str = "http://localhost:8765",
-        ws_url: str = "ws://localhost:8766",
+        daemon_url: str = "http://localhost:60887",
+        ws_url: str = "ws://localhost:60888",
     ) -> None:
         super().__init__()
         self.daemon_url = daemon_url
@@ -321,7 +321,9 @@ class GobbyApp(App[None]):
         await self.ws_client.disconnect()
 
 
-def run_tui(daemon_url: str = "http://localhost:8765", ws_url: str = "ws://localhost:8766") -> None:
+def run_tui(
+    daemon_url: str = "http://localhost:60887", ws_url: str = "ws://localhost:60888"
+) -> None:
     """Entry point for the TUI application."""
     app = GobbyApp(daemon_url=daemon_url, ws_url=ws_url)
     app.run()

gobby/tui/screens/orchestrator.py

@@ -826,8 +826,7 @@ class OrchestratorScreen(Widget):
                 return
             await self.api_client.close_task(
                 task_id,
-                no_commit_needed=True,
-                override_justification="Orchestrator approval - manual user review",
+                reason="completed",
             )
             self.notify(f"Approved: {task.get('ref', task_id)}")
 

gobby/tui/screens/tasks.py

@@ -403,16 +403,14 @@ class TasksScreen(Widget):
                     # Note: In real usage, this would need a commit SHA
                     await client.close_task(
                         task_id,
-                        no_commit_needed=True,
-                        override_justification="TUI completion - manual user action",
+                        reason="obsolete",
                     )
                     self.notify(f"Task completed: {task_id}")
 
                 elif button_id == "btn-approve":
                     await client.close_task(
                         task_id,
-                        no_commit_needed=True,
-                        override_justification="TUI approval - manual user review",
+                        reason="obsolete",
                     )
                     self.notify(f"Task approved: {task_id}")
 

gobby/tui/ws_client.py

@@ -19,7 +19,7 @@ class GobbyWebSocketClient:
 
     def __init__(
         self,
-        ws_url: str = "ws://localhost:8766",
+        ws_url: str = "ws://localhost:60888",
         reconnect_interval: float = 5.0,
         max_reconnect_attempts: int = 10,
     ) -> None:

gobby/utils/daemon_client.py

@@ -11,7 +11,7 @@ Example:
     ```python
     from gobby.utils.daemon_client import DaemonClient
 
-    client = DaemonClient(host="localhost", port=8765)
+    client = DaemonClient(host="localhost", port=60887)
 
     # Check daemon health
     is_healthy, error = client.check_health()
@@ -57,7 +57,7 @@ class DaemonClient:
     def __init__(
         self,
         host: str = "localhost",
-        port: int = 8765,
+        port: int = 60887,
         timeout: float = 5.0,
         logger: logging.Logger | None = None,
     ):