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

gobby/mcp_proxy/tools/tasks/_lifecycle.py

@@ -93,13 +93,21 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Auto-skip validation for certain close reasons
         should_skip = skip_validation or reason.lower() in SKIP_REASONS
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = ctx.resolve_session_id(session_id)
+            except ValueError:
+                pass  # Fall back to raw value if resolution fails
+
         # Enforce commits if session had edits
-        if session_id and not should_skip:
+        if resolved_session_id and not should_skip:
             try:
                 from gobby.storage.sessions import LocalSessionManager
 
                 session_manager = LocalSessionManager(ctx.task_manager.db)
-                session = session_manager.get(session_id)
+                session = session_manager.get(resolved_session_id)
 
                 # Check if task has commits (including the one being linked right now)
                 has_commits = bool(task.commits) or bool(commit_sha)
@@ -185,9 +193,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
             )
 
             # Auto-link session if provided
-            if session_id:
+            if resolved_session_id:
                 try:
-                    ctx.session_task_manager.link_task(session_id, resolved_id, "review")
+                    ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "review")
                 except Exception:
                     pass  # nosec B110 - best-effort linking
 
@@ -208,15 +216,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         ctx.task_manager.close_task(
             resolved_id,
             reason=reason,
-            closed_in_session_id=session_id,
+            closed_in_session_id=resolved_session_id,
             closed_commit_sha=current_commit_sha,
             validation_override_reason=override_justification if store_override else None,
         )
 
         # Auto-link session if provided
-        if session_id:
+        if resolved_session_id:
             try:
-                ctx.session_task_manager.link_task(session_id, resolved_id, "closed")
+                ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "closed")
             except Exception:
                 pass  # nosec B110 - best-effort linking, don't fail the close
 
@@ -224,9 +232,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Respects the clear_task_on_close variable (defaults to True if not set)
         # This is done here because Claude Code's post-tool-use hook doesn't include
         # the tool result, so the detection_helpers can't verify close succeeded
-        if session_id:
+        if resolved_session_id:
             try:
-                state = ctx.workflow_state_manager.get_state(session_id)
+                state = ctx.workflow_state_manager.get_state(resolved_session_id)
                 if state and state.variables.get("claimed_task_id") == resolved_id:
                     # Check if clear_task_on_close is enabled (default: True)
                     clear_on_close = state.variables.get("clear_task_on_close", True)
