devops-bot-sdk 1.4.35__tar.gz → 1.4.39__tar.gz

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.35
+Version: 1.4.39
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.35
+Version: 1.4.39
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.35"
+version = "1.4.39"
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.35
+Version: 1.4.39
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,7 +30,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.4.35"
+__version__ = "1.4.39"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.35"
+SDK_VERSION    = "1.4.39"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -621,6 +621,40 @@ class BackendClient:
         except Exception:
             return []
 
+    async def list_tasks_by_keys(self, keys: list[str], limit: int = 10000) -> list[dict]:
+        """GET /tasks-ml (ML backend) — RAW records for specific Jira keys.
+
+        Unlike list_todo_tasks_raw this does NOT filter by board status: a
+        targeted run (`agentos-auto ticket BBW-81`) should start the named ticket
+        whatever its current status (To Do / In Progress / Done), so a finished
+        ticket can be re-run on demand. Matches `jiraIssueKey` (falls back to
+        `jiraKey`) case-insensitively. Best-effort: returns [] on error. Preserves
+        the order of `keys` (each key's first matching record), so the run follows
+        the order the caller asked for.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        want = [k.strip().upper() for k in keys if k and k.strip()]
+        if not want:
+            return []
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml"
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(url, params={"limit": limit}, headers=headers)
+            if resp.status_code >= 400:
+                return []
+            records = ((resp.json() or {}).get("data") or {}).get("records") or []
+        except Exception:
+            return []
+
+        by_key: dict[str, dict] = {}
+        for rec in records:
+            k = str(rec.get("jiraIssueKey") or rec.get("jiraKey") or "").strip().upper()
+            if k and k not in by_key:
+                by_key[k] = rec
+        return [by_key[k] for k in want if k in by_key]
+
     async def approval_record(self, task_id: str) -> dict | None:
         """GET /api/v1/mgmt/approve/{task_id} → the full decision record (or None).
 
@@ -769,6 +803,71 @@ class BackendClient:
             logger.warning("client.mark_in_progress error task=%s err=%s", task_id, exc)
             return False
 
