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

gobby/cli/conductor.py

@@ -0,0 +1,266 @@
+"""
+Conductor management CLI commands.
+
+Commands for managing the conductor loop:
+- start: Start the conductor loop
+- stop: Stop the conductor loop
+- restart: Restart the conductor loop
+- status: Show conductor status
+- chat: Send a message to the conductor
+"""
+
+import json
+
+import click
+import httpx
+
+
+def get_daemon_url() -> str:
+    """Get daemon URL from config."""
+    from gobby.config.app import load_config
+
+    config = load_config()
+    return f"http://localhost:{config.daemon_port}"
+
+
+@click.group()
+def conductor() -> None:
+    """Manage the conductor orchestration loop."""
+    pass
+
+
+@conductor.command("start")
+@click.option("--interval", "-i", type=int, default=30, help="Check interval in seconds")
+@click.option("--autonomous", "-a", is_flag=True, help="Enable autonomous agent spawning")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def start_conductor(interval: int, autonomous: bool, json_format: bool) -> None:
+    """Start the conductor loop.
+
+    Examples:
+
+        gobby conductor start
+
+        gobby conductor start --interval 60
+
+        gobby conductor start --autonomous
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/start",
+            json={"interval": interval, "autonomous": autonomous},
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo("Conductor started")
+        click.echo(f"  Interval: {interval}s")
+        if autonomous:
+            click.echo("  Autonomous mode: enabled")
+    else:
+        click.echo(f"Failed to start conductor: {result.get('error')}", err=True)
+
+
+@conductor.command("stop")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def stop_conductor(json_format: bool) -> None:
+    """Stop the conductor loop.
+
+    Examples:
+
+        gobby conductor stop
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/stop",
+            json={},
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo("Conductor stopped")
+    else:
+        click.echo(f"Failed to stop conductor: {result.get('error')}", err=True)
+
+
+@conductor.command("restart")
+@click.option("--interval", "-i", type=int, default=30, help="Check interval in seconds")
+@click.option("--autonomous", "-a", is_flag=True, help="Enable autonomous agent spawning")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def restart_conductor(interval: int, autonomous: bool, json_format: bool) -> None:
+    """Restart the conductor loop.
+
+    Examples:
+
+        gobby conductor restart
+
+        gobby conductor restart --interval 60
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/restart",
+            json={"interval": interval, "autonomous": autonomous},
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo("Conductor restarted")
+    else:
+        click.echo(f"Failed to restart conductor: {result.get('error')}", err=True)
+
+
+@conductor.command("status")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def status_conductor(json_format: bool) -> None:
+    """Show conductor status.
+
+    Examples:
+
+        gobby conductor status
+
+        gobby conductor status --json
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.get(
+            f"{daemon_url}/conductor/status",
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    running = result.get("running", False)
+    if running:
+        click.echo("Conductor: running")
+        click.echo(f"  Interval: {result.get('interval', 'unknown')}s")
+        click.echo(f"  Autonomous: {result.get('autonomous', False)}")
+        if result.get("last_tick"):
+            click.echo(f"  Last tick: {result['last_tick']}")
+    else:
+        click.echo("Conductor: not running")
+
+
+@conductor.command("chat")
+@click.argument("message")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def chat_conductor(message: str, json_format: bool) -> None:
+    """Send a message to the conductor.
+
+    The conductor can process commands like status checks, task queries,
+    or trigger manual actions.
+
+    Examples:
+
+        gobby conductor chat "Check all tasks"
+
+        gobby conductor chat "spawn agent for task-123"
+
+        gobby conductor chat --json "status check"
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/chat",
+            json={"message": message},
+            timeout=30.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(result.get("response", "OK"))
+    else:
+        click.echo(f"Error: {result.get('error', 'Unknown error')}", err=True)

gobby/cli/install.py

@@ -250,7 +250,7 @@ def install(
                     click.echo(f"  - {cmd}")
             if result.get("plugins_installed"):
                 click.echo(
-                    f"Installed {len(result['plugins_installed'])} plugins to ~/.gobby/plugins/"
+                    f"Installed {len(result['plugins_installed'])} plugins to .gobby/plugins/"
                 )
                 for plugin in result["plugins_installed"]:
                     click.echo(f"  - {plugin}")
@@ -287,7 +287,7 @@ def install(
                     click.echo(f"  - {cmd}")
             if result.get("plugins_installed"):
                 click.echo(
-                    f"Installed {len(result['plugins_installed'])} plugins to ~/.gobby/plugins/"
+                    f"Installed {len(result['plugins_installed'])} plugins to .gobby/plugins/"
                 )
                 for plugin in result["plugins_installed"]:
                     click.echo(f"  - {plugin}")
@@ -334,7 +334,7 @@ def install(
                         click.echo(f"  - {cmd}")
                 if result.get("plugins_installed"):
                     click.echo(
-                        f"Installed {len(result['plugins_installed'])} plugins to ~/.gobby/plugins/"
+                        f"Installed {len(result['plugins_installed'])} plugins to .gobby/plugins/"
                     )
                     for plugin in result["plugins_installed"]:
                         click.echo(f"  - {plugin}")
@@ -395,7 +395,7 @@ def install(
                     click.echo(f"  - {cmd}")
             if result.get("plugins_installed"):
                 click.echo(
-                    f"Installed {len(result['plugins_installed'])} plugins to ~/.gobby/plugins/"
+                    f"Installed {len(result['plugins_installed'])} plugins to .gobby/plugins/"
                 )
                 for plugin in result["plugins_installed"]:
                     click.echo(f"  - {plugin}")

gobby/cli/installers/antigravity.py

@@ -12,7 +12,7 @@ import logging
 from pathlib import Path
 from typing import Any
 
-from .shared import configure_mcp_server_json, install_shared_skills
+from .shared import configure_mcp_server_json
 
 logger = logging.getLogger(__name__)
 
@@ -43,14 +43,8 @@ def install_antigravity(project_path: Path) -> dict[str, Any]:
     # Configure MCP server in Antigravity's MCP config (~/.gemini/antigravity/mcp_config.json)
     mcp_config = Path.home() / ".gemini" / "antigravity" / "mcp_config.json"
 
-    # Install shared skills to ~/.antigravity/skills/ (Standard Antigravity location)
-    try:
-        skills_path = Path.home() / ".antigravity" / "skills"
-        skills = install_shared_skills(skills_path)
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .antigravity/skills/
 
     mcp_result = configure_mcp_server_json(mcp_config)
 

gobby/cli/installers/claude.py

@@ -17,10 +17,11 @@ from typing import Any
 from gobby.cli.utils import get_install_dir
 
 from .shared import (
+    backup_gobby_skills,
     configure_mcp_server_json,
     install_cli_content,
+    install_router_skills_as_commands,
     install_shared_content,
-    install_shared_skills,
     remove_mcp_server_json,
 )
 
@@ -55,6 +56,12 @@ def install_claude(project_path: Path) -> dict[str, Any]:
     hooks_dir = claude_path / "hooks"
     hooks_dir.mkdir(parents=True, exist_ok=True)
 
+    # Backup existing gobby skills (now auto-synced from database)
+    skills_dir = claude_path / "skills"
+    backup_result = backup_gobby_skills(skills_dir)
+    if backup_result["backed_up"] > 0:
+        logger.info(f"Backed up {backup_result['backed_up']} existing gobby skills")
+
     # Get source files
     install_dir = get_install_dir()
     claude_install_dir = install_dir / "claude"
@@ -119,14 +126,13 @@ def install_claude(project_path: Path) -> dict[str, Any]:
     result["commands_installed"] = cli.get("commands", [])
     result["plugins_installed"] = shared.get("plugins", [])
 
-    # Install shared skills (SKILL.md)
-    try:
-        skills = install_shared_skills(claude_path / "skills")
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        result["error"] = f"Failed to install shared skills: {e}"
-        # Proceeding despite skill install failure
+    # Install router skills (gobby, g) as flattened commands
+    commands_dir = claude_path / "commands"
+    router_commands = install_router_skills_as_commands(commands_dir)
+    result["commands_installed"].extend(router_commands)
+
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .claude/skills/
 
     # Backup existing settings.json if it exists
     backup_file = None

gobby/cli/installers/codex.py

@@ -18,7 +18,6 @@ from .shared import (
     configure_mcp_server_toml,
     install_cli_content,
     install_shared_content,
-    install_shared_skills,
     remove_mcp_server_toml,
 )
 
@@ -69,13 +68,8 @@ def install_codex_notify() -> dict[str, Any]:
     # Install CLI-specific content (can override shared)
     cli = install_cli_content("codex", codex_home)
 
-    # Install shared skills (SKILL.md)
-    try:
-        skills = install_shared_skills(codex_home / "skills")
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .codex/skills/
 
     result["workflows_installed"] = shared["workflows"] + cli["workflows"]
     result["commands_installed"] = cli.get("commands", [])

gobby/cli/installers/gemini.py

@@ -17,8 +17,8 @@ from gobby.cli.utils import get_install_dir
 from .shared import (
     configure_mcp_server_json,
     install_cli_content,
+    install_router_skills_as_gemini_skills,
     install_shared_content,
-    install_shared_skills,
     remove_mcp_server_json,
 )
 
@@ -81,18 +81,18 @@ def install_gemini(project_path: Path) -> dict[str, Any]:
     # Install CLI-specific content (can override shared)
     cli = install_cli_content("gemini", gemini_path)
 
-    # Install shared skills (SKILL.md)
-    try:
-        skills = install_shared_skills(gemini_path / "skills")
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .gemini/skills/
 
     result["workflows_installed"] = shared["workflows"] + cli["workflows"]
     result["commands_installed"] = cli.get("commands", [])
     result["plugins_installed"] = shared.get("plugins", [])
 
+    # Install router skills (gobby, g) as Gemini skills
+    skills_dir = gemini_path / "skills"
+    router_skills = install_router_skills_as_gemini_skills(skills_dir)
+    result["commands_installed"].extend(router_skills)
+
     # Backup existing settings.json if it exists
     if settings_file.exists():
         timestamp = int(time.time())

gobby/cli/installers/shared.py

@@ -23,7 +23,8 @@ def install_shared_content(cli_path: Path, project_path: Path) -> dict[str, list
     """Install shared content from src/install/shared/.
 
     Workflows are cross-CLI and go to {project_path}/.gobby/workflows/.
-    Plugins are global and go to ~/.gobby/plugins/.
+    Plugins are project-scoped and go to {project_path}/.gobby/plugins/.
+    Prompts are project-scoped and go to {project_path}/.gobby/prompts/.
     Docs are project-local and go to {project_path}/.gobby/docs/.
 
     Args:
@@ -34,28 +35,52 @@ def install_shared_content(cli_path: Path, project_path: Path) -> dict[str, list
         Dict with lists of installed items by type
     """
     shared_dir = get_install_dir() / "shared"
-    installed: dict[str, list[str]] = {"workflows": [], "plugins": [], "docs": []}
+    installed: dict[str, list[str]] = {"workflows": [], "plugins": [], "prompts": [], "docs": []}
 
     # Install shared workflows to .gobby/workflows/ (cross-CLI)
     shared_workflows = shared_dir / "workflows"
     if shared_workflows.exists():
         target_workflows = project_path / ".gobby" / "workflows"
         target_workflows.mkdir(parents=True, exist_ok=True)
-        for workflow_file in shared_workflows.iterdir():
-            if workflow_file.is_file():
-                copy2(workflow_file, target_workflows / workflow_file.name)
-                installed["workflows"].append(workflow_file.name)
-
-    # Install shared plugins to ~/.gobby/plugins/ (global)
+        for item in shared_workflows.iterdir():
+            if item.is_file():
+                copy2(item, target_workflows / item.name)
+                installed["workflows"].append(item.name)
+            elif item.is_dir():
+                # Copy subdirectories (e.g., lifecycle/)
+                target_subdir = target_workflows / item.name
+                if target_subdir.exists():
+                    shutil.rmtree(target_subdir)
+                copytree(item, target_subdir)
+                installed["workflows"].append(f"{item.name}/")
+
+    # Install shared plugins to .gobby/plugins/ (project-scoped)
     shared_plugins = shared_dir / "plugins"
     if shared_plugins.exists():
-        target_plugins = Path("~/.gobby/plugins").expanduser()
+        target_plugins = project_path / ".gobby" / "plugins"
         target_plugins.mkdir(parents=True, exist_ok=True)
         for plugin_file in shared_plugins.iterdir():
             if plugin_file.is_file() and plugin_file.suffix == ".py":
                 copy2(plugin_file, target_plugins / plugin_file.name)
                 installed["plugins"].append(plugin_file.name)
 
+    # Install shared prompts to .gobby/prompts/ (project-scoped)
+    shared_prompts = shared_dir / "prompts"
+    if shared_prompts.exists():
+        target_prompts = project_path / ".gobby" / "prompts"
+        target_prompts.mkdir(parents=True, exist_ok=True)
+        for item in shared_prompts.iterdir():
+            if item.is_file():
+                copy2(item, target_prompts / item.name)
+                installed["prompts"].append(item.name)
+            elif item.is_dir():
+                # Copy subdirectories (e.g., expansion/, validation/)
+                target_subdir = target_prompts / item.name
+                if target_subdir.exists():
+                    shutil.rmtree(target_subdir)
+                copytree(item, target_subdir)
+                installed["prompts"].append(f"{item.name}/")
+
     # Install shared docs to .gobby/docs/ (project-local)
     shared_docs = shared_dir / "docs"
     if shared_docs.exists():
@@ -69,6 +94,55 @@ def install_shared_content(cli_path: Path, project_path: Path) -> dict[str, list
     return installed
 
 
+def backup_gobby_skills(skills_dir: Path) -> dict[str, Any]:
+    """Move gobby-prefixed skill directories to a backup location.
+
+    This function is called during installation to preserve existing gobby skills
+    before they are replaced by database-synced skills. User custom skills
+    (non-gobby prefixed) are not touched.
+
+    Args:
+        skills_dir: Path to skills directory (e.g., .claude/skills)
+
+    Returns:
+        Dict with:
+        - success: bool
+        - backed_up: int - number of skills moved to backup
+        - skipped: str (optional) - reason for skipping
+    """
+    result: dict[str, Any] = {
+        "success": True,
+        "backed_up": 0,
+    }
+
+    if not skills_dir.exists():
+        result["skipped"] = "skills directory does not exist"
+        return result
+
+    # Find gobby-prefixed skill directories
+    gobby_skills = [d for d in skills_dir.iterdir() if d.is_dir() and d.name.startswith("gobby-")]
+
+    if not gobby_skills:
+        return result
+
+    # Create backup directory (sibling to skills/)
+    backup_dir = skills_dir.parent / "skills.backup"
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    # Move each gobby skill to backup
+    import shutil
+
+    for skill_dir in gobby_skills:
+        target = backup_dir / skill_dir.name
+        # If already exists in backup, remove it first (replace with newer)
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.move(str(skill_dir), str(target))
+        result["backed_up"] += 1
+
+    return result
+
+
 def install_shared_skills(target_dir: Path) -> list[str]:
     """Install shared SKILL.md files to target directory.
 
@@ -129,6 +203,87 @@ def install_shared_skills(target_dir: Path) -> list[str]:
     return installed
 
 
+def install_router_skills_as_commands(target_commands_dir: Path) -> list[str]:
+    """Install router skills (gobby, g) as flattened Claude commands.
+
+    Claude Code uses .claude/commands/name.md format for slash commands.
+    This function copies the gobby router skills from shared/skills/ to
+    commands/ as flattened .md files.
+
+    Args:
+        target_commands_dir: Path to commands directory (e.g., .claude/commands)
+
+    Returns:
+        List of installed command names
+    """
+    shared_skills_dir = get_install_dir() / "shared" / "skills"
+    installed: list[str] = []
+
+    # Router skills to install as commands
+    router_skills = ["gobby", "g"]
+
+    target_commands_dir.mkdir(parents=True, exist_ok=True)
+
+    for skill_name in router_skills:
+        source_skill_md = shared_skills_dir / skill_name / "SKILL.md"
+        if not source_skill_md.exists():
+            logger.warning(f"Router skill not found: {source_skill_md}")
+            continue
+
+        # Flatten: copy SKILL.md to commands/name.md
+        target_cmd = target_commands_dir / f"{skill_name}.md"
+
+        try:
+            copy2(source_skill_md, target_cmd)
+            installed.append(f"{skill_name}.md")
+        except OSError as e:
+            logger.error(f"Failed to copy router skill {skill_name}: {e}")
+
+    return installed
+
+
+def install_router_skills_as_gemini_skills(target_skills_dir: Path) -> list[str]:
+    """Install router skills (gobby, g) as Gemini skills (directory structure).
+
+    Gemini CLI uses .gemini/skills/name/SKILL.md format for skills.
+    This function copies the gobby router skills from shared/skills/ to
+    the target skills directory preserving the directory structure.
+
+    Args:
+        target_skills_dir: Path to skills directory (e.g., .gemini/skills)
+
+    Returns:
+        List of installed skill names
+    """
+    shared_skills_dir = get_install_dir() / "shared" / "skills"
+    installed: list[str] = []
+
+    # Router skills to install
+    router_skills = ["gobby", "g"]
+
+    target_skills_dir.mkdir(parents=True, exist_ok=True)
+
+    for skill_name in router_skills:
+        source_skill_dir = shared_skills_dir / skill_name
+        source_skill_md = source_skill_dir / "SKILL.md"
+        if not source_skill_md.exists():
+            logger.warning(f"Router skill not found: {source_skill_md}")
+            continue
+
+        # Create skill directory and copy SKILL.md
+        target_skill_dir = target_skills_dir / skill_name
+        target_skill_dir.mkdir(parents=True, exist_ok=True)
+        target_skill_md = target_skill_dir / "SKILL.md"
+
+        try:
+            copy2(source_skill_md, target_skill_md)
+            installed.append(f"{skill_name}/")
+        except OSError as e:
+            logger.error(f"Failed to copy router skill {skill_name}: {e}")
+
+    return installed
+
+
 def install_cli_content(cli_name: str, target_path: Path) -> dict[str, list[str]]:
     """Install CLI-specific workflows/commands (layered on top of shared).
 
@@ -149,10 +304,17 @@ def install_cli_content(cli_name: str, target_path: Path) -> dict[str, list[str]
     if cli_workflows.exists():
         target_workflows = target_path / "workflows"
         target_workflows.mkdir(parents=True, exist_ok=True)
-        for workflow_file in cli_workflows.iterdir():
-            if workflow_file.is_file():
-                copy2(workflow_file, target_workflows / workflow_file.name)
-                installed["workflows"].append(workflow_file.name)
+        for item in cli_workflows.iterdir():
+            if item.is_file():
+                copy2(item, target_workflows / item.name)
+                installed["workflows"].append(item.name)
+            elif item.is_dir():
+                # Copy subdirectories
+                target_subdir = target_workflows / item.name
+                if target_subdir.exists():
+                    shutil.rmtree(target_subdir)
+                copytree(item, target_subdir)
+                installed["workflows"].append(f"{item.name}/")
 
     # CLI-specific commands (slash commands)
     # Claude/Gemini: commands/, Codex: prompts/

gobby/cli/sessions.py

@@ -387,7 +387,7 @@ def create_handoff(
     import time
     from pathlib import Path
 
-    from gobby.mcp_proxy.tools.session_messages import _format_handoff_markdown
+    from gobby.mcp_proxy.tools.sessions._handoff import _format_handoff_markdown
     from gobby.sessions.analyzer import TranscriptAnalyzer
 
     manager = get_session_manager()