@@ -288,7 +296,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). Pass this to track which session closed the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). Pass this to track which session closed the task.",
                     "default": None,
                 },
                 "override_justification": {
@@ -528,8 +536,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         if not task:
             return {"success": False, "error": f"Task {task_id} not found"}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError:
+            pass  # Fall back to raw value if resolution fails
+
         # Check if already claimed by another session
-        if task.assignee and task.assignee != session_id and not force:
+        if task.assignee and task.assignee != resolved_session_id and not force:
             return {
                 "success": False,
                 "error": "Task already claimed by another session",
@@ -540,7 +555,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Update task with assignee and status in single atomic call
         updated = ctx.task_manager.update_task(
             resolved_id,
-            assignee=session_id,
+            assignee=resolved_session_id,
             status="in_progress",
         )
         if not updated:
@@ -548,7 +563,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         # Link task to session (best-effort, don't fail the claim if this fails)
         try:
-            ctx.session_task_manager.link_task(session_id, resolved_id, "claimed")
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "claimed")
         except Exception:
             pass  # nosec B110 - best-effort linking
 
@@ -566,7 +581,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). The session claiming the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). The session claiming the task.",
                 },
                 "force": {
                     "type": "boolean",

gobby/mcp_proxy/tools/tasks/_session.py

@@ -40,15 +40,21 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
         except (TaskNotFoundError, ValueError) as e:
             return {"error": str(e)}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
         try:
-            ctx.session_task_manager.link_task(session_id, resolved_id, action)
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError as e:
+            return {"error": f"Invalid session_id '{session_id}': {e}"}
+
+        try:
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, action)
             return {}
         except ValueError as e:
             return {"error": str(e)}
 
     registry.register(
         name="link_task_to_session",
-        description="Link a task to a session.",
+        description="Link a task to a session. Accepts #N, N, UUID, or prefix for session_id.",
         input_schema={
             "type": "object",
             "properties": {
@@ -58,7 +64,7 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Session ID (optional, defaults to linking context if available)",
+                    "description": "Session reference (accepts #N, N, UUID, or prefix)",
                     "default": None,
                 },
                 "action": {
@@ -74,16 +80,25 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
     def get_session_tasks(session_id: str) -> dict[str, Any]:
         """Get all tasks associated with a session."""
-        tasks = ctx.session_task_manager.get_session_tasks(session_id)
-        return {"session_id": session_id, "tasks": tasks}
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError as e:
+            return {"error": f"Invalid session_id '{session_id}': {e}"}
+
+        tasks = ctx.session_task_manager.get_session_tasks(resolved_session_id)
+        return {"session_id": resolved_session_id, "tasks": tasks}
 
     registry.register(
         name="get_session_tasks",
-        description="Get all tasks associated with a session.",
+        description="Get all tasks associated with a session. Accepts #N, N, UUID, or prefix for session_id.",
         input_schema={
             "type": "object",
             "properties": {
-                "session_id": {"type": "string", "description": "Session ID"},
+                "session_id": {
+                    "type": "string",
+                    "description": "Session reference (accepts #N, N, UUID, or prefix)",
+                },
             },
             "required": ["session_id"],
         },

gobby/mcp_proxy/tools/workflows.py

@@ -113,12 +113,20 @@ def create_workflows_registry(
     Returns:
         InternalToolRegistry with workflow tools registered
     """
+    from gobby.utils.project_context import get_project_context
+
     # Create defaults if not provided
     _db = db or LocalDatabase()
     _loader = loader or WorkflowLoader()
     _state_manager = state_manager or WorkflowStateManager(_db)
     _session_manager = session_manager or LocalSessionManager(_db)
 
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+        return _session_manager.resolve_session_reference(ref, project_id)
+
     registry = InternalToolRegistry(
         name="gobby-workflows",
         description="Workflow management - list, activate, status, transition, end",
@@ -264,7 +272,7 @@ def create_workflows_registry(
 
     @registry.tool(
         name="activate_workflow",
-        description="Activate a step-based workflow for the current session.",
+        description="Activate a step-based workflow for the current session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def activate_workflow(
         name: str,
@@ -278,7 +286,7 @@ def create_workflows_registry(
 
         Args:
             name: Workflow name (e.g., "plan-act-reflect", "auto-task")
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
             initial_step: Optional starting step (defaults to first step)
             variables: Optional initial variables to set (merged with workflow defaults)
             project_path: Project directory path. Auto-discovered from cwd if not provided.
@@ -290,7 +298,7 @@ def create_workflows_registry(
             activate_workflow(
                 name="auto-task",
                 variables={"session_task": "#47"},
-                session_id="..."
+                session_id="#5"
             )
 
         Errors if:
@@ -325,12 +333,18 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
         # Check for existing workflow
         # Allow if:
         # - No existing state
         # - Existing is __lifecycle__ placeholder
         # - Existing is a lifecycle-type workflow (they run concurrently with step workflows)
-        existing = _state_manager.get_state(session_id)
+        existing = _state_manager.get_state(resolved_session_id)
         if existing and existing.workflow_name != "__lifecycle__":
             # Check if existing workflow is a lifecycle type
             existing_def = _loader.load_workflow(existing.workflow_name, proj)
@@ -366,12 +380,12 @@ def create_workflows_registry(
             session_task_val = merged_variables["session_task"]
             if isinstance(session_task_val, str):
                 merged_variables["session_task"] = _resolve_session_task_value(
-                    session_task_val, session_id, _session_manager, _db
+                    session_task_val, resolved_session_id, _session_manager, _db
                 )
 
         # Create state
         state = WorkflowState(
-            session_id=session_id,
+            session_id=resolved_session_id,
             workflow_name=name,
             step=step,
             step_entered_at=datetime.now(UTC),
@@ -391,7 +405,7 @@ def create_workflows_registry(
 
         return {
             "success": True,
-            "session_id": session_id,
+            "session_id": resolved_session_id,
             "workflow": name,
             "step": step,
             "steps": [s.name for s in definition.steps],
@@ -400,7 +414,7 @@ def create_workflows_registry(
 
     @registry.tool(
         name="end_workflow",
-        description="End the currently active step-based workflow.",
+        description="End the currently active step-based workflow. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def end_workflow(
         session_id: str | None = None,
@@ -413,7 +427,7 @@ def create_workflows_registry(
         Does not affect lifecycle workflows (they continue running).
 
         Args:
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
             reason: Optional reason for ending
 
         Returns:
@@ -426,24 +440,30 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
-        state = _state_manager.get_state(session_id)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
+        state = _state_manager.get_state(resolved_session_id)
         if not state:
             return {"error": "No workflow active for session"}
 
-        _state_manager.delete_state(session_id)
+        _state_manager.delete_state(resolved_session_id)
 
         return {}
 
     @registry.tool(
         name="get_workflow_status",
-        description="Get current workflow step and state.",
+        description="Get current workflow step and state. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def get_workflow_status(session_id: str | None = None) -> dict[str, Any]:
         """
         Get current workflow step and state.
 
         Args:
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
 
         Returns:
             Workflow state including step, action counts, artifacts
@@ -455,13 +475,19 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
-        state = _state_manager.get_state(session_id)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"has_workflow": False, "error": str(e)}
+
+        state = _state_manager.get_state(resolved_session_id)
         if not state:
-            return {"has_workflow": False, "session_id": session_id}
+            return {"has_workflow": False, "session_id": resolved_session_id}
 
         return {
             "has_workflow": True,
-            "session_id": session_id,
+            "session_id": resolved_session_id,
             "workflow_name": state.workflow_name,
             "step": state.step,
             "step_action_count": state.step_action_count,
@@ -479,7 +505,7 @@ def create_workflows_registry(
 
     @registry.tool(
         name="request_step_transition",
-        description="Request transition to a different step.",
+        description="Request transition to a different step. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def request_step_transition(
         to_step: str,
@@ -494,7 +520,7 @@ def create_workflows_registry(
         Args:
             to_step: Target step name
             reason: Reason for transition
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
             force: Skip exit condition checks
             project_path: Project directory path. Auto-discovered from cwd if not provided.
 
@@ -516,7 +542,13 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
-        state = _state_manager.get_state(session_id)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
+        state = _state_manager.get_state(resolved_session_id)
         if not state:
             return {"success": False, "error": "No workflow active for session"}
 
@@ -565,7 +597,7 @@ def create_workflows_registry(
 
     @registry.tool(
         name="mark_artifact_complete",
-        description="Register an artifact as complete (plan, spec, etc.).",
+        description="Register an artifact as complete (plan, spec, etc.). Accepts #N, N, UUID, or prefix for session_id.",
     )
     def mark_artifact_complete(
         artifact_type: str,
@@ -578,7 +610,7 @@ def create_workflows_registry(
         Args:
             artifact_type: Type of artifact (e.g., "plan", "spec", "test")
             file_path: Path to the artifact file
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
 
         Returns:
             Success status
@@ -590,7 +622,13 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
-        state = _state_manager.get_state(session_id)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
+        state = _state_manager.get_state(resolved_session_id)
         if not state:
             return {"error": "No workflow active for session"}
 
@@ -602,7 +640,7 @@ def create_workflows_registry(
 
     @registry.tool(
         name="set_variable",
-        description="Set a workflow variable for the current session (session-scoped, not persisted to YAML).",
+        description="Set a workflow variable for the current session (session-scoped, not persisted to YAML). Accepts #N, N, UUID, or prefix for session_id.",
     )
     def set_variable(
         name: str,
@@ -623,7 +661,7 @@ def create_workflows_registry(
         Args:
             name: Variable name (e.g., "session_epic", "is_worktree")
             value: Variable value (string, number, boolean, or null)
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
 
         Returns:
             Success status and updated variables
@@ -635,12 +673,18 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
         # Get or create state
-        state = _state_manager.get_state(session_id)
+        state = _state_manager.get_state(resolved_session_id)
         if not state:
             # Create a minimal lifecycle state for variable storage
             state = WorkflowState(
-                session_id=session_id,
+                session_id=resolved_session_id,
                 workflow_name="__lifecycle__",
                 step="",
                 step_entered_at=datetime.now(UTC),
@@ -664,7 +708,7 @@ def create_workflows_registry(
         # Resolve session_task references (#N or N) to UUIDs upfront
         # This prevents repeated resolution failures in condition evaluation
         if name == "session_task" and isinstance(value, str):
-            value = _resolve_session_task_value(value, session_id, _session_manager, _db)
+            value = _resolve_session_task_value(value, resolved_session_id, _session_manager, _db)
 
         # Set the variable
         state.variables[name] = value
@@ -684,7 +728,7 @@ def create_workflows_registry(
 
     @registry.tool(
         name="get_variable",
-        description="Get workflow variable(s) for the current session.",
+        description="Get workflow variable(s) for the current session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def get_variable(
         name: str | None = None,
@@ -695,7 +739,7 @@ def create_workflows_registry(
 
         Args:
             name: Variable name to get (if None, returns all variables)
-            session_id: Required session ID (must be provided to prevent cross-session bleed)
+            session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
 
         Returns:
             Variable value(s) and session info
@@ -707,19 +751,25 @@ def create_workflows_registry(
                 "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
             }
 
-        state = _state_manager.get_state(session_id)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
+        state = _state_manager.get_state(resolved_session_id)
         if not state:
             if name:
                 return {
                     "success": True,
-                    "session_id": session_id,
+                    "session_id": resolved_session_id,
                     "variable": name,
                     "value": None,
                     "exists": False,
                 }
             return {
                 "success": True,
-                "session_id": session_id,
+                "session_id": resolved_session_id,
                 "variables": {},
             }
 
@@ -727,7 +777,7 @@ def create_workflows_registry(
             value = state.variables.get(name)
             return {
                 "success": True,
-                "session_id": session_id,
+                "session_id": resolved_session_id,
                 "variable": name,
                 "value": value,
                 "exists": name in state.variables,
@@ -735,7 +785,7 @@ def create_workflows_registry(
 
         return {
             "success": True,
-            "session_id": session_id,
+            "session_id": resolved_session_id,
             "variables": state.variables,
         }
 

gobby/mcp_proxy/tools/worktrees.py

@@ -287,6 +287,7 @@ def create_worktrees_registry(
     worktree_storage: LocalWorktreeManager,
     git_manager: WorktreeGitManager | None = None,
     project_id: str | None = None,
+    session_manager: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create a worktree tool registry with all worktree-related tools.
@@ -295,10 +296,20 @@ def create_worktrees_registry(
         worktree_storage: LocalWorktreeManager for database operations.
         git_manager: WorktreeGitManager for git operations.
         project_id: Default project ID for operations.
+        session_manager: Session manager for resolving session references.
 
     Returns:
         InternalToolRegistry with all worktree tools registered.
     """
+
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        if session_manager is None:
+            return ref  # No resolution available, return as-is
+        ctx = get_project_context()
+        proj_id = ctx.get("id") if ctx else project_id
+        return str(session_manager.resolve_session_reference(ref, proj_id))
+
     registry = InternalToolRegistry(
         name="gobby-worktrees",
         description="Git worktree management - create, manage, and cleanup isolated development directories",
@@ -435,7 +446,7 @@ def create_worktrees_registry(
 
     @registry.tool(
         name="list_worktrees",
-        description="List worktrees with optional filters.",
+        description="List worktrees with optional filters. Accepts #N, N, UUID, or prefix for agent_session_id.",
     )
     async def list_worktrees(
         status: str | None = None,
@@ -447,16 +458,24 @@ def create_worktrees_registry(
 
         Args:
             status: Filter by status (active, stale, merged, abandoned).
-            agent_session_id: Filter by owning session.
+            agent_session_id: Session reference (accepts #N, N, UUID, or prefix) to filter by owning session.
             limit: Maximum results (default: 50).
 
         Returns:
             Dict with list of worktrees.
         """
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = agent_session_id
+        if agent_session_id:
+            try:
+                resolved_session_id = _resolve_session_id(agent_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
         worktrees = worktree_storage.list_worktrees(
             project_id=project_id,
             status=status,
-            agent_session_id=agent_session_id,
+            agent_session_id=resolved_session_id,
             limit=limit,
         )
 
@@ -479,7 +498,7 @@ def create_worktrees_registry(
 
     @registry.tool(
         name="claim_worktree",
-        description="Claim ownership of a worktree for an agent session.",
+        description="Claim ownership of a worktree for an agent session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def claim_worktree(
         worktree_id: str,
@@ -490,11 +509,17 @@ def create_worktrees_registry(
 
         Args:
             worktree_id: The worktree ID to claim.
-            session_id: The session ID claiming ownership.
+            session_id: Session reference (accepts #N, N, UUID, or prefix) claiming ownership.
 
         Returns:
             Dict with success status.
         """
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
         worktree = worktree_storage.get(worktree_id)
         if not worktree:
             return {
@@ -502,13 +527,13 @@ def create_worktrees_registry(
                 "error": f"Worktree '{worktree_id}' not found",
             }
 
-        if worktree.agent_session_id and worktree.agent_session_id != session_id:
+        if worktree.agent_session_id and worktree.agent_session_id != resolved_session_id:
             return {
                 "success": False,
                 "error": f"Worktree already claimed by session '{worktree.agent_session_id}'",
             }
 
-        updated = worktree_storage.claim(worktree_id, session_id)
+        updated = worktree_storage.claim(worktree_id, resolved_session_id)
         if not updated:
             return {"error": "Failed to claim worktree"}
 

gobby/memory/extractor.py

@@ -153,10 +153,15 @@ class SessionMemoryExtractor:
         """
         session = self.session_manager.get(session_id)
         if not session:
+            logger.warning(f"Session not found for memory extraction: {session_id}")
             return None
 
-        # Get project info
+        # Get project info - log for debugging NULL project_id issues
         project_id = session.project_id
+        logger.debug(
+            f"Memory extraction context: session={session_id}, "
+            f"project_id={project_id!r} (type={type(project_id).__name__})"
+        )
         project_name = "Unknown Project"
 
         if project_id:
@@ -461,6 +466,15 @@ class SessionMemoryExtractor:
             session_id: Source session ID
             project_id: Project ID for the memories
         """
+        # Log project_id for debugging NULL project_id issues
+        if project_id is None:
+            logger.warning(
+                f"Storing memories with NULL project_id for session {session_id}. "
+                "This may cause duplicate detection issues."
+            )
+        else:
+            logger.debug(f"Storing {len(candidates)} memories with project_id={project_id}")
+
         for candidate in candidates:
             try:
                 await self.memory_manager.remember(