+    async def update_task_ml(
+        self, task_id: str, fields: dict, model_used: list[str] | None = None,
+    ) -> bool:
+        """PUT {BE}/tasks-ml/{id} with arbitrary multipart form fields (best-effort).
+
+        Generic form-update used e.g. to mark an Epic Done while attaching the
+        generated detailed description + AI plan. `model_used` is sent as repeated
+        `modelUsed` fields. None-valued fields are dropped. Returns True on 2xx.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}"
+        headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
+        headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
+        # httpx multipart wants a list of (name, (filename, value)) tuples so a
+        # field like `modelUsed` can repeat.
+        files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
+        for m in (model_used or []):
+            files.append(("modelUsed", (None, str(m))))
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.put(url, files=files, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.update_task_ml failed task=%s status=%s body=%s",
+                               task_id, resp.status_code, resp.text[:200])
+                return False
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.update_task_ml error task=%s err=%s", task_id, exc)
+            return False
+
+    async def create_task_ml(
+        self, fields: dict, model_used: list[str] | None = None,
+    ) -> str | None:
+        """POST {BE}/tasks-ml — create a task via multipart form; return its id.
+
+        Required fields per the API: projectKey, type, summary (description
+        optional but recommended). Used to spin a To Do child Task off a decomposed
+        Epic. Returns the new task id on success, else None (best-effort).
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml"
+        headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
+        headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
+        files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
+        for m in (model_used or []):
+            files.append(("modelUsed", (None, str(m))))
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(url, files=files, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.create_task_ml failed status=%s body=%s",
+                               resp.status_code, resp.text[:300])
+                return None
+            body = resp.json() or {}
+            rec = body.get("data") or body
+            # The created record's id may sit at data.id or data.record.id.
+            if isinstance(rec, dict):
+                return rec.get("id") or ((rec.get("record") or {}).get("id"))
+            return None
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.create_task_ml error err=%s", exc)
+            return None
+
     async def log_activity(self, activity: str) -> bool:
         """POST /ml-api/agent-activity — emit an agent activity event (best-effort).
 

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/sdk/ipc/handlers.py

@@ -351,6 +351,196 @@ def _parse_scope(recon_text: str | None) -> str:
     return "in"
 
 
+# ── Epic decomposition ────────────────────────────────────────────────────
+# An EPIC is not coded directly. It is analysed (grounded in the codebase when a
+# project path exists) into a detailed user-story description + an implementation
+# plan; the Epic is then marked Done with that content and one To Do child Task is
+# created per generated story (inheriting the Epic's project/assignee/priority/…).
+_MAX_EPIC_STORIES = int(os.getenv("AGENTOS_MAX_EPIC_STORIES", "") or 8)
+# Label recorded in the ticket's modelUsed on Epic completion.
+_EPIC_MODELS = [m.strip() for m in (os.getenv("AGENTOS_EPIC_MODELS", "") or "claude-code").split(",") if m.strip()]
+
+
+def _build_epic_prompt(jira_key: str, summary: str, description: str | None,
+                       human_instructions: str | None) -> str:
+    """Read-only prompt that turns an Epic into a decomposition JSON."""
+    parts: list[str] = [
+        "You are decomposing a JIRA EPIC into implementable work. This is ANALYSIS "
+        "ONLY — do NOT create, edit, or delete any file.",
+        f"=== EPIC {jira_key} ===\nSummary: {summary}",
+    ]
+    if description and description.strip():
+        parts.append("Description:\n" + _clip_text(description.strip()))
+    if human_instructions and human_instructions.strip():
+        parts.append(
+            "Operator instructions (authoritative — carry any project location / "
+            "constraints into each story's humanInstructions):\n"
+            + human_instructions.strip()
+        )
+    parts.append(
+        "First understand the existing codebase in this directory (read CLAUDE.md, "
+        "use graphify / Read / Glob / Grep) so the stories fit the REAL architecture. "
+        "Then produce the decomposition.\n\n"
+        "Output ONLY a single fenced ```json block and nothing after it, with shape:\n"
+        "{\n"
+        '  "epic_description": "A detailed description for the epic: a full user-story '
+        "write-up covering goal, the user stories, acceptance criteria and scope.\",\n"
+        '  "plan": "An ordered, numbered high-level implementation plan.",\n'
+        '  "stories": [\n'
+        '    {\n'
+        '      "summary": "Short imperative story title (a JIRA task summary)",\n'
+        '      "description": "Detailed description: what to build + acceptance criteria.",\n'
+        '      "humanInstructions": "Operator instructions to implement THIS story. MUST '
+        "repeat the same project location/path and constraints from the epic so the "
+        'coding run works in the right place.",\n'
+        '      "points": 5\n'
+        "    }\n"
+        "  ]\n"
+        "}\n"
+        "Create as many stories as the epic genuinely needs (do not pad or truncate "
+        "artificially); each story must be independently implementable."
+    )
+    return "\n\n".join(parts)
+
+
+def _extract_json_block(text: str | None) -> dict | None:
+    """Parse the decomposition JSON from a claude response (fenced block preferred)."""
+    if not text:
+        return None
+    import json as _json
+    candidates = re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.S | re.I)
+    if not candidates:
+        start, end = text.find("{"), text.rfind("}")
+        if start != -1 and end > start:
+            candidates = [text[start:end + 1]]
+    for c in reversed(candidates):
+        try:
+            obj = _json.loads(c)
+            if isinstance(obj, dict):
+                return obj
+        except Exception:  # noqa: BLE001
+            continue
+    return None
+
+
+def _epic_inherited_fields(task: dict) -> dict:
+    """Parent-Epic fields a child Task should inherit (drops empties)."""
+    def _date(v: object) -> str | None:
+        s = str(v or "")
+        return s[:10] if s else None   # ISO datetime → YYYY-MM-DD
+
+    fields = {
+        "projectKey": task.get("projectKey"),
+        "priority": task.get("priority"),
+        "assigneeEmail": (task.get("assignee") or {}).get("email"),
+        "teamId": task.get("teamId"),
+        "startDate": _date(task.get("startDate")),
+        "dueDate": _date(task.get("dueDate")),
+        "slaTarget": task.get("slaTarget"),
+    }
+    sprint = task.get("sprint") or {}
+    if sprint.get("jiraSprintId"):
+        fields["jiraSprintId"] = sprint["jiraSprintId"]
+    return {k: v for k, v in fields.items() if v}
+
+
+async def _handle_epic(
+    client: BackendClient, task: dict, payload: dict, send: Callable, thread_id: str,
+) -> None:
+    """Decompose an Epic: generate user stor(y|ies), mark the Epic Done with the
+    detailed description + plan, then create a To Do child Task per story.
+
+    Child tasks are created in "To Do"; a later `agentos-auto` run picks them up and
+    implements them through the normal grounded pipeline. Best-effort throughout —
+    a failure returns the Epic to Backlog for human review rather than raising.
+    """
+    from sdk import local_exec, graphify
+
+    tid = str(task.get("id", ""))
+    jira_key = task.get("jiraIssueKey") or task.get("jiraKey", "") or "EPIC"
+    summary = task.get("summary", "") or ""
+    description = task.get("description")
+    human = task.get("humanInstructions")
+    project_path = _resolve_local_project_path(task, payload)
+
+    await client.mark_in_progress(tid)
+    await send(Envelope(
+        type="step_update", thread_id=thread_id,
+        data={"jira_task_id": tid, "task_id": tid,
+              "current_step": f"Epic {jira_key}: analysing & generating user stories"},
+    ).model_dump())
+
+    # 1. Generate the decomposition, grounded in the codebase where one exists.
+    try:
+        await graphify.prepare(project_path)
+    except Exception:  # noqa: BLE001
+        pass
+    gen = await local_exec.run_claude_local(
+        _build_epic_prompt(jira_key, summary, description, human),
+        project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only analysis
+        github_token=await client.github_token(),
+    )
+    doc = _extract_json_block(gen.get("result")) if gen.get("ok") else None
+    stories = (doc or {}).get("stories") or []
+    if not doc or not stories:
+        reason = (gen.get("error") or "could not generate a valid decomposition")[:200]
+        await client.log_activity(f"Epic {jira_key}: decomposition failed — {reason}")
+        await client.move_to_backlog(tid)
+        await send(Envelope(
+            type=Envelope.TYPE_ERROR, thread_id=thread_id,
+            data={"code": "EPIC_DECOMPOSE_FAILED", "task_id": tid, "message": reason},
+        ).model_dump())
+        return
+
+    # 2. Mark the Epic Done with the detailed description + plan.
+    epic_desc = (doc.get("epic_description") or description or summary or "")[:20000]
+    plan = (doc.get("plan") or "")[:8000]
+    await client.update_task_ml(
+        tid, {"status": "Done", "description": epic_desc, "initialAiPlan": plan},
+        model_used=_EPIC_MODELS,
+    )
+    await send(Envelope(
+        type="step_update", thread_id=thread_id,
+        data={"jira_task_id": tid, "current_step": f"Epic {jira_key}: marked Done — "
+              f"creating {min(len(stories), _MAX_EPIC_STORIES)} child task(s)"},
+    ).model_dump())
+
+    # 3. Create a To Do child Task per story, inheriting the Epic's fields.
+    inherited = _epic_inherited_fields(task)
+    created: list[str] = []
+    for st in stories[:_MAX_EPIC_STORIES]:
+        if not isinstance(st, dict) or not (st.get("summary") or "").strip():
+            continue
+        fields = {
+            **inherited,
+            "type": "Task",
+            "status": "To Do",
+            "summary": str(st.get("summary", "")).strip()[:250],
+            "description": str(st.get("description", "") or "")[:20000],
+            "humanInstructions": str(st.get("humanInstructions") or human or "")[:20000] or None,
+            "parentTaskId": tid,
+        }
+        if st.get("points"):
+            fields["points"] = st["points"]
+        new_id = await client.create_task_ml(fields, model_used=_EPIC_MODELS)
+        if new_id:
+            created.append(new_id)
+            await send(Envelope(
+                type="step_update", thread_id=thread_id,
+                data={"current_step": f"  ↳ created To Do task: {fields['summary']}"},
+            ).model_dump())
+
+    await client.log_activity(
+        f"Epic {jira_key}: Done — created {len(created)}/{len(stories)} child To Do task(s)"
+    )
+    await send(Envelope(
+        type="step_update", thread_id=thread_id,
+        data={"jira_task_id": tid,
+              "current_step": f"Epic {jira_key} complete — {len(created)} child task(s) queued "
+                              "(run again to implement them)"},
+    ).model_dump())
+
+
 async def _run_local_pipeline(
     client: BackendClient, payload: dict, send: Callable
 ) -> None:
@@ -2129,15 +2319,31 @@ async def handle_orchestrate_auto_local_run(
             ).model_dump())
             return
 
-        # RAW /tasks-ml records carry agentMode / jiraIssueKey / humanInstructions.
-        tasks = await client.list_todo_tasks_raw(status="To Do")
-        # Process oldest-created first (FIFO by Jira `createdAt`) so the ticket
-        # raised earliest is started first. Unknown/invalid timestamps sort last.
-        tasks = sorted(tasks, key=_task_created_key)
+        # Targeted run: `only_keys` names specific Jira tickets to run (via
+        # `agentos-auto ticket BBW-81 …`). Those run regardless of board status and
+        # in the ORDER requested. Otherwise fetch the whole To Do queue (default).
+        only_keys = [str(k).strip().upper() for k in (payload.get("only_keys") or []) if str(k).strip()]
+        if only_keys:
+            tasks = await client.list_tasks_by_keys(only_keys)
+            found = {str(t.get("jiraIssueKey") or t.get("jiraKey") or "").strip().upper() for t in tasks}
+            missing = [k for k in only_keys if k not in found]
+            if missing:
+                await send(Envelope(
+                    type="step_update", thread_id=thread_id,
+                    data={"current_step": f"⚠ not found (skipped): {', '.join(missing)}"},
+                ).model_dump())
+            # Keep the requested order (list_tasks_by_keys already does), no re-sort.
+        else:
+            # RAW /tasks-ml records carry agentMode / jiraIssueKey / humanInstructions.
+            tasks = await client.list_todo_tasks_raw(status="To Do")
+            # Process oldest-created first (FIFO by Jira `createdAt`) so the ticket
+            # raised earliest is started first. Unknown/invalid timestamps sort last.
+            tasks = sorted(tasks, key=_task_created_key)
 
         await send(Envelope(
             type="pipeline_started", thread_id=thread_id,
-            data={"mode": "orchestrate-auto-local", "task_count": len(tasks)},
+            data={"mode": "orchestrate-auto-local", "task_count": len(tasks),
+                  "only_keys": only_keys or None},
         ).model_dump())
 
         if not tasks:
@@ -2173,6 +2379,27 @@ async def handle_orchestrate_auto_local_run(
                       "project_path": project_path, "jira_task_id": tid, "agent_mode": agent_mode},
             ).model_dump())
 
+            # EPIC → decompose (generate user stories, mark Done, create To Do
+            # child tasks) instead of coding it directly. Isolated like every other
+            # task: a failure here must not abort the remaining queue.
+            if str(task.get("type") or "").strip().lower() == "epic":
+                try:
+                    await _handle_epic(client, task, payload, send, thread_id)
+                except Exception as exc:  # noqa: BLE001
+                    logger.warning("auto_local.epic_failed task=%s err=%s", tid, exc)
+                    try:
+                        await client.log_activity(f"Task {tid}: epic decomposition errored — {str(exc)[:200]}")
+                        await client.move_to_backlog(tid)
+                    except Exception:  # noqa: BLE001
+                        pass
+                    await send(Envelope(
+                        type=Envelope.TYPE_ERROR, thread_id=thread_id,
+                        data={"code": "EPIC_DECOMPOSE_FAILED", "task_id": tid,
+                              "message": str(exc)[:200]},
+                    ).model_dump())
+                processed += 1
+                continue
+
             task_payload = {
                 "thread_id": thread_id,
                 "jira_task_id": tid,

{devops_bot_sdk-1.4.35 → devops_bot_sdk-1.4.39}/sdk/run_auto.py

@@ -9,6 +9,8 @@ directory, and the result is reported back. The only required input is the
 Commands:
     agentos-auto                 run every To Do task locally, in the BACKGROUND
     agentos-auto resume          alias for run — re-fetches remaining To Do tasks
+    agentos-auto ticket K [K...] run ONLY the named Jira ticket(s), e.g. BBW-81 —
+                                 any status, in the order given (alias: tickets)
     agentos-auto stop            ask the running loop to pause after the current task
     agentos-auto status          show whether the background loop is running / stop pending
     agentos-auto update          upgrade the SDK to the latest version
@@ -224,6 +226,39 @@ def _parse_workspace_root(argv: list[str]) -> str | None:
     return None
 
 
+def _parse_ticket_keys(argv: list[str]) -> list[str]:
+    """Jira keys passed to `agentos-auto ticket <KEY> [<KEY> ...]`.
+
+    Accepts space- and/or comma-separated keys (e.g. `BBW-81 BBW-80` or
+    `BBW-81,BBW-80`), skips the leading subcommand and any flags (and the value
+    of --workspace-root), upper-cases and de-dupes while preserving order.
+    """
+    keys: list[str] = []
+    skip_next = False
+    for i, tok in enumerate(argv):
+        if i == 0:
+            continue  # the subcommand itself (ticket/tickets)
+        if skip_next:
+            skip_next = False
+            continue
+        if tok.startswith("-"):
+            if tok == "--workspace-root":
+                skip_next = True  # its value is a directory, not a ticket key
+            continue
+        for part in tok.split(","):
+            k = part.strip()
+            if k:
+                keys.append(k)
+    seen: set[str] = set()
+    out: list[str] = []
+    for k in keys:
+        ku = k.upper()
+        if ku not in seen:
+            seen.add(ku)
+            out.append(ku)
+    return out
+
+
 _current_task: str | None = None
 
 
@@ -263,7 +298,7 @@ async def _send(env: dict) -> None:
         print(f"  [{etype}] {json.dumps(data)[:200]}")
 
 
-def _run_loop(workspace_root: str | None) -> None:
+def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None) -> None:
     from sdk import local_exec
     from sdk.client import BackendClient, register_status_observer
     from sdk.ipc import handlers
@@ -282,6 +317,9 @@ def _run_loop(workspace_root: str | None) -> None:
     payload: dict = {"thread_id": "agentos-auto-cli"}
     if workspace_root:
         payload["workspace_root"] = workspace_root
+    if only_keys:
+        # Targeted run: only these Jira tickets, in this order, regardless of status.
+        payload["only_keys"] = only_keys
 
     _clear_stop()  # a fresh run/resume clears any stale stop flag
     _clear_backlogged()  # session-scoped: only track Backlog moves from THIS run
@@ -420,7 +458,18 @@ def main() -> None:
         print("stop pending: yes" if _stop_requested() else "stop pending: no")
         return
 
-    if cmd in ("run", "resume"):
+    if cmd in ("run", "resume", "ticket", "tickets"):
+        # Targeted run: `ticket`/`tickets` runs ONLY the named Jira keys (any
+        # status, in the order given); `run`/`resume` runs the whole To Do queue.
+        only_keys: list[str] | None = None
+        if cmd in ("ticket", "tickets"):
+            only_keys = _parse_ticket_keys(argv)
+            if not only_keys:
+                print("usage: agentos-auto ticket <JIRA-KEY> [<JIRA-KEY> ...]")
+                print("   e.g. agentos-auto ticket BBW-81")
+                print("        agentos-auto ticket BBW-81 BBW-80")
+                sys.exit(1)
+
         # Self-update FIRST (before the already-running check) so the installed
         # package is refreshed even when a daemon is already running — otherwise a
         # long-lived old daemon would pin `stop`/`status` to a stale version. Runs
@@ -430,7 +479,7 @@ def main() -> None:
             from sdk.updater import auto_update_and_reexec
             auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
 
-        # Refuse to start a second loop — one background daemon owns the To Do queue.
+        # Refuse to start a second loop — one background daemon owns the queue.
         pid = _daemon_running()
         if pid:
             print(f"agentos-auto is already running in the background (pid {pid}).")
@@ -445,13 +494,14 @@ def main() -> None:
         # attached (useful for debugging). On platforms without fork we stay attached.
         foreground = "--foreground" in argv or "-f" in argv
         if not foreground and hasattr(os, "fork"):
-            print("▶ agentos-auto started in the background — it keeps running after you "
-                  "close this terminal.")
+            target = f" — tickets: {', '.join(only_keys)}" if only_keys else ""
+            print(f"▶ agentos-auto started in the background{target} — it keeps running "
+                  "after you close this terminal.")
             print(f"  logs:   {_LOG_FILE}")
             print("  status: agentos-auto status")
             print("  stop:   agentos-auto stop")
         if not foreground and _daemonize():
-            _run_loop(workspace_root)  # only the detached daemon child reaches here
+            _run_loop(workspace_root, only_keys)  # only the detached daemon child reaches here
             return
         if not foreground:
             print("note: background mode unavailable on this platform — running in the "
@@ -460,10 +510,10 @@ def main() -> None:
             # Foreground run still records a PID so stop/status can find it.
             _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
             _PID_FILE.write_text(str(os.getpid()))
-        _run_loop(workspace_root)
+        _run_loop(workspace_root, only_keys)
         return
 
-    print(f"unknown command '{cmd}'. use: run | resume | stop | status | update")
+    print(f"unknown command '{cmd}'. use: run | resume | ticket | stop | status | update")
     sys.exit(1)