cloudagent-daemon 0.2.6__tar.gz → 0.3.0__tar.gz

{cloudagent_daemon-0.2.6 → cloudagent_daemon-0.3.0}/.gitignore

@@ -9,6 +9,7 @@
 
 # Local work-in-progress scratch dir (never committed)
 abu/
+cc_codex/
 
 # GSD workflow tool config (local only)
 .planning/
@@ -85,5 +86,6 @@ package-lock.json
 
 # playwright 测试相关
 .playwright-mcp/
-tests/
 
+# M7 设计 demo 的解压产物（源在 Opc.zip，解压即得）
+company/m7/refactors/Opc_extracted/

{cloudagent_daemon-0.2.6 → cloudagent_daemon-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudagent-daemon
-Version: 0.2.6
+Version: 0.3.0
 Summary: Local daemon for cloudagent — bridges Claude Code subprocesses to the cloudagent backend over WebSocket.
 Project-URL: Homepage, https://cloudagent.chat
 Project-URL: Repository, https://codeup.aliyun.com/69bd0a4d29ad98af4065ce71/cloudagent

{cloudagent_daemon-0.2.6 → cloudagent_daemon-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cloudagent-daemon"
-version = "0.2.6"
+version = "0.3.0"
 description = "Local daemon for cloudagent — bridges Claude Code subprocesses to the cloudagent backend over WebSocket."
 authors = [{name = "chaoyin", email = "tudoucyx@gmail.com"}]
 readme = "README.md"

cloudagent_daemon-0.3.0/src/cloudagent_daemon/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{cloudagent_daemon-0.2.6 → cloudagent_daemon-0.3.0}/src/cloudagent_daemon/claude_runner.py

@@ -121,6 +121,9 @@ class SpawnResult:
     exit_code: int
     captured_session_id: str | None
     stderr_tail: str
+    # M7 W3 — whole-turn token usage (``_INITIAL_USAGE`` shape) parsed
+    # from the Claude CLI ``type=result`` event. ``None`` when absent.
+    result_usage: dict | None = None
 
 
 @dataclass
@@ -147,6 +150,10 @@ class _SpawnAttempt:
     timeout_hit: bool
     tool_uses: list[str]
     final_result_text: str | None
+    # M7 W3 — whole-turn token usage parsed from the Claude CLI
+    # ``type=result`` event (normalised to ``_INITIAL_USAGE`` shape).
+    # ``None`` when the result event carried no ``usage`` blob.
+    result_usage: dict | None
 
 
 def _build_lazy_identity(agent_id: str, payload: dict) -> dict:
@@ -171,6 +178,7 @@ def _build_lazy_identity(agent_id: str, payload: dict) -> dict:
         "role": str(payload.get("role") or "staff"),
         "workspace_slug": str(payload.get("workspace_slug") or "default"),
         "reports_to": "(unset)",
+        "runtime_engine": str(payload.get("runtime_engine") or "claude_code"),
     }
 
 
@@ -198,18 +206,34 @@ class ClaudeRunner:
         single_wake_timeout: float | None = None,
         partial_publisher: PartialPublisher | None = None,
         agent_to_session: "dict[str, str | None] | None" = None,
-        claude_permission_mode: str = "default",
+        claude_permission_mode: str = "bypassPermissions",
+        runtime_binaries: dict[str, str] | None = None,
+        http: object | None = None,
+        injection_state: object | None = None,
+        delegation_outbox: object | None = None,
     ) -> None:
         self.outbound = outbound
         self.workspace = workspace
         self.claude_binary = claude_binary
-        # Claude CLI ``--permission-mode``. "default" → flag omitted
-        # (legacy behaviour: only the cloudagent MCP toolset is
-        # whitelisted via --allowedTools, Bash/Write/Edit gate). See
-        # DaemonConfig.claude_permission_mode for the per-mode contract.
+        # M7 W3 — localagent context injection + delegation reporting.
+        # ``http`` is the shared HTTPOutbound (GET /v1/daemon/task-context
+        # + POST /v1/daemon/delegation-status). ``injection_state`` is the
+        # file-backed (agent,task) dedup store. ``delegation_outbox`` is
+        # the durable journal for undelivered status reports. All three
+        # are ``None`` in the legacy / test path — the runner then simply
+        # skips injection + reporting (pre-M7 behaviour, no crash).
+        self._http = http
+        self._injection_state = injection_state
+        self._delegation_outbox = delegation_outbox
+        # Claude CLI ``--permission-mode``. The daemon default is now
+        # ``bypassPermissions`` so local agents can run build/git/file
+        # workflows unattended. "default" remains supported as an
+        # explicit opt-out. See DaemonConfig.claude_permission_mode for
+        # the per-mode contract.
         self.claude_permission_mode = claude_permission_mode
         # Allow tests to override the 90-min timeout without monkey-patching
         # a class attribute. Defaults to spec value.
