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

gobby/workflows/actions.py

@@ -28,6 +28,7 @@ from gobby.workflows.git_utils import get_file_changes, get_git_status, get_rece
 from gobby.workflows.llm_actions import call_llm
 from gobby.workflows.mcp_actions import call_mcp_tool
 from gobby.workflows.memory_actions import (
+    memory_extract,
     memory_recall_relevant,
     memory_save,
     memory_sync_export,
@@ -58,6 +59,7 @@ from gobby.workflows.summary_actions import (
     synthesize_title,
 )
 from gobby.workflows.task_enforcement_actions import (
+    block_tools,
     capture_baseline_dirty_files,
     require_active_task,
     require_commit_before_stop,
@@ -226,6 +228,7 @@ class ActionExecutor:
         self.register("memory_recall_relevant", self._handle_memory_recall_relevant)
         self.register("memory_sync_import", self._handle_memory_sync_import)
         self.register("memory_sync_export", self._handle_memory_sync_export)
+        self.register("memory_extract", self._handle_memory_extract)
         self.register(
             "reset_memory_injection_tracking", self._handle_reset_memory_injection_tracking
         )
@@ -236,6 +239,7 @@ class ActionExecutor:
         self.register("start_new_session", self._handle_start_new_session)
         self.register("mark_loop_complete", self._handle_mark_loop_complete)
         # Task enforcement
+        self.register("block_tools", self._handle_block_tools)
         self.register("require_active_task", self._handle_require_active_task)
         self.register("require_commit_before_stop", self._handle_require_commit_before_stop)
         self.register(
@@ -658,6 +662,8 @@ class ActionExecutor:
 
         For compact mode, fetches the current session's existing summary_markdown
         as previous_summary for cumulative compression.
+
+        Supports loading prompts from the prompts collection via the 'prompt' parameter.
         """
         # Detect mode from kwargs or event data
         mode = kwargs.get("mode", "clear")
@@ -683,12 +689,27 @@ class ActionExecutor:
                         f"for cumulative compression"
                     )
 
+        # Load template from prompts collection if 'prompt' parameter provided
+        template = kwargs.get("template")
+        prompt_path = kwargs.get("prompt")
+        if prompt_path and not template:
+            try:
+                from gobby.prompts.loader import PromptLoader
+
+                loader = PromptLoader()
+                prompt_template = loader.load(prompt_path)
+                template = prompt_template.content
+                logger.debug(f"Loaded prompt template from: {prompt_path}")
+            except Exception as e:
+                logger.warning(f"Failed to load prompt from {prompt_path}: {e}")
+                # Fall back to inline template or default
+
         return await generate_handoff(
             session_manager=context.session_manager,
             session_id=context.session_id,
             llm_service=context.llm_service,
             transcript_processor=context.transcript_processor,
-            template=kwargs.get("template"),
+            template=template,
             previous_summary=previous_summary,
             mode=mode,
         )
@@ -780,6 +801,30 @@ class ActionExecutor:
         """Reset memory injection tracking to allow re-injection after context loss."""
         return reset_memory_injection_tracking(state=context.state)
 
+    async def _handle_memory_extract(
+        self, context: ActionContext, **kwargs: Any
+    ) -> dict[str, Any] | None:
+        """Extract memories from the current session.
+
+        Args (via kwargs):
+            min_importance: Minimum importance threshold (default: 0.7)
+            max_memories: Maximum memories to extract (default: 5)
+            dry_run: If True, don't store memories (default: False)
+
+        Returns:
+            Dict with extracted_count and optional memory details
+        """
+        return await memory_extract(
+            session_manager=context.session_manager,
+            session_id=context.session_id,
+            llm_service=context.llm_service,
+            memory_manager=context.memory_manager,
+            transcript_processor=context.transcript_processor,
+            min_importance=kwargs.get("min_importance", 0.7),
+            max_memories=kwargs.get("max_memories", 5),
+            dry_run=kwargs.get("dry_run", False),
+        )
+
     async def _handle_mark_session_status(
         self, context: ActionContext, **kwargs: Any
     ) -> dict[str, Any] | None:
@@ -840,10 +885,47 @@ class ActionExecutor:
             project_path=project_path,
         )
 
+    async def _handle_block_tools(
+        self, context: ActionContext, **kwargs: Any
+    ) -> dict[str, Any] | None:
+        """Block tools based on configurable rules.
+
+        This is the unified tool blocking action that replaces require_active_task
+        for CC native task blocking while also supporting task-before-edit enforcement.
+
+        For MCP tool blocking (mcp_tools rules), also passes:
+        - project_path: for checking dirty files in git status
+        - task_manager: for checking if claimed task has commits
+        - source: CLI source for is_plan_file checks
+        """
+        # Get project_path for git dirty file checks
+        project_path = kwargs.get("project_path")
+        if not project_path and context.event_data:
+            project_path = context.event_data.get("cwd")
+
+        # Get source from session for is_plan_file checks
+        source = None
+        current_session = context.session_manager.get(context.session_id)
+        if current_session:
+            source = current_session.source
+
+        return await block_tools(
+            rules=kwargs.get("rules"),
+            event_data=context.event_data,
+            workflow_state=context.state,
+            project_path=project_path,
+            task_manager=self.task_manager,
+            source=source,
+        )
+
     async def _handle_require_active_task(
         self, context: ActionContext, **kwargs: Any
     ) -> dict[str, Any] | None:
-        """Check for active task before allowing protected tools."""
+        """Check for active task before allowing protected tools.
+
+        DEPRECATED: Use block_tools action with rules instead.
+        Kept for backward compatibility with existing workflows.
+        """
         # Get project_id from session for project-scoped task filtering
         current_session = context.session_manager.get(context.session_id)
         project_id = current_session.project_id if current_session else None

gobby/workflows/context_actions.py

@@ -304,6 +304,17 @@ def extract_handoff_context(
         except Exception as wt_err:
             logger.debug(f"Failed to get worktree context: {wt_err}")
 
+        # Add active skills from HookSkillManager
+        try:
+            from gobby.hooks.skill_manager import HookSkillManager
+
+            skill_manager = HookSkillManager()
+            core_skills = skill_manager.discover_core_skills()
+            always_apply_skills = [s.name for s in core_skills if s.is_always_apply()]
+            handoff_ctx.active_skills = always_apply_skills
+        except Exception as skill_err:
+            logger.debug(f"Failed to get active skills: {skill_err}")
+
         # Format as markdown (like /clear stores formatted summary)
         markdown = format_handoff_as_markdown(handoff_ctx)
 
@@ -320,6 +331,32 @@ def extract_handoff_context(
         return {"error": str(e)}
 
 
+def recommend_skills_for_task(task: dict[str, Any] | None) -> list[str]:
+    """Recommend relevant skills based on task category.
+
+    Uses HookSkillManager to get skill recommendations based on the task's
+    category field. Returns always-apply skills if no category is set.
+
+    Args:
+        task: Task dict with optional 'category' field, or None.
+
+    Returns:
+        List of recommended skill names for this task.
+    """
+    if task is None:
+        return []
+
+    try:
+        from gobby.hooks.skill_manager import HookSkillManager
+
+        manager = HookSkillManager()
+        category = task.get("category")
+        return manager.recommend_skills(category=category)
+    except Exception as e:
+        logger.debug(f"Failed to recommend skills: {e}")
+        return []
+
+
 def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) -> str:
     """Format HandoffContext as markdown for storage.
 
@@ -391,4 +428,10 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
             lines.append(f"- {activity}")
         sections.append("\n".join(lines))
 
+    # Active skills section
+    if hasattr(ctx, "active_skills") and ctx.active_skills:
+        lines = ["### Active Skills"]
+        lines.append(f"Skills available: {', '.join(ctx.active_skills)}")
+        sections.append("\n".join(lines))
+
     return "\n\n".join(sections)

gobby/workflows/detection_helpers.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from gobby.hooks.events import HookEvent
+    from gobby.storage.tasks import LocalTaskManager
     from gobby.tasks.session_tasks import SessionTaskManager
 
     from .definitions import WorkflowState
@@ -22,6 +23,7 @@ def detect_task_claim(
     event: "HookEvent",
     state: "WorkflowState",
     session_task_manager: "SessionTaskManager | None" = None,
+    task_manager: "LocalTaskManager | None" = None,
 ) -> None:
     """Detect gobby-tasks calls that claim or release a task for this session.
 
@@ -44,7 +46,8 @@ def detect_task_claim(
 
     tool_name = event.data.get("tool_name", "")
     tool_input = event.data.get("tool_input", {}) or {}
-    tool_output = event.data.get("tool_output", {}) or {}
+    # Claude Code sends "tool_result", but we also check "tool_output" for compatibility
+    tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
 
     # Check if this is a gobby-tasks call via MCP proxy
     # Tool name could be "call_tool" (from legacy) or "mcp__gobby__call_tool" (direct)
@@ -58,7 +61,34 @@ def detect_task_claim(
 
     # Check inner tool name
     inner_tool_name = tool_input.get("tool_name", "")
-    if inner_tool_name not in ("create_task", "update_task", "close_task"):
+
+    # Handle close_task - clears task_claimed when task is closed
+    # Note: Claude Code doesn't include tool_result in post-tool-use hooks, so for CC
+    # the workflow state is updated directly in the MCP proxy's close_task function.
+    # This detection provides a fallback for CLIs that do report tool results (Gemini/Codex).
+    if inner_tool_name == "close_task":
+        tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
+
+        # If no tool output, skip - can't verify success
+        # The MCP proxy's close_task handles state clearing for successful closes
+        if not tool_output:
+            return
+
+        # Check if close succeeded (not an error)
+        if isinstance(tool_output, dict):
+            if tool_output.get("error") or tool_output.get("status") == "error":
+                return
+            result = tool_output.get("result", {})
+            if isinstance(result, dict) and result.get("error"):
+                return
+
+        # Clear task_claimed on successful close
+        state.variables["task_claimed"] = False
+        state.variables["claimed_task_id"] = None
+        logger.info(f"Session {state.session_id}: task_claimed=False (detected close_task success)")
+        return
+
+    if inner_tool_name not in ("create_task", "update_task", "claim_task"):
         return
 
     # For update_task, only count if status is being set to in_progress
@@ -66,11 +96,9 @@ def detect_task_claim(
         arguments = tool_input.get("arguments", {}) or {}
         if arguments.get("status") != "in_progress":
             return
+    # claim_task always counts (it sets status to in_progress internally)
 
-    # For close_task, we'll clear task_claimed after success check
-    is_close_task = inner_tool_name == "close_task"
-
-    # Check if the call succeeded (not an error)
+    # Check if the call succeeded (not an error) - for non-close_task operations
     # tool_output structure varies, but errors typically have "error" key
     # or the MCP response has "status": "error"
     if isinstance(tool_output, dict):
@@ -81,35 +109,26 @@ def detect_task_claim(
         if isinstance(result, dict) and result.get("error"):
             return
 
-    # Handle close_task - clear the claim only if closing the claimed task
-    if is_close_task:
-        arguments = tool_input.get("arguments", {}) or {}
-        closed_task_id = arguments.get("task_id")
-        claimed_task_id = state.variables.get("claimed_task_id")
-
-        # Only clear task_claimed if we're closing the task that was claimed
-        if closed_task_id and claimed_task_id and closed_task_id == claimed_task_id:
-            state.variables["task_claimed"] = False
-            state.variables["claimed_task_id"] = None
-            logger.info(
-                f"Session {state.session_id}: task_claimed=False "
-                f"(claimed task {closed_task_id} closed via close_task)"
-            )
-        else:
-            logger.debug(
-                f"Session {state.session_id}: close_task for {closed_task_id} "
-                f"(claimed: {claimed_task_id}) - not clearing task_claimed"
-            )
-        return
-
     # Extract task_id based on tool type
     arguments = tool_input.get("arguments", {}) or {}
-    if inner_tool_name == "update_task":
+    if inner_tool_name in ("update_task", "claim_task"):
         task_id = arguments.get("task_id")
+        # Resolve to UUID for consistent comparison with close_task
+        if task_id and task_manager:
+            try:
+                task = task_manager.get_task(task_id)
+                if task:
+                    task_id = task.id  # Use UUID
+            except Exception:  # nosec B110 - best effort resolution, keep original if fails
+                pass
     elif inner_tool_name == "create_task":
         # For create_task, the id is in the result
         result = tool_output.get("result", {}) if isinstance(tool_output, dict) else {}
         task_id = result.get("id") if isinstance(result, dict) else None
+        # Skip if we can't get the task ID (e.g., Claude Code doesn't include tool results)
+        # The MCP tool itself handles state updates in this case via _crud.py
+        if not task_id:
+            return
     else:
         task_id = None
 
@@ -121,8 +140,8 @@ def detect_task_claim(
         f"(via {inner_tool_name})"
     )
 
-    # Auto-link task to session when status is set to in_progress
-    if inner_tool_name == "update_task":
+    # Auto-link task to session when claiming a task
+    if inner_tool_name in ("update_task", "claim_task"):
         arguments = tool_input.get("arguments", {}) or {}
         task_id = arguments.get("task_id")
         if task_id and session_task_manager:
@@ -159,6 +178,70 @@ def detect_plan_mode(event: "HookEvent", state: "WorkflowState") -> None:
         logger.info(f"Session {state.session_id}: plan_mode=False (exited plan mode)")
 
 
+def detect_plan_mode_from_context(event: "HookEvent", state: "WorkflowState") -> None:
+    """Detect plan mode from system reminders injected by Claude Code.
+
+    Claude Code injects system reminders like "Plan mode is active" when the user
+    enters plan mode via the UI (not via the EnterPlanMode tool). This function
+    detects those reminders and sets the plan_mode variable accordingly.
+
+    IMPORTANT: Only matches indicators within <system-reminder> tags to avoid
+    false positives from handoff context or user messages that mention plan mode.
+
+    This complements detect_plan_mode() which only catches programmatic tool calls.
+
+    Args:
+        event: The BEFORE_AGENT hook event (contains user prompt with system reminders)
+        state: Current workflow state (modified in place)
+    """
+    if not event.data:
+        return
+
+    # Check for plan mode system reminder in the prompt
+    prompt = event.data.get("prompt", "") or ""
+
+    # Extract only content within <system-reminder> tags to avoid false positives
+    # from handoff context or user messages mentioning plan mode
+    import re
+
+    system_reminders = re.findall(r"<system-reminder>(.*?)</system-reminder>", prompt, re.DOTALL)
+    reminder_text = " ".join(system_reminders)
+
+    # Claude Code injects these phrases in system reminders when plan mode is active
+    plan_mode_indicators = [
+        "Plan mode is active",
+        "Plan mode still active",
+        "You are in plan mode",
+    ]
+
+    # Check if plan mode is indicated in system reminders only
+    for indicator in plan_mode_indicators:
+        if indicator in reminder_text:
+            if not state.variables.get("plan_mode"):
+                state.variables["plan_mode"] = True
+                logger.info(
+                    f"Session {state.session_id}: plan_mode=True "
+                    f"(detected from system reminder: '{indicator}')"
+                )
+            return
+
+    # Detect exit from plan mode (also only in system reminders)
+    exit_indicators = [
+        "Exited Plan Mode",
+        "Plan mode exited",
+    ]
+
+    for indicator in exit_indicators:
+        if indicator in reminder_text:
+            if state.variables.get("plan_mode"):
+                state.variables["plan_mode"] = False
+                logger.info(
+                    f"Session {state.session_id}: plan_mode=False "
+                    f"(detected from system reminder: '{indicator}')"
+                )
+            return
+
+
 def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
     """Track MCP tool calls by server/tool for workflow conditions.
 
@@ -180,7 +263,8 @@ def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
 
     tool_name = event.data.get("tool_name", "")
     tool_input = event.data.get("tool_input", {}) or {}
-    tool_output = event.data.get("tool_output", {}) or {}
+    # Claude Code sends "tool_result", but we also check "tool_output" for compatibility
+    tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
 
     # Check for MCP proxy call
     if tool_name not in ("call_tool", "mcp__gobby__call_tool"):

gobby/workflows/engine.py

@@ -15,7 +15,12 @@ from .audit_helpers import (
     log_transition,
 )
 from .definitions import WorkflowDefinition, WorkflowState
-from .detection_helpers import detect_mcp_call, detect_plan_mode, detect_task_claim
+from .detection_helpers import (
+    detect_mcp_call,
+    detect_plan_mode,
+    detect_plan_mode_from_context,
+    detect_task_claim,
+)
 from .evaluator import ConditionEvaluator
 from .lifecycle_evaluator import (
     evaluate_all_lifecycle_workflows as _evaluate_all_lifecycle_workflows,
@@ -375,6 +380,7 @@ class WorkflowEngine:
             evaluator=self.evaluator,
             detect_task_claim_fn=self._detect_task_claim,
             detect_plan_mode_fn=self._detect_plan_mode,
+            detect_plan_mode_from_context_fn=self._detect_plan_mode_from_context,
             check_premature_stop_fn=self._check_premature_stop,
             context_data=context_data,
         )
@@ -474,12 +480,17 @@ class WorkflowEngine:
     def _detect_task_claim(self, event: HookEvent, state: WorkflowState) -> None:
         """Detect gobby-tasks calls that claim or release a task for this session."""
         session_task_manager = getattr(self.action_executor, "session_task_manager", None)
-        detect_task_claim(event, state, session_task_manager)
+        task_manager = getattr(self.action_executor, "task_manager", None)
+        detect_task_claim(event, state, session_task_manager, task_manager)
 
     def _detect_plan_mode(self, event: HookEvent, state: WorkflowState) -> None:
         """Detect Claude Code plan mode entry/exit and set workflow variable."""
         detect_plan_mode(event, state)
 
+    def _detect_plan_mode_from_context(self, event: HookEvent, state: WorkflowState) -> None:
+        """Detect plan mode from system reminders in user prompt."""
+        detect_plan_mode_from_context(event, state)
+
     def _detect_mcp_call(self, event: HookEvent, state: WorkflowState) -> None:
         """Track MCP tool calls by server/tool for workflow conditions."""
         detect_mcp_call(event, state)

gobby/workflows/lifecycle_evaluator.py

@@ -439,6 +439,7 @@ async def evaluate_all_lifecycle_workflows(
     detect_plan_mode_fn: Any,
     check_premature_stop_fn: Any,
     context_data: dict[str, Any] | None = None,
+    detect_plan_mode_from_context_fn: Any | None = None,
 ) -> HookResponse:
     """
     Discover and evaluate all lifecycle workflows for the given event.
@@ -453,9 +454,10 @@ async def evaluate_all_lifecycle_workflows(
         action_executor: Action executor for running actions
         evaluator: Condition evaluator
         detect_task_claim_fn: Function to detect task claims
-        detect_plan_mode_fn: Function to detect plan mode
+        detect_plan_mode_fn: Function to detect plan mode (from tool calls)
         check_premature_stop_fn: Async function to check premature stop
         context_data: Optional context data passed between actions
+        detect_plan_mode_from_context_fn: Function to detect plan mode from system reminders
 
     Returns:
         Merged HookResponse with combined context and first non-allow decision.
@@ -594,6 +596,21 @@ async def evaluate_all_lifecycle_workflows(
             detect_plan_mode_fn(event, state)
             state_manager.save_state(state)
 
+    # Detect plan mode from system reminders for BEFORE_AGENT events
+    # This catches plan mode when user enters via UI (not via EnterPlanMode tool)
+    if event.event_type == HookEventType.BEFORE_AGENT and detect_plan_mode_from_context_fn:
+        session_id = event.metadata.get("_platform_session_id")
+        if session_id:
+            state = state_manager.get_state(session_id)
+            if state is None:
+                state = WorkflowState(
+                    session_id=session_id,
+                    workflow_name="__lifecycle__",
+                    step="",
+                )
+            detect_plan_mode_from_context_fn(event, state)
+            state_manager.save_state(state)
+
     # Check for premature stop in active step workflows on STOP events
     if event.event_type == HookEventType.STOP:
         premature_response = await check_premature_stop_fn(event, context_data)
@@ -610,4 +627,15 @@ async def evaluate_all_lifecycle_workflows(
         reason=final_reason,
         context="\n\n".join(all_context) if all_context else None,
         system_message=final_system_message,
+        metadata={
+            "discovered_workflows": [
+                {
+                    "name": w.name,
+                    "priority": w.priority,
+                    "is_project": w.is_project,
+                    "path": str(w.path),
+                }
+                for w in workflows
+            ]
+        },
     )

gobby/workflows/loader.py

@@ -193,6 +193,7 @@ class WorkflowLoader:
             return self._discovery_cache[cache_key]
 
         discovered: dict[str, DiscoveredWorkflow] = {}  # name -> workflow (for shadowing)
+        failed: dict[str, str] = {}  # name -> error message for failed workflows
 
         # 1. Scan global lifecycle directory first (will be shadowed by project)
         for global_dir in self.global_dirs:
@@ -201,7 +202,14 @@ class WorkflowLoader:
         # 2. Scan project lifecycle directory (shadows global)
         if project_path:
             project_dir = Path(project_path) / ".gobby" / "workflows" / "lifecycle"
-            self._scan_directory(project_dir, is_project=True, discovered=discovered)
+            self._scan_directory(project_dir, is_project=True, discovered=discovered, failed=failed)
+
+            # Log errors when project workflow fails but global exists (failed shadowing)
+            for name, error in failed.items():
+                if name in discovered and not discovered[name].is_project:
+                    logger.error(
+                        f"Project workflow '{name}' failed to load, using global instead: {error}"
+                    )
 
         # 3. Filter to lifecycle workflows only
         lifecycle_workflows = [w for w in discovered.values() if w.definition.type == "lifecycle"]
@@ -225,6 +233,7 @@ class WorkflowLoader:
         directory: Path,
         is_project: bool,
         discovered: dict[str, DiscoveredWorkflow],
+        failed: dict[str, str] | None = None,
     ) -> None:
         """
         Scan a directory for workflow YAML files and add to discovered dict.
@@ -233,6 +242,7 @@ class WorkflowLoader:
             directory: Directory to scan
             is_project: Whether this is a project directory (for shadowing)
             discovered: Dict to update (name -> DiscoveredWorkflow)
+            failed: Optional dict to track failed workflows (name -> error message)
         """
         if not directory.exists():
             return
@@ -258,6 +268,8 @@ class WorkflowLoader:
                             data = self._merge_workflows(parent.model_dump(), data)
                     except ValueError as e:
                         logger.warning(f"Skipping workflow {name}: {e}")
+                        if failed is not None:
+                            failed[name] = str(e)
                         continue
 
                 definition = WorkflowDefinition(**data)
@@ -267,6 +279,10 @@ class WorkflowLoader:
                 if definition.settings and "priority" in definition.settings:
                     priority = definition.settings["priority"]
 
+                # Log successful shadowing when project workflow overrides global
+                if name in discovered and is_project and not discovered[name].is_project:
+                    logger.info(f"Project workflow '{name}' shadows global workflow")
+
                 # Project workflows shadow global (overwrite in dict)
                 # Global is scanned first, so project overwrites
                 discovered[name] = DiscoveredWorkflow(
@@ -279,6 +295,8 @@ class WorkflowLoader:
 
             except Exception as e:
                 logger.warning(f"Failed to load workflow from {yaml_path}: {e}")
+                if failed is not None:
+                    failed[name] = str(e)
 
     def clear_cache(self) -> None:
         """
@@ -288,11 +306,6 @@ class WorkflowLoader:
         self._cache.clear()
         self._discovery_cache.clear()
 
-    def clear_discovery_cache(self) -> None:
-        """Clear the discovery cache. Call when workflows may have changed."""
-        # Deprecated: use clear_cache instead to clear everything
-        self.clear_cache()
-
     def validate_workflow_for_agent(
         self,
         workflow_name: str,

gobby/workflows/memory_actions.py

@@ -270,3 +270,77 @@ def reset_memory_injection_tracking(state: Any | None = None) -> dict[str, Any]:
         logger.info(f"reset_memory_injection_tracking: Cleared {cleared_count} injected memory IDs")
 
     return {"success": True, "cleared": cleared_count}
+
+
+async def memory_extract(
+    session_manager: Any,
+    session_id: str,
+    llm_service: Any,
+    memory_manager: Any,
+    transcript_processor: Any | None = None,
+    min_importance: float = 0.7,
+    max_memories: int = 5,
+    dry_run: bool = False,
+) -> dict[str, Any] | None:
+    """Extract memories from a session transcript.
+
+    Uses LLM analysis to identify high-value, reusable knowledge from
+    session transcripts and stores them as memories.
+
+    Args:
+        session_manager: The session manager instance
+        session_id: Current session ID
+        llm_service: LLM service for analysis
+        memory_manager: Memory manager for storage
+        transcript_processor: Optional transcript processor
+        min_importance: Minimum importance threshold (0.0-1.0)
+        max_memories: Maximum memories to extract
+        dry_run: If True, don't store memories
+
+    Returns:
+        Dict with extracted_count and memory details, or error
+    """
+    if not memory_manager:
+        return {"error": "Memory Manager not available"}
+
+    if not memory_manager.config.enabled:
+        logger.debug("memory_extract: Memory system disabled")
+        return None
+
+    if not llm_service:
+        return {"error": "LLM service not available"}
+
+    try:
+        from gobby.memory.extractor import SessionMemoryExtractor
+
+        extractor = SessionMemoryExtractor(
+            memory_manager=memory_manager,
+            session_manager=session_manager,
+            llm_service=llm_service,
+            transcript_processor=transcript_processor,
+        )
+
+        candidates = await extractor.extract(
+            session_id=session_id,
+            min_importance=min_importance,
+            max_memories=max_memories,
+            dry_run=dry_run,
+        )
+
+        if not candidates:
+            logger.debug(f"memory_extract: No memories extracted from session {session_id}")
+            return {"extracted_count": 0, "memories": []}
+
+        logger.info(
+            f"memory_extract: Extracted {len(candidates)} memories from session {session_id}"
+        )
+
+        return {
+            "extracted_count": len(candidates),
+            "memories": [c.to_dict() for c in candidates],
+            "dry_run": dry_run,
+        }
+
+    except Exception as e:
+        logger.error(f"memory_extract: Failed: {e}", exc_info=True)
+        return {"error": str(e)}