gobby 0.2.8__tar.gz → 0.2.11__tar.gz

{gobby-0.2.8 → gobby-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gobby
-Version: 0.2.8
+Version: 0.2.11
 Summary: A local-first daemon to unify your AI coding tools. Session tracking and handoffs across Claude Code, Gemini CLI, and Codex. An MCP proxy that discovers tools without flooding context. Task management with dependencies, validation, and TDD expansion. Agent spawning and worktree orchestration. Persistent memory, extensible workflows, and hooks.
 Author-email: Josh Wilhelmi <josh@gobby.ai>
 License-Expression: MIT
@@ -65,7 +65,7 @@ Dynamic: license-file
 
 ---
 
-Gobby is a local-first daemon that unifies your AI coding assistants—Claude Code, Gemini CLI, and Codex—under one persistent, extensible platform. It handles the stuff these tools forget: sessions that survive restarts, context that carries across compactions, workflows that keep agents from going off the rails, and an MCP proxy that doesn't eat half your context window just loading tool definitions.
+Gobby is a local-first daemon that unifies your AI coding assistants—Claude Code, Gemini CLI, Cursor, Windsurf, Copilot, and Codex—under one persistent, extensible platform. It handles the stuff these tools forget: sessions that survive restarts, context that carries across compactions, workflows that keep agents from going off the rails, and an MCP proxy that doesn't eat half your context window just loading tool definitions.
 
 **Gobby is built with Gobby.** Most of this codebase was written by AI agents running through Gobby's own task system and workflows. Dogfooding isn't a buzzword here—it's the development process.
 
@@ -144,10 +144,11 @@ Built-in workflows: `auto-task`, `plan-execute`, `test-driven`. Or write your ow
 Spawn agents in isolated git worktrees. Run tasks in parallel without stepping on each other. Gobby tracks which agent is where and what they're doing.
 
 ```python
-call_tool("gobby-worktrees", "spawn_agent_in_worktree", {
+call_tool("gobby", "spawn_agent", {
     "prompt": "Implement OAuth flow",
-    "branch_name": "feature/oauth",
-    "task_id": "task-123"
+    "task_id": "#123",
+    "isolation": "worktree",
+    "branch_name": "feature/oauth"
 })
 ```
 
@@ -287,9 +288,33 @@ args = ["mcp-server"]
 
 | CLI | Hooks | Status |
 | :--- | :--- | :--- |
-| **Claude Code** | ✅ All 14 types | Full support |
-| **Gemini CLI** | ⏳ Ready | Waiting on upstream PR (see [#9070](https://github.com/google-gemini/gemini-cli/issues/9070)) |
-| **Codex CLI** | 🔸 Basic | `after_agent` only |
+| **Claude Code** | ✅ Full support | Native adapter, 12 hook types |
+| **Gemini CLI** | ✅ Full support | Native adapter, all hook types |
+| **Codex CLI** | ✅ Full support | Native adapter via app-server |
+| **Cursor** | ✅ Full support | Native adapter, 17 hook types |
+| **Windsurf** | ✅ Full support | Native adapter, 11 hook types |
+| **Copilot** | ✅ Full support | Native adapter, 6 hook types |
+
+### Hook Installation
+
+Gobby uses Python hook dispatchers that capture terminal context and communicate with the daemon. Run `gobby install` in your project to set up hooks:
+
+```bash
+gobby install           # Auto-detect and install hooks for all CLIs
+gobby install --claude  # Install for specific CLI
+gobby install --gemini
+gobby install --codex
+gobby install --cursor
+gobby install --windsurf
+gobby install --copilot
+```
+
+The dispatchers handle:
+- Terminal context capture (TTY, parent PID, session IDs)
+- Proper JSON serialization and HTTP communication
+- Exit code handling for blocking actions
+
+All CLIs can also connect via MCP for tool access (see configuration examples above).
 
 ## How It Compares
 
@@ -342,23 +367,32 @@ Everything runs locally. No cloud. No API keys required (beyond what your AI CLI
 
 Gobby exposes tools via MCP that your AI coding assistant can use:
 
-**Task Management** (`gobby-tasks`)  
-`create_task`, `expand_task`, `validate_task`, `close_task`, `list_ready_tasks`, `suggest_next_task`, `add_dependency`, `get_dependency_tree`, and more.
+**Task Management** (`gobby-tasks`)
+`create_task`, `expand_task`, `validate_task`, `close_task`, `claim_task`, `list_ready_tasks`, `suggest_next_task`, `link_commit`, and more.
 
-**Session Management** (`gobby-sessions`)  
-`pickup` (restore context), `get_handoff_context`, `list_sessions`
+**Session Management** (`gobby-sessions`)
+`get_current_session`, `pickup` (restore context), `get_handoff_context`, `list_sessions`, `send_message`
 
-**Memory** (`gobby-memory`)  
+**Memory** (`gobby-memory`)
 `remember`, `recall`, `forget` — persistent facts across sessions
 
-**Workflows** (`gobby-workflows`)  
-`activate`, `advance`, `set_variable`, `get_status`
+**Workflows** (`gobby-workflows`)
+`activate`, `advance`, `set_variable`, `get_status`, `end_workflow`
+
+**Agents** (`gobby-agents`)
+`spawn_agent` (unified API with `isolation`: current/worktree/clone), `list_agents`, `get_agent`, `kill_agent`
+
+**Worktrees** (`gobby-worktrees`)
+`create_worktree`, `list_worktrees`, `delete_worktree`, `merge_worktree`
+
+**Clones** (`gobby-clones`)
+`create_clone`, `list_clones`, `delete_clone`, `merge_clone_to_target`
 
-**Worktrees** (`gobby-worktrees`)  
-`create_worktree`, `spawn_agent_in_worktree`, `list_worktrees`
+**Artifacts** (`gobby-artifacts`)
+`save_artifact`, `get_artifact`, `list_artifacts` — capture and retrieve session artifacts
 
 **MCP Proxy**
-`list_mcp_servers`, `add_mcp_server`, `import_mcp_server`, `list_tools`, `get_tool_schema`, `call_tool`, `recommend_tools`
+`list_mcp_servers`, `add_mcp_server`, `import_mcp_server`, `list_tools`, `get_tool_schema`, `call_tool`, `recommend_tools`, `search_tools`
 
 **Skills** (`gobby-skills`)
 `list_skills`, `get_skill`, `search_skills`, `install_skill`, `remove_skill`, `update_skill`
@@ -371,13 +405,13 @@ Gobby exposes tools via MCP that your AI coding assistant can use:
 
 See [ROADMAP.md](ROADMAP.md) for the full plan, but highlights:
 
-**Shipped:** Task system v2 (commit linking, validation gates), TDD expansion v2 (red/green/blue generation), workflow engine, MCP proxy with progressive discovery, session tracking and handoffs, memory, hooks integration, worktree primitives
+**Shipped:** Task system v2 (commit linking, validation gates, Claude Code interop), TDD expansion v2 (red/green/blue generation), workflow engine (state machines, tool restrictions, exit conditions), MCP proxy with progressive discovery, session tracking and handoffs, memory v3 (backend abstraction), hooks integration for all CLIs, unified agent spawning, worktree and clone orchestration, skills system, artifacts capture
 
-**In Progress:** Memory v3 (backend abstraction layer for external memory solutions: MemU, Mem0, OpenMemory)
+**Beta:** Autonomous orchestration (conductor daemon, inter-agent messaging, token budget tracking, review gates)
 
-**Next:** Autonomous orchestration, TUI, Web UI (for remote access to your agents), Observability (tool call tracing, OpenTelemetry), Security posture for MCP (allow/deny lists, audit logging)
+**Next:** Security posture for MCP (allow/deny lists, audit logging), Observability (tool call tracing, session timelines), Web UI (read-only dashboard)
 
-**Vision:** Always local first, but Pro cloud features to keep the lights on: Fleet management (manage sessions across multiple machines), Plugin ecosystem, Team workflows, Enterprise hardening
+**Vision:** Always local first, but Pro cloud features to keep the lights on: Fleet management, Plugin ecosystem, Team workflows, Enterprise hardening
 
 ## Changelog
 

{gobby-0.2.8 → gobby-0.2.11}/README.md

@@ -19,7 +19,7 @@
 
 ---
 
-Gobby is a local-first daemon that unifies your AI coding assistants—Claude Code, Gemini CLI, and Codex—under one persistent, extensible platform. It handles the stuff these tools forget: sessions that survive restarts, context that carries across compactions, workflows that keep agents from going off the rails, and an MCP proxy that doesn't eat half your context window just loading tool definitions.
+Gobby is a local-first daemon that unifies your AI coding assistants—Claude Code, Gemini CLI, Cursor, Windsurf, Copilot, and Codex—under one persistent, extensible platform. It handles the stuff these tools forget: sessions that survive restarts, context that carries across compactions, workflows that keep agents from going off the rails, and an MCP proxy that doesn't eat half your context window just loading tool definitions.
 
 **Gobby is built with Gobby.** Most of this codebase was written by AI agents running through Gobby's own task system and workflows. Dogfooding isn't a buzzword here—it's the development process.
 
@@ -98,10 +98,11 @@ Built-in workflows: `auto-task`, `plan-execute`, `test-driven`. Or write your ow
 Spawn agents in isolated git worktrees. Run tasks in parallel without stepping on each other. Gobby tracks which agent is where and what they're doing.
 
 ```python
-call_tool("gobby-worktrees", "spawn_agent_in_worktree", {
+call_tool("gobby", "spawn_agent", {
     "prompt": "Implement OAuth flow",
-    "branch_name": "feature/oauth",
-    "task_id": "task-123"
+    "task_id": "#123",
+    "isolation": "worktree",
+    "branch_name": "feature/oauth"
 })
 ```
 
@@ -241,9 +242,33 @@ args = ["mcp-server"]
 
 | CLI | Hooks | Status |
 | :--- | :--- | :--- |
-| **Claude Code** | ✅ All 14 types | Full support |
-| **Gemini CLI** | ⏳ Ready | Waiting on upstream PR (see [#9070](https://github.com/google-gemini/gemini-cli/issues/9070)) |
-| **Codex CLI** | 🔸 Basic | `after_agent` only |
+| **Claude Code** | ✅ Full support | Native adapter, 12 hook types |
+| **Gemini CLI** | ✅ Full support | Native adapter, all hook types |
+| **Codex CLI** | ✅ Full support | Native adapter via app-server |
+| **Cursor** | ✅ Full support | Native adapter, 17 hook types |
+| **Windsurf** | ✅ Full support | Native adapter, 11 hook types |
+| **Copilot** | ✅ Full support | Native adapter, 6 hook types |
+
+### Hook Installation
+
+Gobby uses Python hook dispatchers that capture terminal context and communicate with the daemon. Run `gobby install` in your project to set up hooks:
+
+```bash
+gobby install           # Auto-detect and install hooks for all CLIs
+gobby install --claude  # Install for specific CLI
+gobby install --gemini
+gobby install --codex
+gobby install --cursor
+gobby install --windsurf
+gobby install --copilot
+```
+
+The dispatchers handle:
+- Terminal context capture (TTY, parent PID, session IDs)
+- Proper JSON serialization and HTTP communication
+- Exit code handling for blocking actions
+
+All CLIs can also connect via MCP for tool access (see configuration examples above).
 
 ## How It Compares
 
@@ -296,23 +321,32 @@ Everything runs locally. No cloud. No API keys required (beyond what your AI CLI
 
 Gobby exposes tools via MCP that your AI coding assistant can use:
 
-**Task Management** (`gobby-tasks`)  
-`create_task`, `expand_task`, `validate_task`, `close_task`, `list_ready_tasks`, `suggest_next_task`, `add_dependency`, `get_dependency_tree`, and more.
+**Task Management** (`gobby-tasks`)
+`create_task`, `expand_task`, `validate_task`, `close_task`, `claim_task`, `list_ready_tasks`, `suggest_next_task`, `link_commit`, and more.
 
-**Session Management** (`gobby-sessions`)  
-`pickup` (restore context), `get_handoff_context`, `list_sessions`
+**Session Management** (`gobby-sessions`)
+`get_current_session`, `pickup` (restore context), `get_handoff_context`, `list_sessions`, `send_message`
 
-**Memory** (`gobby-memory`)  
+**Memory** (`gobby-memory`)
 `remember`, `recall`, `forget` — persistent facts across sessions
 
-**Workflows** (`gobby-workflows`)  
-`activate`, `advance`, `set_variable`, `get_status`
+**Workflows** (`gobby-workflows`)
+`activate`, `advance`, `set_variable`, `get_status`, `end_workflow`
+
+**Agents** (`gobby-agents`)
+`spawn_agent` (unified API with `isolation`: current/worktree/clone), `list_agents`, `get_agent`, `kill_agent`
+
+**Worktrees** (`gobby-worktrees`)
+`create_worktree`, `list_worktrees`, `delete_worktree`, `merge_worktree`
+
+**Clones** (`gobby-clones`)
+`create_clone`, `list_clones`, `delete_clone`, `merge_clone_to_target`
 
-**Worktrees** (`gobby-worktrees`)  
-`create_worktree`, `spawn_agent_in_worktree`, `list_worktrees`
+**Artifacts** (`gobby-artifacts`)
+`save_artifact`, `get_artifact`, `list_artifacts` — capture and retrieve session artifacts
 
 **MCP Proxy**
-`list_mcp_servers`, `add_mcp_server`, `import_mcp_server`, `list_tools`, `get_tool_schema`, `call_tool`, `recommend_tools`
+`list_mcp_servers`, `add_mcp_server`, `import_mcp_server`, `list_tools`, `get_tool_schema`, `call_tool`, `recommend_tools`, `search_tools`
 
 **Skills** (`gobby-skills`)
 `list_skills`, `get_skill`, `search_skills`, `install_skill`, `remove_skill`, `update_skill`
@@ -325,13 +359,13 @@ Gobby exposes tools via MCP that your AI coding assistant can use:
 
 See [ROADMAP.md](ROADMAP.md) for the full plan, but highlights:
 
-**Shipped:** Task system v2 (commit linking, validation gates), TDD expansion v2 (red/green/blue generation), workflow engine, MCP proxy with progressive discovery, session tracking and handoffs, memory, hooks integration, worktree primitives
+**Shipped:** Task system v2 (commit linking, validation gates, Claude Code interop), TDD expansion v2 (red/green/blue generation), workflow engine (state machines, tool restrictions, exit conditions), MCP proxy with progressive discovery, session tracking and handoffs, memory v3 (backend abstraction), hooks integration for all CLIs, unified agent spawning, worktree and clone orchestration, skills system, artifacts capture
 
-**In Progress:** Memory v3 (backend abstraction layer for external memory solutions: MemU, Mem0, OpenMemory)
+**Beta:** Autonomous orchestration (conductor daemon, inter-agent messaging, token budget tracking, review gates)
 
-**Next:** Autonomous orchestration, TUI, Web UI (for remote access to your agents), Observability (tool call tracing, OpenTelemetry), Security posture for MCP (allow/deny lists, audit logging)
+**Next:** Security posture for MCP (allow/deny lists, audit logging), Observability (tool call tracing, session timelines), Web UI (read-only dashboard)
 
-**Vision:** Always local first, but Pro cloud features to keep the lights on: Fleet management (manage sessions across multiple machines), Plugin ecosystem, Team workflows, Enterprise hardening
+**Vision:** Always local first, but Pro cloud features to keep the lights on: Fleet management, Plugin ecosystem, Team workflows, Enterprise hardening
 
 ## Changelog
 

{gobby-0.2.8 → gobby-0.2.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gobby"
-version = "0.2.8"
+version = "0.2.11"
 description = "A local-first daemon to unify your AI coding tools. Session tracking and handoffs across Claude Code, Gemini CLI, and Codex. An MCP proxy that discovers tools without flooding context. Task management with dependencies, validation, and TDD expansion. Agent spawning and worktree orchestration. Persistent memory, extensible workflows, and hooks."
 readme = "README.md"
 license = "MIT"
@@ -194,6 +194,7 @@ dev = [
     "bandit>=1.8.0",
     "black>=24.0.0",
     "mypy>=1.8.0",
+    "pip>=26.0",  # CVE-2026-1703
     "pip-audit>=2.7.0",
     "pre-commit>=4.0.0",
     "pytest>=8.4.2",

{gobby-0.2.8 → gobby-0.2.11}/src/gobby/__init__.py

@@ -1,3 +1,3 @@
 """Gobby - Local-first daemon for multi-CLI session management."""
 
-__version__ = "0.2.7"
+__version__ = "0.2.11"

{gobby-0.2.8 → gobby-0.2.11}/src/gobby/adapters/__init__.py

@@ -19,7 +19,10 @@ from gobby.adapters.base import BaseAdapter
 from gobby.adapters.claude_code import ClaudeCodeAdapter
 from gobby.adapters.codex_impl.adapter import CodexAdapter, CodexNotifyAdapter
 from gobby.adapters.codex_impl.client import CodexAppServerClient
+from gobby.adapters.copilot import CopilotAdapter
+from gobby.adapters.cursor import CursorAdapter
 from gobby.adapters.gemini import GeminiAdapter
+from gobby.adapters.windsurf import WindsurfAdapter
 
 __all__ = [
     "BaseAdapter",
@@ -27,5 +30,8 @@ __all__ = [
     "CodexAdapter",
     "CodexAppServerClient",
     "CodexNotifyAdapter",
+    "CopilotAdapter",
+    "CursorAdapter",
     "GeminiAdapter",
+    "WindsurfAdapter",
 ]

{gobby-0.2.8 → gobby-0.2.11}/src/gobby/adapters/base.py

@@ -68,8 +68,9 @@ class BaseAdapter(ABC):
 
         This method handles the full round-trip:
         1. Translate native event to HookEvent
-        2. Process through HookManager
-        3. Translate response back to native format
+        2. Inject daemon's machine_id if not provided by CLI
+        3. Process through HookManager
+        4. Translate response back to native format
 
         Note: This method is synchronous for Phase 2A-2B compatibility.
         In Phase 2C+, when HookManager.handle() is async, subclasses may
@@ -89,5 +90,13 @@ class BaseAdapter(ABC):
         if hook_event is None:
             # Event ignored by adapter
             return {}
+
+        # Inject daemon's machine_id if CLI didn't provide it
+        # This centralizes machine_id handling - adapters don't generate IDs
+        if not hook_event.machine_id:
+            from gobby.utils.machine_id import get_machine_id
+
+            hook_event.machine_id = get_machine_id()
+
         hook_response = hook_manager.handle(hook_event)
         return self.translate_from_hook_response(hook_response)

{gobby-0.2.8 → gobby-0.2.11}/src/gobby/adapters/claude_code.py

@@ -61,13 +61,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         """Initialize the Claude Code adapter.
 
         Args:
-            hook_manager: Reference to HookManager for strangler fig delegation.
+            hook_manager: Reference to HookManager for delegation.
                          If None, the adapter can only translate (not handle events).
         """
         self._hook_manager = hook_manager
-        # Phase 2C: Use new handle() path with unified HookEvent model
-        # Note: systemMessage handoff notification bug exists in both paths (see plan-multi-cli.md)
-        self._use_legacy = False
 
     def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
         """Convert Claude Code native event to unified HookEvent.
@@ -295,8 +292,8 @@ class ClaudeCodeAdapter(BaseAdapter):
 
         # Build hookSpecificOutput if we have any context to inject
         # Only include hookSpecificOutput for hook types that Claude Code's schema accepts
-        # Valid hookEventName values: PreToolUse, UserPromptSubmit, PostToolUse
-        valid_hook_event_names = {"PreToolUse", "UserPromptSubmit", "PostToolUse"}
+        # Valid hookEventName values: PreToolUse, UserPromptSubmit, PostToolUse, SessionStart
+        valid_hook_event_names = {"PreToolUse", "UserPromptSubmit", "PostToolUse", "SessionStart"}
         if additional_context_parts and hook_event_name in valid_hook_event_names:
             result["hookSpecificOutput"] = {
                 "hookEventName": hook_event_name,
@@ -310,14 +307,6 @@ class ClaudeCodeAdapter(BaseAdapter):
     ) -> dict[str, Any]:
         """Main entry point for HTTP endpoint.
 
-        Strangler fig pattern:
-        - Phase 2A-2B: Delegates to existing execute() — validates translation only
-        - Phase 2C+: Calls new handle() with HookEvent
-
-        Note: This method is synchronous for Phase 2A-2B compatibility with
-        the existing execute() method. In Phase 2C+, it will become async
-        when handle() is implemented as async.
-
         Args:
             native_event: Raw payload from Claude Code's hook_dispatcher.py
             hook_manager: HookManager instance for processing.
@@ -325,22 +314,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         Returns:
             Response dict in Claude Code's expected format.
         """
-        # Always translate (validates our mapping is correct)
+        # Translate to HookEvent
         hook_event = self.translate_to_hook_event(native_event)
 
-        # Phase 2C+: Use new HookEvent-based handler
-        # Legacy execute() path removed as HookManager.execute is deprecated/removed.
+        # Use HookEvent-based handler
         hook_type = native_event.get("hook_type", "")
         hook_response = hook_manager.handle(hook_event)
         return self.translate_from_hook_response(hook_response, hook_type=hook_type)
-
-    def set_legacy_mode(self, use_legacy: bool) -> None:
-        """Toggle between legacy and new code paths.
-
-        This method is used during the strangler fig migration to switch
-        between delegating to execute() and calling handle() directly.
-
-        Args:
-            use_legacy: If True, use legacy execute() path. If False, use new handle() path.
-        """
-        self._use_legacy = use_legacy

{gobby-0.2.8 → gobby-0.2.11}/src/gobby/adapters/codex_impl/adapter.py

@@ -40,46 +40,26 @@ logger = logging.getLogger(__name__)
 # =============================================================================
 
 
-def _get_machine_id() -> str:
-    """Get or generate a stable machine identifier.
+def _get_daemon_machine_id() -> str | None:
+    """Get machine ID from the daemon's centralized utility.
 
-    Priority:
-    1. Hostname (if available)
-    2. MAC address (if real, not random)
-    3. Persisted UUID file (created on first run)
+    This adapter runs in the daemon process, so we use the centralized
+    machine_id management from utils.machine_id.
     """
-    from pathlib import Path
+    from gobby.utils.machine_id import get_machine_id
+
+    return get_machine_id()
+
+
+def _get_machine_id() -> str:
+    """Generate a machine identifier.
 
-    # Try hostname first
+    Used by Codex adapters when no machine_id is provided.
+    """
     node = platform.node()
     if node:
         return str(uuid.uuid5(uuid.NAMESPACE_DNS, node))
-
-    # Try MAC address - getnode() returns random value with multicast bit set if unavailable
-    mac = uuid.getnode()
-    # Check if MAC is real (multicast bit / bit 0 of first octet is 0)
-    if not (mac >> 40) & 1:
-        return str(uuid.uuid5(uuid.NAMESPACE_DNS, str(mac)))
-
-    # Fall back to persisted ID file for stability across restarts
-    machine_id_file = Path.home() / ".gobby" / ".machine_id"
-    try:
-        if machine_id_file.exists():
-            stored_id = machine_id_file.read_text().strip()
-            if stored_id:
-                return stored_id
-    except OSError:
-        pass  # Fall through to generate new ID
-
-    # Generate and persist a new ID
-    new_id = str(uuid.uuid4())
-    try:
-        machine_id_file.parent.mkdir(parents=True, exist_ok=True)
-        machine_id_file.write_text(new_id)
-    except OSError:
-        pass  # Use the generated ID even if we can't persist it
-
-    return new_id
+    return str(uuid.uuid4())
 
 
 # =============================================================================
@@ -163,8 +143,8 @@ class CodexAdapter(BaseAdapter):
         """
         self._hook_manager = hook_manager
         self._codex_client: CodexAppServerClient | None = None
-        self._machine_id: str | None = None
         self._attached = False
+        self._machine_id: str | None = None
 
     @staticmethod
     def is_codex_available() -> bool:
@@ -177,10 +157,18 @@ class CodexAdapter(BaseAdapter):
 
         return shutil.which("codex") is not None
 
-    def _get_machine_id(self) -> str:
-        """Get or generate a machine identifier."""
-        if self._machine_id is None:
+    def _get_machine_id(self) -> str | None:
+        """Get machine ID with caching and daemon fallback."""
+        if self._machine_id:
+            return self._machine_id
+
+        # Try daemon first
+        self._machine_id = _get_daemon_machine_id()
+
+        # Fallback to generated if daemon not available
+        if not self._machine_id:
             self._machine_id = _get_machine_id()
+
         return self._machine_id
 
     def normalize_tool_name(self, codex_tool_name: str) -> str:
@@ -532,15 +520,23 @@ class CodexNotifyAdapter(BaseAdapter):
             max_seen_threads: Max threads to track (default 1000). Oldest evicted when full.
         """
         self._hook_manager = hook_manager
-        self._machine_id: str | None = None
         # Track threads we've seen using LRU cache to avoid unbounded growth
         self._max_seen_threads = max_seen_threads or self.DEFAULT_MAX_SEEN_THREADS
         self._seen_threads: OrderedDict[str, bool] = OrderedDict()
+        self._machine_id: str | None = None
+
+    def _get_machine_id(self) -> str | None:
+        """Get machine ID with caching and daemon fallback."""
+        if self._machine_id:
+            return self._machine_id
 
-    def _get_machine_id(self) -> str:
-        """Get or generate a machine identifier."""
-        if self._machine_id is None:
+        # Try daemon first
+        self._machine_id = _get_daemon_machine_id()
+
+        # Fallback to generated if daemon not available
+        if not self._machine_id:
             self._machine_id = _get_machine_id()
+
         return self._machine_id
 
     def _mark_thread_seen(self, thread_id: str) -> None:
@@ -716,7 +712,6 @@ class CodexNotifyAdapter(BaseAdapter):
 
 
 __all__ = [
-    "_get_machine_id",
     "CodexAdapter",
     "CodexNotifyAdapter",
 ]