+        self.runtime_binaries = runtime_binaries or {}
         self._single_wake_timeout: float = (
             single_wake_timeout
             if single_wake_timeout is not None
@@ -345,6 +369,13 @@ The daemon discards stdout — only the mcp tool call reaches the user.
         if self._agent_to_session is not None:
             self._agent_to_session[agent_id] = _effective_session_id
 
+        # M7 W3 — localagent company-context injection. BEFORE spawning
+        # claude, if this deliver belongs to a task whose context has not
+        # yet been pulled onto this host, fetch + write the company
+        # rules / skills / memory into the agent workspace. Best-effort:
+        # never crashes the wake (see _maybe_inject_task_context).
+        await self._maybe_inject_task_context(agent_id, ws, payload)
+
         wake_start = time.monotonic()
         try:
             attempt = await self._spawn_attempt(
@@ -450,11 +481,9 @@ The daemon discards stdout — only the mcp tool call reaches the user.
                     agent_id=agent_id,
                     session_id=fallback_session,
                     tool_name="send_message",
-                    args={
-                        "target": "user",
-                        "body": attempt.final_result_text,
-                        "kind": "reply",
-                    },
+                    args=self._fallback_reply_args(
+                        payload, attempt.final_result_text
+                    ),
                     # Backend dispatch is fast — short timeout keeps the
                     # wake from blocking the spawn queue if the WS round
                     # trip stalls.
@@ -521,12 +550,164 @@ The daemon discards stdout — only the mcp tool call reaches the user.
             len(stderr_tail),
         )
 
+        # M7 W3 — delegation status + token-usage report. When this
+        # deliver carried a ``delegation_id`` the work is a delegation;
+        # report the outcome (completed/failed) + whole-turn usage to the
+        # backend so the ``delegations`` row gets filled. Best-effort:
+        # never crashes the wake (see _maybe_report_delegation).
+        await self._maybe_report_delegation(
+            payload,
+            timeout_hit=timeout_hit,
+            exit_code=rc,
+            result_usage=attempt.result_usage,
+            final_result_text=attempt.final_result_text,
+        )
+
         return SpawnResult(
             exit_code=rc,
             captured_session_id=captured_session,
             stderr_tail=stderr_tail,
+            result_usage=attempt.result_usage,
         )
 
+    # ------------------------------------------------------------------
+    # M7 W3 — localagent context injection + delegation reporting
+    # ------------------------------------------------------------------
+
+    async def _maybe_inject_task_context(
+        self, agent_id: str, ws: AgentWorkspaceLike, payload: dict
+    ) -> None:
+        """Pull + write company context for a task's first delegation.
+
+        No-op when:
+          * the runner has no ``http`` / ``injection_state`` wired
+            (legacy / test path);
+          * the deliver frame carries no ``task_id`` (old backend that
+            doesn't stamp it — compat matrix: new daemon + old backend);
+          * this ``(agent_id, task_id)`` was already injected (the file-
+            backed marker survives daemon restarts → acceptance W3-04:
+            the second delegation of the same task does NOT re-pull).
+
+        On the first delegation of a task it fetches
+        ``GET /v1/daemon/task-context`` and writes CLAUDE.md / skills /
+        memory into the agent workspace, then records the marker so
+        subsequent delegations skip the pull.
+
+        NEVER raises — a failed injection must not crash or block the
+        wake (acceptance W3-06). The agent simply runs on the user's
+        own ``~/.claude`` (pre-M7 behaviour).
+        """
+        if self._http is None or self._injection_state is None:
+            return
+        task_id = payload.get("task_id")
+        task_id = task_id if isinstance(task_id, str) and task_id else None
+        if not task_id:
+            # Old backend deliver frame — no task_id stamped. Degrade
+            # silently to pre-M7 behaviour.
+            return
+
+        try:
+            already = await self._injection_state.is_injected(
+                agent_id, task_id
+            )
+        except Exception:  # noqa: BLE001 — fail-open: try injecting
+            logger.exception(
+                "claude_runner: injection_state.is_injected failed "
+                "agent=%s task=%s — proceeding with fetch", agent_id, task_id,
+            )
+            already = False
+        if already:
+            logger.info(
+                "claude_runner: task context already injected for "
+                "agent=%s task=%s — skipping re-fetch (W3-04)",
+                agent_id, task_id,
+            )
+            return
+
+        # The injection target is the claude subprocess cwd — claude
+        # reads project-level CLAUDE.md / .claude / .memory relative to
+        # its cwd, exactly as a cloud pod reads them from /workspace.
+        from .context_fetch import fetch_and_write_task_context
+
+        try:
+            injected = await fetch_and_write_task_context(
+                self._http,
+                workspace=ws.cwd,
+                agent_id=agent_id,
+                task_id=task_id,
+            )
+        except Exception:  # noqa: BLE001 — fail-safe (context_fetch
+            # already guards, this is belt-and-braces)
+            logger.exception(
+                "claude_runner: task context injection raised "
+                "agent=%s task=%s — wake proceeds without injection",
+                agent_id, task_id,
+            )
+            return
+
+        if injected:
+            # Mark only after a successful write so a transient fetch
+            # failure can be retried on the next delegation.
+            try:
+                await self._injection_state.mark_injected(agent_id, task_id)
+            except Exception:  # noqa: BLE001
+                logger.exception(
+                    "claude_runner: injection_state.mark_injected failed "
+                    "agent=%s task=%s — may re-inject next delegation "
+                    "(idempotent)", agent_id, task_id,
+                )
+
+    async def _maybe_report_delegation(
+        self,
+        payload: dict,
+        *,
+        timeout_hit: bool,
+        exit_code: int,
+        result_usage: dict | None,
+        final_result_text: str | None,
+    ) -> None:
+        """Report a delegation's outcome + token usage to the backend.
+
+        No-op when the runner has no ``http`` wired or the deliver frame
+        carries no ``delegation_id`` (the work was not a delegation —
+        test-chat / direct task).
+
+        Status mapping: a clean exit (``rc==0`` and no timeout) →
+        ``completed``; anything else → ``failed``. The whole-turn
+        ``usage`` comes from the Claude CLI ``result`` event.
+
+        NEVER raises (acceptance W3-06).
+        """
+        if self._http is None:
+            return
+        delegation_id = payload.get("delegation_id")
+        delegation_id = (
+            delegation_id
+            if isinstance(delegation_id, str) and delegation_id
+            else None
+        )
+        if not delegation_id:
+            return
+
+        status = "completed" if (exit_code == 0 and not timeout_hit) else "failed"
+        from .delegation_report import report_delegation_status
+
+        try:
+            await report_delegation_status(
+                self._http,
+                delegation_id=delegation_id,
+                status=status,
+                usage=result_usage,
+                result=final_result_text,
+                outbox=self._delegation_outbox,  # type: ignore[arg-type]
+            )
+        except Exception:  # noqa: BLE001 — fail-safe (report_delegation_
+            # status already guards, belt-and-braces)
+            logger.exception(
+                "claude_runner: delegation status report raised "
+                "delegation=%s — wake outcome unaffected", delegation_id,
+            )
+
     async def _spawn_attempt(
         self,
         ws: AgentWorkspaceLike,
@@ -551,11 +732,13 @@ The daemon discards stdout — only the mcp tool call reaches the user.
         append_system_prompt = (
             raw_append if isinstance(raw_append, str) and raw_append.strip() else None
         )
+        runtime_engine = self._runtime_engine_for(ws, payload)
         cmd = self._build_cmd(
             ws,
             agent_id,
             with_resume=with_resume,
             append_system_prompt=append_system_prompt,
+            runtime_engine=runtime_engine,
         )
 
         # Task #118 (2026-05-12) — spawn cwd is now the agent-specific
@@ -568,8 +751,9 @@ The daemon discards stdout — only the mcp tool call reaches the user.
 
         # 1i Bug C — Phase 1 demo visibility.
         logger.info(
-            "claude_runner: spawning claude agent=%s msg=%s prior_session=%s "
+            "claude_runner: spawning runtime=%s agent=%s msg=%s prior_session=%s "
             "with_resume=%s cwd=%s cmd=%s",
+            runtime_engine,
             agent_id,
             payload.get("message_id"),
             ws.last_session_id(),
@@ -630,8 +814,16 @@ The daemon discards stdout — only the mcp tool call reaches the user.
         # chunk. session_id is ``test_chat_{host}_{agent}`` for test-
         # chat deliveries (the new per-agent shape from 1k73).
         deliver_session_id = payload.get("session_id")
-        captured_session, tool_uses, final_text = await self._consume_stdout(
+        (
+            captured_session,
+            tool_uses,
+            final_text,
+            result_usage,
+        ) = await self._consume_stdout(
             proc,
+            parse_mode=(
+                "codex_json" if runtime_engine == "codex" else "stream_json"
+            ),
             partial_session_id=(
                 deliver_session_id
                 if isinstance(deliver_session_id, str)
@@ -655,6 +847,7 @@ The daemon discards stdout — only the mcp tool call reaches the user.
             timeout_hit=timeout_hit,
             tool_uses=tool_uses,
             final_result_text=final_text,
+            result_usage=result_usage,
         )
 
     # ------------------------------------------------------------------
@@ -782,6 +975,57 @@ Available cloudagent tools:
             return ""
         return "[meta]\n" + "\n".join(lines) + "\n[/meta]\n\n"
 
+    def _runtime_engine_for(self, ws: AgentWorkspaceLike, payload: dict) -> str:
+        """Resolve the engine for this wake.
+
+        Backend sends ``runtime_engine`` on deliver frames after 2026-05-25
+        and also persists it in ``identity.json`` via ready/assign. Reading
+        both keeps old queued frames working after a daemon restart.
+        """
+        raw = payload.get("runtime_engine")
+        if not isinstance(raw, str) or not raw.strip():
+            try:
+                identity = json.loads(
+                    (ws.path / ".meta" / "identity.json").read_text(
+                        encoding="utf-8"
+                    )
+                )
+            except (FileNotFoundError, json.JSONDecodeError, OSError):
+                identity = {}
+            raw = identity.get("runtime_engine")
+        engine = raw.strip() if isinstance(raw, str) else ""
+        return "codex" if engine == "codex" else "claude_code"
+
+    def _fallback_reply_args(self, payload: dict, body: str) -> dict:
+        """Build daemon fallback ``send_message`` args.
+
+        Claude normally calls the MCP tool itself; Codex can also use the
+        configured MCP server, but the fallback is what keeps a plain final
+        answer visible if a runtime prints text and exits. Route replies to
+        the sender role when this was agent-to-agent work, and to the human
+        surface for direct user/task wakes.
+        """
+        if payload.get("dispatch_source") == "user_direct":
+            target = "user"
+        else:
+            target = (
+                payload.get("sender_role")
+                or payload.get("from")
+                or payload.get("sender")
+                or "user"
+            )
+        if not isinstance(target, str) or not target.strip():
+            target = "user"
+        args: dict = {
+            "target": target.strip(),
+            "body": body,
+            "kind": "reply",
+        }
+        parent = payload.get("parent_msg_id") or payload.get("message_id")
+        if parent not in (None, ""):
+            args["parent_msg_id"] = parent
+        return args
+
     def _build_cmd(
         self,
         ws: AgentWorkspaceLike,
@@ -789,6 +1033,7 @@ Available cloudagent tools:
         *,
         with_resume: bool = True,
         append_system_prompt: str | None = None,
+        runtime_engine: str = "claude_code",
     ) -> list[str]:
         """Build the ``claude`` argv list for one wake.
 
@@ -803,8 +1048,45 @@ Available cloudagent tools:
         contract footer with a blank-line separator so it shows up at the
         very tail of ``--append-system-prompt``.
         """
-        cmd: list[str] = [self.claude_binary]
         last_session = ws.last_session_id() if with_resume else None
+        if runtime_engine == "codex":
+            binary = self.runtime_binaries.get("codex") or "codex"
+            bridge_args = [
+                "mcp-bridge",
+                "--agent-id",
+                agent_id,
+                "--token-file",
+                str(ws.path / ".meta" / "claude-token.txt"),
+            ]
+            cmd: list[str] = [
+                binary,
+                "-c",
+                "mcp_servers.cloudagent.command="
+                + json.dumps("cloudagent-daemon"),
+                "-c",
+                "mcp_servers.cloudagent.args=" + json.dumps(bridge_args),
+            ]
+            if last_session:
+                cmd += [
+                    "exec",
+                    "resume",
+                    "--json",
+                    "--dangerously-bypass-approvals-and-sandbox",
+                    "--skip-git-repo-check",
+                    last_session,
+                    "-",
+                ]
+            else:
+                cmd += [
+                    "exec",
+                    "--json",
+                    "--dangerously-bypass-approvals-and-sandbox",
+                    "--skip-git-repo-check",
+                    "-",
+                ]
+            return cmd
+
+        cmd = [self.runtime_binaries.get("claude_code") or self.claude_binary]
         if last_session:
             cmd += ["--resume", last_session]
         # 1i Bug F — inject operational contract via --append-system-prompt.
@@ -847,14 +1129,104 @@ Available cloudagent tools:
             cmd += ["--permission-mode", self.claude_permission_mode]
         return cmd
 
+    async def _consume_codex_stdout(
+        self,
+        proc: asyncio.subprocess.Process,
+        *,
+        partial_session_id: str | None = None,
+        partial_agent_id: str | None = None,
+    ) -> tuple[str | None, list[str], str | None, dict | None]:
+        """Consume ``codex exec --json`` NDJSON.
+
+        Codex emits ``thread.started`` with ``thread_id`` and one or more
+        ``item.completed`` events for assistant text. Tool-use event names
+        are intentionally ignored here; if Codex prints a final answer
+        without calling MCP, the caller's fallback posts the text through
+        ``send_message`` so the conversation still advances.
+        """
+        captured: str | None = None
+        final_chunks: list[str] = []
+        result_usage: dict | None = None
+        publish_enabled = bool(
+            self._partial_publisher
+            and partial_session_id
+            and partial_agent_id
+        )
+        if proc.stdout is None:
+            return None, [], None, None
+
+        async for line_b in proc.stdout:
+            line = line_b.decode("utf-8", errors="replace").strip()
+            if not line:
+                continue
+            try:
+                evt = json.loads(line)
+            except json.JSONDecodeError:
+                logger.debug("CodexRunner: non-JSON stdout line: %r", line[:120])
+                continue
+            if not isinstance(evt, dict):
+                continue
+
+            evt_type = evt.get("type")
+            if evt_type == "thread.started" and captured is None:
+                sid = evt.get("thread_id")
+                if isinstance(sid, str) and sid:
+                    captured = sid
+                    logger.info("CodexRunner: captured thread_id=%s", sid)
+                continue
+
+            if evt_type == "item.completed":
+                item = evt.get("item")
+                if isinstance(item, dict) and item.get("type") == "agent_message":
+                    text = item.get("text")
+                    if isinstance(text, str) and text:
+                        final_chunks.append(text)
+                        if publish_enabled:
+                            assert self._partial_publisher is not None
+                            assert partial_session_id is not None
+                            assert partial_agent_id is not None
+                            try:
+                                await self._partial_publisher(
+                                    partial_session_id,
+                                    partial_agent_id,
+                                    "\n\n".join(final_chunks),
+                                )
+                            except Exception as exc:  # noqa: BLE001
+                                logger.info(
+                                    "partial_publisher failed (non-fatal): %r",
+                                    exc,
+                                )
+                continue
+
+            if evt_type == "turn.completed":
+                usage = evt.get("usage") or evt.get("token_usage")
+                if isinstance(usage, dict):
+                    result_usage = usage
+                continue
+
+            if evt_type in {"turn.failed", "error"}:
+                err = evt.get("error")
+                msg = None
+                if isinstance(err, dict):
+                    raw = err.get("message")
+                    msg = raw if isinstance(raw, str) else None
+                if msg is None:
+                    raw = evt.get("message")
+                    msg = raw if isinstance(raw, str) else None
+                logger.warning("CodexRunner: stdout error event=%s msg=%r", evt_type, msg)
+
+        final_text = "\n\n".join(final_chunks) if final_chunks else None
+        return captured, [], final_text, result_usage
+
     async def _consume_stdout(
         self,
         proc: asyncio.subprocess.Process,
         *,
+        parse_mode: str = "stream_json",
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None]:
-        """Stream NDJSON from stdout; return ``(session_id, tool_uses, result_text)``.
+    ) -> tuple[str | None, list[str], str | None, dict | None]:
+        """Stream NDJSON from stdout; return ``(session_id, tool_uses, result_text, result_usage)``.
 
         Accepts BOTH session-init event shapes for forward/backward
         compatibility:
@@ -876,12 +1248,32 @@ Available cloudagent tools:
           name the same field differently). Used as the body of the
           fallback ``send_message`` POST.
 
+        M7 W3 — additionally extracts ``result_usage``: the ``usage``
+        object the Claude CLI carries on the terminating
+        ``type == "result"`` event. This is the **whole-turn** token
+        total (the CLI already aggregates every assistant message's
+        usage into it), so the daemon reads it straight off the result
+        event — it must NOT sum per-``message.usage`` blobs, that would
+        double-count against the result aggregate. Normalised to the
+        backend ``_INITIAL_USAGE`` shape via
+        ``delegation_report.normalize_usage`` and used as the ``usage``
+        field of the ``POST /v1/daemon/delegation-status`` report.
+
         Also surfaces ``type=result`` and ``type=tool_use`` events at INFO
         for Phase 1 demo visibility (1i Bug C).
         """
+        if parse_mode == "codex_json":
+            return await self._consume_codex_stdout(
+                proc,
+                partial_session_id=partial_session_id,
+                partial_agent_id=partial_agent_id,
+            )
+
         captured: str | None = None
         tool_uses: list[str] = []
         final_text: str | None = None
+        # M7 W3 — whole-turn usage from the terminating ``result`` event.
+        result_usage: dict | None = None
         # 1k74 — running buffer for token-level streaming. claude emits
         # one ``stream_event`` per content_block_delta (~80 chars at a
         # time); we concatenate them and forward the running total to
@@ -898,7 +1290,7 @@ Available cloudagent tools:
         _cache_read_tokens: int = 0
         _cache_creation_tokens: int = 0
         if proc.stdout is None:
-            return None, tool_uses, final_text
+            return None, tool_uses, final_text, result_usage
 
         async for line_b in proc.stdout:
             line = line_b.decode("utf-8", errors="replace").strip()
@@ -1021,15 +1413,26 @@ Available cloudagent tools:
                         result_text = alt
                 if isinstance(result_text, str) and result_text:
                     final_text = result_text
+                # M7 W3 — capture the whole-turn ``usage`` aggregate the
+                # CLI stamps on the terminating result event. Take it
+                # verbatim here; normalisation to ``_INITIAL_USAGE``
+                # shape happens in the caller via
+                # ``delegation_report.normalize_usage``. Do NOT add
+                # per-message usage — the result event already sums it.
+                evt_usage = evt.get("usage")
+                if isinstance(evt_usage, dict):
+                    result_usage = evt_usage
                 summary = (
                     result_text[:120] + "..."
                     if isinstance(result_text, str) and len(result_text) > 120
                     else result_text
                 )
                 logger.info(
-                    "ClaudeRunner: stdout result subtype=%s text=%r",
+                    "ClaudeRunner: stdout result subtype=%s text=%r "
+                    "usage_present=%s",
                     evt_subtype,
                     summary,
+                    result_usage is not None,
                 )
             elif evt_type == "tool_use":
                 # Standalone tool_use event (older / alternate shape).
@@ -1067,7 +1470,7 @@ Available cloudagent tools:
                 "claude_runner: cache metrics publish failed", exc_info=True
             )
 
-        return captured, tool_uses, final_text
+        return captured, tool_uses, final_text, result_usage
 
     async def _wait_with_timeout(
         self, proc: asyncio.subprocess.Process

{cloudagent_daemon-0.2.6 → cloudagent_daemon-0.3.0}/src/cloudagent_daemon/cli.py

@@ -642,15 +642,16 @@ def install_service_cmd(
     ),
     profile: str | None = typer.Option(None, "--profile", help=_PROFILE_HELP),
     permission_mode: str = typer.Option(
-        "default",
+        "bypassPermissions",
         "--permission-mode",
         help=(
             "Claude CLI permission mode for daemon-spawned staff agents. "
-            "'default' — only the cloudagent MCP toolset runs unattended "
+            "'bypassPermissions' — every tool runs unattended (default; "
+            "needed for staff that run git/build via Bash). 'default' — "
+            "only the cloudagent MCP toolset runs unattended "
             "(staff cannot touch the filesystem). 'acceptEdits' — file "
             "edits auto-accepted within the agent's working directory "
-            "(Bash still gates). 'bypassPermissions' — every tool runs "
-            "unattended (needed for staff that run git/build via Bash). "
+            "(Bash still gates). "
             "Baked into the service unit as CLOUDAGENT_DAEMON_PERMISSION_MODE."
         ),
     ),